archive
/
tf2
mirror of https://github.com/sr2echa/TF2-Source-Code
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Team Fortress 2 Source Code as on 22/4/2020
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
10 Commits
1 Branch
0 Tags
1.4 GiB
 
 
 
 
 
 
Tree: c61d975061
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'c61d975061'
${ noResults }
tf2/tf2_src/utils/itemtest_lib/itemtest.cpp

6226 lines
168 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
//=============================================================================
// Standard includes
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <io.h>
// Valve includes
#include "itemtest/itemtest.h"
#include "bitmap/bitmap.h"
#include "bitmap/imageformat.h"
#include "bitmap/psd.h"
#include "bitmap/tgaloader.h"
#include "bitmap/tgawriter.h"
#include "vtf/vtf.h"
#include "datamodel/dmattribute.h"
#include "datamodel/dmelement.h"
#include "datamodel/idatamodel.h"
#include "fbxutils/dmfbxserializer.h"
#include "filesystem.h"
#include "movieobjects/dmefaceset.h"
#include "movieobjects/dmematerial.h"
#include "movieobjects/dmemesh.h"
#include "movieobjects/dmemodel.h"
#include "movieobjects/dmobjserializer.h"
#include "movieobjects/dmsmdserializer.h"
#include "movieobjects/dmeanimationlist.h"
#include "movieobjects/dmeclip.h"
#include "movieobjects/dmechannel.h"
#include "movieobjects/dmelog.h"
#include "steam/steam_api.h"
#include "tier1/fmtstr.h"
#include "tier1/utlsymbol.h"
#include "tier2/fileutils.h"
#include "tier2/p4helpers.h"
#include "../public/zip_utils.h"
// Last include
#include "tier0/memdbgon.h"
#ifdef BEGIN_DEFINE_LOGGING_CHANNEL
BEGIN_DEFINE_LOGGING_CHANNEL( LOG_ITEMTEST, "ItemTest", LCF_CONSOLE_ONLY, LS_MESSAGE );
ADD_LOGGING_CHANNEL_TAG( "ItemTest" );
END_DEFINE_LOGGING_CHANNEL();
#endif
// This isn't available in the TF runtime (yet?)
#ifndef FUNCTION_LINE_STRING
#define FUNCTION_LINE_STRINGIFY(x) #x
#define FUNCTION_LINE_TOSTRING(x) FUNCTION_LINE_STRINGIFY(x)
#define FUNCTION_LINE_STRING __FUNCTION__ "(" FUNCTION_LINE_TOSTRING(__LINE__) "): "
#endif
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
enum
{
k64KB = 65536
};
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
static CSteamAPIContext g_SteamAPIContext;
bool CItemUpload::m_bDev = false;
bool CItemUpload::m_bIgnoreEnvVars = false;
bool CItemUpload::m_bP4 = false;
CUtlString CItemUpload::m_szForcedSteamID = "";
CItemTestManifest *CItemUpload::m_pItemTestManifest = NULL;
static bool g_bCompilePreview = false;
static const char* kVMT = "VMT%d";
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
inline bool UtlStringLessThan( const CUtlString &sLhs, const CUtlString &sRhs )
{
return CaselessStringLessThanIgnoreSlashes( sLhs.String(), sRhs.String() );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CItemLog::Msg( const char *pszFormat, ... ) const
{
va_list args;
va_start( args, pszFormat );
CFmtStrMax str;
str.AppendFormatV( pszFormat, args );
Log( kItemtest_Log_Info, str );
va_end( args );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CItemLog::Warning( const char *pszFormat, ... ) const
{
va_list args;
va_start( args, pszFormat );
CFmtStrMax str;
str.AppendFormatV( pszFormat, args );
Log( kItemtest_Log_Warning, str );
va_end( args );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CItemLog::Error( const char *pszFormat, ... ) const
{
va_list args;
va_start( args, pszFormat );
CFmtStrMax str;
str.AppendFormatV( pszFormat, args );
Log( kItemtest_Log_Error, str );
va_end( args );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CItemLog::Log( ItemtestLogLevel_t nLogLevel, const char *pszMessage ) const
{
if ( m_pItemLog && m_pItemLog != this )
{
m_pItemLog->Log( nLogLevel, pszMessage );
return;
}
switch ( nLogLevel )
{
case kItemtest_Log_Info:
Log_Msg( LOG_ITEMTEST, "%s", pszMessage );
break;
case kItemtest_Log_Warning:
Log_Warning( LOG_ITEMTEST, "%s", pszMessage );
break;
case kItemtest_Log_Error:
Log_Error( LOG_ITEMTEST, "%s", pszMessage );
break;
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CItemUpload::InitManifest( void )
{
if ( m_pItemTestManifest )
return true;
m_pItemTestManifest = new CItemTestManifest( "scripts/itemtest_manifest.txt", new CItemLog() );
return m_pItemTestManifest->IsValid();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CItemUpload::SanitizeName( const char *pszName, CUtlString &sCleanName )
{
char pszTemp[MAX_PATH];
V_strcpy_safe( pszTemp, pszName );
// Convert to lowercase, strip punctuation and turn spaces into underscores
char *pszSrc = pszTemp;
char *pszDst = pszTemp;
while ( *pszSrc )
{
char c = *pszSrc++;
if ( c >= 'a' && c <= 'z' )
{
*pszDst++ = c;
}
else if ( c >= 'A' && c <= 'Z' )
{
*pszDst++ = c - 'A' + 'a';
}
else if ( c >= '0' && c <= '9' )
{
*pszDst++ = c;
}
else if ( V_isspace(c) || c == '_' )
{
*pszDst++ = '_';
}
else
{
// Punctuation or non-ASCII characters, skip 'em!
}
}
*pszDst = '\0';
sCleanName = pszTemp;
return !sCleanName.IsEmpty();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CItemTestManifest::CItemTestManifest( const char *pszManifestFile, CItemLog *pItemLog ) :
m_pItemLog( pItemLog ),
m_vecVMTTextureRemaps( UtlStringLessThan )
{
m_pManifestKV = NULL;
m_pItemDirectory = "";
m_pAnimationDirectory = "";
m_pIconDirectory = "";
m_pZipSourceDirectory = "";
m_pZipOutputDirectory = "";
m_pQCTemplate = "";
m_pQCITemplate = "";
m_bTerseMessages = false;
m_bItemPathUsesSteamId = true;
m_pManifestKV = new KeyValues( pszManifestFile );
if ( !m_pManifestKV->LoadFromFile(g_pFullFileSystem, pszManifestFile, "MOD") )
{
m_pManifestKV->deleteThis();
m_pManifestKV = NULL;
m_pItemLog->Warning( "ERROR: Failed to load manifest file: %s\n", pszManifestFile );
return;
}
// Class list
if ( !ParseStringsFromManifest( m_pManifestKV, "classes", m_vecClasses ) )
return;
// MDL Extensions
if ( !ParseStringsFromManifest( m_pManifestKV, "mdl_files", m_vecMDLExtensions ) )
return;
// Animation MDL Extensions
if ( !ParseStringsFromManifest( m_pManifestKV, "animation_mdl_files", m_vecAnimationMDLExtensions ) )
return;
// Material types
KeyValues *pKVMaterialTypes = m_pManifestKV->FindKey("material_types");
if ( !pKVMaterialTypes )
{
m_pItemLog->Warning( "ERROR: Failed to find a 'material_types' section in manifest file: %s\n", pszManifestFile );
return;
}
FOR_EACH_SUBKEY( pKVMaterialTypes, pKVMaterialType )
{
const char *pszString = pKVMaterialType->GetName();
int nIdx = m_vecMaterialTypes.AddToTail();
m_vecMaterialTypes[nIdx].pszMaterialType = pszString;
}
const char *pszDefaultMatTypeString = m_pManifestKV->GetString("default_material_type");
if ( !pszDefaultMatTypeString || !pszDefaultMatTypeString[0] )
{
m_pItemLog->Warning( "ERROR: Failed to find a 'default_material_type' string in manifest file: %s\n", pszManifestFile );
return;
}
m_nDefaultMaterialType = GetMaterialType( pszDefaultMatTypeString );
if ( m_nDefaultMaterialType == kInvalidMaterialType )
{
m_pItemLog->Warning( "ERROR: Default material type '%s' wasn't found in the material type list in manifest file: %s\n", m_nDefaultMaterialType, pszManifestFile );
return;
}
// Material skins
KeyValues *pKVMaterialSkins = m_pManifestKV->FindKey("material_skins");
if ( pKVMaterialSkins )
{
FOR_EACH_SUBKEY( pKVMaterialSkins, pKVMaterialSkin )
{
const char *pszString = pKVMaterialSkin->GetName();
int nIdx = m_vecMaterialSkins.AddToTail();
m_vecMaterialSkins[nIdx].pszMaterialSkin = pszString;
m_vecMaterialSkins[nIdx].pszFilenameAppend = pKVMaterialSkin->GetString("file_append");
}
const char *pszDefaultMatSkinString = m_pManifestKV->GetString("default_material_skin");
if ( !pszDefaultMatSkinString || !pszDefaultMatSkinString[0] )
{
m_pItemLog->Warning( "ERROR: Failed to find a 'default_material_skin' string in manifest file: %s\n", pszManifestFile );
return;
}
m_nDefaultMaterialSkin = GetMaterialSkin( pszDefaultMatSkinString );
if ( m_nDefaultMaterialSkin == kInvalidMaterialSkin )
{
m_pItemLog->Warning( "ERROR: Default material skin '%s' wasn't found in the material skin list in manifest file: %s\n", pszDefaultMatSkinString, pszManifestFile );
m_nDefaultMaterialSkin = 0;
return;
}
}
else
{
m_nDefaultMaterialSkin = 0;
}
// Texture types
KeyValues *pKVTextureTypes = m_pManifestKV->FindKey("texture_types");
if ( !pKVTextureTypes )
{
m_pItemLog->Warning( "ERROR: Failed to find a 'texture_types' section in manifest file: %s\n", pszManifestFile );
return;
}
FOR_EACH_SUBKEY( pKVTextureTypes, pKVTexture )
{
const char *pszString = pKVTexture->GetName();
int nIdx = m_vecTextureTypes.AddToTail();
m_vecTextureTypes[nIdx].pszTextureType = pszString;
m_vecTextureTypes[nIdx].bOptional = pKVTexture->GetBool( "optional" );
m_vecTextureTypes[nIdx].pkvAddToVTEXConfig = pKVTexture->FindKey("add_to_vtex_config");
}
// VMT templates
KeyValues *pKVTemplates = m_pManifestKV->FindKey("vmt_templates");
if ( !pKVTemplates )
{
m_pItemLog->Warning( "ERROR: Failed to find a 'vmt_templates' section in manifest file: %s\n", pszManifestFile );
return;
}
KeyValues *pKVClassTemplates = pKVTemplates->FindKey("classes");
if ( pKVClassTemplates )
{
m_vecClassTemplates.SetCount( m_vecClasses.Count() );
for ( int i = 0; i < m_vecClassTemplates.Count(); ++i )
{
m_vecClassTemplates[ i ] = NULL;
}
FOR_EACH_SUBKEY( pKVClassTemplates, pKVClassTemplate )
{
const char *pszHero = pKVClassTemplate->GetName();
const char *pszTemplate = pKVClassTemplate->GetString();
int iClass = m_vecClasses.Find( pszHero );
if ( iClass == m_vecClasses.InvalidIndex() )
{
m_pItemLog->Warning( "ERROR: Found an invalid class '%s' in the vmt_templates entries in manifest file: %s\n", pszHero, pszManifestFile );
return;
}
m_vecClassTemplates[iClass] = pszTemplate;
}
}
KeyValues *pKVVMTRemaps = pKVTemplates->FindKey("vmt_texture_settings");
if ( pKVVMTRemaps )
{
FOR_EACH_SUBKEY( pKVVMTRemaps, pKVRemap )
{
const char *pszVMTVar = pKVRemap->GetName();
const char *pszTexture = pKVRemap->GetString();
m_vecVMTTextureRemaps.Insert( pszTexture, pszVMTVar );
}
}
// Icon types
KeyValues *pKVIconTypes = m_pManifestKV->FindKey("icon_types");
if ( pKVIconTypes )
{
FOR_EACH_SUBKEY( pKVIconTypes, pKVIcon )
{
const char *pszString = pKVIcon->GetName();
int nIdx = m_vecIconTypes.AddToTail();
m_vecIconTypes[nIdx].pszIconType = pszString;
m_vecIconTypes[nIdx].nWidth = pKVIcon->GetInt( "width" );
m_vecIconTypes[nIdx].nHeight = pKVIcon->GetInt( "height" );
m_vecIconTypes[nIdx].pszFilenameAppend = pKVIcon->GetString("file_append");
m_vecIconTypes[nIdx].pkvAddToVTEXConfig = pKVIcon->FindKey("add_to_vtex_config");
KeyValues *pKVVMT = pKVIcon->FindKey("vmt_template");
if ( pKVVMT )
{
m_vecIconTypes[nIdx].pkvVMTTemplate = pKVVMT->GetFirstSubKey();
}
else
{
m_vecIconTypes[nIdx].pkvVMTTemplate = NULL;
}
}
}
m_pItemDirectory = m_pManifestKV->GetString("item_directory");
m_pAnimationDirectory = m_pManifestKV->GetString("animation_directory");
m_pIconDirectory = m_pManifestKV->GetString("icon_directory");
m_pZipSourceDirectory = m_pManifestKV->GetString("archive_source_path");
m_pZipOutputDirectory = m_pManifestKV->GetString("archive_output_path");
m_pQCTemplate = m_pManifestKV->GetString("qc_template");
if ( V_strlen( m_pQCTemplate ) == 0 )
{
m_pItemLog->Warning( "ERROR: qc_template not defined in manifest file: %s\n", pszManifestFile );
return;
}
m_pQCITemplate = m_pManifestKV->GetString( "qci_template" );
if ( V_strlen( m_pQCITemplate ) == 0 )
{
m_pItemLog->Warning( "ERROR: qci_template not defined in manifest file: %s\n", pszManifestFile );
return;
}
const char *pszQCLODDistances = m_pManifestKV->GetString("qc_lod_distances");
CUtlVector<char*> vecQCLODDistances;
V_SplitString( pszQCLODDistances, ",", vecQCLODDistances );
m_vecQCLODDistances.SetCount( vecQCLODDistances.Count() );
for ( int i = 0; i < vecQCLODDistances.Count(); ++i )
{
m_vecQCLODDistances[i] = V_atoi( vecQCLODDistances[i] );
}
m_bTerseMessages = m_pManifestKV->GetBool( "terse_messages", false );
m_bItemPathUsesSteamId = m_pManifestKV->GetBool( "item_path_has_steamid", true );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CItemTestManifest::ParseStringsFromManifest( KeyValues *pKV, const char *pszKeyName, CUtlVector< CUtlString > &vecList )
{
KeyValues *pKVSub = pKV->FindKey(pszKeyName);
if ( !pKVSub )
{
m_pItemLog->Warning( "ERROR: Failed to find a '%s' section in manifest file.\n", pszKeyName );
return false;
}
FOR_EACH_SUBKEY( pKVSub, pKVSubKey )
{
const char *pszString = pKVSubKey->GetName();
vecList.AddToTail( pszString );
}
return true;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
int CItemTestManifest::GetMaterialType( const char *pszMaterialType )
{
FOR_EACH_VEC( m_vecMaterialTypes, i )
{
if ( V_stricmp(m_vecMaterialTypes[i].pszMaterialType, pszMaterialType) == 0 )
return i;
}
return kInvalidMaterialType;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
int CItemTestManifest::GetMaterialSkin( const char *pszMaterialSkin )
{
FOR_EACH_VEC( m_vecMaterialSkins, i )
{
if ( V_stricmp(m_vecMaterialSkins[i].pszMaterialSkin, pszMaterialSkin) == 0 )
return i;
}
return kInvalidMaterialSkin;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
int CItemTestManifest::GetTextureType( const char *pszTextureType )
{
FOR_EACH_VEC( m_vecTextureTypes, i )
{
if ( V_stricmp(m_vecTextureTypes[i].pszTextureType, pszTextureType) == 0 )
return i;
}
return -1;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
KeyValues *CItemTestManifest::GetTextureAddToVTEXConfig( const char *pszTextureType )
{
int nIdx = GetTextureType(pszTextureType);
if ( nIdx == -1 )
return NULL;
return m_vecTextureTypes[nIdx].pkvAddToVTEXConfig;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
int CItemTestManifest::GetIconType( const char *pszIconType )
{
FOR_EACH_VEC( m_vecIconTypes, i )
{
if ( V_stricmp(m_vecIconTypes[i].pszIconType, pszIconType) == 0 )
return i;
}
return -1;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CItemTestManifest::GetIconDimensions( int nIcon, int &nWidth, int &nHeight )
{
if ( nIcon >= 0 && nIcon < m_vecIconTypes.Count() )
{
nWidth = m_vecIconTypes[nIcon].nWidth;
nHeight = m_vecIconTypes[nIcon].nHeight;
return true;
}
else
{
nWidth = 0;
nHeight = 0;
return false;
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
const char *CItemTestManifest::GetVMTVarForTextureType( const char *pszTexture )
{
int nIndex = m_vecVMTTextureRemaps.Find(pszTexture);
if ( nIndex == m_vecVMTTextureRemaps.InvalidIndex() )
return NULL;
return m_vecVMTTextureRemaps[nIndex];
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
int GetClassCount()
{
return CItemUpload::Manifest()->GetNumClasses();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
const char *GetClassString( int i )
{
return ( i < 0 || i >= GetClassCount() ) ? NULL : CItemUpload::Manifest()->GetClass(i);
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
const char *GetClassString( const char *pszClassString )
{
if ( !pszClassString || V_strlen( pszClassString ) <= 0 )
return NULL;
// Make sure it exists in our manifest file
for ( int i = 0; i < CItemUpload::Manifest()->GetNumClasses(); i++ )
{
const char *pszHero = CItemUpload::Manifest()->GetClass(i);
if ( V_stricmp(pszHero, pszClassString) == 0 )
return pszHero;
}
//Log_Warning( LOG_ITEMTEST, "Invalid class specified: %s\n", pszClassString );
return NULL;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
int GetClassIndex( const char *pszClassString )
{
const char *pszCleanClassString = GetClassString( pszClassString );
if ( !pszCleanClassString )
return -1;
for ( int i = 0; i < GetClassCount(); ++i )
{
if ( !V_stricmp( pszCleanClassString, GetClassString( i ) ) )
{
return i;
}
}
return -1;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
template < class T >
const Vector &CItemUploadGame< T >::GetBipHead( int i )
{
static const Vector vOrigin( 0, 0, 0 );
return ( i < 0 || i >= GetClassCount() ) ? vOrigin : CItemUploadGame< T >::s_vBipHead[i];
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
template < class T >
const RadianEuler &CItemUploadGame< T >::GetBipHeadRotation( int i )
{
static const RadianEuler eOrigin( 0, 0, 0 );
return ( i < 0 || i >= GetClassCount() ) ? eOrigin : CItemUploadGame< T >::s_eBipHead[i];
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
const Vector CItemUploadGame< CItemUploadTF >::s_vBipHead[] =
{
Vector( 0, 76.142968, -0.39608 ), // demo
Vector( 0, 69.030248, -1.264691 ), // engineer
Vector( -0.000138993, 79.541796, -3.352982 ), // heavy
Vector( -0.000111273, 76.504372, -0.565035 ), // medic
Vector( -0.000102534, 71.788881, 2.145585 ), // pyro
Vector( 0, 73.501752, -1.429994 ), // scout
Vector( 0, 75.982279, -3.858408 ), // sniper
Vector( 0, 75.194376, -1.120618 ), // soldier
Vector( 0, 75.679732, -2.87915 ) // spy
};
COMPILE_TIME_ASSERT( ARRAYSIZE( CItemUploadGame< CItemUploadTF >::s_vBipHead ) == CItemUploadTF::kClassCount );
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
const RadianEuler CItemUploadGame< CItemUploadTF >::s_eBipHead[] =
{
RadianEuler( DEG2RAD( -180.0 ), 0, 0 ), // demo
RadianEuler( DEG2RAD( -170.459 ), 0, 0 ), // engineer
RadianEuler( DEG2RAD( -180.0 ), 0, 0 ), // heavy
RadianEuler( DEG2RAD( -180.0 ), 0, 0 ), // medic
RadianEuler( DEG2RAD( -154.175 ), 0, 0 ), // pyro
RadianEuler( DEG2RAD( -173.451 ), 0, 0 ), // scout
RadianEuler( DEG2RAD( -172.722 ), 0, 0 ), // sniper
RadianEuler( DEG2RAD( -179.729 ), 0, 0 ), // soldier
RadianEuler( DEG2RAD( -180.0 ), 0, 0 ) // spy
};
COMPILE_TIME_ASSERT( ARRAYSIZE( CItemUploadGame< CItemUploadTF >::s_eBipHead ) == CItemUploadTF::kClassCount );
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
template class CItemUploadGame< CItemUploadTF >;
//-----------------------------------------------------------------------------
//
// Try and get the Steam Account ID and return it as a 10 character hex
// string prefixed with 0x.
//
//-----------------------------------------------------------------------------
bool CItemUpload::GetSteamId( CUtlString &sSteamId )
{
if ( GetDevMode() )
{
sSteamId = "";
return true;
}
const char *pszForcedSteamID = GetForcedSteamID();
if ( pszForcedSteamID && pszForcedSteamID[0] )
{
sSteamId = pszForcedSteamID;
return true;
}
bool bRetVal = false;
char szBuf[ BUFSIZ ];
szBuf[0] = '\0';
// Try to query steam directly, this will fail if steam isn't running or the
// process calling this function wasn't launched through steam (or through a
// process launched through steam) or there isn't a steam_appid.txt in
// the same directory as the executable running this (use 440 for TF).
bool shutdownSteam = false;
if ( !SteamClient() )
{
SteamAPI_InitSafe();
SteamAPI_SetTryCatchCallbacks( false ); // We don't use exceptions, so tell steam not to use try/catch in callback handlers
shutdownSteam = true;
}
if ( SteamAPI_IsSteamRunning() )
{
g_SteamAPIContext.Init();
ISteamUser *pSteamUser = g_SteamAPIContext.SteamUser();
if ( pSteamUser )
{
CSteamID cSteamID = pSteamUser->GetSteamID();
const uint32 nAccountID = cSteamID.GetAccountID();
V_snprintf( szBuf, ARRAYSIZE( szBuf ), "0x%08x", nAccountID );
bRetVal = true;
}
}
if ( shutdownSteam )
{
SteamAPI_Shutdown();
}
sSteamId = szBuf;
return bRetVal;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CItemUpload::GetVProjectDir( CUtlString &sVProjectDir )
{
char szVProject[ BUFSIZ ] = "";
GetModSubdirectory( "", szVProject, ARRAYSIZE( szVProject ) );
V_StripTrailingSlash( szVProject );
sVProjectDir = szVProject;
return true;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CItemUpload::GetVMod( CUtlString &sVMod )
{
sVMod = "";
CUtlString sVProjectDir;
if ( !GetVProjectDir( sVProjectDir ) )
return false;
char szBuf[ k64KB ];
V_FileBase( sVProjectDir.String(), szBuf, ARRAYSIZE( szBuf ) );
sVMod = szBuf;
return true;
}
//-----------------------------------------------------------------------------
// Guess where the SourceSDK root is based on executable directory...
// If there's a /bin/orangebox/bin/ in the executable path we know
// the SourceSDK is above it, otherwise we don't know anything and false is
// returned
//
// If DevMode (-dev) then always returns false
//
// TODO: This is for TF & SourceSDK only and likely this is the only
// weird configuration this hack needs to be done with. If it's
// a normal game/content tree then none of this hacky stuff
// should be needed
//-----------------------------------------------------------------------------
bool CItemUpload::GetSourceSDKFromExe( CUtlString &sSourceSDK, CUtlString &sSourceSDKBin )
{
if ( GetDevMode() )
return false;
CUtlString sCurrentExecutableFileName;
GetCurrentExecutableFileName( sCurrentExecutableFileName );
// Special hack for executables running out of the orange box SDK
sCurrentExecutableFileName.FixSlashes( '/' );
const char *pszBinOrangeBoxBin = V_strstr( sCurrentExecutableFileName.String(), "/bin/orangebox/bin/" );
if ( pszBinOrangeBoxBin )
{
sSourceSDK.SetDirect( sCurrentExecutableFileName.String(), pszBinOrangeBoxBin - sCurrentExecutableFileName.String() );
char szBinDir[ MAX_PATH ];
V_ExtractFilePath( sCurrentExecutableFileName.String(), szBinDir, ARRAYSIZE( szBinDir ) );
sSourceSDKBin = szBinDir;
return true;
}
// Get Source SDK path
HKEY hKey;
char szSDKPath[ k64KB ];
char szEngineVersion[ k64KB ];
szSDKPath[0] = szEngineVersion[0] = '\0';
GetEnvironmentVariable( "SOURCESDK", szSDKPath, sizeof( szSDKPath ) );
if ( ERROR_SUCCESS == RegOpenKey( HKEY_CURRENT_USER, "Software\\Valve\\Source SDK", &hKey ) )
{
DWORD dwSize = sizeof( szEngineVersion );
RegQueryValueEx( hKey, "EngineVer", NULL, NULL, (LPBYTE)szEngineVersion, &dwSize );
RegCloseKey( hKey );
}
else
{
// Let's assume orange box for now
V_strcpy_safe( szEngineVersion, "orangebox" );
}
if ( *szSDKPath )
{
// Normalize slashes to be consistent with the orange box SDK code above
V_FixSlashes( szSDKPath, '/' );
sSourceSDK = szSDKPath;
sSourceSDKBin.Format( "%s/bin/%s/bin", szSDKPath, szEngineVersion );
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Returns $SOURCESDK_content/FileName( $VPROJECT ) if it SOURCESDK is set
// otherwise returns VCONTENT if it is set, otherwise returns
// $VPROJECT/../
//-----------------------------------------------------------------------------
static bool CheckContentPath( CUtlString &sContentDir )
{
char szContentDir[ MAX_PATH ];
V_FixupPathName( szContentDir, ARRAYSIZE( szContentDir ), sContentDir );
V_StripTrailingSlash( szContentDir );
sContentDir = szContentDir;
return g_pFullFileSystem->IsDirectory( sContentDir );
}
bool CItemUpload::GetContentDir( CUtlString &sContentDir )
{
// Without VPROJECT set, can't figure anything out
CUtlString sVMod;
if ( !GetVMod( sVMod ) )
return false;
char szBuf[ k64KB ];
// The game includes its own content directory?
if ( IgnoreEnvironmentVariables() )
{
CUtlString sVProject;
if ( !GetVProjectDir( sVProject ) )
return false;
sVProject.FixSlashes( '/' );
// When we run in Steam, we get something like this back:
// "u:/steambeta/steamapps/common/[staging] dota 2/dota"
// We need to trim off the game name, and append content.
V_strcpy_safe( szBuf, sVProject );
if ( !V_StripLastDir( szBuf, ARRAYSIZE( szBuf ) ) )
return false;
sContentDir = szBuf;
sContentDir += "content/";
sContentDir += sVMod;
return true;
}
CUtlString sSourceSDK, sSourceSDKBin;
// Check for the game/content layout in dev builds
CUtlString sVProject;
if ( GetVProjectDir( sVProject ) )
{
sVProject.FixSlashes( '/' );
const char *pszGame = V_stristr( sVProject.String(), "/game/" );
if ( pszGame )
{
sContentDir = sVProject;
sContentDir.SetLength( pszGame - sVProject.String() );
sContentDir += "/content/";
sContentDir += sVMod;
V_FixupPathName( szBuf, ARRAYSIZE( szBuf ), sContentDir.String() );
sContentDir = szBuf;
if ( CheckContentPath( sContentDir ) )
{
return true;
}
}
else
{
// try to look for workshop/content in the mod dir
sContentDir = sVProject;
sContentDir += "/workshop/content";
V_FixupPathName( szBuf, ARRAYSIZE( szBuf ), sContentDir.String() );
sContentDir = szBuf;
if ( CheckContentPath( sContentDir ) )
{
return true;
}
}
}
// Check for the VCONTENT environment variable
if ( GetEnvironmentVariable( "VCONTENT", szBuf, ARRAYSIZE( szBuf ) ) != 0 )
{
sContentDir = szBuf;
sContentDir += "/";
sContentDir += sVMod;
V_FixupPathName( szBuf, ARRAYSIZE( szBuf ), sContentDir.String() );
sContentDir = szBuf;
if ( CheckContentPath( sContentDir ) )
{
return true;
}
}
// Check for the Source SDK in steam builds
if ( GetSourceSDKFromExe( sSourceSDK, sSourceSDKBin ) )
{
sContentDir = sSourceSDK;
sContentDir += "_content\\";
sContentDir += sVMod;
V_FixupPathName( szBuf, ARRAYSIZE( szBuf ), sContentDir.String() );
sContentDir = szBuf;
if ( CheckContentPath( sContentDir ) )
{
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
//
// Find the directory for the binaries
//
//-----------------------------------------------------------------------------
static bool CheckToolPath( CUtlString &sBinDir )
{
char szBinDir[ MAX_PATH ];
V_FixupPathName( szBinDir, ARRAYSIZE( szBinDir ), sBinDir );
V_StripTrailingSlash( szBinDir );
sBinDir = szBinDir;
char szVtexFileName[ MAX_PATH ];
V_ComposeFileName( sBinDir, "vtex.exe", szVtexFileName, ARRAYSIZE( szVtexFileName ) );
char szStudiomdlFileName[ MAX_PATH ];
V_ComposeFileName( sBinDir, "studiomdl.exe", szStudiomdlFileName, ARRAYSIZE( szStudiomdlFileName ) );
return g_pFullFileSystem->FileExists( szVtexFileName ) && g_pFullFileSystem->FileExists( szStudiomdlFileName );
}
bool CItemUpload::GetBinDirectory( CUtlString &sBinDir )
{
// Get the full path to the executable this code is running in
// this should be the 'bin' directory we want... just to be sure
// make sure vtex.exe and studiomdl.exe exist in that directory
CUtlString sCurrentExecutableFileName;
GetCurrentExecutableFileName( sCurrentExecutableFileName );
char szBinDir[ MAX_PATH ];
V_ExtractFilePath( sCurrentExecutableFileName.String(), szBinDir, ARRAYSIZE( szBinDir ) );
sBinDir = szBinDir;
if ( CheckToolPath( sBinDir ) )
{
return true;
}
// Check for the game/bin directory
CUtlString sVProject;
if ( GetVProjectDir( sVProject ) && !sVProject.IsEmpty() )
{
sVProject.FixSlashes( '/' );
const char *pszGame = V_stristr( sVProject.String(), "/game/" );
if ( pszGame )
{
sBinDir = sVProject;
sBinDir.SetLength( pszGame - sVProject.String() );
sBinDir += "/game/bin";
if ( CheckToolPath( sBinDir ) )
{
return true;
}
}
// When we run in Steam, we get something like this back:
// "u:/steambeta/steamapps/common/[staging] dota 2/dota"
// We need to trim off the game name, and append bin.
V_strcpy_safe( szBinDir, sVProject );
if ( !V_StripLastDir( szBinDir, ARRAYSIZE( szBinDir ) ) )
return false;
sBinDir = szBinDir;
sBinDir += "/bin";
if ( CheckToolPath( sBinDir ) )
{
return true;
}
}
// Check for the Source SDK in steam builds
CUtlString sSourceSDK;
if ( !GetDevMode() && GetSourceSDKFromExe( sSourceSDK, sBinDir ) )
{
if ( CheckToolPath( sBinDir ) )
{
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CItemUpload::FileExists( const char *pszFilename )
{
DWORD attribs = ::GetFileAttributesA( pszFilename );
if ( attribs == INVALID_FILE_ATTRIBUTES )
return false;
return ( ( attribs & FILE_ATTRIBUTE_DIRECTORY ) == 0 );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CItemUpload::CopyFiles( const char *pszSourceDir, const char *pszPattern, const char *pszDestDir )
{
char szFindPattern[ k64KB ];
bool bAllSucceeded = true;
V_snprintf( szFindPattern, sizeof( szFindPattern ), "%s%s", pszSourceDir, pszPattern );
WIN32_FIND_DATA findData;
HANDLE hFind = FindFirstFile( szFindPattern, &findData );
if ( hFind == INVALID_HANDLE_VALUE )
{
return false;
}
else
{
do
{
char szSrcPath[ k64KB ];
char szDestPath[ k64KB ];
V_snprintf( szSrcPath, sizeof( szSrcPath ), "%s%s", pszSourceDir, findData.cFileName );
V_snprintf( szDestPath, sizeof( szDestPath ), "%s\\%s", pszDestDir, findData.cFileName );
DeleteFile( szDestPath );
::CopyFile( szSrcPath, szDestPath, false );
bAllSucceeded &= FileExists( szDestPath );
} while ( FindNextFile( hFind, &findData ) );
FindClose( hFind );
return bAllSucceeded;
}
}
static bool DoFileCopy( const char *pszSourceFile, const char *pszDestFile )
{
int remaining, count;
char buf[4096];
FileHandle_t in, out;
in = g_pFullFileSystem->Open( pszSourceFile, "rb" );
AssertMsg( in, "DoFileCopy: Input file failed to open" );
if ( in == FILESYSTEM_INVALID_HANDLE )
return false;
// create directories up to the cache file
char szDestPath[MAX_PATH];
V_ExtractFilePath( pszDestFile, szDestPath, sizeof( szDestPath ) );
g_pFullFileSystem->CreateDirHierarchy( szDestPath );
out = g_pFullFileSystem->Open( pszDestFile, "wb" );
AssertMsg( out, "DoFileCopy: Output file failed to open" );
if ( out == FILESYSTEM_INVALID_HANDLE )
{
g_pFullFileSystem->Close( in );
return false;
}
remaining = g_pFullFileSystem->Size( in );
while ( remaining > 0 )
{
if (remaining < sizeof(buf))
{
count = remaining;
}
else
{
count = sizeof(buf);
}
g_pFullFileSystem->Read( buf, count, in );
g_pFullFileSystem->Write( buf, count, out );
remaining -= count;
}
g_pFullFileSystem->Close( in );
g_pFullFileSystem->Close( out );
return true;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CItemUpload::CopyFile( const char *pszSourceFile, const char *pszDestFile )
{
if ( ::CopyFile( pszSourceFile, pszDestFile, false ) == 0 )
return false;
DWORD nFileAttr = GetFileAttributes( pszDestFile );
if ( nFileAttr == INVALID_FILE_ATTRIBUTES )
return false;
nFileAttr &= ~FILE_ATTRIBUTE_READONLY;
SetFileAttributes( pszDestFile, nFileAttr );
return true;
}
//=============================================================================
//
//=============================================================================
static bool RemoveTextBlock( const char *str, char const *search, char *pszOutBuf, int nSizeofOutBuf )
{
if ( str != pszOutBuf )
{
V_strncpy( pszOutBuf, str, nSizeofOutBuf );
}
bool changed = false;
if ( !V_strstr( str, search ) )
{
return false;
}
int offset = 0;
while ( true )
{
char* pos = V_strstr( str + offset, search );
if ( !pos )
{
break;
}
CUtlString temp = str;
// Found an instance
int left = pos - str;
CUtlString strLeft = temp.Slice( 0, left );
pos = V_strstr( str + left, "}" );
if ( !pos )
{
AssertMsg( pos, "cannot find end of text block\n" );
return false;
}
int right = pos - str + 1;
CUtlString strRight = temp.Slice( right );
temp = strLeft;
temp += strRight;
// Replace entire string
V_strncpy( pszOutBuf, temp.String(), nSizeofOutBuf );
offset = right;
changed = true;
}
return changed;
}
//=============================================================================
//
//=============================================================================
CTargetBase::CTargetBase( CAsset *pAsset, const CTargetBase *pTargetParent )
: CItemLog( pAsset )
, m_pAsset( pAsset )
, m_nRefCount( 0 )
, m_pTargetParent( pTargetParent )
, m_bIgnoreP4( false )
, m_kvCustomKeys( new KeyValues( "custom keys" ) )
{
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetBase::Compile()
{
CUtlString sName;
if ( !GetOutputPath( sName, 0, PATH_FLAG_FILE | PATH_FLAG_EXTENSION ) )
{
Warning( "CTarget%s::Compile - GetOutputPath failed\n", GetTypeString() );
return false;
}
CUtlString sTmp;
if ( !IsOk( sTmp ) )
{
Warning( "CTarget%s::Compile( %s ) - Not Valid: %s\n", GetTypeString(), sName.String(), sTmp.String() );
return false;
}
// Compile all inputs first
if ( !CreateOutputDirectory() )
{
Warning( "CTarget%s::Compile - CreateOutputDirectory failed\n", GetTypeString() );
return false;
}
CUtlVector< CTargetBase * > inputs;
bool bRet = GetInputs( inputs );
if ( !bRet )
{
Warning( "CTarget%s::Compile - GetInputs failed\n", GetTypeString() );
return bRet;
}
for ( int i = 0; i < inputs.Count(); ++i )
{
CTargetBase *pTargetBase = inputs.Element( i );
if ( !pTargetBase )
{
Warning( "WARNING: CTarget%s::Compile - Target %d NULL\n", GetTypeString(), i );
continue;
}
if ( !pTargetBase->Compile() )
{
Warning( "WARNING: CTarget%s::Compile - Target %d Compile Failed\n", GetTypeString(), i );
bRet = false;
break;
}
}
return bRet;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
const char *CTargetBase::GetItemDirectory() const
{
if ( m_pTargetParent )
{
return m_pTargetParent->GetItemDirectory();
}
else
{
return CItemUpload::Manifest()->GetItemDirectory();
}
}
//-----------------------------------------------------------------------------
// Return the number of files that are output from this CTarget
//-----------------------------------------------------------------------------
int CTargetBase::GetOutputCount() const
{
const ExtensionList *pList = GetExtensionsAndCount();
return (pList ? pList->Count() : 0);
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetBase::GetOutputPath(
CUtlString &sOutputPath,
int nIndex /* = 0 */,
uint nPathFlags /* = PATH_FLAG_ALL */ ) const
{
sOutputPath.Clear();
if ( nIndex < 0 )
return false;
CUtlVector< CUtlString > sOutputPaths;
if ( !GetOutputPaths( sOutputPaths, nPathFlags ) )
return false;
if ( nIndex >= sOutputPaths.Count() )
return false;
sOutputPath = sOutputPaths.Element( nIndex );
return ( sOutputPath.Length() > 0 );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetBase::GetOutputPaths(
CUtlVector< CUtlString > &sOutputPaths,
uint nPathFlags /* = PATH_FLAG_ALL */,
bool bRecurse /* = false */ ) const
{
CUtlString sTmp;
if ( !IsOk( sTmp ) )
{
Warning( FUNCTION_LINE_STRING "Error! CTarget%s - Not Valid: %s\n", GetTypeString(), sTmp.String() );
return false;
}
CUtlString sDirName;
if ( nPathFlags & PATH_FLAG_PATH )
{
if ( !GetDirName( sDirName, nPathFlags ) )
return false;
}
const ExtensionList *pvecExtensions = GetExtensionsAndCount();
int nExtCount = pvecExtensions ? pvecExtensions->Count() : 0;
for ( int i = 0; i < nExtCount; ++i )
{
CUtlString &sOutputPath = sOutputPaths.Element( sOutputPaths.AddToTail() );
if ( nPathFlags & PATH_FLAG_PATH )
{
sOutputPath = sDirName;
}
if ( nPathFlags & PATH_FLAG_FILE )
{
if ( sOutputPath.Length() > 0 )
{
sOutputPath += "/";
}
CUtlString sName;
GetName( sName );
sOutputPath += sName;
if ( nPathFlags & PATH_FLAG_EXTENSION )
{
sOutputPath += pvecExtensions->Element(i);
}
}
sOutputPath.FixSlashes();
}
bool bRet = sOutputPaths.Count() > 0;
if ( bRecurse )
{
CUtlVector< CTargetBase * > inputs;
if ( GetInputs( inputs ) )
{
for ( int i = 0; i < inputs.Count(); ++i )
{
CTargetBase *pTargetBase = inputs.Element( i );
if ( !pTargetBase )
continue;
bRet = pTargetBase->GetOutputPaths( sOutputPaths, nPathFlags, bRecurse );
}
}
else
{
bRet = false;
}
}
return bRet;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetBase::GetOutputPaths(
CUtlVector< CUtlString > &sOutputPaths,
bool bRelative /* = true */,
bool bRecurse /* = true */,
bool bExtension /* = true */,
bool bPrefix /* = true */ ) const
{
CUtlString sTmp;
if ( !IsOk( sTmp ) )
{
Warning( FUNCTION_LINE_STRING "Error! CTarget%s - Not Valid: %s\n", GetTypeString(), sTmp.String() );
return false;
}
CUtlString sDirA;
if ( bRelative )
{
if ( !Asset()->GetRelativeDir( sDirA, bPrefix ? GetPrefix() : NULL, this ) )
return false;
}
else
{
if ( !Asset()->GetAbsoluteDir( sDirA, bPrefix ? GetPrefix() : NULL, this ) )
return false;
}
const ExtensionList *pvecExtensions = GetExtensionsAndCount();
int nExtCount = pvecExtensions ? pvecExtensions->Count() : 0;
for ( int i = 0; i < nExtCount; ++i )
{
CUtlString &sRelativePath = sOutputPaths.Element( sOutputPaths.AddToTail() );
CUtlString sName;
GetName( sName );
sRelativePath = sDirA;
sRelativePath += "/";
sRelativePath += sName;
if ( bExtension )
{
sRelativePath += pvecExtensions->Element(i);
}
sRelativePath.FixSlashes();
}
bool bRet = sOutputPaths.Count() > 0;
if ( bRecurse )
{
CUtlVector< CTargetBase * > inputs;
if ( GetInputs( inputs ) )
{
for ( int i = 0; i < inputs.Count(); ++i )
{
CTargetBase *pTargetBase = inputs.Element( i );
if ( !pTargetBase )
continue;
bRet = pTargetBase->GetOutputPaths( sOutputPaths, bRelative, bRecurse, bExtension ) && bRet;
}
}
else
{
bRet = false;
}
}
return bRet;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetBase::GetInputPaths(
CUtlVector< CUtlString > &sInputPaths,
bool bRelative /* = true */,
bool bRecurse /* = true */,
bool bExtension /* = true */ )
{
CUtlString sTmp;
if ( !IsOk( sTmp ) )
{
Warning( FUNCTION_LINE_STRING "Error! CTarget%s - Not Valid: %s\n", GetTypeString(), sTmp.String() );
return false;
}
CUtlVector< CTargetBase * > inputs;
if ( !GetInputs( inputs ) )
return false;
bool bRet = true;
for ( int i = 0; bRet && i < inputs.Count(); ++i )
{
CTargetBase *pTargetBase = inputs.Element( i );
if ( !pTargetBase )
continue;
bRet = pTargetBase->GetOutputPaths( sInputPaths, bRelative, false, bExtension ) && bRet;
if ( bRecurse )
{
bRet = pTargetBase->GetInputPaths( sInputPaths, bRelative, bRecurse, bExtension ) && bRet;
}
}
return bRet;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CTargetBase::GetName( CUtlString &sName ) const
{
if ( !GetCustomOutputName().IsEmpty() )
{
sName = GetCustomOutputName();
sName += GetNameSuffix();
return;
}
// don't take parent's custom output name
if ( m_pTargetParent && m_pTargetParent->GetCustomOutputName().IsEmpty() )
{
m_pTargetParent->GetName( sName );
}
else
{
sName = GetAssetName();
}
sName += GetNameSuffix();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
const CUtlString &CTargetBase::GetAssetName() const
{
return Asset()->GetAssetName();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CAsset *CTargetBase::Asset() const
{
return m_pAsset;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetBase::CheckFile( const char *pszFilename ) const
{
if ( _access( pszFilename, 06 ) == 0 )
return true;
Warning( "CTarget%s::Compile NO FILE! - %s\n", GetTypeString(), pszFilename );
return false;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetBase::GetDirName(
CUtlString &sDirName,
uint nPathFlags /* = PATH_FLAG_ALL */ ) const
{
sDirName.Clear();
CAsset *pAsset = Asset();
if ( !pAsset )
{
Warning( FUNCTION_LINE_STRING "Error! CTarget%s - NULL Asset\n", GetTypeString() );
return false;
}
CUtlString sTmp;
if ( !pAsset->IsOk( sTmp ) )
{
Warning( FUNCTION_LINE_STRING "Error! CTarget%s - Not Valid: %s\n", GetTypeString(), sTmp.String() );
return false;
}
if ( nPathFlags & PATH_FLAG_ABSOLUTE )
{
if ( IsContent() )
{
if ( !CItemUpload::GetContentDir( sDirName ) )
return false;
}
else
{
if ( !CItemUpload::GetVProjectDir( sDirName ) )
return false;
}
sDirName += "/";
// ABSOLUTE implies PREFIX & MODELS
nPathFlags |= PATH_FLAG_PREFIX;
nPathFlags |= PATH_FLAG_MODELS;
}
if ( nPathFlags & PATH_FLAG_ZIP )
{
const char *pszZipPrefix;
if ( IsContent() )
{
pszZipPrefix = CItemUpload::Manifest()->GetZipSourceDirectory();
}
else
{
pszZipPrefix = CItemUpload::Manifest()->GetZipOutputDirectory();
}
if ( *pszZipPrefix )
{
sDirName += pszZipPrefix;
sDirName += "/";
}
}
if ( ( nPathFlags & PATH_FLAG_PREFIX ) && ( nPathFlags & PATH_FLAG_MODELS ) )
{
const char *pszPrefix = GetPrefix();
if ( pszPrefix )
{
sDirName += pszPrefix;
sDirName += "/";
}
// PREFIX implies MODELS
nPathFlags |= PATH_FLAG_MODELS;
}
if ( nPathFlags & PATH_FLAG_MODELS && IsModelPath() )
{
// If not starting with prefix, then optionally start with models
sDirName += "models/";
}
if ( GetCustomRelativeDir() )
{
sDirName += GetCustomRelativeDir();
}
else
{
sDirName += GetItemDirectory();
sDirName += pAsset->GetClass();
sDirName += "/";
if ( CItemUpload::Manifest()->GetItemPathUsesSteamId() )
{
const char *pszSteamId = pAsset->GetSteamId();
if ( pszSteamId )
{
sDirName += pszSteamId;
sDirName += "/";
}
}
sDirName += pAsset->GetAssetName();
}
char szBuf[ k64KB ];
V_FixupPathName( szBuf, ARRAYSIZE( szBuf ), sDirName.String() );
sDirName = szBuf;
return true;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetBase::CreateOutputDirectory() const
{
CUtlString sDir;
if ( !GetOutputPath( sDir, 0, PATH_FLAG_PATH | PATH_FLAG_ABSOLUTE ) )
return false;
if ( !CItemUpload::CreateDirectory( sDir.String() ) )
{
Warning( "CTarget%s::CreateDirectory( %s ) - Failed\n", GetTypeString(), sDir.String() );
return false;
}
return true;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CTargetBase::AddOrEditP4File( const char *pszFilePath )
{
if ( m_bIgnoreP4 )
return;
if ( CItemUpload::GetP4() )
{
char szCorrectCaseFilePath[MAX_PATH];
g_pFullFileSystem->GetCaseCorrectFullPath( pszFilePath, szCorrectCaseFilePath );
CP4AutoEditAddFile a( szCorrectCaseFilePath );
}
}
//=============================================================================
//
//=============================================================================
bool VTFGetInfo( const char *fileName, int *width, int *height, ImageFormat *imageFormat, float *sourceGamma )
{
// Just load the whole file into a memory buffer
CUtlBuffer bufFileContents;
if ( !g_pFullFileSystem->ReadFile( fileName, NULL, bufFileContents ) )
{
return false;
}
IVTFTexture *pVTFTexture = CreateVTFTexture();
if ( !pVTFTexture->Unserialize( bufFileContents, true ) )
{
return false;
}
*width = pVTFTexture->Width();
*height = pVTFTexture->Height();
// It's not actually RGBA, but it will be when we decompress and load it...
*imageFormat = IMAGE_FORMAT_RGBA8888;
*sourceGamma = 0.0f;
DestroyVTFTexture( pVTFTexture );
return true;
}
//=============================================================================
//
//=============================================================================
CTargetTGA::CTargetTGA( CAsset *pAsset, const CTargetVMT *pTargetVMT )
: CTargetBase( pAsset, pTargetVMT )
, m_pTargetVMT( pTargetVMT )
, m_nSrcImageType( IMAGE_FILE_UNKNOWN )
, m_nWidth( 0 )
, m_nHeight( 0 )
, m_nChannelCount( 0 )
, m_bNoNiceFiltering( false )
, m_bAlpha( false )
, m_bPowerOfTwo( false )
{
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CTargetTGA::~CTargetTGA()
{
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetTGA::IsOk( CUtlString &sMsg ) const
{
// No input file specified
if ( m_sInputFile.Length() <= 0 )
{
sMsg = "No input file specified";
return false;
}
// Input file invalid size
if ( m_nWidth <= 0 )
{
sMsg = "Invalid image width (";
sMsg += m_nWidth;
sMsg += ")";
return false;
}
if ( m_nHeight <= 0 )
{
sMsg = "Invalid image height (";
sMsg += m_nHeight;
sMsg += ")";
return false;
}
// TODO: Maximum size?
// Only 3 or 4 channel images ok
if ( m_nChannelCount != 3 && m_nChannelCount != 4 )
{
sMsg = "Invalid number of channels (";
sMsg += m_nChannelCount;
sMsg = ") only 3 (RGB) and 4 (RGBA) channel images allowed";
return false;
}
// Has to be a power of two
if ( !m_bPowerOfTwo )
{
sMsg = "Image dimensions are not a power of two";
return false;
}
return true;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetTGA::IsModelPath() const
{
return m_pTargetVMT->IsModelPath();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetTGA::GetInputPaths(
CUtlVector< CUtlString > &sInputPaths,
bool bRelative /* = true */,
bool bRecurse /* = true */,
bool bExtension /* = true */ )
{
sInputPaths.AddToTail( m_sInputFile );
return CTargetBase::GetInputPaths( sInputPaths, bRelative, bRecurse, bExtension );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
const ExtensionList *CTargetTGA::GetExtensionsAndCount( void ) const
{
static ExtensionList vecExtensions;
if ( !vecExtensions.Count() )
{
vecExtensions.AddToTail( ".tga" );
vecExtensions.AddToTail( ".txt" );
}
return &vecExtensions;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
const char *CTargetTGA::GetPrefix() const
{
if ( m_sPrefix.IsEmpty() ) {
CUtlString strParentPrefix = m_pTargetVMT->GetPrefix();
m_sPrefix = strParentPrefix.Replace( "materials", "materialsrc" );
}
return m_sPrefix.String();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CTargetTGA::GetName( CUtlString &sName ) const
{
if ( GetCustomOutputName().IsEmpty() )
{
CTargetBase::GetName( sName );
}
else
{
sName = GetCustomOutputName();
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetTGA::Compile()
{
// 'reset' the input file from the current value to force a reload on compile, make a temp copy as it's going to be overwritten
if ( !SetInputFile( CUtlString( GetInputFile() ).String() ) )
return false;
if ( !CTargetBase::Compile() )
return false;
CUtlString sName;
if ( !GetOutputPath( sName, 0, PATH_FLAG_FILE | PATH_FLAG_EXTENSION ) )
{
Warning( "CTarget%s::Compile - GetOutputPath Failed\n", GetTypeString() );
return false;
}
CUtlString sTmp;
if ( !IsOk( sTmp ) )
{
Warning( "CTarget%s::Compile( %s ) - Not Valid: %s\n", GetTypeString(), sName.String(), sTmp.String() );
return false;
}
CUtlString sAbsPath;
GetOutputPath( sAbsPath, 0 );
CUtlString sRelPath;
GetOutputPath( sRelPath, 0, PATH_FLAG_ALL & ~PATH_FLAG_ABSOLUTE );
if ( sAbsPath.IsEmpty() || sRelPath.IsEmpty() )
{
Warning( "CTarget%s::Compile( %s ) - GetOutputPath failed\n", GetTypeString(), sName.String() );
return false;
}
Msg( "Compiling %s: %s\n", GetTypeString(), sRelPath.String() );
if ( CItemUpload::IsSameFile( m_sInputFile.String(), sAbsPath.String() ) )
{
Warning( "CTarget%s::Compile( %s ) - Same File, No Work To Do!\n", GetTypeString(), sName.String() );
return true;
}
Bitmap_t bitmap;
CUtlMemory< unsigned char > tgaBits;
switch ( m_nSrcImageType )
{
case IMAGE_FILE_TGA:
{
int nWidth = 0, nHeight = 0;
if ( !TGALoader::LoadRGBA8888( m_sInputFile.String(), tgaBits, nWidth, nHeight ) )
{
Warning( "CTarget%s::Compile( %s ) - Couldn't Load TGA\n", GetTypeString(), sName.String() );
return false;
}
bitmap.SetBuffer( nWidth, nHeight, IMAGE_FORMAT_RGBA8888, tgaBits.Base(), false, nWidth*4 );
}
break;
case IMAGE_FILE_PSD:
{
if ( !PSDReadFileRGBA8888( m_sInputFile.String(), NULL, bitmap ) )
{
Warning( "CTarget%s::Compile( %s ) - Couldn't Load PSD\n", GetTypeString(), sName.String() );
return false;
}
}
break;
case IMAGE_FILE_VTF:
{
// Just load the whole file into a memory buffer
CUtlBuffer bufFileContents;
if ( !g_pFullFileSystem->ReadFile( m_sInputFile.String(), NULL, bufFileContents ) )
{
Warning( "CTarget%s::Compile( %s ) - Couldn't Load VTF\n", GetTypeString(), sName.String() );
return false;
}
IVTFTexture *pVTFTexture = CreateVTFTexture();
if ( !pVTFTexture->Unserialize( bufFileContents ) )
{
Warning( "CTarget%s::Compile( %s ) - Couldn't Load VTF\n", GetTypeString(), sName.String() );
return false;
}
int nWidth = pVTFTexture->Width();
int nHeight = pVTFTexture->Height();
pVTFTexture->ConvertImageFormat( IMAGE_FORMAT_RGBA8888, false );
int nMemSize = ImageLoader::GetMemRequired( nWidth, nHeight, 1, IMAGE_FORMAT_RGBA8888, false );
tgaBits.EnsureCapacity( nMemSize );
Q_memcpy( tgaBits.Base(), pVTFTexture->ImageData(), nMemSize );
DestroyVTFTexture( pVTFTexture );
bitmap.SetBuffer( nWidth, nHeight, IMAGE_FORMAT_RGBA8888, tgaBits.Base(), false, nWidth*4 );
}
break;
}
if ( bitmap.Format() != IMAGE_FORMAT_RGBA8888 || bitmap.Width() != m_nWidth || bitmap.Height() != m_nHeight )
{
Warning( "CTarget%s::Compile( %s ) - Invalid Bitmap Size, Expected %d x %d x %d (%d)\n",
GetTypeString(), sName.String(), m_nWidth, m_nHeight, 4, m_nWidth * m_nHeight * 4 );
return false;
}
CUtlBuffer bufVTEXConfig( 0, 0, CUtlBuffer::TEXT_BUFFER );
// If we're supposed to resize these to another resolution, setup the VTEX config file to do so.
int nTargetWidth = m_pTargetVMT->GetTargetWidth();
int nTargetHeight = m_pTargetVMT->GetTargetHeight();
if ( nTargetWidth && nTargetHeight )
{
// We want to use "reduce", not "maxwidth" & "maxheight", so we throw away the higher resolution mips.
// Determine the right amount of reduction based on the texture's width & height (and fail if it's the wrong aspect ratio)
int nFactor = (m_nWidth / nTargetWidth);
if ( nFactor <= 0 )
{
Warning( "CTarget%s::Compile( %s ) - Failed to determine reduction factor (target width is %d, texture is %d)\n", GetTypeString(), sName.String(), nTargetWidth, m_nWidth );
return false;
}
int nHeightFactor = (m_nHeight / nTargetHeight);
if ( nFactor != nHeightFactor )
{
Warning( "CTarget%s::Compile( %s ) - Failed to determine reduction factor (target size aspect ratio (%dx%d) doesn't match texture's aspect ratio (%dx%d))\n", GetTypeString(), sName.String(), nTargetWidth, nTargetHeight, m_nWidth, m_nHeight );
return false;
}
if ( nFactor > 1 )
{
bufVTEXConfig.PutString( CFmtStr("reduce %d\n", nFactor) );
}
}
KeyValues *pKV = m_pTargetVMT->GetTextureAddToVTEXConfigForTGA( this );
if ( pKV )
{
FOR_EACH_SUBKEY( pKV, pKVEntry )
{
bufVTEXConfig.Printf( "%s %s\n", pKVEntry->GetName(), pKVEntry->GetString() );
}
}
// check if we should modify abspath
CUtlString sTGAOutput = Asset()->CheckRedundantOutputFilePath( GetInputFile().String(), bufVTEXConfig.String(), sAbsPath.String() );
AddOrEditP4File( sTGAOutput.String() );
char szVTEXConfigFilename[MAX_PATH];
V_strcpy_safe( szVTEXConfigFilename, sTGAOutput.String() );
V_SetExtension( szVTEXConfigFilename, ".txt", sizeof(szVTEXConfigFilename) );
AddOrEditP4File( szVTEXConfigFilename );
g_pFullFileSystem->WriteFile( szVTEXConfigFilename, NULL, bufVTEXConfig );
// TODO: Don't write alpha if VMT using this doesn't specify the alpha is used for anything
CUtlBuffer outBuf;
const bool bWriteTGA = TGAWriter::WriteToBuffer( bitmap.GetBits(), outBuf, bitmap.Width(), bitmap.Height(), bitmap.Format(), m_bAlpha ? IMAGE_FORMAT_BGRA8888 : IMAGE_FORMAT_BGR888 );
if ( !bWriteTGA )
{
Warning( "CTarget%s::Compile( %s ) - Couldn't write TGA to buffer\n", GetTypeString(), sName.String() );
return false;
}
if ( !g_pFullFileSystem->WriteFile( sTGAOutput.String(), NULL, outBuf ) )
{
Warning( "CTarget%s::Compile( %s ) - Couldn't write TGA to file \"%s\"\n", GetTypeString(), sName.String(), sTGAOutput.String() );
return false;
}
if ( !CheckFile( sTGAOutput.String() ) )
{
Warning( "CTarget%s::Compile( %s ) - File Check Failed - \"%s\"\n", GetTypeString(), sName.String(), sTGAOutput.String() );
return false;
}
if ( CItemUpload::Manifest()->UseTerseMessages() )
{
Msg( " - Compilation successful.\n" );
}
else
{
Msg( "CTarget%s::Compile OK! - %s\n", GetTypeString(), sRelPath.String() );
}
// store the output name to use it to output VTF file
char szFileName[FILENAME_MAX];
V_StripExtension( V_GetFileName( szVTEXConfigFilename ), szFileName, ARRAYSIZE( szFileName ) );
SetCustomOutputName( szFileName );
return true;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CTargetTGA::Clear()
{
m_sInputFile = "";
m_sFileBase = "";
m_sExtension = "";
m_nWidth = 0;
m_nHeight = 0;
m_nChannelCount = 0;
m_bNoNiceFiltering = false;
m_bAlpha = false;
m_bPowerOfTwo = false;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetTGA::SetInputFile( const char *pszFilename )
{
Clear();
if ( !pszFilename || V_strlen( pszFilename ) <= 0 )
{
Warning( "ERROR: Empty filename specified for TGA file\n" );
return false;
}
char szBuf[ k64KB ];
m_sInputFile = pszFilename;
V_FileBase( pszFilename, szBuf, ARRAYSIZE( szBuf ) );
m_sFileBase = szBuf;
// Try to automatically handle the suffixes for properly named assets
static const char *szSuffixes[] =
{
//"_color",
"_normal",
"_height",
"_specmask"
"_specexp",
"_trans",
"_illum",
"_color_red",
"_color_blue"
};
CUtlString sTmp;
for ( int i = 0; i < ARRAYSIZE( szSuffixes ); ++i )
{
const char *pszSuffix = szSuffixes[i];
sTmp = GetAssetName();
sTmp += pszSuffix;
if ( m_sFileBase == sTmp )
{
SetNameSuffix( pszSuffix );
}
}
V_ExtractFileExtension( pszFilename, szBuf, ARRAYSIZE( szBuf ) );
m_sExtension = szBuf;
ImageFormat imageFormat;
float flSourceGamma = 0;
if ( TGALoader::GetInfo( pszFilename, &m_nWidth, &m_nHeight, &imageFormat, &flSourceGamma ) )
{
m_nSrcImageType = IMAGE_FILE_TGA;
}
else if ( PSDGetInfo( pszFilename, NULL, &m_nWidth, &m_nHeight, &imageFormat, &flSourceGamma ) )
{
m_nSrcImageType = IMAGE_FILE_PSD;
}
else if ( VTFGetInfo( pszFilename, &m_nWidth, &m_nHeight, &imageFormat, &flSourceGamma ) )
{
m_nSrcImageType = IMAGE_FILE_VTF;
}
else
{
Warning( "ERROR: Specified file is not a TGA (Targa) or PSD File: \"%s\"\n", szBuf );
Clear();
return false;
}
// ImageFormat can only be one of:
switch ( imageFormat )
{
case IMAGE_FORMAT_I8:
m_nChannelCount = 1;
m_bAlpha = false;
break;
case IMAGE_FORMAT_ABGR8888:
case IMAGE_FORMAT_BGRA8888:
m_nChannelCount = 4;
m_bAlpha = true;
break;
case IMAGE_FORMAT_BGR888:
m_nChannelCount = 3;
m_bAlpha = false;
break;
case IMAGE_FORMAT_RGBA8888:
m_nChannelCount = 4;
m_bAlpha = true;
break;
case IMAGE_FORMAT_RGB888:
m_nChannelCount = 3;
m_bAlpha = false;
break;
default:
break;
}
const int nWidthPow = NearestPowerOfTwo( m_nWidth );
const int nHeightPow = NearestPowerOfTwo( m_nHeight );
if ( nWidthPow == m_nWidth && nHeightPow == m_nHeight )
{
m_bPowerOfTwo = true;
}
else
{
Warning( "ERROR: Specified texture file (%s) Size %dx%d dimensions not powers of two, perhaps resize to %dx%d\n",
m_sInputFile.String(),
m_nWidth, m_nHeight,
nWidthPow, nHeightPow );
return false;
}
return true;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
const CUtlString &CTargetTGA::GetInputFile() const
{
return m_sInputFile;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
template < class T >
T CTargetTGA::NearestPowerOfTwo( T v )
{
if (v == 0)
return static_cast< T >( 1 );
T k;
for ( k = sizeof( T ) * 8 - 1; ( ( static_cast< T >( 1U ) << k) & v ) == 0; --k);
if ( ( ( static_cast< T >( 1U ) << ( k - 1 ) ) & v ) == 0 )
return static_cast< T >( 1U ) << k;
return static_cast< T >( 1U ) << ( k + 1 );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CTargetTGA::UpdateManifest( KeyValues *pKv )
{
pKv->SetString( "filename", m_sInputFile.String() );
CUtlString sOutName;
if ( GetOutputPath( sOutName, 0, PATH_FLAG_PATH | PATH_FLAG_FILE | PATH_FLAG_PREFIX | PATH_FLAG_MODELS | PATH_FLAG_EXTENSION ) )
{
pKv->SetString( "out_filename", sOutName );
}
pKv->SetInt( "width", m_nWidth );
pKv->SetInt( "height", m_nHeight );
pKv->SetInt( "channels", m_nChannelCount );
pKv->SetInt( "nonice", m_bNoNiceFiltering );
pKv->SetBool( "alpha", m_bAlpha );
const char *pszTextureType = m_pTargetVMT->GetTextureTypeForTGA( this );
if ( pszTextureType )
{
KeyValues *pVTEXKV = CItemUpload::Manifest()->GetTextureAddToVTEXConfig( pszTextureType );
if ( pVTEXKV )
{
KeyValues *pTmpKey = new KeyValues( pVTEXKV->GetName() );
pKv->AddSubKey( pTmpKey );
pVTEXKV->CopySubkeys( pTmpKey );
}
}
}
//=============================================================================
//
//=============================================================================
CTargetVTF::CTargetVTF( CAsset *pAsset, const CTargetVMT *pTargetVMT )
: CTargetBase( pAsset, pTargetVMT )
, m_pTargetVMT( pTargetVMT )
{
m_pTargetTGA = Asset()->NewTarget< CTargetTGA >( m_pTargetVMT );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CTargetVTF::~CTargetVTF()
{
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetVTF::IsModelPath() const
{
return m_pTargetVMT->IsModelPath();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetVTF::Compile()
{
if ( !CTargetBase::Compile() )
return false;
CUtlString sName;
if ( !GetOutputPath( sName, 0, PATH_FLAG_FILE | PATH_FLAG_EXTENSION ) )
return false;
CUtlString sTmp;
if ( !IsOk( sTmp ) )
{
Warning( "CTarget%s::Compile( %s ) - Not Valid: %s\n", GetTypeString(), sName.String(), sTmp.String() );
return false;
}
CUtlString sBinDir;
if ( !CItemUpload::GetBinDirectory( sBinDir ) )
{
Warning( "CTarget%s::Compile( %s ) - GetBinDirectory Failed\n", GetTypeString(), sName.String() );
return false;
}
CUtlString sAbsPath;
GetOutputPath( sAbsPath, 0 );
CUtlString sRelPath;
GetOutputPath( sRelPath, 0, PATH_FLAG_ALL & ~PATH_FLAG_ABSOLUTE );
if ( sAbsPath.IsEmpty() || sRelPath.IsEmpty() )
{
Warning( "CTarget%s::Compile( %s ) - GetOutputPath failed\n", GetTypeString(), sName.String() );
return false;
}
Msg( "Compiling %s: %s\n", GetTypeString(), sRelPath.String() );
AddOrEditP4File( sAbsPath.String() );
CUtlVector< CUtlString > sAbsInputPaths;
if ( !GetInputPaths( sAbsInputPaths, false, false ) )
{
Warning( "CTarget%s::Compile( %s ) - GetInputPaths failed\n", GetTypeString(), sName.String() );
return false;
}
if ( sAbsInputPaths.Count() != 2 )
{
Warning( "CTarget%s::Compile( %s ) - GetPaths returned %d paths, expected 2\n", GetTypeString(), sName.String(), sAbsInputPaths.Count() );
return false;
}
CFmtStrN< k64KB > sCmd;
if ( CItemUpload::IgnoreEnvironmentVariables() )
{
// We can't rely on environment variables in VTEX. So tell it to just built it on the spot, and we'll move it afterwards.
sCmd.sprintf( "\"%s\\vtex.exe\" -nop4 -nopause -dontusegamedir \"%s\"", sBinDir.String(), sAbsInputPaths.Element( 0 ).String() );
}
else
{
CUtlString sVProject;
CItemUpload::GetVProjectDir( sVProject );
sCmd.sprintf( "\"%s\\vtex.exe\" -nop4 -nopause -vproject \"%s\" \"%s\"", sBinDir.String(), sVProject.String(), sAbsInputPaths.Element( 0 ).String() );
}
if ( !CItemUpload::RunCommandLine( sCmd.Access(), sBinDir.String(), this ) )
{
Warning( "CTarget%s::Compile( %s ) - RunCommandLine Failed - \"%s\"\n", GetTypeString(), sName.String(), sCmd.Access() );
return false;
}
if ( CItemUpload::IgnoreEnvironmentVariables() )
{
char sVTFName[MAX_PATH];
V_strcpy_safe( sVTFName, sAbsInputPaths.Element( 0 ).String() );
V_SetExtension( sVTFName, ".vtf", sizeof(sVTFName) );
// We built the VTF in the directory with the content. Now move it to the out dir.
if ( ::MoveFileEx( sVTFName, sAbsPath.String(), MOVEFILE_REPLACE_EXISTING ) == 0 )
{
Warning( "CTarget%s::Compile( %s ) - Failed to move \"%s\" to \"%s\"\n", GetTypeString(), sName.String(), sVTFName, sAbsPath.String() );
return false;
}
}
if ( !CheckFile( sAbsPath.String() ) )
{
Warning( "CTarget%s::Compile( %s ) - File Check Failed - \"%s\"\n", GetTypeString(), sName.String(), sAbsPath.String() );
return false;
}
if ( CItemUpload::Manifest()->UseTerseMessages() )
{
Msg( " - Compilation successful.\n" );
}
else
{
Msg( "CTarget%s::Compile OK! - %s\n", GetTypeString(), sRelPath.String() );
}
return true;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetVTF::GetInputs( CUtlVector< CTargetBase * > &inputs ) const
{
Assert( m_pTargetTGA.IsValid() );
inputs.AddToTail( m_pTargetTGA.GetObject() );
return inputs.Count() > 0;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
const ExtensionList *CTargetVTF::GetExtensionsAndCount( void ) const
{
static ExtensionList vecExtensions;
if ( !vecExtensions.Count() )
{
vecExtensions.AddToTail( ".vtf" );
}
return &vecExtensions;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
const char *CTargetVTF::GetPrefix() const
{
return m_pTargetVMT->GetPrefix();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CTargetVTF::GetName( CUtlString &sName ) const
{
Assert( m_pTargetTGA.IsValid() );
m_pTargetTGA->GetName( sName );
}
//=============================================================================
//
//=============================================================================
CTargetVMT::CTargetVMT( CAsset *pAsset, const CTargetBase *pTargetParent )
: CTargetBase( pAsset, pTargetParent )
, m_pVMTKV( NULL )
, m_nColorAlphaType( kNoColorAlpha )
, m_nNormalAlphaType( kNoNormalAlpha )
, m_nMaterialType( kInvalidMaterialType )
, m_bDuplicate( false )
, m_nTargetWidth( 0 )
, m_nTargetHeight( 0 )
{
m_vecTargetVTFs.SetCount( CItemUpload::Manifest()->GetNumMaterialSkins() );
FOR_EACH_VEC( m_vecTargetVTFs, i )
{
m_vecTargetVTFs[i].SetCount( CItemUpload::Manifest()->GetNumTextureTypes() );
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CTargetVMT::~CTargetVMT()
{
if ( m_pVMTKV )
{
m_pVMTKV->deleteThis();
}
CUtlString sMaterialId;
GetMaterialId( sMaterialId );
Asset()->RemoveMaterial( sMaterialId );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetVMT::Compile()
{
if ( GetDuplicate() )
return true;
if ( !CTargetBase::Compile() )
return g_bCompilePreview ? true : false;
CAsset *pAsset = Asset();
if ( !pAsset )
return false;
CUtlString sName;
if ( !GetOutputPath( sName, 0, PATH_FLAG_FILE | PATH_FLAG_EXTENSION ) )
return false;
CUtlString sTmp;
if ( !IsOk( sTmp ) )
{
Warning( "CTarget%s::Compile( %s ) - Not Valid: %s\n", GetTypeString(), sName.String(), sTmp.String() );
return false;
}
int nVmtCount = GetOutputCount();
CUtlVector< CUtlString > sAbsOutputPaths;
CUtlVector< CUtlString > sRelOutputPaths;
if ( !GetOutputPaths( sAbsOutputPaths, false, false, true ) || !GetOutputPaths( sRelOutputPaths, true, false, true ) )
{
Warning( "CTarget%s::Compile( %s ) - GetOutputPaths failed\n", GetTypeString(), sName.String() );
return false;
}
if ( sAbsOutputPaths.Count() != nVmtCount || sAbsOutputPaths.Count() != sRelOutputPaths.Count() )
{
Warning( "CTarget%s::Compile( %s ) - GetOutputPaths returned %d paths, expected %d\n", GetTypeString(), sName.String(), sAbsOutputPaths.Count(), 1 );
return false;
}
Assert( nVmtCount == sAbsOutputPaths.Count() );
Assert( nVmtCount == sRelOutputPaths.Count() );
char szBuf[ k64KB ];
for ( int i = 0; i < nVmtCount; ++i )
{
CUtlVector< CUtlString > sChildRelOutputPaths;
if ( !GetOutputPath( sName, i, PATH_FLAG_FILE | PATH_FLAG_EXTENSION ) )
{
Warning( "CTarget%s::Compile( %s ) - Can't GetOutputPath %d\n", GetTypeString(), sName.String(), i );
return false;
}
Msg( "Compiling %s: %s\n", GetTypeString(), sRelOutputPaths.Element( i ).String() );
AddOrEditP4File( sAbsOutputPaths.Element( i ).String() );
// Load the template in.
KeyValues *pVMTKV = GetVMTKV( i );
if ( !pVMTKV )
{
// We've already printed a warning, so we're done
return false;
}
// Set any remapped VMT vars.
FOR_EACH_VEC( m_vecTargetVTFs[i], iVTF )
{
if ( m_vecTargetVTFs[i][iVTF].IsValid() )
{
const char *pszVMTVar = CItemUpload::Manifest()->GetVMTVarForTextureType( CItemUpload::Manifest()->GetTextureType(iVTF) );
if ( pszVMTVar && pszVMTVar[0] )
{
sChildRelOutputPaths.RemoveAll();
m_vecTargetVTFs[i][iVTF]->GetOutputPaths( sChildRelOutputPaths, true, false, false, false );
if ( sChildRelOutputPaths.Count() > 0 )
{
V_strncpy( szBuf, sChildRelOutputPaths.Element( 0 ).String(), ARRAYSIZE( szBuf ) );
V_FixSlashes( szBuf, '/' );
if ( pVMTKV->FindKey( pszVMTVar ) )
{
pVMTKV->SetString( pszVMTVar, szBuf );
}
}
}
}
}
CUtlBuffer fileBuf( 0, 0, CUtlBuffer::TEXT_BUFFER );
pVMTKV->RecursiveSaveToFile( fileBuf, 0 );
g_pFullFileSystem->WriteFile( sAbsOutputPaths.Element( i ).String(), "MOD", fileBuf );
Msg( "CTarget%s::Compile OK! - %s\n", GetTypeString(), sRelOutputPaths.Element( i ).String() );
}
return true;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
const char *CTargetVMT::MaterialTypeToString( int nMaterialType )
{
if ( nMaterialType == kInvalidMaterialType )
return "InvalidMaterialType";
const char *pszMaterialName = CItemUpload::Manifest()->GetMaterialType( nMaterialType );
if ( pszMaterialName )
return pszMaterialName;
return "Unknown";
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
int CTargetVMT::StringToMaterialType( const char *pszUserData )
{
return CItemUpload::Manifest()->GetMaterialType( pszUserData );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetVMT::IsOk( CUtlString &sMsg ) const
{
if ( GetMaterialType() == kInvalidMaterialType )
{
sMsg += "\"";
sMsg += m_sMaterialId;
sMsg += "\": ";
sMsg += "Invalid material type, must be one of Primary or Secondary";
return false;
}
if ( GetDuplicate() )
return true;
if ( !g_bCompilePreview )
{
// Make sure we have all the required textures.
int nSkinIndex = CItemUpload::Manifest()->GetDefaultMaterialSkin();
FOR_EACH_VEC( m_vecTargetVTFs[ nSkinIndex ], i )
{
if ( !m_vecTargetVTFs[nSkinIndex][i].IsValid() && CItemUpload::Manifest()->IsTextureTypeRequired( i ) )
{
sMsg += "\"";
sMsg += m_sMaterialId;
sMsg += "\": ";
sMsg += "Missing required texture type";
Warning( "Missing texture of type '%s'\n", CItemUpload::Manifest()->GetTextureType( i ) );
return false;
}
}
}
return true;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
const ExtensionList *CTargetVMT::GetExtensionsAndCount( void ) const
{
if ( GetDuplicate() )
return NULL;
m_vecExtensions.SetCount( 0 );
FOR_EACH_VEC( m_vecTargetVTFs, i )
{
FOR_EACH_VEC( m_vecTargetVTFs[i], j )
{
if ( m_vecTargetVTFs[i][j].IsValid() )
{
CUtlString sExtension = CItemUpload::Manifest()->GetMaterialSkinFilenameAppend( i );
sExtension += ".vmt";
m_vecExtensions.AddToTail( sExtension );
break;
}
}
}
return &m_vecExtensions;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetVMT::GetInputs( CUtlVector< CTargetBase * > &inputs ) const
{
CUtlString sTmp;
if ( !IsOk( sTmp ) )
{
Warning( FUNCTION_LINE_STRING "Error! CTarget%s - Not Valid: %s\n", GetTypeString(), sTmp.String() );
return false;
}
FOR_EACH_VEC( m_vecTargetVTFs, i )
{
FOR_EACH_VEC( m_vecTargetVTFs[i], j )
{
if ( m_vecTargetVTFs[i][j].IsValid() )
{
inputs.AddToTail( m_vecTargetVTFs[i][j].GetObject() );
}
}
}
return inputs.Count() > 0;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CTargetVMT::GetName( CUtlString &sName ) const
{
sName.Clear();
if ( GetDuplicate() )
{
}
else
{
CTargetBase::GetName( sName );
if ( m_nMaterialType == kInvalidMaterialType )
{
sName += "_INVALID";
}
else
{
if ( m_nMaterialType > 0 )
{
sName += "_";
sName += m_nMaterialType;
}
}
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CTargetVMT::SetMaterialId( const char *pszMaterialId )
{
m_sMaterialId = pszMaterialId;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetVMT::SetMaterialType( int nMaterialType )
{
CAsset *pAsset = Asset();
if ( !pAsset )
return false;
if ( nMaterialType < 0 || nMaterialType >= CItemUpload::Manifest()->GetNumMaterialTypes() )
return false;
m_bDuplicate = false;
m_nMaterialType = kInvalidMaterialType;
if ( nMaterialType == kInvalidMaterialType )
return true;
// Recursively increment other non-duplicate materials which match this material
// and so on...
for ( int i = 0; i < pAsset->GetTargetVMTCount(); ++i )
{
CTargetVMT *pTargetVMT = pAsset->GetTargetVMT( i );
if ( !pTargetVMT )
continue;
if ( !pTargetVMT->GetDuplicate() && pTargetVMT->GetMaterialType() == nMaterialType )
{
pTargetVMT->SetMaterialType( ( ( nMaterialType + 1 ) % CItemUpload::Manifest()->GetNumMaterialTypes() ) );
}
}
m_nMaterialType = nMaterialType;
return true;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
int CTargetVMT::GetMaterialType() const
{
return m_nMaterialType;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CTargetVMT::SetDuplicate( int nMaterialType )
{
if ( nMaterialType < 0 || nMaterialType >= CItemUpload::Manifest()->GetNumMaterialTypes() )
return;
m_bDuplicate = true;
m_nMaterialType = nMaterialType;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetVMT::SetTargetVTF( const char *pszTextureType, const char *pszFilename, int nSkinIndex )
{
// Make sure it's a valid texture type
int nTextureType = CItemUpload::Manifest()->GetTextureType( pszTextureType );
if ( nTextureType == -1 )
{
Warning( "Invalid texture type specified: '%s'\n", pszTextureType );
return false;
}
if ( nSkinIndex == kInvalidMaterialSkin )
{
Warning( "Invalid skin type specified: '%d'\n", nSkinIndex );
return false;
}
CUtlString sSuffix;
sSuffix += CItemUpload::Manifest()->GetMaterialSkinFilenameAppend( nSkinIndex );
sSuffix += pszTextureType;
return SetTargetVTF( m_vecTargetVTFs[nSkinIndex][nTextureType], pszFilename, sSuffix.String() );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetVMT::SetTargetVTF(
CSmartPtr< CTargetVTF > &pTargetVTF,
const char *pszFilename,
const char *pszSuffix ) const
{
if ( !pTargetVTF )
{
pTargetVTF = Asset()->NewTarget< CTargetVTF >( this );
}
if ( !pTargetVTF )
return false;
pTargetVTF->SetNameSuffix( pszSuffix );
bool bResult = pTargetVTF->SetInputFile( pszFilename );
return bResult;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CTargetVMT::SetVMTKV( const KeyValues *pKV, int nSkinIndex /*= 0*/ )
{
if ( !m_pVMTKV )
{
m_pVMTKV = new KeyValues( "data" );
}
const char* pszKeyName = CFmtStr( kVMT, nSkinIndex );
if ( KeyValues *pPreviousKey = m_pVMTKV->FindKey( pszKeyName ) )
{
m_pVMTKV->RemoveSubKey( pPreviousKey );
}
KeyValues *pNewKey = new KeyValues( pszKeyName );
pNewKey->AddSubKey( pKV->MakeCopy() );
m_pVMTKV->AddSubKey( pNewKey );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
KeyValues *CTargetVMT::GetVMTKV( int nSkinIndex )
{
if ( !m_pVMTKV )
{
m_pVMTKV = new KeyValues( "data" );
}
const char* pszKeyName = CFmtStr( kVMT, nSkinIndex );
KeyValues* pKey = m_pVMTKV->FindKey( pszKeyName );
if ( pKey )
{
return pKey->GetFirstSubKey();
}
KeyValues *pVMTKV = new KeyValues("VMTTemplate");
if ( CItemUpload::Manifest()->HasClassVMTTemplates() )
{
const int nClassIndex = GetClassIndex( Asset()->GetClass() );
const char *pszVMTTemplate = CItemUpload::Manifest()->GetClassVMTTemplate( nClassIndex );
if ( !pszVMTTemplate )
{
Warning( "Could not find a VMT template for class '%s'\n", Asset()->GetClass() );
pVMTKV->deleteThis();
return NULL;
}
if ( !pVMTKV->LoadFromFile( g_pFullFileSystem, pszVMTTemplate, "MOD" ) )
{
Warning( "Failed to load specified VMT template '%s' for class '%s'.\n", pszVMTTemplate, Asset()->GetClass() );
pVMTKV->deleteThis();
return NULL;
}
}
else
{
CreateLegacyTemplate( pVMTKV );
}
KeyValues *pNewKey = new KeyValues( pszKeyName );
pNewKey->AddSubKey( pVMTKV );
m_pVMTKV->AddSubKey( pNewKey );
return pVMTKV;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CTargetVMT::CreateLegacyTemplate( KeyValues *pVMTKV )
{
pVMTKV->SetName( "VertexlitGeneric" );
for ( int iVTF = 0; iVTF < CItemUpload::Manifest()->GetNumTextureTypes(); ++iVTF )
{
const char *pszVMTVar = CItemUpload::Manifest()->GetVMTVarForTextureType( CItemUpload::Manifest()->GetTextureType( iVTF ) );
if ( pszVMTVar && *pszVMTVar )
{
pVMTKV->SetString( pszVMTVar, "" );
}
}
// Wearables usually use this lightwarp: "models/player/pyro/pyro_lightwarp"
// Weapons usually use this lightwarp: "models/lightwarps/weapon_lightwarp"
// Weapons are the more custom case, so we'll default to a good wearable lightwarp
pVMTKV->SetString( "$lightwarptexture", "models/player/pyro/pyro_lightwarp" );
pVMTKV->SetString( "$phong", "1" );
pVMTKV->SetString( "$phongexponent", "25" );
pVMTKV->SetString( "$phongboost", "0.1" );
pVMTKV->SetString( "$phongfresnelranges", "[.25 .5 1]" );
pVMTKV->SetString( "$rimlight", "1" ); // To enable rim lighting (requires phong)
pVMTKV->SetString( "$rimlightexponent", "4" ); // Exponent for phong component of rim
pVMTKV->SetString( "$rimlightboost", "2" ); // Boost for ambient cube component of rim lighting
switch ( m_nColorAlphaType )
{
case kNoColorAlpha:
break;
case kTransparency:
pVMTKV->SetString( "$translucent", "1" );
break;
case kPaintable:
pVMTKV->SetString( "$blendtintbybasealpha", "1" );
pVMTKV->SetString( "$blendtintcoloroverbase", "0" ); // between 0-1 determines how much blended by tinting vs. replacing the color
pVMTKV->SetString( "$colortint_base", "{ 255 255 255 }" ); // put the RGB value of whats being colored when no paint is present, if $blendtintcoloroverbase is 0 then put [255 255 255] here.
pVMTKV->SetString( "$color2", "{ 255 255 255 }" );
pVMTKV->SetString( "$colortint_tmp", "[0 0 0]" );
break;
case kColorSpecPhong:
pVMTKV->SetString( "$basemapalphaphongmask", "1" );
break;
}
switch ( m_nNormalAlphaType )
{
case kNoNormalAlpha:
break;
case kNormalSpecPhong:
pVMTKV->SetString( "$bumpmapalphaphongmask", "1" );
break;
}
// Variables for the cloak effect
pVMTKV->SetString( "$cloakPassEnabled", "1" );
// Variables for the burning effect
pVMTKV->SetString( "$detail", "effects/tiledfire/fireLayeredSlowTiled512" );
pVMTKV->SetString( "$detailscale", "5" );
pVMTKV->SetString( "$detailblendfactor", "0" );
pVMTKV->SetString( "$detailblendmode", "6" );
// Variables for the jarate effect
pVMTKV->SetString( "$yellow", "0" );
// The order of the proxies is important!
KeyValues *pProxies = pVMTKV->FindKey( "Proxies", true );
// Proxies for the cloak effect
KeyValues *pProxiesWeaponInvis = pProxies->FindKey( "invis", true );
pProxiesWeaponInvis->FindKey( "temp_key_wont_print_dont_worry", true );
// Proxies for the burning effect
KeyValues *pProxiesAnimatedTexture = pProxies->FindKey( "AnimatedTexture", true );
pProxiesAnimatedTexture->SetString( "animatedtexturevar", "$detail" );
pProxiesAnimatedTexture->SetString( "animatedtextureframenumvar", "$detailframe" );
pProxiesAnimatedTexture->SetString( "animatedtextureframerate", "30" );
KeyValues *pProxiesBurnLevel = pProxies->FindKey( "BurnLevel", true );
pProxiesBurnLevel->SetString( "resultVar", "$detailblendfactor" );
// Proxies for paintable items
if ( m_nColorAlphaType == kPaintable )
{
KeyValues *pProxiesItemTintColor = pProxies->FindKey( "ItemTintColor", true );
pProxiesItemTintColor->SetString( "resultVar", "$colortint_tmp" );
KeyValues *pProxiesSelectFirstIfNonZero = pProxies->FindKey( "SelectFirstIfNonZero", true );
pProxiesSelectFirstIfNonZero->SetString( "srcVar1", "$colortint_tmp" );
pProxiesSelectFirstIfNonZero->SetString( "srcVar2", "$colortint_base" );
pProxiesSelectFirstIfNonZero->SetString( "resultVar", "$color2" );
// Proxies for the jarate effect
KeyValues *pProxiesYellowLevel = pProxies->FindKey( "YellowLevel", true );
pProxiesYellowLevel->SetString( "resultVar", "$yellow" );
KeyValues *pProxiesMultiply = pProxies->FindKey( "Multiply", true );
pProxiesMultiply->SetString( "srcVar1", "$color2" );
pProxiesMultiply->SetString( "srcVar2", "$yellow" );
pProxiesMultiply->SetString( "resultVar", "$color2" );
}
else
{
// Proxies for the jarate effect
KeyValues *pProxiesYellowLevel = pProxies->FindKey( "YellowLevel", true );
pProxiesYellowLevel->SetString( "resultVar", "$yellow" );
KeyValues *pProxiesEquals = pProxies->FindKey( "Equals", true );
pProxiesEquals->SetString( "srcVar1", "$yellow" );
pProxiesEquals->SetString( "resultVar", "$color2" );
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CTargetVMT::UpdateManifest( KeyValues *pKV )
{
pKV->SetString( "materialId", m_sMaterialId.String() );
pKV->SetString( "materialType", MaterialTypeToString( GetMaterialType() ) );
pKV->SetInt( "duplicate", GetDuplicate() );
pKV->SetInt( "target_width", m_nTargetWidth );
pKV->SetInt( "target_height", m_nTargetHeight );
if ( !GetDuplicate() )
{
KeyValues *pColorSubKey = new KeyValues( "color" );
pKV->AddSubKey( pColorSubKey );
pColorSubKey->SetString( "alphaType", ColorAlphaTypeToString( GetColorAlphaType() ) );
FOR_EACH_VEC( m_vecTargetVTFs, i )
{
KeyValues *pSkinSubKey;
const char *pszSkinType = CItemUpload::Manifest()->GetMaterialSkin(i);
if ( pszSkinType )
pSkinSubKey = new KeyValues( pszSkinType );
else
pSkinSubKey = pColorSubKey;
FOR_EACH_VEC( m_vecTargetVTFs[i], j )
{
if ( m_vecTargetVTFs[i][j].IsValid() )
{
const char *pszTextureType = CItemUpload::Manifest()->GetTextureType(j);
KeyValues *pSubKey = new KeyValues( pszTextureType );
pSkinSubKey->AddSubKey( pSubKey );
m_vecTargetVTFs[i][j]->UpdateManifest( pSubKey );
}
}
}
}
}
//=============================================================================
//
//=============================================================================
CTargetIcon::CTargetIcon( CAsset *pAsset, int nIconType )
: CTargetVMT( pAsset, pAsset )
, m_nIconType( nIconType )
{
int nWidth, nHeight;
CItemUpload::Manifest()->GetIconDimensions( m_nIconType, nWidth, nHeight );
SetTargetResolution( nWidth, nHeight );
const char *pszSuffix = CItemUpload::Manifest()->GetIconFilenameAppend( m_nIconType );
SetNameSuffix( pszSuffix );
KeyValues *pVMTKV = CItemUpload::Manifest()->GetIconVMTTemplate( m_nIconType );
if ( pVMTKV )
{
SetVMTKV( pVMTKV );
}
SetMaterialType( CItemUpload::Manifest()->GetDefaultMaterialType() );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetIcon::SetTargetVTF( const char *pszFilename )
{
return CTargetVMT::SetTargetVTF( m_vecTargetVTFs[0][0], pszFilename, "" );
}
//=============================================================================
//
//=============================================================================
CTargetDMX::CTargetDMX( CAsset *pAsset, const CTargetQC *pTargetQC )
: CTargetBase( pAsset, pTargetQC )
, m_pDmRoot( NULL )
, m_nLod( -1 )
, m_flAnimationLoopStartTime( -1.f )
{
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CTargetDMX::~CTargetDMX()
{
Clear();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetDMX::IsOk( CUtlString &sMsg ) const
{
if ( m_nLod < 0 )
{
sMsg = "Invalid LOD (";
sMsg += m_nLod;
sMsg += ")";
return false;
}
if ( m_sInputFile.IsEmpty() || m_sExtension.IsEmpty() )
{
sMsg = "No input file specified";
return false;
}
if ( !CItemUpload::FileExists( m_sInputFile.String() ) )
{
sMsg = "Input file: \"";
sMsg += m_sInputFile;
sMsg += "\" doesn't exist";
return false;
}
if ( !( IsInputSmd() || IsInputObj() || IsInputDmx() || IsInputFbx() ) )
{
sMsg = "Input file: \"";
sMsg += m_sInputFile;
sMsg += "\" is not a DMX, OBJ or SMD file";
return false;
}
if ( !m_pDmRoot )
{
sMsg = "Input file: \"";
sMsg += m_sInputFile;
sMsg += "\" couldn't be read";
return false;
}
const int nPolyCount = GetPolyCount();
if ( nPolyCount <= 0 && m_strQCITemplate.IsEmpty() )
{
sMsg = "Invalid polygon count (";
sMsg += nPolyCount;
sMsg += ")";
return false;
}
return true;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetDMX::Compile()
{
if ( !ReloadFile() )
return false;
if ( !CTargetBase::Compile() )
return false;
CUtlString sName;
if ( !GetOutputPath( sName, 0, PATH_FLAG_FILE | PATH_FLAG_EXTENSION ) )
return false;
CUtlString sTmp;
if ( !IsOk( sTmp ) )
{
Warning( "CTarget%s::Compile( %s ) - Not Valid: %s\n", GetTypeString(), sName.String(), sTmp.String() );
return false;
}
CUtlString sAbsPath;
GetOutputPath( sAbsPath, 0 );
CUtlString sRelPath;
GetOutputPath( sRelPath, 0, PATH_FLAG_ALL & ~PATH_FLAG_ABSOLUTE );
if ( sAbsPath.IsEmpty() || sRelPath.IsEmpty() )
{
Warning( "CTarget%s::Compile( %s ) - GetOutputPath failed\n", GetTypeString(), sName.String() );
return false;
}
Msg( "Compiling %s: %s\n", GetTypeString(), sRelPath.String() );
AddOrEditP4File( sAbsPath.String() );
CUndoScopeGuard undo( "replaceMaterial" );
ReplaceMaterials();
SkinToBipHead();
#ifdef _DEBUG
const bool bRet = g_pDataModel->SaveToFile( sAbsPath.String(), NULL, "keyvalues2", "model", m_pDmRoot );
#else // ifdef _DEBUG
const bool bRet = g_pDataModel->SaveToFile( sAbsPath.String(), NULL, "binary", "model", m_pDmRoot );
#endif // _DEBUG
undo.Abort();
if ( !bRet )
{
Msg( "CTarget%s::Compile( %s ) - SaveToFile failed - \"%s\"\n", GetTypeString(), sName.String(), sAbsPath.String() );
return false;
}
if ( !CheckFile( sAbsPath.String() ) )
{
Warning( "CTarget%s::Compile( %s ) - File Check Failed - \"%s\"\n", GetTypeString(), sName.String(), sAbsPath.String() );
return false;
}
if ( !OutputQCIFile() )
{
return false;
}
if ( CItemUpload::Manifest()->UseTerseMessages() )
{
Msg( " - Compilation successful.\n" );
}
else
{
Msg( "CTarget%s::Compile OK! - %s\n", GetTypeString(), sRelPath.String() );
}
return true;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetDMX::GetInputPaths(
CUtlVector< CUtlString > &sInputPaths,
bool bRelative /* = true */,
bool bRecurse /* = true */,
bool bExtension /* = true */ )
{
sInputPaths.AddToTail( m_sInputFile );
return CTargetBase::GetInputPaths( sInputPaths, bRelative, bRecurse, bExtension );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
const ExtensionList *CTargetDMX::GetExtensionsAndCount( void ) const
{
static ExtensionList vecExtensions;
vecExtensions.RemoveAll();
vecExtensions.AddToTail( ".dmx" );
if ( !m_strQCITemplate.IsEmpty() )
{
vecExtensions.AddToTail( ".qci" );
}
return &vecExtensions;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CTargetDMX::GetName( CUtlString &sName ) const
{
CTargetBase::GetName( sName );
if ( GetLod() > 0 )
{
sName += "_lod";
sName += GetLod();
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
int CTargetDMX::GetPolyCount() const
{
if ( !m_pDmRoot )
return 0;
int nPolyCount = 0;
const DmFileId_t hRootFileId = m_pDmRoot->GetFileId();
for ( DmElementHandle_t hElement = g_pDataModel->FirstAllocatedElement(); hElement != DMELEMENT_HANDLE_INVALID; hElement = g_pDataModel->NextAllocatedElement( hElement ) )
{
if ( hElement == DMELEMENT_HANDLE_INVALID )
continue;
CDmeMesh *pDmeMesh = CastElement< CDmeMesh >( g_pDataModel->GetElement( hElement ) );
if ( !pDmeMesh || pDmeMesh->GetFileId() != hRootFileId )
continue;
for ( int i = 0; i < pDmeMesh->FaceSetCount(); ++i )
{
CDmeFaceSet *pDmeFaceSet = pDmeMesh->GetFaceSet( i );
if ( !pDmeFaceSet )
continue;
nPolyCount += pDmeFaceSet->GetFaceCount();
}
}
return nPolyCount;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
int CTargetDMX::GetTriangleCount() const
{
if ( !m_pDmRoot )
return 0;
int nTriangleCount = 0;
const DmFileId_t hRootFileId = m_pDmRoot->GetFileId();
for ( DmElementHandle_t hElement = g_pDataModel->FirstAllocatedElement(); hElement != DMELEMENT_HANDLE_INVALID; hElement = g_pDataModel->NextAllocatedElement( hElement ) )
{
if ( hElement == DMELEMENT_HANDLE_INVALID )
continue;
CDmeMesh *pDmeMesh = CastElement< CDmeMesh >( g_pDataModel->GetElement( hElement ) );
if ( !pDmeMesh || pDmeMesh->GetFileId() != hRootFileId )
continue;
for ( int i = 0; i < pDmeMesh->FaceSetCount(); ++i )
{
CDmeFaceSet *pDmeFaceSet = pDmeMesh->GetFaceSet( i );
if ( !pDmeFaceSet )
continue;
nTriangleCount += pDmeFaceSet->GetTriangulatedIndexCount() / 3;
}
}
return nTriangleCount;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
int CTargetDMX::GetVertexCount() const
{
if ( !m_pDmRoot )
return 0;
int nVertexCount = 0;
const DmFileId_t hRootFileId = m_pDmRoot->GetFileId();
for ( DmElementHandle_t hElement = g_pDataModel->FirstAllocatedElement(); hElement != DMELEMENT_HANDLE_INVALID; hElement = g_pDataModel->NextAllocatedElement( hElement ) )
{
if ( hElement == DMELEMENT_HANDLE_INVALID )
continue;
CDmeMesh *pDmeMesh = CastElement< CDmeMesh >( g_pDataModel->GetElement( hElement ) );
if ( !pDmeMesh || pDmeMesh->GetFileId() != hRootFileId )
continue;
CDmeVertexData *pVertexData = pDmeMesh->GetBindBaseState();
if ( !pVertexData )
continue;
nVertexCount += pVertexData->VertexCount();
}
return nVertexCount;
}
bool CTargetDMX::GetAnimationFrameInfo( float& flFrameRate, int& nFrameCount ) const
{
if ( !m_pDmRoot )
return false;
CDmeAnimationList *pDmeAnimationList = m_pDmRoot->GetValueElement< CDmeAnimationList >( "animationList" );
CDmeChannelsClip *pDmeChannelsClip = NULL;
if ( pDmeAnimationList )
{
if ( pDmeAnimationList->GetAnimationCount() < 0 )
{
Warning( "No DmeChannelsClips found in root.animationList of DMX file: \"%s\"\n", m_sInputFile.String() );
return false;
}
pDmeChannelsClip = pDmeAnimationList->GetAnimation( 0 );
if ( !pDmeChannelsClip )
{
Warning( "No DmeChannelsClip found in root.animationList[0] of DMX file: \"%s\"\n", m_sInputFile.String() );
return false;
}
flFrameRate = pDmeChannelsClip->GetValue< int >( "frameRate", 30 );
nFrameCount = (int)( ( pDmeChannelsClip->GetDuration().GetSeconds() * flFrameRate ) + 0.5f ) + 1;
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Returns true if all meshes in the DMX data have skinning information
// false if any mesh doesn't have skinning data
//-----------------------------------------------------------------------------
bool CTargetDMX::AreAllMeshesSkinned() const
{
if ( !m_pDmRoot )
return false; // No DMX data
const DmFileId_t hRootFileId = m_pDmRoot->GetFileId();
int nMeshCount = 0;
for ( DmElementHandle_t hElement = g_pDataModel->FirstAllocatedElement(); hElement != DMELEMENT_HANDLE_INVALID; hElement = g_pDataModel->NextAllocatedElement( hElement ) )
{
if ( hElement == DMELEMENT_HANDLE_INVALID )
continue;
CDmeMesh *pDmeMesh = CastElement< CDmeMesh >( g_pDataModel->GetElement( hElement ) );
if ( !pDmeMesh || pDmeMesh->GetFileId() != hRootFileId )
continue;
CDmeVertexData *pDmeVertexData = pDmeMesh->GetBindBaseState();
if ( !pDmeVertexData )
continue;
// If even one mesh doesn't have skinning data, abort
if ( !pDmeVertexData->HasSkinningData() )
return false;
}
// Make sure we saw at least one mesh
return ( nMeshCount > 0 );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
const CUtlString &CTargetDMX::GetInputFile() const
{
return m_sInputFile;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CTargetDMX::Clear()
{
if ( m_pDmRoot )
{
CDisableUndoScopeGuard noUndo;
m_targetVmtList.RemoveAll();
g_pDataModel->UnloadFile( m_pDmRoot->GetFileId() );
m_pDmRoot = NULL;
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetDMX::SetInputFile( const char *pszFilename )
{
// Because of the way datamodel works, bad things will happen if the same file is loaded twice
Clear();
m_sInputFile = pszFilename;
char szBuf[ k64KB ];
V_ExtractFileExtension( pszFilename, szBuf, ARRAYSIZE( szBuf ) );
m_sExtension = szBuf;
DmFileId_t hRootFileId = g_pDataModel->GetFileId( pszFilename );
DmElementHandle_t hRootElement = g_pDataModel->GetFileRoot( hRootFileId );
CDmElement *pDmRoot = g_pDataModel->GetElement( hRootElement );
if ( !pDmRoot )
{
pDmRoot = LoadDmx();
}
if ( !pDmRoot )
{
pDmRoot = LoadFbx();
}
if ( !pDmRoot )
{
pDmRoot = LoadSmd();
}
if ( !pDmRoot )
{
pDmRoot = LoadObj();
}
if ( !pDmRoot )
{
Warning( "ERROR: Don't Know What Type Of Input File Is\n" );
return false;
}
m_pDmRoot = pDmRoot;
// TODO: Change to walking from root?
hRootFileId = m_pDmRoot->GetFileId();
// we must store the root handle so we don't reload the same file multiple time
g_pDataModel->SetFileRoot( hRootFileId, m_pDmRoot->GetHandle() );
int nMaterialType = 0;
for ( DmElementHandle_t hElement = g_pDataModel->FirstAllocatedElement(); hElement != DMELEMENT_HANDLE_INVALID; hElement = g_pDataModel->NextAllocatedElement( hElement ) )
{
if ( hElement == DMELEMENT_HANDLE_INVALID )
continue;
CDmeMaterial *pDmeMaterial = CastElement< CDmeMaterial >( g_pDataModel->GetElement( hElement ) );
if ( !pDmeMaterial || pDmeMaterial->GetFileId() != hRootFileId )
continue;
CSmartPtr< CTargetVMT > pTargetVMT = Asset()->FindOrAddMaterial( pDmeMaterial->GetMaterialName(), nMaterialType );
if ( pTargetVMT.IsValid() )
{
m_targetVmtList.AddToTail( pTargetVMT );
++nMaterialType;
}
}
CUtlString sTmp;
if ( IsOk( sTmp ) )
return true;
Warning( FUNCTION_LINE_STRING "Error! CTarget%s - Not Valid: %s\n", GetTypeString(), sTmp.String() );
return false;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetDMX::ReloadFile()
{
// Keep references to all target VMT's to prevent them from being destroyed by a reload of the same file
CUtlVector< CSmartPtr< CTargetVMT > > tmpVmtCopy;
tmpVmtCopy = m_targetVmtList;
// 'reset' the input file from the current value to force a reload on compile, make a temp copy as it's going to be overwritten
if ( !SetInputFile( CUtlString( GetInputFile() ).String() ) )
return false;
return true;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetDMX::IsInputObj() const
{
// TODO: Perhaps look at magic in the start of the file
return !V_stricmp( "obj", m_sExtension.String() );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetDMX::IsInputSmd() const
{
// TODO: Perhaps look at magic in the start of the file
return !V_stricmp( "smd", m_sExtension.String() );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetDMX::IsInputDmx() const
{
// TODO: Perhaps look at magic in the start of the file
return !V_stricmp( "dmx", m_sExtension.String() );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetDMX::IsInputFbx() const
{
// TODO: Perhaps look at magic in the start of the file
return !V_stricmp( "fbx", m_sExtension.String() );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CDmElement *CTargetDMX::LoadObj()
{
if ( !IsInputObj() )
return NULL;
CDisableUndoScopeGuard noUndo;
CDmObjSerializer dmObjSerializer;
return dmObjSerializer.ReadOBJ( m_sInputFile.String() );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CDmElement *CTargetDMX::LoadSmd()
{
if ( !IsInputSmd() )
return NULL;
CDisableUndoScopeGuard noUndo;
CDmSmdSerializer dmSmdSerializer;
dmSmdSerializer.SetIsAnimation( !m_strQCITemplate.IsEmpty() );
return dmSmdSerializer.ReadSMD( m_sInputFile.String() );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CDmElement *CTargetDMX::LoadDmx()
{
if ( !IsInputDmx() )
return NULL;
CDisableUndoScopeGuard noUndo;
CDmElement *pDmRoot = NULL;
g_pDataModel->RestoreFromFile( m_sInputFile.String(), NULL, NULL, &pDmRoot );
return pDmRoot;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CDmElement *CTargetDMX::LoadFbx()
{
if ( !IsInputFbx() )
return NULL;
CDisableUndoScopeGuard noUndo;
CDmFbxSerializer dmFbxSerializer;
return dmFbxSerializer.ReadFBX( m_sInputFile.String() );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CTargetDMX::ReplaceMaterials() const
{
CUtlString sTmp;
if ( !IsOk( sTmp ) )
{
Warning( FUNCTION_LINE_STRING "Error! CTarget%s - Not Valid: %s\n", GetTypeString(), sTmp.String() );
return;
}
DmFileId_t hRootFileId = m_pDmRoot->GetFileId();
if ( hRootFileId == DMFILEID_INVALID )
return;
CAsset *pAsset = Asset();
if ( !pAsset )
return;
CUtlMap< CUtlString, CUtlString > materialMap( UtlStringLessThan );
CUtlString sRelativeDir;
pAsset->GetRelativeDir( sRelativeDir, NULL, this );
char szBuf[ k64KB ];
for ( int i = 0; i < pAsset->GetTargetVMTCount(); ++i )
{
CTargetVMT *pTargetVMT = pAsset->GetTargetVMT( i );
if ( !pTargetVMT )
continue;
CUtlString sMaterialId;
pTargetVMT->GetMaterialId( sMaterialId );
if ( sMaterialId.IsEmpty() || materialMap.IsValidIndex( materialMap.Find( sMaterialId ) ) )
continue;
CTargetVMT *pSrcTargetVMT = pTargetVMT;
if ( pTargetVMT->GetDuplicate() )
{
const int nMaterialType = pTargetVMT->GetMaterialType();
if ( nMaterialType < 0 || nMaterialType >= CItemUpload::Manifest()->GetNumMaterialTypes() )
{
Warning( "CTarget%s::ReplaceMaterials - Duplicate VMT (%s) with bad material type (%d)\n", GetTypeString(), sMaterialId.String(), nMaterialType );
continue;
}
for ( int j = 0; j < pAsset->GetTargetVMTCount(); ++j )
{
CTargetVMT *pTmpTargetVMT = pAsset->GetTargetVMT( j );
if ( !pTmpTargetVMT || pTmpTargetVMT->GetDuplicate() )
continue;
if ( pTmpTargetVMT->GetMaterialType() == nMaterialType )
{
pSrcTargetVMT = pTmpTargetVMT;
break;
}
}
if ( pTargetVMT == pSrcTargetVMT )
{
Warning( "CTarget%s::ReplaceMaterials - Duplicate VMT (%s) Cannot Find Source Material Type (%d)\n", GetTypeString(), sMaterialId.String(), nMaterialType );
continue;
}
}
sMaterialId.FixSlashes( '/' );
// The full extension can be _red.vmt or _blue.vmt so we need to keep the _red but not the .vmt
CUtlString sMaterialPath;
pSrcTargetVMT->GetOutputPath( sMaterialPath, 0, PATH_FLAG_FILE | PATH_FLAG_EXTENSION | PATH_FLAG_PATH | PATH_FLAG_MODELS );
V_StripExtension( sMaterialPath, szBuf, ARRAYSIZE( szBuf ) );
sMaterialPath.FixSlashes( '/' );
sMaterialPath = szBuf;
materialMap.InsertOrReplace( sMaterialId, sMaterialPath.String() );
}
for ( DmElementHandle_t hElement = g_pDataModel->FirstAllocatedElement(); hElement != DMELEMENT_HANDLE_INVALID; hElement = g_pDataModel->NextAllocatedElement( hElement ) )
{
if ( hElement == DMELEMENT_HANDLE_INVALID )
continue;
CDmeMesh *pDmeMesh = CastElement< CDmeMesh >( g_pDataModel->GetElement( hElement ) );
if ( !pDmeMesh || pDmeMesh->GetFileId() != hRootFileId )
continue;
FOR_EACH_MAP_FAST( materialMap, mmi )
{
pDmeMesh->ReplaceMaterial( materialMap.Key( mmi ), materialMap.Element( mmi ) );
}
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CTargetDMX::SkinToBipHead()
{
CAssetTF *pAssetTF = dynamic_cast< CAssetTF * >( Asset() );
if ( !pAssetTF )
return;
if ( !pAssetTF->SkinToBipHead() )
return;
CDisableUndoScopeGuard undoGuard;
CDmeModel *pSrcModel = m_pDmRoot->GetValueElement< CDmeModel >( "model" );
if ( !pSrcModel )
return;
const DmFileId_t nFileId = m_pDmRoot->GetFileId();
CDmElement *pDstRoot = CreateElement< CDmElement >( m_pDmRoot->GetName(), nFileId );
CDmeModel *pDstModel = CreateElement< CDmeModel >( pSrcModel->GetName(), nFileId );
pDstModel->GetTransform()->SetName( pDstModel->GetName() );
pDstRoot->SetValue( "model", pDstModel );
pDstRoot->SetValue( "skeleton", pDstModel );
CDmeJoint *pBipHead = CreateElement< CDmeJoint >( "bip_head", nFileId );
pBipHead->GetTransform()->SetName( "bip_head" );
pDstModel->AddChild( pBipHead );
pDstModel->AddJoint( pBipHead );
const Vector &vBipHead = pAssetTF->GetBipHead();
const RadianEuler &eBipHead = pAssetTF->GetBipHeadRotation();
const Quaternion qBipHead = eBipHead;
pBipHead->GetTransform()->SetOrientation( qBipHead );
CUtlStack< CDmeDag * > depthFirstStack;
depthFirstStack.Push( pSrcModel );
while ( depthFirstStack.Count() )
{
CDmeDag *pDmeDag = NULL;
depthFirstStack.Pop( pDmeDag );
if ( !pDmeDag )
continue;
SkinToBipHead_R( pDstModel, pDmeDag, vBipHead );
for ( int i = pDmeDag->GetChildCount() - 1; i >= 0; --i )
{
depthFirstStack.Push( pDmeDag->GetChild( i ) );
}
}
pDstModel->CaptureJointsToBaseState( "bind" );
DestroyElement( m_pDmRoot, TD_ALL );
m_pDmRoot = pDstRoot;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CTargetDMX::SkinToBipHead_R( CDmeModel *pDstModel, CDmeDag *pSrcDag, const Vector &vBipHead )
{
if ( !pDstModel || !pSrcDag )
return;
CDmeMesh *pSrcMesh = CastElement< CDmeMesh >( pSrcDag->GetShape() );
if ( !pSrcMesh )
return;
CDmeVertexData *pSrcBind = pSrcMesh->GetBindBaseState();
if ( !pSrcBind )
return;
CDmeDag *pDstDag = CreateElement< CDmeDag >( pSrcDag->GetName(), pDstModel->GetFileId() );
if ( !pDstDag )
return;
pDstDag->GetTransform()->SetName( pDstDag->GetName() );
CDmeMesh *pDstMesh = pSrcMesh->Copy();
if ( !pDstMesh )
return;
// Current state is left empty, not sure why
pDstMesh->SetBindBaseState( pDstMesh->GetCurrentBaseState() );
pDstMesh->Resolve();
pDstDag->SetShape( pDstMesh );
pDstModel->AddChild( pDstDag );
matrix3x4_t mIdentity; // TODO: Is there a static identity matrix like quat_identity?
SetIdentityMatrix( mIdentity );
matrix3x4_t mSrcAbs;
// pSrcDag->GetAbsTransform( mSrcAbs );
{
matrix3x4_t parentToWorld;
pSrcDag->GetParentWorldMatrix( parentToWorld );
matrix3x4_t localMatrix;
pSrcDag->GetLocalMatrix( localMatrix );
ConcatTransforms( parentToWorld, localMatrix, mSrcAbs );
}
matrix3x4_t mNormal;
MatrixInverseTranspose( mSrcAbs, mNormal );
bool bConvertToWorldSpace = !MatricesAreEqual( mIdentity, mSrcAbs );
for ( int i = 0; i < pDstMesh->BaseStateCount(); ++i )
{
CDmeVertexData *pDstVertexData = pDstMesh->GetBaseState( i );
if ( !pDstVertexData )
continue;
pDstVertexData->Resolve();
// Remove all skinning information
// This seems a little odd, creating data to remove it but if it already exists this is
// the only way of setting the joint count to 0 without cheating (i.e. referring to the field by name)
FieldIndex_t nJointWeightField;
FieldIndex_t nJointIndexField;
pDstVertexData->CreateJointWeightsAndIndices( 0, &nJointWeightField, &nJointIndexField );
pDstVertexData->RemoveAttribute( pDstVertexData->FieldName( nJointWeightField ) );
pDstVertexData->RemoveAttribute( pDstVertexData->FieldName( nJointIndexField ) );
// Convert data to world space if required
{
Vector vTmp;
static const int nZero = 0;
static const float flOne = 1;
FieldIndex_t nPositionField = pDstVertexData->FindFieldIndex( CDmeVertexData::FIELD_POSITION );
if ( nPositionField >= 0 )
{
CDmAttribute *pPosAttr = pDstVertexData->GetVertexData( nPositionField );
if ( pPosAttr )
{
CDmrArray< Vector > posData = pPosAttr;
// Set everything up to be skinned to joint 0
pDstVertexData->CreateJointWeightsAndIndices( 1, &nJointWeightField, &nJointIndexField );
pDstVertexData->AddVertexData( nJointIndexField, posData.Count() );
pDstVertexData->AddVertexData( nJointWeightField, posData.Count() );
if ( bConvertToWorldSpace )
{
for ( int iPos = 0; iPos < posData.Count(); ++iPos )
{
pDstVertexData->SetVertexData( nJointIndexField, iPos, 1, AT_INT, &nZero );
pDstVertexData->SetVertexData( nJointWeightField, iPos, 1, AT_FLOAT, &flOne );
}
}
else
{
for ( int iPos = 0; iPos < posData.Count(); ++iPos )
{
VectorTransform( posData[iPos], mSrcAbs, vTmp );
posData.Set( iPos, vTmp );
pDstVertexData->SetVertexData( nJointIndexField, i, 1, AT_INT, &nZero );
pDstVertexData->SetVertexData( nJointWeightField, i, 1, AT_FLOAT, &flOne );
}
}
}
}
FieldIndex_t nNormalField = pDstVertexData->FindFieldIndex( CDmeVertexData::FIELD_NORMAL );
if ( nNormalField >= 0 )
{
CDmAttribute *pNormalAttr = pDstVertexData->GetVertexData( nNormalField );
if ( pNormalAttr )
{
CDmrArray< Vector > normalData = pNormalAttr;
for ( int iData = 0; iData < normalData.Count(); ++iData )
{
VectorRotate( normalData[iData], mNormal, vTmp );
vTmp.NormalizeInPlace();
normalData.Set( iData, vTmp );
}
}
}
}
pDstVertexData->Resolve();
}
Vector vMin;
Vector vMax;
pDstMesh->GetBoundingBox( vMin, vMax );
const Vector vCenter = ( vMax - vMin ) / 2.0 + vMin;
const float flSqDistOrigin = vCenter.DistToSqr( Vector( 0, 0, 0 ) );
const float flSqDistBipHead = vCenter.DistToSqr( vBipHead );
// See where the model was modelled... around the bip_head bone or at the origin?
// There are probably other problems which aren't accounted for this is a really naive
// algorithm
if ( flSqDistBipHead < flSqDistOrigin )
{
// Model centered around bip head, subtract vBipHead from position data
Vector vTmp;
for ( int i = 0; i < pDstMesh->BaseStateCount(); ++i )
{
CDmeVertexData *pDstVertexData = pDstMesh->GetBaseState( i );
if ( !pDstVertexData )
continue;
pDstVertexData->Resolve();
FieldIndex_t nPositionField = pDstVertexData->FindFieldIndex( CDmeVertexData::FIELD_POSITION );
if ( nPositionField >= 0 )
{
CDmAttribute *pPosAttr = pDstVertexData->GetVertexData( nPositionField );
if ( pPosAttr )
{
CDmrArray< Vector > posData = pPosAttr;
for ( int iPos = 0; iPos < posData.Count(); ++iPos )
{
VectorSubtract( posData[iPos], vBipHead, vTmp );
posData.Set( iPos, vTmp );
}
}
}
pDstVertexData->Resolve();
}
}
}
//=============================================================================
//
//=============================================================================
bool CTargetDMX::OutputQCIFile()
{
// Should we output QCI?
if ( !m_strQCITemplate.IsEmpty() )
{
CUtlString sDMXName;
if ( !GetOutputPath( sDMXName, 0, PATH_FLAG_FILE | PATH_FLAG_EXTENSION ) )
return false;
CUtlString sName;
if ( !GetOutputPath( sName, 1, PATH_FLAG_FILE ) )
return false;
CUtlString sAbsPath;
if ( !GetOutputPath( sAbsPath, 1 ) )
return false;
float flFrameRate;
int nFrameCount;
if ( !GetAnimationFrameInfo( flFrameRate, nFrameCount ) )
{
Warning( "Failed to get animation's frame info for %s\n", sAbsPath.String() );
return false;
}
const int nBlendFrameOffset = 5;
const int nLastFrameIndex = nFrameCount - 1;
CUtlString strLayerName = "layer_";
strLayerName += sName;
CUtlString strBuf = m_strQCITemplate.Replace( "<ITEMTEST_SEQUENCE_LAYER_NAME>", strLayerName.String() );
strBuf = strBuf.Replace( "<ITEMTEST_SEQUENCE_NAME>", sName.String() );
strBuf = strBuf.Replace( "<ITEMTEST_DMX_FILE>", sName.String() );
strBuf = strBuf.Replace( "<FPS>", CFmtStr( "fps %d", (int)flFrameRate ) );
strBuf = strBuf.Replace( "<BLEND_LAYER_RANGE>", CFmtStr( "0 %d %d <LAST_FRAME_INDEX>", nBlendFrameOffset, nLastFrameIndex - nBlendFrameOffset ) );
strBuf = strBuf.Replace( "<FRAME_COUNT>", CFmtStr( "%d", nFrameCount ) );
strBuf = strBuf.Replace( "<LAST_FRAME_INDEX>", CFmtStr( "%d", nLastFrameIndex ) );
CUtlBuffer bufQCFile( 0, 0, CUtlBuffer::TEXT_BUFFER );
bufQCFile.PutString( strBuf.String() );
AddOrEditP4File( sAbsPath.String() );
g_pFullFileSystem->WriteFile( sAbsPath.String(), "MOD", bufQCFile );
}
return true;
}
void LeftRightToValueBalance( float flLeft, float flRight, float &flOutValue, float &flOutBalance )
{
if ( flLeft > flRight )
{
flOutValue = flLeft;
flOutBalance = 0.5f * flRight / flLeft;
}
else
{
flOutValue = flRight;
flOutBalance = 1.0f - 0.5f * flRight / flLeft;
}
}
void BufPrintf( CUtlBuffer& buf, int nLevel, const char *fmt, ... )
{
va_list argptr;
va_start( argptr, fmt );
while ( nLevel-- > 0 )
{
buf.Printf( " " );
}
buf.VaPrintf( fmt, argptr );
va_end( argptr );
}
void BufBeginBlock( CUtlBuffer& buf, int &nLevel )
{
BufPrintf( buf, nLevel, "{\n" );
++nLevel;
}
void BufEndBlock( CUtlBuffer& buf, int &nLevel )
{
--nLevel;
BufPrintf( buf, nLevel, "}\n" );
}
template< class T >
CDmeTypedLogLayer< T > *GetTopmostLogLayer( CDmeChannel *pChannel )
{
if ( !pChannel )
return NULL;
CDmeTypedLog< T > *pLog = CastElement< CDmeTypedLog< T > >( pChannel->GetLog() );
if ( !pLog )
return NULL;
return pLog->GetLayer( pLog->GetTopmostLayer() );
}
void CTargetDMX::OutputSounds( CUtlBuffer &buf, int nIndentLevel, CDmElement *pExportedSounds )
{
if ( !pExportedSounds )
return;
CDmrElementArray< CDmElement > soundsArray( pExportedSounds, "sounds" );
if ( !soundsArray.IsValid() )
return;
int nSounds = soundsArray.Count();
if ( nSounds == 0 )
return;
CUtlBuffer soundScriptBuffer( 0, 0, CUtlBuffer::TEXT_BUFFER );
if ( !m_strSoundScriptFile.IsEmpty() )
{
if ( !g_pFullFileSystem->ReadFile( m_strSoundScriptFile.String(), "MOD", soundScriptBuffer ) )
{
Warning( "Failed to load sound script file\n" );
return;
}
}
else
{
Warning( "Sound script file not specified\n" );
return;
}
BufPrintf( buf, nIndentLevel, "channel \"sounds\"\n" );
BufBeginBlock( buf, nIndentLevel );
{
for ( int i = 0; i < nSounds; ++i )
{
CDmElement *pSound = soundsArray[ i ];
if ( !pSound )
continue;
float flStartTime = pSound->GetValue< float >( "startTime" );
CUtlString strWaveName = pSound->GetValueString( "fileName" );
V_FixSlashes( strWaveName.GetForModify(), '/' );
if ( !g_pFullFileSystem->FileExists( CFmtStr( "sound/%s", strWaveName.String() ), "GAME" ) )
{
CUtlString strSoundName = strWaveName.StripExtension();
if ( !g_pFullFileSystem->FileExists( CFmtStr( "sound/%s.mp3", strSoundName.String() ), "GAME" ) )
{
Warning( "OutputSounds to VCD missing sound file: %s.wav/mp3\n", strSoundName.String() );
continue;
}
}
bool bIsVO = V_strstr( strWaveName.String(), "vo/" ) != NULL;
const char *pszSoundScriptName = CFmtStr( "<CLASS_NAME>_<ITEMTEST_SEQUENCE_NAME>_%s", pSound->GetName() );
// write sound script entry to sound script file
int nSoundIndentLevel = 0;
BufPrintf( soundScriptBuffer, nSoundIndentLevel, "\"%s\"\n", pszSoundScriptName );
BufBeginBlock( soundScriptBuffer, nSoundIndentLevel );
{
BufPrintf( soundScriptBuffer, nSoundIndentLevel, "\"channel\" \"%s\"\n", bIsVO ? "CHAN_VOICE" : "CHAN_STATIC" );
BufPrintf( soundScriptBuffer, nSoundIndentLevel, "\"volume\" \"VOL_NORM\"\n" );
BufPrintf( soundScriptBuffer, nSoundIndentLevel, "\"pitch\" \"PITCH_NORM\"\n" );
BufPrintf( soundScriptBuffer, nSoundIndentLevel, "\"soundlevel\" \"SNDLVL_95dB\"\n" );
BufPrintf( soundScriptBuffer, nSoundIndentLevel, "\"wave\" \"%s\"\n", strWaveName.String() );
}
BufEndBlock( soundScriptBuffer, nSoundIndentLevel );
// write vcd speak event
BufPrintf( buf, nIndentLevel, "event speak \"%s\"\n", pszSoundScriptName );
BufBeginBlock( buf, nIndentLevel );
{
BufPrintf( buf, nIndentLevel, "time %f <MAX_SEQUENCE_LENGTH>\n", flStartTime );
BufPrintf( buf, nIndentLevel, "param \"%s\"", pszSoundScriptName );
BufPrintf( buf, nIndentLevel, "fixedlength\n" );
BufPrintf( buf, nIndentLevel, "cctpe \"cc_master\"\n" );
BufPrintf( buf, nIndentLevel, "cctoken \"\"\n" );
}
BufEndBlock( buf, nIndentLevel );
}
}
BufEndBlock( buf, nIndentLevel );
CUtlString strBuf = soundScriptBuffer.String();
FOR_EACH_SUBKEY( GetCustomKeyValues(), pSubKey )
{
strBuf = strBuf.Replace( pSubKey->GetName(), pSubKey->GetString() );
}
soundScriptBuffer.Clear();
soundScriptBuffer.PutString( strBuf.String() );
// write to sound script file
CUtlString sWorkingDir;
CItemUpload::GetVProjectDir( sWorkingDir );
char szSoundScriptFullPath[MAX_PATH];
V_MakeAbsolutePath( szSoundScriptFullPath, sizeof( szSoundScriptFullPath ), m_strSoundScriptFile.String(), sWorkingDir.String() );
if ( !g_pFullFileSystem->WriteFile( szSoundScriptFullPath, NULL, soundScriptBuffer ) )
{
Warning( "Failed to output soundscript: %s\n", szSoundScriptFullPath );
}
if ( GetCustomModPath() )
{
char szCustomPath[MAX_PATH];
V_MakeAbsolutePath( szCustomPath, sizeof( szCustomPath ), CFmtStr( "%s/%s", GetCustomModPath(), m_strSoundScriptFile.String() ), sWorkingDir.String() );
V_FixSlashes( szCustomPath );
if ( DoFileCopy( szSoundScriptFullPath, szCustomPath ) )
{
Asset()->AddModOutput( szCustomPath );
}
}
}
// pChannelsClip is assumed to be an exported channelsclip (vs a live channelsclip)
bool CTargetDMX::WriteVCD( CUtlBuffer &vcdBuf )
{
CDmeAnimationList *pDmeAnimationList = m_pDmRoot->GetValueElement< CDmeAnimationList >( "animationList" );
CDmeChannelsClip *pDmeChannelsClip = NULL;
if ( pDmeAnimationList )
{
if ( pDmeAnimationList->GetAnimationCount() < 0 )
{
Warning( "No DmeChannelsClips found in root.animationList of DMX file: \"%s\"\n", m_sInputFile.String() );
return false;
}
pDmeChannelsClip = pDmeAnimationList->GetAnimation( 0 );
if ( !pDmeChannelsClip )
{
Warning( "No DmeChannelsClip found in root.animationList[0] of DMX file: \"%s\"\n", m_sInputFile.String() );
return false;
}
}
DmeFramerate_t framerate( pDmeChannelsClip->GetValue< int >( "frameRate", 30 ) );
int nLevel = 0;
BufPrintf( vcdBuf, nLevel, "// Choreo version 1\n" );
// loop animation?
if ( m_flAnimationLoopStartTime >= 0.f )
{
BufPrintf( vcdBuf, nLevel, "event loop \"<ITEMTEST_SEQUENCE_NAME>_loop\"\n" );
BufBeginBlock( vcdBuf, nLevel );
{
BufPrintf( vcdBuf, nLevel, "time <MAX_SEQUENCE_LENGTH> -1.000000\n" );
BufPrintf( vcdBuf, nLevel, "param \"%f\"\n", m_flAnimationLoopStartTime );
BufPrintf( vcdBuf, nLevel, "loopcount \"-1\"\n" );
}
BufEndBlock( vcdBuf, nLevel );
}
BufPrintf( vcdBuf, nLevel, "actor \"<CLASS_NAME>\"\n" );
BufBeginBlock( vcdBuf, nLevel );
{
// sequence channel
BufPrintf( vcdBuf, nLevel, "channel \"<CLASS_NAME>\"\n" );
BufBeginBlock( vcdBuf, nLevel );
{
BufPrintf( vcdBuf, nLevel, "event sequence <ITEMTEST_SEQUENCE_NAME>\n" );
BufBeginBlock( vcdBuf, nLevel );
{
BufPrintf( vcdBuf, nLevel, "time 0.000000 <MAX_SEQUENCE_LENGTH>\n" );
BufPrintf( vcdBuf, nLevel, "param <ITEMTEST_SEQUENCE_NAME>\n" );
}
BufEndBlock( vcdBuf, nLevel );
}
BufEndBlock( vcdBuf, nLevel );
// Flex Anim channel
BufPrintf( vcdBuf, nLevel, "channel \"Face\"\n" );
BufBeginBlock( vcdBuf, nLevel );
{
int nChannelCount = pDmeChannelsClip->m_Channels.Count();
for ( int ci = 0; ci < nChannelCount; ++ci )
{
CDmeChannel *pChannel = pDmeChannelsClip->m_Channels[ ci ];
// skip all transform
if ( !pChannel || !pChannel->GetToAttribute() || pChannel->GetToAttribute()->GetType() != AT_FLOAT )
continue;
CDmElement *pToElement = pChannel->GetToElement();
const char *pszToElementName = pToElement->GetName();
// figure out IsStereoControl by checking if prefix is left_ and right_
// in pDmeChannelsClip->m_Channels
CDmeChannel *pLeftChannel = NULL; //pChannel->GetValueElement< CDmeChannel >( "leftvaluechannel" );
CDmeChannel *pRightChannel = NULL; //pChannel->GetValueElement< CDmeChannel >( "rightvaluechannel" );
for ( int iSearch = 0; iSearch < nChannelCount; ++iSearch )
{
CDmeChannel *pSearchChannel = pDmeChannelsClip->m_Channels[ iSearch ];
if ( !pSearchChannel )
continue;
// search for left and right channels
const char *pszSearchChannelName = pSearchChannel->GetName();
if ( V_strstr( pszSearchChannelName, pszToElementName ) )
{
if ( V_strstr( pszSearchChannelName, "left_" ) )
{
Assert( pLeftChannel == NULL );
pLeftChannel = pSearchChannel;
}
else if ( V_strstr( pszSearchChannelName, "right_" ) )
{
Assert( pRightChannel == NULL );
pRightChannel = pSearchChannel;
}
}
}
bool bIsStereo = pLeftChannel && pRightChannel;
if ( bIsStereo )
{
// should we do anything for stereo (eye animation)?
AssertMsg( 0, "Stereo channel is not supported." );
continue;
CDmeFloatLogLayer *pLeftLogLayer = GetTopmostLogLayer< float >( pLeftChannel );
CDmeFloatLogLayer *pRightLogLayer = GetTopmostLogLayer< float >( pRightChannel );
if ( !pLeftLogLayer || !pRightLogLayer )
continue;
CUtlVectorFixedGrowable< DmeTime_t, 1024 > times;
CUtlVectorFixedGrowable< float, 1024 > values;
CUtlVectorFixedGrowable< float, 1024 > balances;
// we should have some key count on both left and right key
if ( pLeftLogLayer->GetKeyCount() == 0 || pRightLogLayer->GetKeyCount() == 0 )
{
// something is wrong here.
Assert( 0 );
continue;
}
DmeTime_t tStartOnFrame = MIN( pLeftLogLayer ->GetKeyTime( 0 ), pRightLogLayer->GetKeyTime( 0 ) );
DmeTime_t tEndOnFrame = MAX( pLeftLogLayer ->GetKeyTime( pLeftLogLayer->GetKeyCount() - 1 ), pRightLogLayer->GetKeyTime( pRightLogLayer->GetKeyCount() - 1 ) );
#if 1 // resample time
for ( DmeTime_t tCurr = tStartOnFrame; tCurr <= tEndOnFrame; tCurr = tCurr.TimeAtNextFrame( framerate ) )
{
float flLeftValue = pLeftLogLayer->GetValue( pDmeChannelsClip->FromChildMediaTime( tCurr ) );
float flRightValue = pLeftLogLayer->GetValue( pDmeChannelsClip->FromChildMediaTime( tCurr ) );
float flValue, flBalance;
LeftRightToValueBalance( flLeftValue, flRightValue, flValue, flBalance );
times.AddToTail( tCurr );
values.AddToTail( flValue );
balances.AddToTail( flBalance );
}
#else // merge time list from left and right channels
int nLeft = pLeftLogLayer->GetKeyCount();
int nRight = pRightLogLayer->GetKeyCount();
int iLeft = pLeftLogLayer->FindKey( pDmeChannelsClip->ToChildMediaTime( tStart ) );
int iRight = pLeftLogLayer->FindKey( pDmeChannelsClip->ToChildMediaTime( tStart ) );
while ( iLeft < nLeft || iRight < nRight )
{
DmeTime_t tLeft = iLeft < nLeft ? pDmeChannelsClip->FromChildMediaTime( pLeftLogLayer ->GetKeyTime( iLeft ) ) : DMETIME_MAXTIME;
DmeTime_t tRight = iRight < nRight ? pDmeChannelsClip->FromChildMediaTime( pRightLogLayer->GetKeyTime( iRight ) ) : DMETIME_MAXTIME;
DmeTime_t t;
float flLeftVal, flRightVal;
if ( tLeft == tRight )
{
t = tLeft;
flLeftVal = pLeftLogLayer->GetKeyValue( iLeft );
flRightVal = pRightLogLayer->GetKeyValue( iRight );
iLeft++;
iRight++;
}
else if ( tLeft < tRight )
{
t = tLeft;
flLeftVal = pLeftLogLayer->GetKeyValue( iLeft );
flRightVal = pRightLogLayer->GetValue( t );
iLeft++;
}
else
{
t = tRight;
flLeftVal = pLeftLogLayer->GetValue( t );
flRightVal = pRightLogLayer->GetKeyValue( iRight );
iRight++;
}
float flValue, flBalance;
LeftRightToValueBalance( flLeftVal, flRightVal, flValue, flBalance );
times.AddToTail( t );
values.AddToTail( flValue );
balances.AddToTail( flBalance );
}
#endif
BufPrintf( vcdBuf, nLevel, "\"%s\" combo\n", pChannel->GetName() );
BufBeginBlock( vcdBuf, nLevel );
int nSamples = times.Count();
for ( int si = 0; si < nSamples; ++si )
{
BufPrintf( vcdBuf, nLevel, "%.4f %.4f\n", times[ si ].GetSeconds(), values[ si ] );
}
BufEndBlock( vcdBuf, nLevel );
BufBeginBlock( vcdBuf, nLevel );
for ( int si = 0; si < nSamples; ++si )
{
BufPrintf( vcdBuf, nLevel, "%.4f %.4f\n", times[ si ].GetSeconds(), balances[ si ] );
}
BufEndBlock( vcdBuf, nLevel );
}
else
{
CDmeFloatLogLayer *pLogLayer = GetTopmostLogLayer< float >( pChannel );
if ( !pLogLayer || pLogLayer->GetKeyCount() == 0 )
continue;
BufPrintf( vcdBuf, nLevel, "event expression \"%s\"\n", pToElement->GetName() );
BufBeginBlock( vcdBuf, nLevel );
{
BufPrintf( vcdBuf, nLevel, "time %.4f %.4f\n", pDmeChannelsClip->GetStartTime().GetSeconds(), pDmeChannelsClip->GetEndTime().GetSeconds() );
BufPrintf( vcdBuf, nLevel, "param \"player\\<CLASS_NAME>\\emotion\\emotion\"\n" );
BufPrintf( vcdBuf, nLevel, "param2 \"%s\"\n", pToElement->GetName() );
BufPrintf( vcdBuf, nLevel, "event_ramp\n" );
BufBeginBlock( vcdBuf, nLevel );
{
#if 0 // resampling
if ( tStart < tStartOnFrame )
{
float flValue = pLogLayer->GetValue( pDmeChannelsClip->FromChildMediaTime( tStart ) );
BufPrintf( vcdBuf, nLevel, "%.4f %.4f\n", tStart.GetSeconds(), flValue );
}
for ( DmeTime_t tCurr = tStartOnFrame; tCurr <= tEndOnFrame; tCurr = tCurr.TimeAtNextFrame( framerate ) )
{
float flValue = pLogLayer->GetValue( pDmeChannelsClip->FromChildMediaTime( tCurr ) );
BufPrintf( vcdBuf, nLevel, "%.4f %.4f\n", tCurr.GetSeconds(), flValue );
}
if ( tEnd > tEndOnFrame )
{
float flValue = pLogLayer->GetValue( pDmeChannelsClip->FromChildMediaTime( tEnd ) );
BufPrintf( vcdBuf, nLevel, "%.4f %.4f\n", tEnd.GetSeconds(), flValue );
}
#else // use sample time that's already in the animation
int nKeys = pLogLayer->GetKeyCount();
for ( int k = 0; k < nKeys; ++k )
{
DmeTime_t t = pDmeChannelsClip->FromChildMediaTime( pLogLayer->GetKeyTime( k ) );
float flValue = pLogLayer->GetKeyValue( k );
BufPrintf( vcdBuf, nLevel, "%.4f %.4f\n", t.GetSeconds(), flValue );
}
#endif
}
BufEndBlock( vcdBuf, nLevel );
}
BufEndBlock( vcdBuf, nLevel );
}
}
// channel sounds
OutputSounds( vcdBuf, nLevel, m_pDmRoot->GetValueElement< CDmElement >( "exportedSounds" ) );
}
BufEndBlock( vcdBuf, nLevel );
}
BufEndBlock( vcdBuf, nLevel );
BufPrintf( vcdBuf, nLevel, "fps %d\n", RoundFloatToInt( framerate.GetFramesPerSecond() ) );
BufPrintf( vcdBuf, nLevel, "snap off\n" );
CUtlString strBuf = vcdBuf.String();
FOR_EACH_SUBKEY( GetCustomKeyValues(), pSubKey )
{
strBuf = strBuf.Replace( pSubKey->GetName(), pSubKey->GetString() );
}
vcdBuf.Clear();
vcdBuf.PutString( strBuf );
return true;
}
//=============================================================================
//
//=============================================================================
CTargetVCD::CTargetVCD( CAsset *pAsset, const CTargetQC *pTargetQC )
: CTargetBase( pAsset, pTargetQC ), m_pTargetQC( pTargetQC )
{
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetVCD::Compile()
{
if ( !CTargetBase::Compile() )
return false;
CUtlString sName;
if ( !GetOutputPath( sName, 0, PATH_FLAG_FILE | PATH_FLAG_EXTENSION ) )
return false;
CUtlString sTmp;
if ( !IsOk( sTmp ) )
{
Warning( "CTarget%s::Compile( %s ) - Not Valid: %s\n", GetTypeString(), sName.String(), sTmp.String() );
return false;
}
CUtlString sBinDir;
if ( !CItemUpload::GetBinDirectory( sBinDir ) )
{
Warning( "CTarget%s::Compile( %s ) - GetBinDirectory Failed\n", GetTypeString(), sName.String() );
return false;
}
CUtlString sAbsPath;
GetOutputPath( sAbsPath, 0 );
CUtlString sRelPath;
GetOutputPath( sRelPath, 0, PATH_FLAG_ALL & ~PATH_FLAG_ABSOLUTE );
if ( sAbsPath.IsEmpty() || sRelPath.IsEmpty() )
{
Warning( "CTarget%s::Compile( %s ) - GetOutputPath failed\n", GetTypeString(), sName.String() );
return false;
}
Msg( "Compiling %s: %s\n", GetTypeString(), sRelPath.String() );
CUtlBuffer bufVCDFile( 0, 0, CUtlBuffer::TEXT_BUFFER );
if ( m_strVCDPath.IsEmpty() )
{
if ( !m_pTargetQC->GetTargetDMX( 0 )->WriteVCD( bufVCDFile ) )
{
Warning( "CTarget%s::Compile( %s ) - failed to create VCD buffer\n", GetTypeString(), m_strVCDPath.String() );
return false;
}
}
else if ( !g_pFullFileSystem->ReadFile( m_strVCDPath, NULL, bufVCDFile ) )
{
Warning( "CTarget%s::Compile( %s ) - failed to read input file\n", GetTypeString(), m_strVCDPath.String() );
return false;
}
// output to the correct file path
AddOrEditP4File( sAbsPath.String() );
g_pFullFileSystem->WriteFile( sAbsPath.String(), "MOD", bufVCDFile );
Msg( "CTarget%s::Compile OK! - %s\n", GetTypeString(), sRelPath );
if ( GetCustomModPath() )
{
CUtlString sWorkingDir;
if ( CItemUpload::IgnoreEnvironmentVariables() )
{
sWorkingDir = sAbsPath;
sWorkingDir.SetLength( sWorkingDir.Length() - sRelPath.Length() );
V_StripTrailingSlash( sWorkingDir.GetForModify() );
}
else
{
CItemUpload::GetVProjectDir( sWorkingDir );
}
char szCustomPath[MAX_PATH];
V_MakeAbsolutePath( szCustomPath, sizeof( szCustomPath ), CFmtStr( "%s/%s", GetCustomModPath(), sRelPath.String() ), sWorkingDir.String() );
V_FixSlashes( szCustomPath );
if ( DoFileCopy( sAbsPath.String(), szCustomPath ) )
{
Asset()->AddModOutput( szCustomPath );
}
}
return true;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
const ExtensionList *CTargetVCD::GetExtensionsAndCount( void ) const
{
static ExtensionList vecExtensions;
if ( !vecExtensions.Count() )
{
vecExtensions.AddToTail( ".vcd" );
}
return &vecExtensions;
}
//=============================================================================
//
//=============================================================================
CTargetQC::CTargetQC( CAsset *pAsset, const CTargetMDL *pTargetMDL )
: CTargetBase( pAsset, pTargetMDL )
, m_QCTemplate( 0, 0, CUtlBuffer::TEXT_BUFFER )
, m_TargetVCD( NULL )
{
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetQC::IsOk( CUtlString &sMsg ) const
{
if ( m_TargetDMXs.Count() <= 0 )
{
sMsg = "No DMX input files specified";
return false;
}
return true;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetQC::Compile()
{
if ( !CTargetBase::Compile() )
return false;
CUtlString sName;
if ( !GetOutputPath( sName, 0, PATH_FLAG_FILE | PATH_FLAG_EXTENSION ) )
return false;
CUtlString sAbsPath;
GetOutputPath( sAbsPath, 0 );
CUtlString sRelPath;
GetOutputPath( sRelPath, 0, PATH_FLAG_ALL & ~PATH_FLAG_ABSOLUTE );
if ( sAbsPath.IsEmpty() || sRelPath.IsEmpty() )
{
Warning( "CTarget%s::Compile( %s ) - GetOutputPath failed\n", GetTypeString(), sName.String() );
return false;
}
CUtlString sLOD0;
GetOutputPath( sLOD0, 0, PATH_FLAG_PATH | PATH_FLAG_FILE | PATH_FLAG_PREFIX | PATH_FLAG_MODELS );
sLOD0.FixSlashes( '/' );
const char *pszPostModel = V_strstr( sLOD0.String(), "models/" );
CUtlString sModelName = pszPostModel ? pszPostModel + 7 : sLOD0;
sModelName += ".mdl";
Msg( "Compiling %s: %s\n", GetTypeString(), sRelPath.String() );
AddOrEditP4File( sAbsPath.String() );
CUtlString strBuf = GetQCTemplate();
if ( strBuf.IsEmpty() )
{
return false;
}
strBuf = strBuf.Replace( "<ITEMTEST_REPLACE_MDLABSPATH>", sModelName.String() );
for ( int nLOD = 1; nLOD < m_TargetDMXs.Count(); ++nLOD )
{
strBuf = strBuf.Replace( CFmtStr( "<ITEMTEST_REPLACE_LOD%d_HEADER>", nLOD ), CFmtStr( "$lod %d", CItemUpload::Manifest()->GetQCLODDistance( nLOD ) ) );
}
// Remove REPLACE_LOD block if it's not necessary
RemoveTextBlock( strBuf.String(), "<ITEMTEST_REPLACE_LOD1_HEADER>", strBuf.GetForModify(), strBuf.Length() );
RemoveTextBlock( strBuf.String(), "<ITEMTEST_REPLACE_LOD2_HEADER>", strBuf.GetForModify(), strBuf.Length() );
CUtlString sSearch = "<ITEMTEST_REPLACE_SKIN_OPTIONALBLOCK>";
CUtlString sReplace = "$cdmaterials \"<ITEMTEST_REPLACE_MATERIALS_PATH>\"\n$texturegroup skinfamilies\n{\n";
CUtlString sMaterialPath;
for ( int nSkin = 0; nSkin < CItemUpload::Manifest()->GetNumMaterialSkins(); ++nSkin )
{
int nVMTCount = 0;
CUtlString sSkinMaterials = " { ";
for ( int nVMT = 0; nVMT < Asset()->GetTargetVMTCount(); ++nVMT )
{
CTargetVMT *pTargetVMT = Asset()->GetTargetVMT( nVMT );
if ( nSkin >= pTargetVMT->GetOutputCount() )
continue;
// We grab the extension which includes the skin variant, and then trim the actual file extension
CUtlString sVMTName;
if ( !pTargetVMT->GetOutputPath( sVMTName, nSkin, PATH_FLAG_FILE | PATH_FLAG_EXTENSION ) )
{
Warning( "CTarget%s::Compile( %s ) - VMT %d skin %d GetOutputPath failed\n", GetTypeString(), sName.String(), nVMT, nSkin );
continue;
}
V_StripExtension( sVMTName.String(), sVMTName.GetForModify(), sVMTName.Length() );
if ( sMaterialPath.IsEmpty() )
{
pTargetVMT->GetOutputPath( sMaterialPath, 0, PATH_FLAG_PATH | PATH_FLAG_MODELS );
}
sSkinMaterials += CFmtStr( "\"%s\" ", sVMTName.String() );
++nVMTCount;
}
sSkinMaterials += "}\n";
if ( nVMTCount > 0 )
{
sReplace += sSkinMaterials;
}
}
sReplace += "}\n";
strBuf = strBuf.Replace( sSearch.String(), sReplace.String() );
strBuf = strBuf.Replace( "<ITEMTEST_REPLACE_MATERIALS_PATH>", sMaterialPath.String() );
for ( int nLOD = 0; nLOD < m_TargetDMXs.Count(); ++nLOD )
{
CUtlString sLOD;
m_TargetDMXs[ nLOD ]->GetOutputPath( sLOD, 0, PATH_FLAG_FILE | PATH_FLAG_EXTENSION );
strBuf = strBuf.Replace( CFmtStr( "<ITEMTEST_REPLACE_LOD%d>", nLOD ), sLOD.String() );
}
// Should we include QCI?
if ( !m_strQCITemplate.IsEmpty() )
{
CUtlString strQCIDir;
m_TargetDMXs[ 0 ]->GetOutputPath( strQCIDir, 1, PATH_FLAG_PATH & ~PATH_FLAG_ABSOLUTE );
strQCIDir = strQCIDir.Replace( '\\', '/' );
strBuf = strBuf.Replace( "<QCI_RELATIVE_DIR>", strQCIDir.String() );
CUtlString strQCIRel;
m_TargetDMXs[ 0 ]->GetOutputPath( strQCIRel, 1, PATH_FLAG_ALL & ~PATH_FLAG_ABSOLUTE & ~PATH_FLAG_MODELS );
strQCIRel = strQCIRel.Replace( '\\', '/' );
strBuf = strBuf.Replace( "<QCI_RELATIVE_PATH>", strQCIRel.String() );
}
FOR_EACH_SUBKEY( GetCustomKeyValues(), pSubKey )
{
strBuf = strBuf.Replace( pSubKey->GetName(), pSubKey->GetString() );
}
CUtlBuffer bufQCFile( 0, 0, CUtlBuffer::TEXT_BUFFER );
bufQCFile.PutString( strBuf.String() );
g_pFullFileSystem->WriteFile( sAbsPath.String(), "MOD", bufQCFile );
if ( !CheckFile( sAbsPath.String() ) )
{
Warning( "CTarget%s::Compile( %s ) - File Check Failed - \"%s\"\n", GetTypeString(), sName.String(), sAbsPath.String() );
return false;
}
if ( CItemUpload::Manifest()->UseTerseMessages() )
{
Msg( " - Compilation successful.\n" );
}
else
{
Msg( "CTarget%s::Compile OK! - %s\n", GetTypeString(), sRelPath.String() );
}
return true;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
const ExtensionList *CTargetQC::GetExtensionsAndCount( void ) const
{
static ExtensionList vecExtensions;
if ( !vecExtensions.Count() )
{
vecExtensions.AddToTail( ".qc" );
}
return &vecExtensions;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetQC::GetInputs( CUtlVector< CTargetBase * > &sInputs ) const
{
CUtlString sTmp;
if ( !IsOk( sTmp ) )
{
Warning( FUNCTION_LINE_STRING "Error! CTarget%s - Not Valid: %s\n", GetTypeString(), sTmp.String() );
return false;
}
int nOkCount = 0;
for ( int i = 0; i < m_TargetDMXs.Count(); ++i )
{
CTargetBase *pTargetBase = m_TargetDMXs.Element( i ).GetObject();
if ( !pTargetBase )
continue;
nOkCount += ( sInputs.AddToTail( pTargetBase ) >= 0 ? 1 : 0 );
}
if ( m_TargetVCD.IsValid() )
{
CTargetBase *pTargetBase = m_TargetVCD.GetObject();
if ( pTargetBase )
{
nOkCount += ( sInputs.AddToTail( pTargetBase ) >= 0 ? 1 : 0 );
}
}
return nOkCount > 0;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
int CTargetQC::TargetDMXCount() const
{
return m_TargetDMXs.Count();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CTargetQC::SetQCTemplate( const char *pszQCTemplate )
{
m_QCTemplate.Clear();
m_QCTemplate.PutString( pszQCTemplate );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
const char *CTargetQC::GetQCTemplate()
{
if ( m_QCTemplate.TellMaxPut() == 0 )
{
const char *pszQCTemplate = CItemUpload::Manifest()->GetQCTemplate();
if ( pszQCTemplate )
{
if ( !g_pFullFileSystem->ReadFile( pszQCTemplate, "MOD", m_QCTemplate ) )
{
Warning( "Failed to load specified QC template '%s'.\n", pszQCTemplate );
}
}
}
return (char*)m_QCTemplate.Base();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
int CTargetQC::AddTargetDMX( const char *pszGeometryFile )
{
CSmartPtr< CTargetDMX > pTargetDMX = Asset()->NewTarget< CTargetDMX >( this );
if ( !pTargetDMX )
return -1;
const int nIndex = m_TargetDMXs.AddToTail( pTargetDMX );
if ( nIndex < 0 )
{
// Failed to add
return -1;
}
if ( !SetTargetDMX( nIndex, pszGeometryFile ) )
{
m_TargetDMXs.RemoveMultipleFromTail( 1 );
return -1;
}
return nIndex;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetQC::SetTargetDMX( int nLOD, const char *pszGeometryFile )
{
if ( nLOD >= TargetDMXCount() )
return false;
CSmartPtr< CTargetDMX > pTargetDMX = m_TargetDMXs.Element( nLOD );
if ( !pTargetDMX )
return false;
pTargetDMX->SetNameSuffix( GetNameSuffix() );
pTargetDMX->SetLod( nLOD );
pTargetDMX->SetQCITemplate( m_strQCITemplate.String() );
return pTargetDMX->SetInputFile( pszGeometryFile );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetQC::RemoveTargetDMX( int nLOD )
{
if ( nLOD != m_TargetDMXs.Count() - 1 )
return false;
m_TargetDMXs.RemoveMultipleFromTail( 1 );
return false;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CSmartPtr< CTargetDMX > CTargetQC::GetTargetDMX( int nLOD ) const
{
if ( nLOD >= TargetDMXCount() )
return NULL;
return m_TargetDMXs.Element( nLOD );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CSmartPtr< CTargetVCD > CTargetQC::GetTargetVCD()
{
if ( m_TargetVCD == NULL )
{
m_TargetVCD = Asset()->NewTarget< CTargetVCD >( this );
}
return m_TargetVCD;
}
//=============================================================================
//
//=============================================================================
CTargetMDL::CTargetMDL( CAsset *pAsset, const CTargetBase *pTargetParent )
: CTargetBase( pAsset, pTargetParent )
, m_pTargetQC( NULL )
{
m_pTargetQC = Asset()->NewTarget< CTargetQC >( this );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetMDL::IsOk( CUtlString &sMsg ) const
{
CUtlString sTmp;
if ( !m_pTargetQC || !m_pTargetQC->IsOk( sTmp ) )
{
sMsg = "Invalid QC: ";
sMsg += sTmp;
return false;
}
return true;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetMDL::Compile()
{
if ( !CTargetBase::Compile() )
return false;
CUtlString sName;
if ( !GetOutputPath( sName, 0, PATH_FLAG_FILE | PATH_FLAG_EXTENSION ) )
return false;
CUtlString sBinDir;
if ( !CItemUpload::GetBinDirectory( sBinDir ) )
{
Warning( "CTarget%s::Compile( %s ) - GetBinDirectory Failed\n", GetTypeString(), sName.String() );
return false;
}
CUtlVector< CUtlString > sAbsPaths;
GetOutputPaths( sAbsPaths );
if ( sAbsPaths.Count() <= 0 )
{
Warning( "CTarget%s::Compile( %s ) - GetOutputPaths failed\n", GetTypeString(), sName.String() );
return false;
}
CUtlString sAbsPath = sAbsPaths.Element( 0 );
CUtlString sRelPath;
GetOutputPath( sRelPath, 0, PATH_FLAG_ALL & ~PATH_FLAG_ABSOLUTE );
if ( sAbsPath.IsEmpty() || sRelPath.IsEmpty() )
{
Warning( "CTarget%s::Compile( %s ) - GetOutputPath failed\n", GetTypeString(), sName.String() );
return false;
}
CUtlVector< CUtlString > sAbsInputPaths;
if ( !GetInputPaths( sAbsInputPaths, false, false ) )
{
Warning( "CTarget%s::Compile( %s ) - GetInputPaths failed\n", GetTypeString(), sName.String() );
return false;
}
if ( sAbsInputPaths.Count() != 1 )
{
Warning( "CTarget%s::Compile( %s ) - GetPaths returned %d paths, expected 1\n", GetTypeString(), sName.String(), sAbsInputPaths.Count() );
return false;
}
if ( !Asset()->Mkdir( NULL, this ) )
{
Warning( "CTarget%s::Compile - Mkdir failed\n", GetTypeString() );
return false;
}
Msg( "Compiling %s: %s\n", GetTypeString(), sRelPath.String() );
if ( CItemUpload::GetP4() )
{
for ( int i = 0; i < sAbsPaths.Count(); ++i )
{
AddOrEditP4File( sAbsPaths.Element( i ).String() );
}
}
CUtlString sWorkingDir;
CFmtStrN< k64KB > sCmd;
if ( CItemUpload::IgnoreEnvironmentVariables() )
{
sWorkingDir = sAbsPath;
sWorkingDir.SetLength( sWorkingDir.Length() - sRelPath.Length() );
V_StripTrailingSlash( sWorkingDir.GetForModify() );
sCmd.sprintf( "\"%s\\studiomdl.exe\" -nop4 -game \"%s\" \"%s\"", sBinDir.String(), sWorkingDir.String(), sAbsInputPaths.Element( 0 ).String() );
}
else
{
CItemUpload::GetVProjectDir( sWorkingDir );
sCmd.sprintf( "\"%s\\studiomdl.exe\" -nop4 -vproject \"%s\" \"%s\"", sBinDir.String(), sWorkingDir.String(), sAbsInputPaths.Element( 0 ).String() );
}
bool bOk = true;
if ( CItemUpload::RunCommandLine( sCmd.Access(), sBinDir.String(), this ) )
{
for ( int i = 0; i < sAbsPaths.Count(); ++i )
{
if ( !CheckFile( sAbsPaths.Element( i ).String() ) )
{
Warning( "CTarget%s::Compile( %s ) - CheckFile failed - \"%s\"\n", GetTypeString(), sName.String(), sAbsPaths.Element( i ).String() );
bOk = false;
break;
}
}
}
else
{
bOk = false;
}
if ( bOk )
{
if ( CItemUpload::Manifest()->UseTerseMessages() )
{
Msg( " - Compilation successful.\n" );
}
else
{
Msg( "CTarget%s::Compile OK! - %s\n", GetTypeString(), sRelPath.String() );
}
}
else
{
Warning( "CTarget%s::Compile Failed - %s\n", GetTypeString(), sAbsPath.String() );
return false;
}
if ( GetCustomModPath() )
{
char szCustomPath[MAX_PATH];
V_MakeAbsolutePath( szCustomPath, sizeof( szCustomPath ), CFmtStr( "%s/%s", GetCustomModPath(), sRelPath.String() ), sWorkingDir.String() );
V_FixSlashes( szCustomPath );
DoFileCopy( sAbsPath.String(), szCustomPath );
Asset()->AddModOutput( szCustomPath );
}
return true;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
const ExtensionList *CTargetMDL::GetExtensionsAndCount( void ) const
{
// Only output .mdl for animation
CSmartPtr< CTargetQC > pTargetQC = GetTargetQC();
if ( pTargetQC.IsValid() && pTargetQC->GetQCITemplate() )
{
return CItemUpload::Manifest()->GetAnimationMDLExtentions();
}
return CItemUpload::Manifest()->GetMDLExtensions();
/*
static const char *s_szExtensionsDX8[] = {
".mdl",
".dx80.vtx",
".dx90.vtx",
".sw.vtx",
".phy",
".vvd"
};
static const char *s_szExtensions[] = {
".mdl",
".dx90.vtx",
".phy",
".vvd"
};
static const char **s_ppszExtensions = s_szExtensionsDX8;
static bool s_bGameInfoParsed = false;
if ( !s_bGameInfoParsed )
{
KeyValues *pKeyValues = new KeyValues( "gameinfo.txt" );
if ( pKeyValues != NULL )
{
if ( g_pFullFileSystem && pKeyValues->LoadFromFile( g_pFullFileSystem, "gameinfo.txt" ) )
{
if ( pKeyValues->GetInt( "SupportsDX8" ) != 0 )
{
s_ppszExtensions = s_szExtensionsDX8;
}
else
{
s_ppszExtensions = s_szExtensions;
}
s_bGameInfoParsed = true;
}
pKeyValues->deleteThis();
}
}
if ( s_ppszExtensions == s_szExtensions )
{
nExtensionCount = ARRAYSIZE( s_szExtensions );
}
else
{
nExtensionCount = ARRAYSIZE( s_szExtensionsDX8 );
}
return s_ppszExtensions;
*/
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CTargetMDL::GetInputs( CUtlVector< CTargetBase * > &inputs ) const
{
CUtlString sTmp;
if ( !IsOk( sTmp ) )
{
Warning( FUNCTION_LINE_STRING "Error! CTarget%s - Not Valid: %s\n", GetTypeString(), sTmp.String() );
return false;
}
inputs.RemoveAll();
inputs.AddToTail( m_pTargetQC.GetObject() );
return true;
}
//=============================================================================
//
//=============================================================================
CAsset::CAsset()
: CTargetBase( NULL, NULL )
, m_bSkinToBipHead( false )
, m_nCurrentModel( -1 )
, m_vmtMap( UtlStringLessThan )
, m_bShouldBuildScenesImage( false )
{
m_pAsset = this;
CItemUpload::GetSteamId( m_sSteamId );
AddModel();
m_vecTargetIcons.SetCount( CItemUpload::Manifest()->GetNumIconTypes() );
m_sExcludeFileExtensions.AddToTail( "zip" );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CAsset::CAsset( const char *pszName, bool *pbOk /* = NULL */ )
: CTargetBase( NULL, NULL )
, m_nCurrentModel( -1 )
, m_bShouldBuildScenesImage( false )
{
m_pAsset = this;
CItemUpload::GetSteamId( m_sSteamId );
m_sName = pszName;
AddModel();
m_vecTargetIcons.SetCount( CItemUpload::Manifest()->GetNumIconTypes() );
if ( pbOk )
{
CUtlString sTmp;
*pbOk = IsOk( sTmp );
if ( !( *pbOk ) )
{
Warning( FUNCTION_LINE_STRING "Error! CTarget%s - Not Valid: %s\n", GetTypeString(), sTmp.String() );
}
}
m_sExcludeFileExtensions.AddToTail( "zip" );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CAsset::~CAsset()
{
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CAsset::IsOk( CUtlString &sMsg ) const
{
if ( !IsNameValid() )
{
sMsg = "Invalid asset name";
return false;
}
if ( !IsSteamIdValid() )
{
sMsg = "Invalid steam id";
return false;
}
if ( !GetTargetMDL().IsValid() )
{
sMsg = "No target MDL";
return false;
}
CUtlString sTmp;
if ( !CItemUpload::GetContentDir( sTmp ) || sTmp.IsEmpty() )
{
sMsg = "Cannot figure out content directory, have you installed the Source SDK and restarted Steam?";
return false;
}
return true;
}
bool CAsset::BuildScenesImage()
{
CUtlString sBinDir;
if ( !CItemUpload::GetBinDirectory( sBinDir ) )
{
Warning( "CTarget%s::Compile( %s ) - GetBinDirectory Failed\n", GetTypeString(), GetAssetName() );
return false;
}
CUtlString sAbsPath;
GetOutputPath( sAbsPath );
CUtlString sRelPath;
GetOutputPath( sRelPath, 0, PATH_FLAG_ALL & ~PATH_FLAG_ABSOLUTE );
CUtlString sWorkingDir;
if ( CItemUpload::IgnoreEnvironmentVariables() )
{
sWorkingDir = sAbsPath;
sWorkingDir.SetLength( sWorkingDir.Length() - sRelPath.Length() );
V_StripTrailingSlash( sWorkingDir.GetForModify() );
}
else
{
CItemUpload::GetVProjectDir( sWorkingDir );
}
char szScenesImage[MAX_PATH];
V_MakeAbsolutePath( szScenesImage, sizeof( szScenesImage ), "scenes\\scenes.image", sWorkingDir.String() );
AddOrEditP4File( szScenesImage );
CFmtStrN< k64KB > sCmd;
sCmd.sprintf( "%s\\makescenesimage.exe", sBinDir.String() );
if ( !CItemUpload::RunCommandLine( sCmd.Access(), sWorkingDir.String(), this ) )
{
Warning( "Failed to build %s\n", szScenesImage );
return false;
}
Msg( "Build scenes.image OK!\n" );
if ( GetCustomModPath() )
{
char szCustomPath[MAX_PATH];
V_MakeAbsolutePath( szCustomPath, sizeof( szCustomPath ), CFmtStr( "%s/%s", GetCustomModPath(), "scenes/scenes.image" ), sWorkingDir.String() );
V_FixSlashes( szCustomPath );
DoFileCopy( szScenesImage, szCustomPath );
Asset()->AddModOutput( szCustomPath );
}
return true;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CAsset::CompilePreview()
{
bool bOldP4State = CItemUpload::GetP4();
CItemUpload::SetP4( false );
m_CompileOutputFiles.RemoveAll();
g_bCompilePreview = true;
// Record the files that are created so they can be removed after preview
m_sAbsPaths.RemoveAll();
m_sRelPaths.RemoveAll();
m_sModOutputs.RemoveAll();
CUtlVector< CTargetBase * > inputs;
if ( GetInputs( inputs ) )
{
for ( int i = 0; i < inputs.Count(); ++i )
{
CTargetBase *pTargetBase = inputs.Element( i );
if ( !pTargetBase )
continue;
pTargetBase->GetOutputPaths( m_sAbsPaths, PATH_FLAG_ALL, true );
pTargetBase->GetOutputPaths( m_sRelPaths, (PATH_FLAG_ALL & ~PATH_FLAG_ABSOLUTE) | PATH_FLAG_ZIP, true );
}
}
bool bResult = CTargetBase::Compile();
g_bCompilePreview = false;
CItemUpload::SetP4( bOldP4State );
if ( bResult )
{
PostCompilePreview();
}
return bResult;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CAsset::PostCompilePreview()
{
Msg( "CAsset::PostCompilePreview Start:\n");
bool bResult = true;
if ( m_bShouldBuildScenesImage )
{
bResult = BuildScenesImage();
}
if ( bResult )
{
Msg( "CAsset::PostCompilePreview OK!\n" );
}
else
{
Msg( "CAsset::PostCompilePreview FAILED!\n" );
}
return bResult;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CAsset::Compile()
{
m_CompileOutputFiles.RemoveAll();
if ( m_sArchivePath.IsEmpty() )
{
GetOutputPath( m_sArchivePath, 0 );
}
CUtlString sRelPath;
GetOutputPath( sRelPath, 0, PATH_FLAG_ALL & ~PATH_FLAG_ABSOLUTE );
if ( m_sArchivePath.IsEmpty() || sRelPath.IsEmpty() )
{
Warning( "CTarget%s::Compile - GetOutputPath failed\n", GetTypeString() );
return false;
}
// this gets filled by Compile()
m_sModOutputs.RemoveAll();
if ( !CTargetBase::Compile() )
return false;
m_sAbsPaths.RemoveAll();
GetOutputPaths( m_sAbsPaths, PATH_FLAG_ALL, true );
m_sRelPaths.RemoveAll();
GetOutputPaths( m_sRelPaths, (PATH_FLAG_ALL & ~PATH_FLAG_ABSOLUTE) | PATH_FLAG_ZIP, true );
Assert( m_sAbsPaths.Count() == m_sRelPaths.Count() );
if ( m_sAbsPaths.Count() <= 0 || m_sAbsPaths.Count() != m_sRelPaths.Count() )
{
Warning( "CTarget%s::Compile - GetOutputPaths failed\n", GetTypeString() );
return false;
}
Msg( "Compiling %s: %s\n", GetTypeString(), sRelPath.String() );
AddOrEditP4File( m_sArchivePath.String() );
if ( CItemUpload::FileExists( m_sArchivePath.String() ) )
{
_unlink( m_sArchivePath.String() );
}
HANDLE m_hOutputZipFile = CreateFile( m_sArchivePath.String(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
if ( m_hOutputZipFile == INVALID_HANDLE_VALUE )
{
Warning( "CTarget%s::Compile CreateZip Failed - Unable to create ZIP file %s.\n", GetTypeString(), m_sArchivePath.String() );
return false;
}
IZip *pZip = IZip::CreateZip();
if ( pZip == NULL )
{
Warning( "CTarget%s::Compile CreateZip Failed - %s\n", GetTypeString(), sRelPath.String() );
CloseHandle( m_hOutputZipFile );
return false;
}
CUtlBuffer kvBuf( 0, 0, CUtlBuffer::TEXT_BUFFER );
CreateManifest( kvBuf );
pZip->AddBufferToZip( "manifest.txt", kvBuf.Base(), kvBuf.TellPut(), true );
for ( int i = 0; i < m_sAbsPaths.Count(); ++i )
{
const char *pszFileExtension = V_GetFileExtension( m_sAbsPaths.Element( i ).String() );
bool bExcluded = false;
FOR_EACH_VEC( m_sExcludeFileExtensions, e )
{
if ( m_sExcludeFileExtensions[e] == pszFileExtension )
{
bExcluded = true;
break;
}
}
if ( bExcluded )
continue;
if ( CItemUpload::Manifest()->UseTerseMessages() )
{
Msg( " - added %s\n", m_sRelPaths.Element( i ).String() );
}
else
{
Msg( " + Zip Add: %s\n", m_sRelPaths.Element( i ).String() );
}
pZip->AddFileToZip( m_sRelPaths.Element( i ).String(), m_sAbsPaths.Element( i ).String() );
}
pZip->SaveToDisk( m_hOutputZipFile );
IZip::ReleaseZip( pZip );
CloseHandle( m_hOutputZipFile );
if ( !CheckFile( m_sArchivePath.String() ) )
{
if ( CItemUpload::Manifest()->UseTerseMessages() )
{
Warning( "Failed to write .zip file: \"%s\"\n", m_sArchivePath.String() );
}
else
{
Warning( "CTarget%s::Compile - File Check Failed - \"%s\"\n", GetTypeString(), m_sArchivePath.String() );
}
return false;
}
if ( CItemUpload::Manifest()->UseTerseMessages() )
{
Msg( " - Compilation successful.\n" );
}
else
{
Msg( "CTarget%s::Compile OK! - %s\n", GetTypeString(), sRelPath.String() );
}
return PostCompile();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CAsset::PostCompile()
{
Msg( "CAsset::PostCompile Start:\n");
bool bResult = true;
if ( m_bShouldBuildScenesImage )
{
bResult = BuildScenesImage();
}
if ( bResult )
{
Msg( "CAsset::PostCompile OK!\n" );
}
else
{
Msg( "CAsset::PostCompile FAILED!\n" );
}
return bResult;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CAsset::GetInputs( CUtlVector< CTargetBase * > &inputs ) const
{
CUtlString sTmp;
if ( !IsOk( sTmp ) )
{
Warning( FUNCTION_LINE_STRING "Error! CTarget%s - Not Valid: %s\n", GetTypeString(), sTmp.String() );
return false;
}
for ( int nIcon = 0; nIcon < m_vecTargetIcons.Count(); ++nIcon )
{
if ( m_vecTargetIcons[ nIcon ].IsValid() )
{
inputs.AddToTail( m_vecTargetIcons[ nIcon ].GetObject() );
}
}
for ( int i = 0; i < GetTargetVMTCount(); ++i )
{
inputs.AddToTail( GetTargetVMT( i ) );
}
FOR_EACH_VEC( m_vecModels, nModelIndex )
{
if ( m_vecModels[ nModelIndex ].IsValid() )
{
inputs.AddToTail( m_vecModels[ nModelIndex ].GetObject() );
}
}
return inputs.Count() > 0;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
const ExtensionList *CAsset::GetExtensionsAndCount( void ) const
{
static ExtensionList vecExtensions;
if ( !vecExtensions.Count() )
{
vecExtensions.AddToTail( ".zip" );
}
return &vecExtensions;
}
//-----------------------------------------------------------------------------
// Returns items/<steamid>/<name>, false if there's something wrong
//-----------------------------------------------------------------------------
bool CAsset::GetRelativeDir( CUtlString &sRelativeDir, const char *pszPrefix, const CTargetBase *pTarget ) const
{
CUtlString sTmp;
if ( !IsOk( sTmp ) )
{
Warning( FUNCTION_LINE_STRING "Error! CTarget%s - Not Valid: %s\n", GetTypeString(), sTmp.String() );
return false;
}
if ( pszPrefix )
{
sRelativeDir = pszPrefix;
sRelativeDir += "/";
}
else
{
sRelativeDir = "";
}
if ( pTarget->IsModelPath() )
sRelativeDir += "models/";
if ( pTarget->GetCustomRelativeDir() )
{
sRelativeDir += pTarget->GetCustomRelativeDir();
}
else
{
sRelativeDir += pTarget->GetItemDirectory();
const char *pszClass = GetClass();
if ( pszClass )
{
sRelativeDir += pszClass;
sRelativeDir += "/";
}
if ( CItemUpload::Manifest()->GetItemPathUsesSteamId() )
{
if ( !m_sSteamId.IsEmpty() )
{
sRelativeDir += m_sSteamId;
sRelativeDir += "/";
}
}
sRelativeDir += m_sName;
}
sRelativeDir.FixSlashes();
return true;
}
//-----------------------------------------------------------------------------
// Returns GetAbsoluteContentDir()/GetRelativeDir() or GetAbsoluteGameDir()/GetRelativeDir()
//-----------------------------------------------------------------------------
bool CAsset::GetAbsoluteDir( CUtlString &sAbsoluteDir, const char *pszPrefix /* = NULL */, const CTargetBase *pTarget ) const
{
CUtlString sDirA;
if ( pTarget->IsContent() )
{
if ( !CItemUpload::GetContentDir( sDirA ) )
return false;
}
else
{
if ( !CItemUpload::GetVProjectDir( sDirA ) )
return false;
}
CUtlString sDirB;
if ( !GetRelativeDir( sDirB, pszPrefix, pTarget ) )
return false;
sAbsoluteDir = sDirA;
sAbsoluteDir += "/";
sAbsoluteDir += sDirB;
sAbsoluteDir.FixSlashes();
return true;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CAsset::SetName( const char *pszName )
{
if ( !CItemUpload::SanitizeName( pszName, m_sName ) )
return false;
return IsNameValid();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CAsset::IsNameValid() const
{
return m_sName.Length() > 0;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
const char *CAsset::GetSteamId() const
{
return m_sSteamId.String();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CAsset::IsSteamIdValid() const
{
return CItemUpload::GetDevMode() || m_sSteamId.Length() > 0;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CAsset::SetTargetIcon( int nIcon, const char *pszIconFile )
{
if ( !m_vecTargetIcons[ nIcon ].IsValid() )
{
m_vecTargetIcons[ nIcon ] = new CTargetIcon( this, nIcon );
}
return m_vecTargetIcons[ nIcon ]->SetTargetVTF( pszIconFile );
}
//-----------------------------------------------------------------------------
// Add a new model to the output and make it current
//-----------------------------------------------------------------------------
int CAsset::AddModel()
{
CSmartPtr< CTargetMDL > pModel = NewTarget< CTargetMDL >( this );
m_nCurrentModel = m_vecModels.AddToTail( pModel );
return m_nCurrentModel;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CAsset::SetCurrentModel( int nModel )
{
if ( nModel >= 0 && nModel < GetNumModels() )
{
m_nCurrentModel = nModel;
return true;
}
return false;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CAsset::RemoveModels()
{
m_vecModels.RemoveAll();
m_nCurrentModel = -1;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
int CAsset::TargetDMXCount() const
{
CSmartPtr< CTargetQC > pTargetQC = GetTargetQC();
if ( !pTargetQC )
return false;
return pTargetQC->TargetDMXCount();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
int CAsset::AddTargetDMX( const char *pszGeometryFile )
{
CSmartPtr< CTargetQC > pTargetQC = GetTargetQC();
if ( !pTargetQC )
return -1;
return pTargetQC->AddTargetDMX( pszGeometryFile );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CAsset::SetTargetDMX( int nLOD, const char *pszGeometryFile )
{
CSmartPtr< CTargetQC > pTargetQC = GetTargetQC();
if ( !pTargetQC )
return false;
return pTargetQC->SetTargetDMX( nLOD, pszGeometryFile );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CAsset::RemoveTargetDMX( int nLOD )
{
CSmartPtr< CTargetQC > pTargetQC = GetTargetQC();
if ( !pTargetQC )
return false;
return pTargetQC->RemoveTargetDMX( nLOD );
}
//-----------------------------------------------------------------------------
//
//----------------------------------------------------------------------------
CSmartPtr< CTargetDMX > CAsset::GetTargetDMX( int nLOD )
{
CSmartPtr< CTargetQC > pTargetQC = GetTargetQC();
if ( !pTargetQC )
return false;
return pTargetQC->GetTargetDMX( nLOD );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CSmartPtr< CTargetMDL > CAsset::GetTargetMDL() const
{
if ( m_nCurrentModel >= 0 )
{
return m_vecModels[ m_nCurrentModel ];
}
return CSmartPtr< CTargetMDL >();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CSmartPtr< CTargetQC > CAsset::GetTargetQC() const
{
CSmartPtr< CTargetMDL > pTargetMDL = GetTargetMDL();
if ( !pTargetMDL )
return NULL;
return pTargetMDL->GetTargetQC();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
int CAsset::GetTargetVMTCount() const
{
return m_vmtMap.Count();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CTargetVMT *CAsset::GetTargetVMT( int nIndex ) const
{
if ( nIndex < 0 || nIndex >= GetTargetVMTCount() )
return NULL;
int nMapIndex = 0;
FOR_EACH_MAP( m_vmtMap, nMapIt )
{
if ( nIndex == nMapIndex )
return m_vmtMap.Element( nMapIt );
++nMapIndex;
}
return NULL;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CSmartPtr< CTargetVMT > CAsset::FindOrAddMaterial( const char *pszMaterial, int nMaterialType )
{
const CUtlString sMaterial( pszMaterial );
CUtlMap< CUtlString, CTargetVMT * >::IndexType_t nIndex = m_vmtMap.Find( sMaterial );
if ( !m_vmtMap.IsValidIndex( nIndex ) )
{
CSmartPtr< CTargetVMT > pTargetVMT = NewTarget< CTargetVMT >( this );
if ( !pTargetVMT )
return NULL;
pTargetVMT->SetMaterialId( pszMaterial );
m_vmtMap.Insert( sMaterial, pTargetVMT.GetObject() );
// See if this is a duplicate of an existing material
for ( int i = 0; i < GetTargetVMTCount(); ++i )
{
CTargetVMT *pTmpTargetVMT = GetTargetVMT( i );
if ( !pTmpTargetVMT )
continue;
if ( pTmpTargetVMT->GetMaterialType() == nMaterialType )
{
pTargetVMT->SetDuplicate( nMaterialType );
break;
}
}
if ( !pTargetVMT->GetDuplicate() )
{
pTargetVMT->SetMaterialType( nMaterialType );
}
return pTargetVMT;
}
else
{
return m_vmtMap.Element( nIndex );
}
return NULL;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
CSmartPtr< CTargetVMT > CAsset::FindMaterial( const char *pszMaterial )
{
const CUtlString sMaterial( pszMaterial );
CUtlMap< CUtlString, CTargetVMT * >::IndexType_t nIndex = m_vmtMap.Find( sMaterial );
if ( m_vmtMap.IsValidIndex( nIndex ) )
return m_vmtMap.Element( nIndex );
return NULL;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CAsset::Mkdir( const char *pszPrefix, const CTargetBase *pTarget )
{
CUtlString sAbsolute;
if ( !GetAbsoluteDir( sAbsolute, pszPrefix, pTarget ) )
return false;
char szBuf[ k64KB ];
if ( _fullpath( szBuf, sAbsolute.String(), ARRAYSIZE( szBuf ) ) == NULL )
return false;
return CItemUpload::CreateDirectory( szBuf );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CAsset::CreateManifest( CUtlBuffer &manifestBuf )
{
KeyValues *pAssetKV = new KeyValues( "asset" );
UpdateManifest( pAssetKV );
manifestBuf.Clear();
manifestBuf.SetBufferType( true, true );
pAssetKV->RecursiveSaveToFile( manifestBuf, 0 );
pAssetKV->deleteThis();
}
const char* CAsset::CheckRedundantOutputFilePath( const char* pszInputFilePath, const char* pszVTEXConfig, const char* pszOutputFilePath )
{
const char* pszLocalVTEXConfig = pszVTEXConfig ? pszVTEXConfig : "";
// we don't want to output multiple of the same texture file with the same vtex config
for ( int i=0; i<m_CompileOutputFiles.Count(); ++i )
{
const CompileOutputFile_t& tga = m_CompileOutputFiles[i];
if ( !V_stricmp( tga.m_strInputFilePath.String(), pszInputFilePath ) )
{
if ( !V_stricmp( tga.m_strVTEXConfig.String(), pszLocalVTEXConfig ) )
{
return tga.m_strOutputFilePath.String();
}
}
}
int index = m_CompileOutputFiles.AddToTail();
CompileOutputFile_t& newTGA = m_CompileOutputFiles[index];
newTGA.m_strInputFilePath = pszInputFilePath;
newTGA.m_strVTEXConfig = pszLocalVTEXConfig;
newTGA.m_strOutputFilePath = pszOutputFilePath;
return newTGA.m_strOutputFilePath.String();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CAsset::RemoveMaterial( const char *pszMaterial )
{
const CUtlString sMaterial( pszMaterial );
return m_vmtMap.Remove( sMaterial );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
const CUtlString &CAsset::GetAssetName() const
{
return m_sName;
}