776 lines
21 KiB
C++
776 lines
21 KiB
C++
//========= 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 );
|