1
This commit is contained in:
FluorescentCIAAfricanAmerican
775
utils/texturecompile/texturecompile.cpp
Normal file
775
utils/texturecompile/texturecompile.cpp
Normal file
@ -0,0 +1,775 @@
|
||||
//========= Copyright Valve Corporation, All rights reserved. ============//
|
||||
//
|
||||
// Purpose:
|
||||
//
|
||||
// $NoKeywords: $
|
||||
//
|
||||
//=============================================================================//
|
||||
// vmpi_bareshell.cpp : Defines the entry point for the console application.
|
||||
//
|
||||
|
||||
#include <windows.h>
|
||||
#include <conio.h>
|
||||
#include <process.h>
|
||||
#include "vmpi.h"
|
||||
#include "filesystem.h"
|
||||
#include "vmpi_filesystem.h"
|
||||
#include "vmpi_distribute_work.h"
|
||||
#include "vmpi_tools_shared.h"
|
||||
#include "cmdlib.h"
|
||||
#include "tier1/utlvector.h"
|
||||
#include "tier1/utlbuffer.h"
|
||||
#include "tier1/utllinkedlist.h"
|
||||
#include "tier1/utlstringmap.h"
|
||||
#include "tier0/icommandline.h"
|
||||
#include "tier1/strtools.h"
|
||||
#include "threads.h"
|
||||
#include "tier0/dbg.h"
|
||||
#include "interface.h"
|
||||
#include "ilaunchabledll.h"
|
||||
#include <direct.h>
|
||||
#include "io.h"
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
|
||||
#define STARTWORK_PACKETID 5
|
||||
#define WORKUNIT_PACKETID 6
|
||||
#define ERRMSG_PACKETID 7
|
||||
#define TEXTUREHADERROR_PACKETID 8
|
||||
#define MACHINE_NAME 9
|
||||
|
||||
#define TEXTURES_PER_WORKUNIT 1
|
||||
|
||||
#ifdef _DEBUG
|
||||
//#define DEBUGFP
|
||||
#endif
|
||||
|
||||
const char *g_pGameDir = NULL;
|
||||
const char *g_pTextureOutputDir = NULL;
|
||||
char g_WorkerTempPath[MAX_PATH];
|
||||
char g_ExeDir[MAX_PATH];
|
||||
CUtlVector<char *> g_CompileCommands;
|
||||
int g_nTexturesPerWorkUnit = 0;
|
||||
#ifdef DEBUGFP
|
||||
FILE *g_WorkerDebugFp = NULL;
|
||||
#endif
|
||||
bool g_bGotStartWorkPacket = false;
|
||||
double g_flStartTime;
|
||||
bool g_bVerbose = false;
|
||||
|
||||
struct TextureInfo_t
|
||||
{
|
||||
};
|
||||
|
||||
void Texture_ParseTextureInfoFromCompileCommands( int nCompileCommandID, TextureInfo_t &shaderInfo );
|
||||
void Worker_GetSourceFiles( int iWorkUnit );
|
||||
|
||||
void Worker_GetLocalCopyOfTextureSource( const char *pVtfName );
|
||||
|
||||
// g_ByteCode["shadername"][shadercombo][bytecodeoffset]
|
||||
//typedef CUtlVector<CUtlBuffer> VectorOfBuffers_t;
|
||||
|
||||
//CUtlStringMap<TextureInfo_t> g_TextureToTextureInfo;
|
||||
|
||||
typedef CUtlVector<char> CharVector_t;
|
||||
|
||||
struct SourceTargetPair_t
|
||||
{
|
||||
char *pSrcName;
|
||||
char *pTargetName;
|
||||
};
|
||||
|
||||
CUtlVector<SourceTargetPair_t> g_SourceTargetPairs;
|
||||
|
||||
CUtlStringMap<bool> g_Master_TextureHadError;
|
||||
|
||||
CDispatchReg g_DistributeWorkReg( WORKUNIT_PACKETID, DistributeWorkDispatch );
|
||||
|
||||
unsigned long VMPI_Stats_GetJobWorkerID( void )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
bool StartWorkDispatch( MessageBuffer *pBuf, int iSource, int iPacketID )
|
||||
{
|
||||
g_bGotStartWorkPacket = true;
|
||||
return true;
|
||||
}
|
||||
|
||||
CDispatchReg g_StartWorkReg( STARTWORK_PACKETID, StartWorkDispatch );
|
||||
|
||||
bool ErrMsgDispatch( MessageBuffer *pBuf, int iSource, int iPacketID )
|
||||
{
|
||||
static CUtlStringMap<bool> errorMessages;
|
||||
if( !errorMessages.Defined( pBuf->data + 1 ) )
|
||||
{
|
||||
errorMessages[pBuf->data + 1] = true;
|
||||
fprintf( stderr, "ERROR: %s\n", pBuf->data + 1 );
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
CDispatchReg g_ErrMsgReg( ERRMSG_PACKETID, ErrMsgDispatch );
|
||||
|
||||
bool TextureHadErrorDispatch( MessageBuffer *pBuf, int iSource, int iPacketID )
|
||||
{
|
||||
g_Master_TextureHadError[pBuf->data+1] = true;
|
||||
return true;
|
||||
}
|
||||
|
||||
CDispatchReg g_TextureHadErrorReg( TEXTUREHADERROR_PACKETID, TextureHadErrorDispatch );
|
||||
|
||||
void DebugOut( const char *pMsg, ... )
|
||||
{
|
||||
char msg[2048];
|
||||
va_list marker;
|
||||
va_start( marker, pMsg );
|
||||
_vsnprintf( msg, sizeof( msg ), pMsg, marker );
|
||||
va_end( marker );
|
||||
|
||||
if (g_bVerbose)
|
||||
{
|
||||
Msg( "%s", msg );
|
||||
}
|
||||
|
||||
#ifdef DEBUGFP
|
||||
fprintf( g_WorkerDebugFp, "%s", msg );
|
||||
fflush( g_WorkerDebugFp );
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
// Worker should implement this so it will quit nicely when the master disconnects.
|
||||
void MyDisconnectHandler( int procID, const char *pReason )
|
||||
{
|
||||
// If we're a worker, then it's a fatal error if we lose the connection to the master.
|
||||
if ( !g_bMPIMaster )
|
||||
{
|
||||
Msg( "Master disconnected.\n ");
|
||||
DebugOut( "Master disconnected.\n" );
|
||||
TerminateProcess( GetCurrentProcess(), 1 );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// pBuf is ready to read the results written to the buffer in ProcessWorkUnitFn.
|
||||
// work is done. .master gets it back this way.
|
||||
// compiled code in pBuf
|
||||
void Master_ReceiveWorkUnitFn( uint64 iWorkUnit, MessageBuffer *pBuf, int iWorker )
|
||||
{
|
||||
DebugOut( "Master_ReceiveWorkUnitFn\n" );
|
||||
int textureStart = iWorkUnit * g_nTexturesPerWorkUnit;
|
||||
int textureEnd = textureStart + g_nTexturesPerWorkUnit;
|
||||
textureEnd = min( g_CompileCommands.Count(), textureEnd );
|
||||
int i;
|
||||
for( i = textureStart; i < textureEnd; i++ )
|
||||
{
|
||||
int len;
|
||||
pBuf->read( &len, sizeof( len ) );
|
||||
if( len == 0 )
|
||||
{
|
||||
continue;
|
||||
}
|
||||
CUtlBuffer fileData;
|
||||
fileData.EnsureCapacity( len );
|
||||
pBuf->read( fileData.Base(), len );
|
||||
|
||||
Warning( "%s\n", g_CompileCommands[i] );
|
||||
FILE *fp;
|
||||
fp = fopen( g_CompileCommands[i], "wb" );
|
||||
if ( !fp )
|
||||
Error( "Can't open %s for writing.\n", g_CompileCommands[i] );
|
||||
fwrite( fileData.Base(), 1, len, fp );
|
||||
fclose( fp );
|
||||
}
|
||||
}
|
||||
|
||||
// same as "system", but doesn't pop up a window
|
||||
void MySystem( char *pCommand )
|
||||
{
|
||||
FILE *batFp = fopen( "temp.bat", "w" );
|
||||
fprintf( batFp, "%s\n", pCommand );
|
||||
fclose( batFp );
|
||||
|
||||
STARTUPINFO si;
|
||||
PROCESS_INFORMATION pi;
|
||||
|
||||
ZeroMemory( &si, sizeof(si) );
|
||||
si.cb = sizeof(si);
|
||||
ZeroMemory( &pi, sizeof(pi) );
|
||||
|
||||
// Start the child process.
|
||||
if( !CreateProcess( NULL, // No module name (use command line).
|
||||
"temp.bat", // Command line.
|
||||
NULL, // Process handle not inheritable.
|
||||
NULL, // Thread handle not inheritable.
|
||||
FALSE, // Set handle inheritance to FALSE.
|
||||
IDLE_PRIORITY_CLASS | CREATE_NO_WINDOW, // No creation flags.
|
||||
NULL, // Use parent's environment block.
|
||||
g_WorkerTempPath, // Use parent's starting directory.
|
||||
&si, // Pointer to STARTUPINFO structure.
|
||||
&pi ) // Pointer to PROCESS_INFORMATION structure.
|
||||
)
|
||||
{
|
||||
Error( "CreateProcess failed." );
|
||||
Assert( 0 );
|
||||
}
|
||||
|
||||
// Wait until child process exits.
|
||||
WaitForSingleObject( pi.hProcess, INFINITE );
|
||||
|
||||
// Close process and thread handles.
|
||||
CloseHandle( pi.hProcess );
|
||||
CloseHandle( pi.hThread );
|
||||
}
|
||||
|
||||
void VTFNameToTGAName( const char *pSrcName, char *pDstName )
|
||||
{
|
||||
pDstName[0] = '\0';
|
||||
const char *pMaterials = Q_stristr( pSrcName, "materials" );
|
||||
Assert( pMaterials );
|
||||
if( pMaterials )
|
||||
{
|
||||
Q_strncpy( pDstName, pSrcName, pMaterials - pSrcName + 1 );
|
||||
}
|
||||
Q_strcat( pDstName, "materialsrc", MAX_PATH );
|
||||
Q_strcat( pDstName, pMaterials + strlen( "materials" ), MAX_PATH );
|
||||
Q_StripExtension( pDstName, pDstName, strlen( pDstName ) );
|
||||
Q_strcat( pDstName, ".tga", MAX_PATH );
|
||||
}
|
||||
|
||||
// You must append data to pBuf with the work unit results.
|
||||
void Worker_ProcessWorkUnitFn( int iThread, uint64 iWorkUnit, MessageBuffer *pBuf )
|
||||
{
|
||||
DebugOut( "Worker_ProcessWorkUnitFn textures/workunit=%d\n", g_nTexturesPerWorkUnit );
|
||||
Worker_GetSourceFiles( iWorkUnit );
|
||||
int textureStart = iWorkUnit * g_nTexturesPerWorkUnit;
|
||||
int textureEnd = textureStart + g_nTexturesPerWorkUnit;
|
||||
textureEnd = min( g_CompileCommands.Count(), textureEnd );
|
||||
|
||||
int i;
|
||||
for( i = textureStart; i < textureEnd; i++ )
|
||||
{
|
||||
DebugOut( "texture to compile: \"%s\"\n", g_CompileCommands[i] );
|
||||
char cmdline[1024];
|
||||
char tganame[1024];
|
||||
VTFNameToTGAName( g_CompileCommands[i], tganame );
|
||||
sprintf( cmdline, "vtex -allowdebug -vproject \"%s%s\" -mkdir -nopause \"%s%s\"", g_WorkerTempPath, g_pGameDir + 3, g_WorkerTempPath, tganame + 3 ); // hack hack
|
||||
DebugOut( cmdline );
|
||||
DebugOut( "\n" );
|
||||
// MySystem( cmdline );
|
||||
system( cmdline );
|
||||
|
||||
char localVTFName[1024];
|
||||
sprintf( localVTFName, "%s%s", g_WorkerTempPath, g_CompileCommands[i] + 3 );
|
||||
DebugOut( "local: \"%s\"\n", localVTFName );
|
||||
|
||||
FILE *fp = fopen( localVTFName, "rb" );
|
||||
if( fp )
|
||||
{
|
||||
// Send the compiled shader to the master
|
||||
fseek( fp, 0, SEEK_END );
|
||||
int len = ftell( fp );
|
||||
fseek( fp, 0, SEEK_SET );
|
||||
CUtlBuffer buf;
|
||||
buf.EnsureCapacity( len );
|
||||
int nBytesRead = fread( buf.Base(), 1, len, fp );
|
||||
fclose( fp );
|
||||
buf.SeekPut( CUtlBuffer::SEEK_HEAD, nBytesRead );
|
||||
|
||||
pBuf->write( &len, sizeof( len ) );
|
||||
pBuf->write( buf.Base(), len );
|
||||
}
|
||||
else
|
||||
{
|
||||
// static CUtlStringMap<bool> m_FileAlreadyFailed;
|
||||
//
|
||||
// if( !m_FileAlreadyFailed.Defined( g_CompileCommands[i] ) )
|
||||
// {
|
||||
// m_FileAlreadyFailed[g_CompileCommands[i]] = true;
|
||||
// CUtlVector<char> fileNameBuf;
|
||||
// fileNameBuf.AddToTail( ( char )TEXTUREHADERROR_PACKETID );
|
||||
// int len = strlen( g_CompileCommands[i] );
|
||||
// fileNameBuf.AddMultipleToTail( len + 1, g_CompileCommands[i] );
|
||||
// VMPI_SendData( fileNameBuf.Base(), fileNameBuf.Count(), VMPI_MASTER_ID );
|
||||
// }
|
||||
|
||||
// Write zero to signify that we didn't do anything here.
|
||||
int len = 0;
|
||||
pBuf->write( &len, sizeof( len ) );
|
||||
}
|
||||
VMPI_HandleSocketErrors();
|
||||
}
|
||||
}
|
||||
|
||||
void MakeDirHier( const char *pPath )
|
||||
{
|
||||
char temp[1024];
|
||||
Q_strncpy( temp, pPath, 1024 );
|
||||
int i;
|
||||
for( i = 0; i < strlen( temp ); i++ )
|
||||
{
|
||||
if( temp[i] == '/' || temp[i] == '\\' )
|
||||
{
|
||||
temp[i] = '\0';
|
||||
// DebugOut( "mkdir( %s )\n", temp );
|
||||
mkdir( temp );
|
||||
temp[i] = '\\';
|
||||
}
|
||||
}
|
||||
// DebugOut( "mkdir( %s )\n", temp );
|
||||
mkdir( temp );
|
||||
}
|
||||
|
||||
void Worker_ReadFilesToCopy( void )
|
||||
{
|
||||
// Create virtual files for all of the stuff that we need to compile the shader
|
||||
// make sure and prefix the file name so that it doesn't find it locally.
|
||||
char filename[1024];
|
||||
sprintf( filename, "%s\\filestocopy.txt", g_pGameDir );
|
||||
DebugOut( "using \"%s\" as filestocopy\n", filename );
|
||||
char buf[1024];
|
||||
FileHandle_t fp = g_pFileSystem->Open( filename, "r" );
|
||||
if( fp == FILESYSTEM_INVALID_HANDLE )
|
||||
{
|
||||
fprintf( stderr, "Can't open uniquefilestocopy.txt!\n" );
|
||||
exit( -1 );
|
||||
}
|
||||
|
||||
while( CmdLib_FGets( buf, sizeof( buf ), fp ) )
|
||||
{
|
||||
// get rid of the newline if there is one.
|
||||
int len = strlen( buf );
|
||||
if( buf[len-1] == 0xd || buf[len-1] == 0xa )
|
||||
{
|
||||
buf[len-1] = '\0';
|
||||
}
|
||||
// DebugOut( "buf: %s\n", buf );
|
||||
|
||||
char *pStar = Q_stristr( buf, "*" );
|
||||
Assert( pStar );
|
||||
if( !pStar )
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
*pStar = '\0';
|
||||
char *pVtfName = buf;
|
||||
char *pSrcName = pStar + 1;
|
||||
|
||||
SourceTargetPair_t &pair = g_SourceTargetPairs[g_SourceTargetPairs.AddToTail()];
|
||||
pair.pSrcName = strdup( pSrcName );
|
||||
pair.pTargetName = strdup( pVtfName );
|
||||
}
|
||||
g_pFileSystem->Close( fp );
|
||||
}
|
||||
|
||||
void Worker_GetSourceFiles( int iWorkUnit )
|
||||
{
|
||||
DebugOut( "Worker_GetSourceFiles( %d )\n", iWorkUnit );
|
||||
int textureStart = iWorkUnit * g_nTexturesPerWorkUnit;
|
||||
int textureEnd = textureStart + g_nTexturesPerWorkUnit;
|
||||
textureEnd = min( g_CompileCommands.Count(), textureEnd );
|
||||
int i;
|
||||
for( i = textureStart; i < textureEnd; i++ )
|
||||
{
|
||||
Worker_GetLocalCopyOfTextureSource( g_CompileCommands[i] );
|
||||
}
|
||||
}
|
||||
|
||||
void Worker_GetFileFromMaster( const char *pFileName )
|
||||
{
|
||||
DebugOut( "Worker_GetFileFromMaster: \"%s\"\n", pFileName );
|
||||
FileHandle_t fp2 = g_pFileSystem->Open( pFileName, "rb" );
|
||||
bool bZeroLength = false;
|
||||
if( fp2 == FILESYSTEM_INVALID_HANDLE )
|
||||
{
|
||||
bZeroLength = true;
|
||||
Warning( "zero length file: \"%s\"\n", pFileName );
|
||||
// make a zero length file hack hack hack
|
||||
// continue;
|
||||
}
|
||||
CUtlVector<char> fileBuf;
|
||||
int fileLen = 0;
|
||||
if( !bZeroLength )
|
||||
{
|
||||
// printf( "getting local copy of file: \"%s\"\n", pFileName );
|
||||
fileLen = g_pFileSystem->Size( fp2 );
|
||||
fileBuf.SetCount( fileLen );
|
||||
g_pFileSystem->Read( fileBuf.Base(), fileLen, fp2 );
|
||||
g_pFileSystem->Close( fp2 );
|
||||
}
|
||||
|
||||
// create the dir that the file needs to go into.
|
||||
char path[1024];
|
||||
char filename[1024];
|
||||
sprintf( path, "%s%s", g_WorkerTempPath, pFileName + 3 ); // dear lord . .skip the u:\ BUG BUG BUG
|
||||
// printf( "creating \"%s\"\n", path );
|
||||
Q_StripFilename( path );
|
||||
MakeDirHier( path );
|
||||
|
||||
sprintf( filename, "%s%s", g_WorkerTempPath, pFileName + 3 ); // dear lord . .skip the u:\ BUG BUG BUG
|
||||
// printf( "creating \"%s\"\n", pFileName );
|
||||
|
||||
FILE *fp3 = fopen( filename, "wb" );
|
||||
if( !fp3 )
|
||||
{
|
||||
Error( "Couldn't open \"%s\"\n", filename );
|
||||
}
|
||||
if( !bZeroLength )
|
||||
{
|
||||
fwrite( fileBuf.Base(), 1, fileLen, fp3 );
|
||||
}
|
||||
fclose( fp3 );
|
||||
}
|
||||
|
||||
void Worker_GetLocalCopyOfTextureSource( const char *pVtfName )
|
||||
{
|
||||
int i;
|
||||
for( i = 0; i < g_SourceTargetPairs.Count(); i++ )
|
||||
{
|
||||
// DebugOut( "comparing: \"%s\" \"%s\"\n", pVtfName, g_SourceTargetPairs[i].pTargetName );
|
||||
if( Q_stricmp( pVtfName, g_SourceTargetPairs[i].pTargetName ) == 0 )
|
||||
{
|
||||
// DebugOut( "MATCH!\n" );
|
||||
Worker_GetFileFromMaster( g_SourceTargetPairs[i].pSrcName );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void Worker_GetLocalCopyOfBinary( const char *pFilename )
|
||||
{
|
||||
CUtlBuffer fileBuf;
|
||||
char tmpFilename[MAX_PATH];
|
||||
sprintf( tmpFilename, "%s\\%s", g_ExeDir, pFilename );
|
||||
printf( "trying to open: %s\n", tmpFilename );
|
||||
|
||||
FILE *fp = fopen( tmpFilename, "rb" );
|
||||
if( !fp )
|
||||
{
|
||||
Assert( 0 );
|
||||
fprintf( stderr, "Can't open %s!\n", pFilename );
|
||||
exit( -1 );
|
||||
}
|
||||
fseek( fp, 0, SEEK_END );
|
||||
int fileLen = ftell( fp );
|
||||
fseek( fp, 0, SEEK_SET );
|
||||
fileBuf.EnsureCapacity( fileLen );
|
||||
int nBytesRead = fread( fileBuf.Base(), 1, fileLen, fp );
|
||||
fclose( fp );
|
||||
fileBuf.SeekPut( CUtlBuffer::SEEK_HEAD, nBytesRead );
|
||||
|
||||
char newFilename[MAX_PATH];
|
||||
sprintf( newFilename, "%s%s", g_WorkerTempPath, pFilename );
|
||||
|
||||
DebugOut( "this is fucked \"%s\"\n", newFilename );
|
||||
FILE *fp2 = fopen( newFilename, "wb" );
|
||||
if( !fp2 )
|
||||
{
|
||||
Assert( 0 );
|
||||
fprintf( stderr, "Can't open %s!\n", newFilename );
|
||||
exit( -1 );
|
||||
}
|
||||
fwrite( fileBuf.Base(), 1, fileLen, fp2 );
|
||||
fclose( fp2 );
|
||||
}
|
||||
|
||||
void Worker_GetLocalCopyOfBinaries( void )
|
||||
{
|
||||
Worker_GetLocalCopyOfBinary( "vtex.exe" );
|
||||
Worker_GetLocalCopyOfBinary( "vtex_dll.dll" );
|
||||
Worker_GetLocalCopyOfBinary( "vstdlib.dll" );
|
||||
Worker_GetLocalCopyOfBinary( "tier0.dll" );
|
||||
}
|
||||
|
||||
void Shared_ParseListOfCompileCommands( void )
|
||||
{
|
||||
char buf[1024];
|
||||
|
||||
char fileListFileName[1024];
|
||||
sprintf( fileListFileName, "%s\\texturelist.txt", g_pGameDir );
|
||||
FileHandle_t fp = g_pFileSystem->Open( fileListFileName, "r" );
|
||||
if( fp == FILESYSTEM_INVALID_HANDLE )
|
||||
{
|
||||
DebugOut( "Can't open %s!\n", fileListFileName );
|
||||
fprintf( stderr, "Can't open %s!\n", fileListFileName );
|
||||
exit( -1 );
|
||||
}
|
||||
while( CmdLib_FGets( buf, 1023, fp ) )
|
||||
{
|
||||
char *pNewString = new char[ strlen( buf ) + 1 ];
|
||||
strcpy( pNewString, buf );
|
||||
pNewString[strlen( pNewString ) - 2] = '\0'; // This is some hacky shit right here.
|
||||
int newID = g_CompileCommands.AddToTail();
|
||||
g_CompileCommands[newID] = pNewString;
|
||||
}
|
||||
g_pFileSystem->Close( fp );
|
||||
|
||||
// printf( "%d compiles\n", g_CompileCommands.Count() );
|
||||
DebugOut( "%d compiles\n", g_CompileCommands.Count() );
|
||||
}
|
||||
|
||||
void SetupPaths( int argc, char **argv )
|
||||
{
|
||||
GetTempPath( sizeof( g_WorkerTempPath ), g_WorkerTempPath );
|
||||
strcat( g_WorkerTempPath, "texturecompiletemp\\" );
|
||||
char tmp[MAX_PATH];
|
||||
sprintf( tmp, "rd /s /q \"%s\"", g_WorkerTempPath );
|
||||
system( tmp );
|
||||
_mkdir( g_WorkerTempPath );
|
||||
// printf( "g_WorkerTempPath: \"%s\"\n", g_WorkerTempPath );
|
||||
|
||||
CommandLine()->CreateCmdLine( argc, argv );
|
||||
g_pGameDir = CommandLine()->ParmValue( "-gamedir", "" );
|
||||
strcpy( g_ExeDir, argv[0] );
|
||||
Q_StripFilename( g_ExeDir );
|
||||
Q_FixSlashes( g_ExeDir );
|
||||
// printf( "exedir: \"%s\"\n", g_ExeDir );
|
||||
|
||||
g_pTextureOutputDir = CommandLine()->ParmValue( "-textureoutputdir", "" );
|
||||
// printf( "shaderoutputdir: \"%s\"\n", g_pShaderOutputDir );
|
||||
|
||||
g_bVerbose = CommandLine()->FindParm("-verbose") != 0;
|
||||
}
|
||||
|
||||
void SetupDebugFile( void )
|
||||
{
|
||||
#ifdef DEBUGFP
|
||||
const char *pComputerName = getenv( "COMPUTERNAME" );
|
||||
char filename[MAX_PATH];
|
||||
sprintf( filename, "\\\\fileserver\\user\\gary\\debug\\%s.txt", pComputerName );
|
||||
g_WorkerDebugFp = fopen( filename, "w" );
|
||||
Assert( g_WorkerDebugFp );
|
||||
DebugOut( "opened debug file\n" );
|
||||
#endif
|
||||
}
|
||||
|
||||
void WriteTexture( const char *pTextureName )
|
||||
{
|
||||
#if 0
|
||||
CUtlVector<CUtlBuffer> &byteCodeArray = g_ByteCode[pShaderName];
|
||||
const ShaderInfo_t &shaderInfo = g_ShaderToShaderInfo[pShaderName];
|
||||
// printf( "%s : %d combos centroid mask: 0x%x numDynamicCombos: %d flags: 0x%x\n",
|
||||
// pShaderName, shaderInfo.m_nTotalShaderCombos,
|
||||
// shaderInfo.m_CentroidMask, shaderInfo.m_nDynamicCombos, shaderInfo.m_Flags );
|
||||
CUtlBuffer header;
|
||||
CUtlBuffer body;
|
||||
header.PutInt( SHADER_VCS_VERSION_NUMBER ); // version
|
||||
header.PutInt( shaderInfo.m_nTotalShaderCombos );
|
||||
header.PutInt( shaderInfo.m_nDynamicCombos );
|
||||
header.PutUnsignedInt( shaderInfo.m_Flags );
|
||||
header.PutUnsignedInt( shaderInfo.m_CentroidMask );
|
||||
|
||||
int headerSize = sizeof( int ) * 5;
|
||||
int directorySize = sizeof( int ) * 2 * shaderInfo.m_nTotalShaderCombos;
|
||||
int bodyOffset = headerSize + directorySize;
|
||||
int nCombo;
|
||||
for( nCombo = 0; nCombo < shaderInfo.m_nTotalShaderCombos; nCombo++ )
|
||||
{
|
||||
CUtlBuffer &byteCode = byteCodeArray[nCombo];
|
||||
if( byteCode.TellPut() == 0 )
|
||||
{
|
||||
// This is a skipped combo.
|
||||
header.PutInt( -1 );
|
||||
header.PutInt( 0 );
|
||||
}
|
||||
else
|
||||
{
|
||||
header.PutInt( body.TellPut() + bodyOffset );
|
||||
header.PutInt( byteCode.TellPut() );
|
||||
body.Put( byteCode.Base(), byteCode.TellPut() );
|
||||
}
|
||||
}
|
||||
|
||||
char filename[MAX_PATH];
|
||||
char filename2[MAX_PATH];
|
||||
// strcpy( filename2, g_pShaderOutputDir );
|
||||
strcpy( filename2, g_pShaderPath );
|
||||
strcat( filename2, "\\shaders\\fxc" );
|
||||
|
||||
struct _stat buf;
|
||||
if( _stat( filename2, &buf ) == -1 )
|
||||
{
|
||||
printf( "mkdir %s\n", filename2 );
|
||||
// doh. . need to make the directory that the vcs file is going to go into.
|
||||
_mkdir( filename2 );
|
||||
}
|
||||
|
||||
strcat( filename2, "\\" );
|
||||
strcpy( filename, pShaderName );
|
||||
char *dot = strstr( filename, "." );
|
||||
if( dot )
|
||||
{
|
||||
*dot = '\0';
|
||||
}
|
||||
strcat( filename, ".vcs" );
|
||||
strcat( filename2, filename );
|
||||
if( _stat( filename2, &buf ) != -1 )
|
||||
{
|
||||
// The file exists, let's see if it's writable.
|
||||
if( !( buf.st_mode & _S_IWRITE ) )
|
||||
{
|
||||
// It isn't writable. . we'd better change it's permissions (or check it out possibly).
|
||||
printf( "Warning: making %s writable!\n", filename2 );
|
||||
_chmod( filename2, _S_IREAD | _S_IWRITE );
|
||||
}
|
||||
}
|
||||
FILE *fp = fopen( filename2, "wb" );
|
||||
if( !fp )
|
||||
{
|
||||
printf( "Can't open %s\n", filename2 );
|
||||
return;
|
||||
}
|
||||
printf( "writing %s\n", filename );
|
||||
fwrite( header.Base(), 1, headerSize + directorySize, fp );
|
||||
fwrite( body.Base(), 1, body.TellPut(), fp );
|
||||
fclose( fp );
|
||||
#endif
|
||||
}
|
||||
|
||||
void TouchFile( const char *path )
|
||||
{
|
||||
Warning( "TouchFile: %s\n", path );
|
||||
char dir[MAX_PATH];
|
||||
Q_strcpy( dir, path );
|
||||
Q_StripFilename( dir );
|
||||
MakeDirHier( dir );
|
||||
FILE *fp = fopen( path, "wb" );
|
||||
fclose( fp );
|
||||
}
|
||||
|
||||
int TextureCompile_Main( int argc, char* argv[] )
|
||||
{
|
||||
InstallSpewFunction();
|
||||
g_bSuppressPrintfOutput = false;
|
||||
g_flStartTime = Plat_FloatTime();
|
||||
|
||||
SetupDebugFile();
|
||||
numthreads = 1; // holy shit batman!
|
||||
SetupPaths( argc, argv );
|
||||
|
||||
// Master, start accepting connections.
|
||||
// Worker, make a connection.
|
||||
DebugOut( "Before VMPI_Init\n" );
|
||||
g_bSuppressPrintfOutput = true;
|
||||
VMPIRunMode mode = VMPI_RUN_NETWORKED;
|
||||
if ( !VMPI_Init( argc, argv, "dependency_info_texturecompile.txt", MyDisconnectHandler, mode ) )
|
||||
{
|
||||
g_bSuppressPrintfOutput = false;
|
||||
DebugOut( "MPI_Init failed.\n" );
|
||||
Error( "MPI_Init failed." );
|
||||
}
|
||||
g_bSuppressPrintfOutput = false;
|
||||
|
||||
DebugOut( "After VMPI_Init\n" );
|
||||
|
||||
int maxFileSystemMemoryUsageBytes = 50000000;
|
||||
CmdLib_InitFileSystem( ".", maxFileSystemMemoryUsageBytes );
|
||||
|
||||
DebugOut( "After VMPI_FileSystem_Init\n" );
|
||||
Shared_ParseListOfCompileCommands();
|
||||
DebugOut( "After Shared_ParseListOfCompileCommands\n" );
|
||||
|
||||
// 4-ish work units per machine
|
||||
g_nTexturesPerWorkUnit = TEXTURES_PER_WORKUNIT;
|
||||
int nWorkUnits = g_CompileCommands.Count() / g_nTexturesPerWorkUnit + 1;
|
||||
|
||||
// printf( "nWorkUnits: %d\n", nWorkUnits );
|
||||
// printf( "g_nShadersPerWorkUnit: %d\n", g_nShadersPerWorkUnit );
|
||||
|
||||
DebugOut( "Before conditional\n" );
|
||||
if ( g_bMPIMaster )
|
||||
{
|
||||
// Send all of the workers the complete list of work to do.
|
||||
DebugOut( "Before STARTWORK_PACKETID\n" );
|
||||
|
||||
char packetID = STARTWORK_PACKETID;
|
||||
VMPI_SendData( &packetID, sizeof( packetID ), VMPI_PERSISTENT );
|
||||
|
||||
// nWorkUnits is how many work units. . .1000 is good.
|
||||
// The work unit number impies which combo to do.
|
||||
DebugOut( "Before DistributeWork\n" );
|
||||
DistributeWork( nWorkUnits, WORKUNIT_PACKETID, NULL, Master_ReceiveWorkUnitFn );
|
||||
}
|
||||
else
|
||||
{
|
||||
// wait until we get a packet from the master to start doing stuff.
|
||||
MessageBuffer buf;
|
||||
DebugOut( "Before VMPI_DispatchUntil\n" );
|
||||
while ( !g_bGotStartWorkPacket )
|
||||
{
|
||||
VMPI_DispatchNextMessage();
|
||||
}
|
||||
DebugOut( "after VMPI_DispatchUntil\n" );
|
||||
|
||||
Worker_ReadFilesToCopy();
|
||||
// Worker_GetSourceFiles();
|
||||
// DebugOut( "Before Worker_GetLocalCopyOfShaders\n" );
|
||||
// Worker_GetLocalCopyOfTextureSource();
|
||||
// DebugOut( "Before Worker_GetLocalCopyOfBinaries\n" );
|
||||
DebugOut( "Before _chdir\n" );
|
||||
_chdir( g_WorkerTempPath );
|
||||
|
||||
// DIE DIE KILL KILL AHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
||||
char path[MAX_PATH];
|
||||
sprintf( path, "%s%s\\bin\\server.dll", g_WorkerTempPath, g_pGameDir + 3 ); // hack hack
|
||||
TouchFile( path );
|
||||
sprintf( path, "%s%s\\bin\\client.dll", g_WorkerTempPath, g_pGameDir + 3 );// hack hack
|
||||
TouchFile( path );
|
||||
|
||||
Worker_GetLocalCopyOfBinaries();
|
||||
|
||||
// nWorkUnits is how many work units. . .1000 is good.
|
||||
// The work unit number impies which combo to do.
|
||||
DebugOut( "Before DistributeWork\n" );
|
||||
|
||||
DistributeWork( nWorkUnits, WORKUNIT_PACKETID, Worker_ProcessWorkUnitFn, NULL );
|
||||
}
|
||||
|
||||
DebugOut( "Before VMPI_Finalize\n" );
|
||||
g_bSuppressPrintfOutput = true;
|
||||
VMPI_FileSystem_Term();
|
||||
VMPI_Finalize();
|
||||
g_bSuppressPrintfOutput = false;
|
||||
|
||||
if( g_bMPIMaster )
|
||||
{
|
||||
/*
|
||||
printf( "\n" );
|
||||
int nStrings = g_ByteCode.GetNumStrings();
|
||||
int i;
|
||||
for( i = 0; i < nStrings; i++ )
|
||||
{
|
||||
if( g_Master_TextureHadError.Defined( g_ByteCode.String( i ) ) )
|
||||
{
|
||||
printf( "FAILED: \"%s\"\n", g_ByteCode.String( i ) );
|
||||
}
|
||||
else
|
||||
{
|
||||
// printf( "\"%s\" succeeded!\n", g_ByteCode.String( i ) );
|
||||
WriteTexture( g_ByteCode.String( i ) );
|
||||
}
|
||||
}
|
||||
|
||||
double end = Plat_FloatTime();
|
||||
|
||||
char str[512];
|
||||
GetHourMinuteSecondsString( (int)( end - g_flStartTime ), str, sizeof( str ) );
|
||||
Msg( "%s elapsed\n", str );
|
||||
*/
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
class CTextureCompileDLL : public ILaunchableDLL
|
||||
{
|
||||
int main( int argc, char **argv );
|
||||
};
|
||||
|
||||
int CTextureCompileDLL::main( int argc, char **argv )
|
||||
{
|
||||
return TextureCompile_Main( argc, argv );
|
||||
}
|
||||
|
||||
EXPOSE_SINGLE_INTERFACE( CTextureCompileDLL, ILaunchableDLL, LAUNCHABLE_DLL_INTERFACE_VERSION );
|
||||
Reference in New Issue
Block a user