568 lines
14 KiB
C++
568 lines
14 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 GPL Source Code
|
|
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).
|
|
|
|
Doom 3 Source Code is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Doom 3 Source Code is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#include "../../idlib/precompiled.h"
|
|
#pragma hdrstop
|
|
|
|
#include "../Game_local.h"
|
|
#include "../../MayaImport/maya_main.h"
|
|
|
|
/***********************************************************************
|
|
|
|
Maya conversion functions
|
|
|
|
***********************************************************************/
|
|
|
|
static idStr Maya_Error;
|
|
|
|
static exporterInterface_t Maya_ConvertModel = NULL;
|
|
static exporterShutdown_t Maya_Shutdown = NULL;
|
|
static int importDLL = 0;
|
|
|
|
bool idModelExport::initialized = false;
|
|
|
|
/*
|
|
====================
|
|
idModelExport::idModelExport
|
|
====================
|
|
*/
|
|
idModelExport::idModelExport() {
|
|
Reset();
|
|
}
|
|
|
|
/*
|
|
====================
|
|
idModelExport::Shutdown
|
|
====================
|
|
*/
|
|
void idModelExport::Shutdown( void ) {
|
|
if ( Maya_Shutdown ) {
|
|
Maya_Shutdown();
|
|
}
|
|
|
|
if ( importDLL ) {
|
|
sys->DLL_Unload( importDLL );
|
|
}
|
|
|
|
importDLL = 0;
|
|
Maya_Shutdown = NULL;
|
|
Maya_ConvertModel = NULL;
|
|
Maya_Error.Clear();
|
|
initialized = false;
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idModelExport::CheckMayaInstall
|
|
|
|
Determines if Maya is installed on the user's machine
|
|
=====================
|
|
*/
|
|
bool idModelExport::CheckMayaInstall( void ) {
|
|
#ifndef _WIN32
|
|
return false;
|
|
#elif 0
|
|
HKEY hKey;
|
|
long lres, lType;
|
|
|
|
lres = RegOpenKey( HKEY_LOCAL_MACHINE, "SOFTWARE\\Alias|Wavefront\\Maya\\4.5\\Setup\\InstallPath", &hKey );
|
|
|
|
if ( lres != ERROR_SUCCESS ) {
|
|
return false;
|
|
}
|
|
|
|
lres = RegQueryValueEx( hKey, "MAYA_INSTALL_LOCATION", NULL, (unsigned long*)&lType, (unsigned char*)NULL, (unsigned long*)NULL );
|
|
|
|
RegCloseKey( hKey );
|
|
|
|
if ( lres != ERROR_SUCCESS ) {
|
|
return false;
|
|
}
|
|
return true;
|
|
#else
|
|
HKEY hKey;
|
|
long lres;
|
|
|
|
// only check the non-version specific key so that we only have to update the maya dll when new versions are released
|
|
lres = RegOpenKey( HKEY_LOCAL_MACHINE, "SOFTWARE\\Alias|Wavefront\\Maya", &hKey );
|
|
RegCloseKey( hKey );
|
|
|
|
if ( lres != ERROR_SUCCESS ) {
|
|
return false;
|
|
}
|
|
return true;
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idModelExport::LoadMayaDll
|
|
|
|
Checks to see if we can load the Maya export dll
|
|
=====================
|
|
*/
|
|
void idModelExport::LoadMayaDll( void ) {
|
|
exporterDLLEntry_t dllEntry;
|
|
char dllPath[ MAX_OSPATH ];
|
|
|
|
fileSystem->FindDLL( "MayaImport", dllPath, false );
|
|
if ( !dllPath[ 0 ] ) {
|
|
return;
|
|
}
|
|
importDLL = sys->DLL_Load( dllPath );
|
|
if ( !importDLL ) {
|
|
return;
|
|
}
|
|
|
|
// look up the dll interface functions
|
|
dllEntry = ( exporterDLLEntry_t )sys->DLL_GetProcAddress( importDLL, "dllEntry" );
|
|
Maya_ConvertModel = ( exporterInterface_t )sys->DLL_GetProcAddress( importDLL, "Maya_ConvertModel" );
|
|
Maya_Shutdown = ( exporterShutdown_t )sys->DLL_GetProcAddress( importDLL, "Maya_Shutdown" );
|
|
if ( !Maya_ConvertModel || !dllEntry || !Maya_Shutdown ) {
|
|
Maya_ConvertModel = NULL;
|
|
Maya_Shutdown = NULL;
|
|
sys->DLL_Unload( importDLL );
|
|
importDLL = 0;
|
|
gameLocal.Error( "Invalid interface on export DLL." );
|
|
return;
|
|
}
|
|
|
|
// initialize the DLL
|
|
if ( !dllEntry( MD5_VERSION, common, sys ) ) {
|
|
// init failed
|
|
Maya_ConvertModel = NULL;
|
|
Maya_Shutdown = NULL;
|
|
sys->DLL_Unload( importDLL );
|
|
importDLL = 0;
|
|
gameLocal.Error( "Export DLL init failed." );
|
|
return;
|
|
}
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
idModelExport::ConvertMayaToMD5
|
|
|
|
Checks if a Maya model should be converted to an MD5, and converts if if the time/date or
|
|
version number has changed.
|
|
=====================
|
|
*/
|
|
bool idModelExport::ConvertMayaToMD5( void ) {
|
|
ID_TIME_T sourceTime;
|
|
ID_TIME_T destTime;
|
|
int version;
|
|
idToken cmdLine;
|
|
idStr path;
|
|
|
|
// check if our DLL got loaded
|
|
if ( initialized && !Maya_ConvertModel ) {
|
|
Maya_Error = "MayaImport dll not loaded.";
|
|
return false;
|
|
}
|
|
|
|
// if idAnimManager::forceExport is set then we always reexport Maya models
|
|
if ( idAnimManager::forceExport ) {
|
|
force = true;
|
|
}
|
|
|
|
// get the source file's time
|
|
if ( fileSystem->ReadFile( src, NULL, &sourceTime ) < 0 ) {
|
|
// source file doesn't exist
|
|
return true;
|
|
}
|
|
|
|
// get the destination file's time
|
|
if ( !force && ( fileSystem->ReadFile( dest, NULL, &destTime ) >= 0 ) ) {
|
|
idParser parser( LEXFL_ALLOWPATHNAMES | LEXFL_NOSTRINGESCAPECHARS );
|
|
|
|
parser.LoadFile( dest );
|
|
|
|
// read the file version
|
|
if ( parser.CheckTokenString( MD5_VERSION_STRING ) ) {
|
|
version = parser.ParseInt();
|
|
|
|
// check the command line
|
|
if ( parser.CheckTokenString( "commandline" ) ) {
|
|
parser.ReadToken( &cmdLine );
|
|
|
|
// check the file time, scale, and version
|
|
if ( ( destTime >= sourceTime ) && ( version == MD5_VERSION ) && ( cmdLine == commandLine ) ) {
|
|
// don't convert it
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// if this is the first time we've been run, check if Maya is installed and load our DLL
|
|
if ( !initialized ) {
|
|
initialized = true;
|
|
|
|
if ( !CheckMayaInstall() ) {
|
|
Maya_Error = "Maya not installed in registry.";
|
|
return false;
|
|
}
|
|
|
|
LoadMayaDll();
|
|
|
|
// check if our DLL got loaded
|
|
if ( !Maya_ConvertModel ) {
|
|
Maya_Error = "Could not load MayaImport dll.";
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// we need to make sure we have a full path, so convert the filename to an OS path
|
|
// _D3XP :: we work out of the cdpath, at least until we get Alienbrain
|
|
src = fileSystem->RelativePathToOSPath( src, "fs_cdpath" );
|
|
dest = fileSystem->RelativePathToOSPath( dest, "fs_cdpath" );
|
|
|
|
dest.ExtractFilePath( path );
|
|
if ( path.Length() ) {
|
|
fileSystem->CreateOSPath( path );
|
|
}
|
|
|
|
// get the os path in case it needs to create one
|
|
path = fileSystem->RelativePathToOSPath( "", "fs_cdpath" /* _D3XP */ );
|
|
|
|
common->SetRefreshOnPrint( true );
|
|
Maya_Error = Maya_ConvertModel( path, commandLine );
|
|
common->SetRefreshOnPrint( false );
|
|
if ( Maya_Error != "Ok" ) {
|
|
return false;
|
|
}
|
|
|
|
// conversion succeded
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
====================
|
|
idModelExport::Reset
|
|
====================
|
|
*/
|
|
void idModelExport::Reset( void ) {
|
|
force = false;
|
|
commandLine = "";
|
|
src = "";
|
|
dest = "";
|
|
}
|
|
|
|
/*
|
|
====================
|
|
idModelExport::ExportModel
|
|
====================
|
|
*/
|
|
bool idModelExport::ExportModel( const char *model ) {
|
|
const char *game = cvarSystem->GetCVarString( "fs_game" );
|
|
if ( strlen(game) == 0 ) {
|
|
game = BASE_GAMEDIR;
|
|
}
|
|
|
|
Reset();
|
|
src = model;
|
|
dest = model;
|
|
dest.SetFileExtension( MD5_MESH_EXT );
|
|
|
|
sprintf( commandLine, "mesh %s -dest %s -game %s", src.c_str(), dest.c_str(), game );
|
|
if ( !ConvertMayaToMD5() ) {
|
|
gameLocal.Printf( "Failed to export '%s' : %s", src.c_str(), Maya_Error.c_str() );
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
====================
|
|
idModelExport::ExportAnim
|
|
====================
|
|
*/
|
|
bool idModelExport::ExportAnim( const char *anim ) {
|
|
const char *game = cvarSystem->GetCVarString( "fs_game" );
|
|
if ( strlen(game) == 0 ) {
|
|
game = BASE_GAMEDIR;
|
|
}
|
|
|
|
Reset();
|
|
src = anim;
|
|
dest = anim;
|
|
dest.SetFileExtension( MD5_ANIM_EXT );
|
|
|
|
sprintf( commandLine, "anim %s -dest %s -game %s", src.c_str(), dest.c_str(), game );
|
|
if ( !ConvertMayaToMD5() ) {
|
|
gameLocal.Printf( "Failed to export '%s' : %s", src.c_str(), Maya_Error.c_str() );
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
====================
|
|
idModelExport::ParseOptions
|
|
====================
|
|
*/
|
|
bool idModelExport::ParseOptions( idLexer &lex ) {
|
|
idToken token;
|
|
idStr destdir;
|
|
idStr sourcedir;
|
|
|
|
if ( !lex.ReadToken( &token ) ) {
|
|
lex.Error( "Expected filename" );
|
|
return false;
|
|
}
|
|
|
|
src = token;
|
|
dest = token;
|
|
|
|
while( lex.ReadToken( &token ) ) {
|
|
if ( token == "-" ) {
|
|
if ( !lex.ReadToken( &token ) ) {
|
|
lex.Error( "Expecting option" );
|
|
return false;
|
|
}
|
|
if ( token == "sourcedir" ) {
|
|
if ( !lex.ReadToken( &token ) ) {
|
|
lex.Error( "Missing pathname after -sourcedir" );
|
|
return false;
|
|
}
|
|
sourcedir = token;
|
|
} else if ( token == "destdir" ) {
|
|
if ( !lex.ReadToken( &token ) ) {
|
|
lex.Error( "Missing pathname after -destdir" );
|
|
return false;
|
|
}
|
|
destdir = token;
|
|
} else if ( token == "dest" ) {
|
|
if ( !lex.ReadToken( &token ) ) {
|
|
lex.Error( "Missing filename after -dest" );
|
|
return false;
|
|
}
|
|
dest = token;
|
|
} else {
|
|
commandLine += va( " -%s", token.c_str() );
|
|
}
|
|
} else {
|
|
commandLine += va( " %s", token.c_str() );
|
|
}
|
|
}
|
|
|
|
if ( sourcedir.Length() ) {
|
|
src.StripPath();
|
|
sourcedir.BackSlashesToSlashes();
|
|
sprintf( src, "%s/%s", sourcedir.c_str(), src.c_str() );
|
|
}
|
|
|
|
if ( destdir.Length() ) {
|
|
dest.StripPath();
|
|
destdir.BackSlashesToSlashes();
|
|
sprintf( dest, "%s/%s", destdir.c_str(), dest.c_str() );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
====================
|
|
idModelExport::ParseExportSection
|
|
====================
|
|
*/
|
|
int idModelExport::ParseExportSection( idParser &parser ) {
|
|
idToken command;
|
|
idToken token;
|
|
idStr defaultCommands;
|
|
idLexer lex;
|
|
idStr temp;
|
|
idStr parms;
|
|
int count;
|
|
|
|
const char *game = cvarSystem->GetCVarString( "fs_game" );
|
|
|
|
if ( strlen(game) == 0 ) {
|
|
game = BASE_GAMEDIR;
|
|
}
|
|
|
|
// only export sections that match our export mask
|
|
if ( g_exportMask.GetString()[ 0 ] ) {
|
|
if ( parser.CheckTokenString( "{" ) ) {
|
|
parser.SkipBracedSection( false );
|
|
return 0;
|
|
}
|
|
|
|
parser.ReadToken( &token );
|
|
if ( token.Icmp( g_exportMask.GetString() ) ) {
|
|
parser.SkipBracedSection();
|
|
return 0;
|
|
}
|
|
parser.ExpectTokenString( "{" );
|
|
} else if ( !parser.CheckTokenString( "{" ) ) {
|
|
// skip the export mask
|
|
parser.ReadToken( &token );
|
|
parser.ExpectTokenString( "{" );
|
|
}
|
|
|
|
count = 0;
|
|
|
|
lex.SetFlags( LEXFL_NOSTRINGCONCAT | LEXFL_ALLOWPATHNAMES | LEXFL_ALLOWMULTICHARLITERALS | LEXFL_ALLOWBACKSLASHSTRINGCONCAT );
|
|
|
|
while( 1 ) {
|
|
|
|
if ( !parser.ReadToken( &command ) ) {
|
|
parser.Error( "Unexpoected end-of-file" );
|
|
break;
|
|
}
|
|
|
|
if ( command == "}" ) {
|
|
break;
|
|
}
|
|
|
|
if ( command == "options" ) {
|
|
parser.ParseRestOfLine( defaultCommands );
|
|
} else if ( command == "addoptions" ) {
|
|
parser.ParseRestOfLine( temp );
|
|
defaultCommands += " ";
|
|
defaultCommands += temp;
|
|
} else if ( ( command == "mesh" ) || ( command == "anim" ) || ( command == "camera" ) ) {
|
|
if ( !parser.ReadToken( &token ) ) {
|
|
parser.Error( "Expected filename" );
|
|
}
|
|
|
|
temp = token;
|
|
parser.ParseRestOfLine( parms );
|
|
|
|
if ( defaultCommands.Length() ) {
|
|
sprintf( temp, "%s %s", temp.c_str(), defaultCommands.c_str() );
|
|
}
|
|
|
|
if ( parms.Length() ) {
|
|
sprintf( temp, "%s %s", temp.c_str(), parms.c_str() );
|
|
}
|
|
|
|
lex.LoadMemory( temp, temp.Length(), parser.GetFileName() );
|
|
|
|
Reset();
|
|
if ( ParseOptions( lex ) ) {
|
|
const char *game = cvarSystem->GetCVarString( "fs_game" );
|
|
if ( strlen(game) == 0 ) {
|
|
game = BASE_GAMEDIR;
|
|
}
|
|
|
|
if ( command == "mesh" ) {
|
|
dest.SetFileExtension( MD5_MESH_EXT );
|
|
} else if ( command == "anim" ) {
|
|
dest.SetFileExtension( MD5_ANIM_EXT );
|
|
} else if ( command == "camera" ) {
|
|
dest.SetFileExtension( MD5_CAMERA_EXT );
|
|
} else {
|
|
dest.SetFileExtension( command );
|
|
}
|
|
idStr back = commandLine;
|
|
sprintf( commandLine, "%s %s -dest %s -game %s%s", command.c_str(), src.c_str(), dest.c_str(), game, commandLine.c_str() );
|
|
if ( ConvertMayaToMD5() ) {
|
|
count++;
|
|
} else {
|
|
parser.Warning( "Failed to export '%s' : %s", src.c_str(), Maya_Error.c_str() );
|
|
}
|
|
}
|
|
lex.FreeSource();
|
|
} else {
|
|
parser.Error( "Unknown token: %s", command.c_str() );
|
|
parser.SkipBracedSection( false );
|
|
break;
|
|
}
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idModelExport::ExportDefFile
|
|
================
|
|
*/
|
|
int idModelExport::ExportDefFile( const char *filename ) {
|
|
idParser parser( LEXFL_NOSTRINGCONCAT | LEXFL_ALLOWPATHNAMES | LEXFL_ALLOWMULTICHARLITERALS | LEXFL_ALLOWBACKSLASHSTRINGCONCAT );
|
|
idToken token;
|
|
int count;
|
|
|
|
count = 0;
|
|
|
|
if ( !parser.LoadFile( filename ) ) {
|
|
gameLocal.Printf( "Could not load '%s'\n", filename );
|
|
return 0;
|
|
}
|
|
|
|
while( parser.ReadToken( &token ) ) {
|
|
if ( token == "export" ) {
|
|
count += ParseExportSection( parser );
|
|
} else {
|
|
parser.ReadToken( &token );
|
|
parser.SkipBracedSection();
|
|
}
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idModelExport::ExportModels
|
|
================
|
|
*/
|
|
int idModelExport::ExportModels( const char *pathname, const char *extension ) {
|
|
int count;
|
|
|
|
count = 0;
|
|
|
|
idFileList *files;
|
|
int i;
|
|
|
|
if ( !CheckMayaInstall() ) {
|
|
// if Maya isn't installed, don't bother checking if we have anims to export
|
|
return 0;
|
|
}
|
|
|
|
gameLocal.Printf( "--------- Exporting models --------\n" );
|
|
if ( !g_exportMask.GetString()[ 0 ] ) {
|
|
gameLocal.Printf( " Export mask: '%s'\n", g_exportMask.GetString() );
|
|
}
|
|
|
|
count = 0;
|
|
|
|
files = fileSystem->ListFiles( pathname, extension );
|
|
for( i = 0; i < files->GetNumFiles(); i++ ) {
|
|
count += ExportDefFile( va( "%s/%s", pathname, files->GetFile( i ) ) );
|
|
}
|
|
fileSystem->FreeFileList( files );
|
|
|
|
gameLocal.Printf( "...%d models exported.\n", count );
|
|
gameLocal.Printf( "-----------------------------------\n" );
|
|
|
|
return count;
|
|
}
|