Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
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.

614 lines
18 KiB

5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Interface for makefiles to build differently depending on where they are run from
//
//===========================================================================//
#include "movieobjects/dmemakefileutils.h"
#include "movieobjects/dmemdlmakefile.h"
#include "movieobjects/dmedccmakefile.h"
#include "tier2/fileutils.h"
#include "filesystem.h"
//-----------------------------------------------------------------------------
// Statics
//-----------------------------------------------------------------------------
IMPLEMENT_DMEMAKEFILE_UTIL_CLASS( CDmeMakefileUtils );
//-----------------------------------------------------------------------------
// Default implementation
//-----------------------------------------------------------------------------
static CDmeMakefileUtils s_MakefileUtils;
IDmeMakefileUtils *GetDefaultDmeMakefileUtils()
{
return &s_MakefileUtils;
}
//-----------------------------------------------------------------------------
// Constructor, destructor
//-----------------------------------------------------------------------------
CDmeMakefileUtils::CDmeMakefileUtils() : BaseClass( false )
{
m_CompilationStep = NOT_COMPILING;
m_hCompileProcess = PROCESS_HANDLE_INVALID;
m_nCurrentCompileTask = -1;
m_nExitCode = 0;
}
CDmeMakefileUtils::~CDmeMakefileUtils()
{
}
//-----------------------------------------------------------------------------
// Here's where systems can access other interfaces implemented by this object
//-----------------------------------------------------------------------------
void *CDmeMakefileUtils::QueryInterface( const char *pInterfaceName )
{
if ( !V_strcmp( pInterfaceName, DMEMAKEFILE_UTILS_INTERFACE_VERSION ) )
return (IDmeMakefileUtils*)this;
return NULL;
}
//-----------------------------------------------------------------------------
// Initialization.. set up messagemaps
//-----------------------------------------------------------------------------
InitReturnVal_t CDmeMakefileUtils::Init()
{
InitializeFuncMaps();
return INIT_OK;
}
//-----------------------------------------------------------------------------
// Looks for an appropriate method to compile this element with
//-----------------------------------------------------------------------------
CCompileFuncAdapterBase *CDmeMakefileUtils::DetermineCompileAdapter( CDmElement *pElement )
{
int nBestInheritanceDepth = -1;
CCompileFuncAdapterBase *pBestAdapter = NULL;
CompileFuncTree_t *pTree = GetCompileTree();
while ( pTree )
{
CCompileFuncAdapterBase *pCurr = pTree->m_pFirstAdapter;
for ( ; pCurr; pCurr = pCurr->m_pNext )
{
// Choose this factory if it's more derived than the previous best
int nInheritanceDepth = pElement->GetInheritanceDepth( pCurr->m_ElementType );
if ( nInheritanceDepth < 0 )
continue;
if ( nInheritanceDepth == 0 )
{
// Found exact match.. do it!
return pCurr;
}
// Don't look for the best thingy if we're not the root
if ( nBestInheritanceDepth >= 0 && ( nInheritanceDepth >= nBestInheritanceDepth ) )
continue;
nBestInheritanceDepth = nInheritanceDepth;
pBestAdapter = pCurr;
}
pTree = pTree->m_pBaseAdapterTree;
}
// Return the closest match we could find
return pBestAdapter;
}
//-----------------------------------------------------------------------------
// Looks for an appropriate method to open this element with
//-----------------------------------------------------------------------------
COpenEditorFuncAdapterBase *CDmeMakefileUtils::DetermineOpenEditorAdapter( CDmElement *pElement )
{
int nBestInheritanceDepth = -1;
COpenEditorFuncAdapterBase *pBestAdapter = NULL;
OpenEditorFuncTree_t *pTree = GetOpenEditorTree();
while ( pTree )
{
COpenEditorFuncAdapterBase *pCurr = pTree->m_pFirstAdapter;
for ( ; pCurr; pCurr = pCurr->m_pNext )
{
// Choose this factory if it's more derived than the previous best
int nInheritanceDepth = pElement->GetInheritanceDepth( pCurr->m_ElementType );
if ( nInheritanceDepth < 0 )
continue;
// Found exact match.. do it!
if ( nInheritanceDepth == 0 )
return pCurr;
if ( nBestInheritanceDepth >= 0 && ( nInheritanceDepth >= nBestInheritanceDepth ) )
continue;
nBestInheritanceDepth = nInheritanceDepth;
pBestAdapter = pCurr;
}
pTree = pTree->m_pBaseAdapterTree;
}
return pBestAdapter;
}
//-----------------------------------------------------------------------------
// Opens a element in an external editor
//-----------------------------------------------------------------------------
void CDmeMakefileUtils::PerformOpenEditor( CDmElement *pElement )
{
COpenEditorFuncAdapterBase *pAdapter = DetermineOpenEditorAdapter( pElement );
if ( pAdapter )
{
pAdapter->OpenEditor( pElement );
}
}
//-----------------------------------------------------------------------------
// Queues up a compilation task
//-----------------------------------------------------------------------------
void CDmeMakefileUtils::AddCompilationTask( CDmElement* pElement, CCompileFuncAdapterBase *pAdapter )
{
Assert( m_CompilationStep == BUILDING_STANDARD_DEPENDENCIES || m_CompilationStep == BUILDING_ALL_DEPENDENCIES );
// Queue up the compilation task
int j = m_CompileTasks.AddToTail();
m_CompileTasks[j].m_hElement = pElement;
m_CompileTasks[j].m_pAdapter = pAdapter;
}
void CDmeMakefileUtils::AddCompilationTask( CDmElement* pElement )
{
CCompileFuncAdapterBase *pAdapter = DetermineCompileAdapter( pElement );
if ( pAdapter )
{
// Queue up the compilation task
AddCompilationTask( pElement, pAdapter );
}
}
//-----------------------------------------------------------------------------
// Sets the compile process
//-----------------------------------------------------------------------------
void CDmeMakefileUtils::SetCompileProcess( ProcessHandle_t hProcess )
{
Assert( m_CompilationStep == PERFORMING_COMPILATION );
m_hCompileProcess = hProcess;
if ( m_hCompileProcess == PROCESS_HANDLE_INVALID )
{
m_CompilationStep = AFTER_COMPILATION_FAILED;
}
}
//-----------------------------------------------------------------------------
// Default implementatations for compile dependencies
//-----------------------------------------------------------------------------
bool CDmeMakefileUtils::AddCompileDependencies( CDmeMakefile *pMakefile, bool bBuildAllDependencies )
{
if ( !pMakefile )
return true;
CUtlVector< CUtlString > outputs;
int nCount = pMakefile->GetSourceCount();
for ( int i = 0; i < nCount; ++i )
{
CDmeSource *pSource = pMakefile->GetSource( i );
if ( !pSource )
continue;
CDmeMakefile *pDependentMakefile = pSource->GetDependentMakefile();
if ( !pDependentMakefile )
continue;
bool bShouldBuildFile = bBuildAllDependencies;
// Does the output files exist?
int j = 0;
if ( !bBuildAllDependencies )
{
pDependentMakefile->GetOutputs( outputs );
int nOutputCount = outputs.Count();
for ( j = 0; j < nOutputCount; ++j )
{
// If the file doesn't exist, we have to build it
if ( !g_pFullFileSystem->FileExists( outputs[j] ) )
break;
bShouldBuildFile = true;
break;
}
}
if ( !bShouldBuildFile )
continue;
CCompileFuncAdapterBase *pAdapter = DetermineCompileAdapter( pDependentMakefile );
if ( pAdapter )
{
// Add dependent makefiles first
if ( !pAdapter->PerformCompilationStep( pDependentMakefile, bBuildAllDependencies ? BUILDING_ALL_DEPENDENCIES : BUILDING_STANDARD_DEPENDENCIES ) )
return false;
}
// Queue up the compilation task
AddCompilationTask( pDependentMakefile, pAdapter );
}
return true;
}
//-----------------------------------------------------------------------------
// Default implementatations for precompilation step
//-----------------------------------------------------------------------------
bool CDmeMakefileUtils::PerformCompilationStep( CDmElement *pElement, CompilationStep_t step )
{
// Do nothing
return true;
}
bool CDmeMakefileUtils::PerformCompilationStep( CDmeMakefile *pMakefile, CompilationStep_t step )
{
switch( step )
{
case BUILDING_ALL_DEPENDENCIES:
return AddCompileDependencies( pMakefile, true );
case BUILDING_STANDARD_DEPENDENCIES:
return AddCompileDependencies( pMakefile, false );
case BEFORE_COMPILATION:
pMakefile->PreCompile();
break;
case AFTER_COMPILATION_SUCCEEDED:
pMakefile->PostCompile();
break;
}
return true;
}
//-----------------------------------------------------------------------------
// Starts the next compile task
//-----------------------------------------------------------------------------
void CDmeMakefileUtils::StartNextCompileTask( )
{
Assert( m_hCompileProcess == PROCESS_HANDLE_INVALID );
++m_nCurrentCompileTask;
if ( m_nCurrentCompileTask == m_CompileTasks.Count() )
{
PerformCompilationStep( AFTER_COMPILATION_SUCCEEDED );
m_nCurrentCompileTask = -1;
m_CompileTasks.RemoveAll();
return;
}
m_hCompileProcess = PROCESS_HANDLE_INVALID;
// NOTE: PerformCompilationStep is expected to call SetCompileProcess to set m_hCompileProcess
CompileInfo_t &info = m_CompileTasks[m_nCurrentCompileTask];
bool bOk = info.m_pAdapter->PerformCompilationStep( info.m_hElement, PERFORMING_COMPILATION );
if ( !bOk || ( m_hCompileProcess == PROCESS_HANDLE_INVALID ) )
{
AbortCurrentCompilation();
return;
}
}
//-----------------------------------------------------------------------------
// Performs the compilation step on all elements
//-----------------------------------------------------------------------------
bool CDmeMakefileUtils::PerformCompilationStep( CompilationStep_t step )
{
// Iterate through all elements and run a compilation step
m_CompilationStep = step;
int nCount = m_CompileTasks.Count();
for ( int i = 0; i < nCount; ++i )
{
CompileInfo_t &info = m_CompileTasks[i];
if ( info.m_hElement.Get() )
{
if ( !info.m_pAdapter->PerformCompilationStep( info.m_hElement, step ) )
return false;
}
}
return true;
}
//-----------------------------------------------------------------------------
// Main entry point for compilation
//-----------------------------------------------------------------------------
void CDmeMakefileUtils::PerformCompile( CDmElement *pElement, bool bBuildAllDependencies )
{
if ( IsCurrentlyCompiling() )
{
AbortCurrentCompilation();
}
CCompileFuncAdapterBase *pAdapter = DetermineCompileAdapter( pElement );
if ( !pAdapter )
{
m_CompilationStep = AFTER_COMPILATION_FAILED;
return;
}
// Add dependent makefiles first
m_CompilationStep = bBuildAllDependencies ? BUILDING_ALL_DEPENDENCIES : BUILDING_STANDARD_DEPENDENCIES;
if ( !pAdapter->PerformCompilationStep( pElement, m_CompilationStep ) )
{
AbortCurrentCompilation();
return;
}
// Queue up the compilation task
AddCompilationTask( pElement, pAdapter );
// Iterate through all elements and run a precompilation step
// NOTE: This is where perforce integration should go
if ( !PerformCompilationStep( BEFORE_COMPILATION ) )
{
AbortCurrentCompilation();
return;
}
// Dequeue the first compile task and start it up
m_CompilationStep = PERFORMING_COMPILATION;
StartNextCompileTask();
}
//-----------------------------------------------------------------------------
// Are we in the middle of compiling this makefile?
//-----------------------------------------------------------------------------
bool CDmeMakefileUtils::IsCurrentlyCompiling()
{
return ( m_CompilationStep != NOT_COMPILING );
}
//-----------------------------------------------------------------------------
// Aborts any current compilation
//-----------------------------------------------------------------------------
void CDmeMakefileUtils::AbortCurrentCompilation()
{
if ( m_hCompileProcess != PROCESS_HANDLE_INVALID )
{
g_pProcessUtils->AbortProcess( m_hCompileProcess );
m_hCompileProcess = PROCESS_HANDLE_INVALID;
}
if ( IsCurrentlyCompiling() )
{
PerformCompilationStep( AFTER_COMPILATION_FAILED );
m_nCurrentCompileTask = -1;
m_CompileTasks.RemoveAll();
}
}
//-----------------------------------------------------------------------------
// Returns the exit code of the failed compilation (if COMPILATION_FAILED occurred)
//-----------------------------------------------------------------------------
int CDmeMakefileUtils::GetExitCode()
{
return m_nExitCode;
}
//-----------------------------------------------------------------------------
// Returns output from the compilation
//-----------------------------------------------------------------------------
int CDmeMakefileUtils::GetCompileOutputSize()
{
if ( m_hCompileProcess == PROCESS_HANDLE_INVALID )
return 0;
return g_pProcessUtils->GetProcessOutputSize( m_hCompileProcess );
}
CompilationState_t CDmeMakefileUtils::UpdateCompilation( char *pOutputBuf, int nBufLen )
{
switch( m_CompilationStep )
{
case BUILDING_STANDARD_DEPENDENCIES:
case BUILDING_ALL_DEPENDENCIES:
case BEFORE_COMPILATION:
return COMPILATION_NOT_COMPLETE;
case AFTER_COMPILATION_FAILED:
m_CompilationStep = NOT_COMPILING;
return COMPILATION_FAILED;
case AFTER_COMPILATION_SUCCEEDED:
m_CompilationStep = NOT_COMPILING;
return COMPILATION_SUCCESSFUL;
}
// This is the PERFORMING_COMPILATION case:
// FIXME: Check return codes from compile process..
// fail if compilation process had a problem
if ( m_hCompileProcess == PROCESS_HANDLE_INVALID )
{
if ( nBufLen > 0 )
{
pOutputBuf[0] = 0;
}
return COMPILATION_SUCCESSFUL;
}
if ( nBufLen > 0 )
{
g_pProcessUtils->GetProcessOutput( m_hCompileProcess, pOutputBuf, nBufLen );
}
if ( !g_pProcessUtils->IsProcessComplete( m_hCompileProcess ) )
return COMPILATION_NOT_COMPLETE;
m_nExitCode = g_pProcessUtils->GetProcessExitCode( m_hCompileProcess );
bool bCompileSucceeded = ( m_nExitCode == 0 );
g_pProcessUtils->CloseProcess( m_hCompileProcess );
m_hCompileProcess = PROCESS_HANDLE_INVALID;
if ( !bCompileSucceeded )
{
AbortCurrentCompilation();
return COMPILATION_NOT_COMPLETE;
}
StartNextCompileTask();
if ( m_CompilationStep == PERFORMING_COMPILATION )
return COMPILATION_NOT_COMPLETE;
CompilationState_t retVal = ( m_CompilationStep == AFTER_COMPILATION_SUCCEEDED ) ? COMPILATION_SUCCESSFUL : COMPILATION_FAILED;
m_CompilationStep = NOT_COMPILING;
return retVal;
}
//-----------------------------------------------------------------------------
// Type-specific compilation functions
//-----------------------------------------------------------------------------
bool CDmeMakefileUtils::PerformCompilationStep( CDmeMDLMakefile *pMakeFile, CompilationStep_t step )
{
if ( step != PERFORMING_COMPILATION )
return PerformCompilationStep( static_cast<CDmeMakefile*>( pMakeFile ), step );
char pBinDirectory[MAX_PATH];
GetModSubdirectory( "..\\bin", pBinDirectory, sizeof(pBinDirectory) );
Q_RemoveDotSlashes( pBinDirectory );
char pStudioMDLCmd[MAX_PATH];
#ifdef _DEBUG
Q_snprintf( pStudioMDLCmd, sizeof(pStudioMDLCmd), "%s\\studiomdl.exe -allowdebug %s", pBinDirectory, pMakeFile->GetFileName() );
#else
Q_snprintf( pStudioMDLCmd, sizeof(pStudioMDLCmd), "%s\\studiomdl.exe %s", pBinDirectory, pMakeFile->GetFileName() );
#endif
ProcessHandle_t hProcess = g_pProcessUtils->StartProcess( pStudioMDLCmd, true );
SetCompileProcess( hProcess );
return true;
}
//-----------------------------------------------------------------------------
// Exports a Maya file to a DMX file
//-----------------------------------------------------------------------------
bool CDmeMakefileUtils::PerformCompilationStep( CDmeMayaMakefile *pMakeFile, CompilationStep_t step )
{
if ( step != PERFORMING_COMPILATION )
return PerformCompilationStep( static_cast<CDmeMakefile*>( pMakeFile ), step );
// FIXME: Create batch export command here
CUtlString mayaCommand;
mayaCommand = "vsDmxIO -export";
CUtlVector< CDmeHandle< CDmeSourceMayaFile > > sources;
pMakeFile->GetSources( sources );
if ( !sources.Count() )
return false;
CDmeSourceMayaFile *pDmeSourceDCCFile( sources[ 0 ].Get() );
mayaCommand += " -selection";
char pObjectId[128];
UniqueIdToString( pMakeFile->GetId(), pObjectId, sizeof(pObjectId) );
mayaCommand += " -makefileObjectId \\\"";
mayaCommand += pObjectId;
mayaCommand += "\\\"";
mayaCommand += " -";
mayaCommand += pDmeSourceDCCFile->m_ExportType.GetAttribute()->GetName();
switch ( pDmeSourceDCCFile->m_ExportType.Get() )
{
case 1: // skeletal animation
mayaCommand += " skeletalAnimation";
mayaCommand += " -";
mayaCommand += pDmeSourceDCCFile->m_FrameStart.GetAttribute()->GetName();
mayaCommand += " ";
mayaCommand += pDmeSourceDCCFile->m_FrameStart.Get();
mayaCommand += " -";
mayaCommand += pDmeSourceDCCFile->m_FrameEnd.GetAttribute()->GetName();
mayaCommand += " ";
mayaCommand += pDmeSourceDCCFile->m_FrameEnd.Get();
mayaCommand += " -";
mayaCommand += pDmeSourceDCCFile->m_FrameIncrement.GetAttribute()->GetName();
mayaCommand += " ";
mayaCommand += pDmeSourceDCCFile->m_FrameIncrement.Get();
break;
default: // Model
mayaCommand += " model";
break;
}
char pFileName[MAX_PATH];
Q_strncpy( pFileName, pMakeFile->GetFileName(), sizeof( pFileName ) );
Q_FixSlashes( pFileName, '/' );
mayaCommand += " -filename \\\"";
mayaCommand += pFileName;
mayaCommand += "\\\"";
const int rootObjectCount( pDmeSourceDCCFile->m_RootDCCObjects.Count() );
for ( int rootObjectIndex( 0 ); rootObjectIndex < rootObjectCount; ++rootObjectIndex )
{
mayaCommand += " ";
mayaCommand += pDmeSourceDCCFile->m_RootDCCObjects[ rootObjectIndex ];
}
char pSourcePath[MAX_PATH];
pMakeFile->GetSourceFullPath( pDmeSourceDCCFile, pSourcePath, sizeof(pSourcePath) );
// Maya wants forward slashes
Q_FixSlashes( pSourcePath, '/' );
char pMayaCommand[1024];
Q_snprintf( pMayaCommand, sizeof(pMayaCommand), "mayabatch.exe -batch -file \"%s\" -command \"%s\"", pSourcePath, mayaCommand.Get() );
ProcessHandle_t hProcess = g_pProcessUtils->StartProcess( pMayaCommand, true );
SetCompileProcess( hProcess );
return true;
}
//-----------------------------------------------------------------------------
// Opens Maya with a particular file
//-----------------------------------------------------------------------------
void CDmeMakefileUtils::OpenEditor( CDmeSourceMayaFile *pDmeSourceDCCFile )
{
CDmeMayaMakefile *pMakefile = FindReferringElement< CDmeMayaMakefile >( pDmeSourceDCCFile, "sources" );
if ( !pMakefile )
return;
char pSourcePath[MAX_PATH];
pMakefile->GetSourceFullPath( pDmeSourceDCCFile, pSourcePath, sizeof(pSourcePath) );
// Maya wants forward slashes
Q_FixSlashes( pSourcePath, '/' );
char pMayaCommand[1024];
Q_snprintf( pMayaCommand, sizeof(pMayaCommand), "maya.exe -file \"%s\"", pSourcePath );
g_pProcessUtils->StartProcess( pMayaCommand, true );
}