int DoSignature(TCHAR *homepath) {
TCHAR fullsrcfile[MAX_PATH],fulldstfile[MAX_PATH];
#if TESTBENCH
StartupStore(_T(".... DoSignature start, homepath=<%s>\n"),homepath);
#endif
wsprintf(fullsrcfile,TEXT("%s/LOGGER_TMP.IGC"),homepath);
wsprintf(fulldstfile,TEXT("%s/LOGGER_SIG.IGC"),homepath);
// Force removal of anything existing.
// We should have checked already that this file does not exist, and rename it eventually.
// If it is here, we remove it, we are in the hurry and cannot loose time on previous files.
FILE *ft;
ft=NULL;
DeleteFile(fulldstfile);
if ( (ft=_wfopen(fulldstfile,TEXT("r")))!=NULL ) {
StartupStore(_T("... DoSignature: ERROR existing destination file <%S>!%s"),fulldstfile,NEWLINE);
fclose(ft);
return 12;
}
if (ReadInputFile(Linelist, fullsrcfile)) {
StartupStore(_T("... DoSignature: ERROR source file <%S> disappeared%s"),fullsrcfile,NEWLINE);
return 1;
}
GenerateMD5(Linelist, &md5gen);
AddGRecordToBuffer(Linelist, &md5gen);
WriteOutputFile(Linelist, fulldstfile);
#if TESTBENCH
StartupStore(_T("... DoSignature: signature OK%s"),NEWLINE);
#endif
return 0;
}
/* History:
03/2007 NW Implementation
**************************************************************************/
int ExecuteDelaunay3DProcess(char* infilepath, char* outfilepath)
{
int ireturnCode = 0;
int node = 0;
double* x = (double*)malloc(sizeof(double) * (NODE_MAX + 4));
double* y = (double*)malloc(sizeof(double) * (NODE_MAX + 4));
double* z = (double*)malloc(sizeof(double) * (NODE_MAX + 4));
int nelm = 0;
int* mtj = (int*)malloc(sizeof(int) * (ELEM_MAX * 4));
int* jac = (int*)malloc(sizeof(int) * (ELEM_MAX * 4));
int maxelm = ELEM_MAX;
int maxnode = NODE_MAX;
//printf("\n[AVAILABLE MEMORY]\n");
//printf("X: %x\nY: %x\nZ: %x\n", x, y, z);
//printf("MTJ: %x\nJAC: %x\n\n", mtj, jac);
if (x == NULL || y == NULL || z == NULL || mtj == NULL || jac == NULL)
//MyOutputDebugString("ERROR: Fail to malloc()");
return 999;
if(ReadInputFile(infilepath, &node, x, y, z))
{
generate_tetrahedra_mesh(&ireturnCode,&maxnode,&maxelm,&node,x,y,z,&nelm,mtj,jac);
if (ireturnCode == 0)
WriteOutputFile(outfilepath, &node,x,y,z,&nelm,mtj,jac,&maxelm);
}
else
//MyOutputDebugString("ERROR: input()\n");
return 999;
free(x);
free(y);
free(z);
free(mtj);
free(jac);
return ireturnCode;
}
/*
============
Dmap
============
*/
void Dmap( const idCmdArgs &args ) {
int i;
int start, end;
char path[1024];
idStr passedName;
bool leaked = false;
bool noCM = false;
bool noAAS = false;
ResetDmapGlobals();
if ( args.Argc() < 2 ) {
DmapHelp();
return;
}
common->Printf("---- dmap ----\n");
dmapGlobals.fullCarve = true;
dmapGlobals.shadowOptLevel = SO_MERGE_SURFACES; // create shadows by merging all surfaces, but no super optimization
// dmapGlobals.shadowOptLevel = SO_CLIP_OCCLUDERS; // remove occluders that are completely covered
// dmapGlobals.shadowOptLevel = SO_SIL_OPTIMIZE;
// dmapGlobals.shadowOptLevel = SO_CULL_OCCLUDED;
dmapGlobals.noLightCarve = true;
for ( i = 1 ; i < args.Argc() ; i++ ) {
const char *s;
s = args.Argv(i);
if ( s[0] == '-' ) {
s++;
if ( s[0] == '\0' ) {
continue;
}
}
if ( !idStr::Icmp( s,"glview" ) ) {
dmapGlobals.glview = true;
} else if ( !idStr::Icmp( s, "v" ) ) {
common->Printf( "verbose = true\n" );
dmapGlobals.verbose = true;
} else if ( !idStr::Icmp( s, "draw" ) ) {
common->Printf( "drawflag = true\n" );
dmapGlobals.drawflag = true;
} else if ( !idStr::Icmp( s, "noFlood" ) ) {
common->Printf( "noFlood = true\n" );
dmapGlobals.noFlood = true;
} else if ( !idStr::Icmp( s, "noLightCarve" ) ) {
common->Printf( "noLightCarve = true\n" );
dmapGlobals.noLightCarve = true;
} else if ( !idStr::Icmp( s, "lightCarve" ) ) {
common->Printf( "noLightCarve = false\n" );
dmapGlobals.noLightCarve = false;
} else if ( !idStr::Icmp( s, "noOpt" ) ) {
common->Printf( "noOptimize = true\n" );
dmapGlobals.noOptimize = true;
} else if ( !idStr::Icmp( s, "verboseentities" ) ) {
common->Printf( "verboseentities = true\n");
dmapGlobals.verboseentities = true;
} else if ( !idStr::Icmp( s, "noCurves" ) ) {
common->Printf( "noCurves = true\n");
dmapGlobals.noCurves = true;
} else if ( !idStr::Icmp( s, "noModels" ) ) {
common->Printf( "noModels = true\n" );
dmapGlobals.noModelBrushes = true;
} else if ( !idStr::Icmp( s, "noClipSides" ) ) {
common->Printf( "noClipSides = true\n" );
dmapGlobals.noClipSides = true;
} else if ( !idStr::Icmp( s, "noCarve" ) ) {
common->Printf( "noCarve = true\n" );
dmapGlobals.fullCarve = false;
} else if ( !idStr::Icmp( s, "shadowOpt" ) ) {
dmapGlobals.shadowOptLevel = (shadowOptLevel_t)atoi( args.Argv( i+1 ) );
common->Printf( "shadowOpt = %i\n",dmapGlobals.shadowOptLevel );
i += 1;
} else if ( !idStr::Icmp( s, "noTjunc" ) ) {
// triangle optimization won't work properly without tjunction fixing
common->Printf ("noTJunc = true\n" );
dmapGlobals.noTJunc = true;
dmapGlobals.noOptimize = true;
common->Printf ("forcing noOptimize = true\n" );
} else if ( !idStr::Icmp( s, "noCM" ) ) {
noCM = true;
common->Printf( "noCM = true\n" );
} else if ( !idStr::Icmp( s, "noAAS" ) ) {
noAAS = true;
common->Printf( "noAAS = true\n" );
} else if ( !idStr::Icmp( s, "editorOutput" ) ) {
#ifdef _WIN32
com_outputMsg = true;
#endif
} else {
break;
}
}
if ( i >= args.Argc() ) {
common->Error( "usage: dmap [options] mapfile" );
}
passedName = args.Argv(i); // may have an extension
passedName.BackSlashesToSlashes();
if ( passedName.Icmpn( "maps/", 4 ) != 0 ) {
passedName = "maps/" + passedName;
}
idStr stripped = passedName;
stripped.StripFileExtension();
idStr::Copynz( dmapGlobals.mapFileBase, stripped, sizeof(dmapGlobals.mapFileBase) );
bool region = false;
// if this isn't a regioned map, delete the last saved region map
if ( passedName.Right( 4 ) != ".reg" ) {
sprintf( path, "%s.reg", dmapGlobals.mapFileBase );
fileSystem->RemoveFile( path );
} else {
region = true;
}
passedName = stripped;
// delete any old line leak files
sprintf( path, "%s.lin", dmapGlobals.mapFileBase );
fileSystem->RemoveFile( path );
//
// start from scratch
//
start = Sys_Milliseconds();
if ( !LoadDMapFile( passedName ) ) {
return;
}
if ( ProcessModels() ) {
WriteOutputFile();
} else {
leaked = true;
}
FreeDMapFile();
common->Printf( "%i total shadow triangles\n", dmapGlobals.totalShadowTriangles );
common->Printf( "%i total shadow verts\n", dmapGlobals.totalShadowVerts );
end = Sys_Milliseconds();
common->Printf( "-----------------------\n" );
common->Printf( "%5.0f seconds for dmap\n", ( end - start ) * 0.001f );
if ( !leaked ) {
if ( !noCM ) {
// make sure the collision model manager is not used by the game
cmdSystem->BufferCommandText( CMD_EXEC_NOW, "disconnect" );
// create the collision map
start = Sys_Milliseconds();
collisionModelManager->LoadMap( dmapGlobals.dmapFile );
collisionModelManager->FreeMap();
end = Sys_Milliseconds();
common->Printf( "-------------------------------------\n" );
common->Printf( "%5.0f seconds to create collision map\n", ( end - start ) * 0.001f );
}
if ( !noAAS && !region ) {
// create AAS files
RunAAS_f( args );
}
}
// free the common .map representation
delete dmapGlobals.dmapFile;
// clear the map plane list
dmapGlobals.mapPlanes.Clear();
#ifdef _WIN32
if ( com_outputMsg && com_hwndMsg != NULL ) {
unsigned int msg = ::RegisterWindowMessage( DMAP_DONE );
::PostMessage( com_hwndMsg, msg, 0, 0 );
}
#endif
}
// ==============================================================
// Extract License & Notes files
// These are stored as 4-bytes length, followed by length-bytes of compressed data
int ExtractTextFile(BLOCK_DATA *Blk, ULONG FileType)
{
ULONG n, m;
BYTE *zSrcBuf = (BYTE *) Blk->SrcBuf;
BYTE *zDstBuf = (BYTE *) Blk->DstBuf;
const char *FileExt;
if (FileType == FLAGS_License)
FileExt = LicenseExt;
else if (FileType == FLAGS_Notes)
FileExt = NotesExt;
else
return 0;
// NB:Can't use BioReadBuf... aligment problems? Yet it works for ProcessNextBlock() !!??
// Ok, can use ReadInputFile here cause everythjing is whole no. of bytes...
//BioReadBuf((BYTE *)&n, sizeof(n)); // Read length of block from file
ReadInputFile((BYTE *)&n, sizeof(n)); // Read length of block from file
FixEndian(&n, sizeof(n)); // Fix endian
if (n <= 0 || n > ZBUF_SIZE) // Check for valid block length
{
sprintf(MsgTxt, "ERROR - Invalid length for %s file (apparently %ld bytes) %s", FileExt, n, CorruptedMsg);
msg(MsgTxt, MSG_PopUp);
GlobalErrorFlag = SFARKLIB_ERR_CORRUPT;
return 0;
}
//BioReadBuf(zSrcBuf, n); // Read the block
ReadInputFile((BYTE *)zSrcBuf, n); // Read the block
m = UnMemcomp(zSrcBuf, n, zDstBuf, ZBUF_SIZE); // Uncompress
Blk->FileCheck = adler32(Blk->FileCheck, zDstBuf, m); // Accumulate checksum
if (GlobalErrorFlag || m > ZBUF_SIZE) // Uncompressed ok & size is valid?
return 0;
// Write file - Use original file name plus specified extension for OutFileName...
char OutFileName[MAX_FILENAME];
strncpy(OutFileName, Blk->FileHeader.FileName, sizeof(OutFileName)); // copy output filename
ChangeFileExt(OutFileName, FileExt, sizeof(OutFileName));
OpenOutputFile(OutFileName); // Create notes / license file
WriteOutputFile(zDstBuf, m); // and write to output file
CloseOutputFile();
if (FileType == FLAGS_License)
{
sprintf(MsgTxt, "Created license file: %s", OutFileName);
msg(MsgTxt, 0);
if (GetLicenseAgreement((const char *)zDstBuf, OutFileName) == 0)
{
GlobalErrorFlag = SFARKLIB_ERR_LICENSE;
return EndProcess(0);
}
}
else if (FileType == FLAGS_Notes)
{
sprintf(MsgTxt, "Created notes file: %s", OutFileName);
msg(MsgTxt, 0);
DisplayNotes((const char *)zDstBuf, OutFileName);
}
return 1;
}
// ==============================================================
int ProcessNextBlock(BLOCK_DATA *Blk)
{
//int TotBytesRead = 0; // Total bytes read in file
int NumWords; //
uint32_t n, m; // NB: Must be 32-bit integer
#define AWBYTES (sizeof(AWORD))
BYTE *zSrcBuf = (BYTE *) Blk->SrcBuf;
BYTE *zDstBuf = (BYTE *) Blk->DstBuf;
switch (Blk->FileSection)
{
case AUDIO:
{
NumWords = Blk->ReadSize; // Number of words we will read in this block
n = NumWords * AWBYTES; // ... and number of bytes
if (Blk->TotBytesWritten + n >= Blk->FileHeader.PostAudioStart) // Short block? (near end of file)
{
n = Blk->FileHeader.PostAudioStart - Blk->TotBytesWritten; // Get exact length in bytes
NumWords = n / AWBYTES; // ... and words
Blk->FileSection = POST_AUDIO; // End of Audio -- PostAudio section is next
}
//printf("AUDIO, read %ld bytes\n", n);
if (Blk->FileHeader.CompMethod == COMPRESSION_v2Turbo) // If using Turbo compression
DecompressTurbo(Blk, NumWords); // Decompress
else // For all other methods
DecompressFast(Blk, NumWords); // Decompress
//printf("B4 WriteOutputFile: %ld\n", adler32(0, (const BYTE *) Blk->SrcBuf, n) & 0xffff);
/*#ifdef __BIG_ENDIAN__
#define WFIX(I) s = bp[I+0]; bp[I+0] = bp[I+1]; bp[I+1] = s;
BYTE *bp = (BYTE *) Blk->SrcBuf; BYTE *ep = bp + n;
do {
BYTE s;
WFIX(0); WFIX(2); WFIX(4); WFIX(6);
WFIX(8); WFIX(10); WFIX(12); WFIX(14);
bp += 16;
} while (bp < ep);
#undef WFIX
#endif*/
WriteOutputFile((const BYTE *)Blk->SrcBuf, n); // Write to output file
Blk->TotBytesWritten += n; // Accumulate total bytes written
break;
}
case PRE_AUDIO: case POST_AUDIO: case NON_AUDIO:
{
BioReadBuf((BYTE *) &n, sizeof(n));
FixEndian(&n, sizeof(n));
//printf("Reading PRE/POST AUDIO block, compressed %ld bytes\n", n);
if (n > ZBUF_SIZE) // Check for valid block length
{
sprintf(MsgTxt, "ERROR - Invalid length for Non-audio Block (apparently %d bytes) %s", n, CorruptedMsg);
msg(MsgTxt, MSG_PopUp);
return (GlobalErrorFlag = SFARKLIB_ERR_CORRUPT);
}
BioReadBuf(zSrcBuf, n); // Read the block
m = UnMemcomp(zSrcBuf, n, zDstBuf, ZBUF_SIZE); //printf("PRE/POST AUDIO block, compressed %ld bytes, uncompressed %ld bytes\n", n, m);
// Uncompress
if (GlobalErrorFlag != SFARKLIB_SUCCESS) return(GlobalErrorFlag);
if (m <= ZBUF_SIZE) // Uncompressed ok & size is valid?
{
//printf("writing uncompressed block %ld bytes\n", m);
Blk->FileCheck = adler32(Blk->FileCheck, zDstBuf, m); // Accumulate checksum
WriteOutputFile(zDstBuf, m); // and write to output file
Blk->TotBytesWritten += m; // Accumulate byte count
}
else
return SFARKLIB_ERR_CORRUPT;
#if DB_BLOCKCHECK // If debug mode block check enabled
ULONG BlockCheck = BioRead(16); // Read block check bits
FixEndian(&BlockCheck, sizeof(Blockcheck));
ULONG CalcBlockCheck = adler32(0, zDstBuf, m) & 0xFFFF;
printf("NonAudio Block Checks Read: %ld, Calc %ld Length=%d\n", BlockCheck, CalcBlockCheck, m);
if (BlockCheck != CalcBlockCheck) // Compare to calculated cheksum
{
printf("*** NonAudio Block check FAIL\n");
}
else
printf("NonAudio Block check Ok\n");
#endif
//printf("PRE/POST AUDIO, read %ld bytes, writing %ld bytes...", n, m);
if (Blk->TotBytesWritten >= Blk->FileHeader.OriginalSize) // Have we finished the file?
Blk->FileSection = FINISHED;
else if (Blk->FileSection == PRE_AUDIO && Blk->TotBytesWritten >= Blk->FileHeader.AudioStart) // finished Pre-Audio?
Blk->FileSection = AUDIO; // .. then next section is Audio
break;
} // case
} //switch
//sprintf(MsgTxt, "BytesWritten: %ld of %ld", Blk->TotBytesWritten, Blk->FileHeader.OriginalSize);
//msg(MsgTxt, 0);
return SFARKLIB_SUCCESS;
}
int main (int argc, const char * argv[])
{
if (argc == 1) {
fprintf (stderr, "%s\n", usageStr);
exit(0);
}
char* filePath = 0;
bool shouldPlay = false;
bool shouldSetBank = false;
bool shouldUseMIDIEndpoint = false;
bool shouldPrint = true;
bool waitAtEnd = false;
bool diskStream = false;
OSType dataFormat = 0;
Float64 srate = 0;
const char* outputFilePath = 0;
MusicSequenceLoadFlags loadFlags = 0;
char* bankPath = 0;
Float32 startTime = 0;
UInt32 numFrames = 512;
std::set<int> trackSet;
for (int i = 1; i < argc; ++i)
{
if (!strcmp ("-p", argv[i]))
{
shouldPlay = true;
}
else if (!strcmp ("-w", argv[i]))
{
waitAtEnd = true;
}
else if (!strcmp ("-d", argv[i]))
{
diskStream = true;
}
else if (!strcmp ("-b", argv[i]))
{
shouldSetBank = true;
if (++i == argc) goto malformedInput;
bankPath = const_cast<char*>(argv[i]);
}
else if (!strcmp ("-n", argv[i]))
{
shouldPrint = false;
}
else if ((filePath == 0) && (argv[i][0] == '/' || argv[i][0] == '~'))
{
filePath = const_cast<char*>(argv[i]);
}
else if (!strcmp ("-s", argv[i]))
{
if (++i == argc) goto malformedInput;
sscanf (argv[i], "%f", &startTime);
}
else if (!strcmp ("-t", argv[i]))
{
int index;
if (++i == argc) goto malformedInput;
sscanf (argv[i], "%d", &index);
trackSet.insert(--index);
}
else if (!strcmp("-e", argv[i]))
{
shouldUseMIDIEndpoint = true;
}
else if (!strcmp("-c", argv[i]))
{
loadFlags = kMusicSequenceLoadSMF_ChannelsToTracks;
}
else if (!strcmp ("-i", argv[i]))
{
if (++i == argc) goto malformedInput;
sscanf (argv[i], "%lu", (unsigned long*)(&numFrames));
}
else if (!strcmp ("-f", argv[i]))
{
if (i + 3 >= argc) goto malformedInput;
outputFilePath = argv[++i];
StrToOSType (argv[++i], dataFormat);
sscanf (argv[++i], "%lf", &srate);
}
else
{
malformedInput:
fprintf (stderr, "%s\n", usageStr);
exit (1);
}
}
if (filePath == 0) {
fprintf (stderr, "You have to specify a MIDI file to print or play\n");
fprintf (stderr, "%s\n", usageStr);
exit (1);
}
if (shouldUseMIDIEndpoint && outputFilePath) {
printf ("can't write a file when you try to play out to a MIDI Endpoint\n");
exit (1);
}
MusicSequence sequence;
OSStatus result;
FailIf ((result = LoadSMF (filePath, sequence, loadFlags)), fail, "LoadSMF");
if (shouldPrint)
CAShow (sequence);
if (shouldPlay)
{
AUGraph graph = 0;
AudioUnit theSynth = 0;
FailIf ((result = MusicSequenceGetAUGraph (sequence, &graph)), fail, "MusicSequenceGetAUGraph");
FailIf ((result = AUGraphOpen (graph)), fail, "AUGraphOpen");
FailIf ((result = GetSynthFromGraph (graph, theSynth)), fail, "GetSynthFromGraph");
FailIf ((result = AudioUnitSetProperty (theSynth,
kAudioUnitProperty_CPULoad,
kAudioUnitScope_Global, 0,
&maxCPULoad, sizeof(maxCPULoad))), fail, "AudioUnitSetProperty: kAudioUnitProperty_CPULoad");
if (shouldUseMIDIEndpoint)
{
MIDIClientRef theMidiClient;
MIDIClientCreate(CFSTR("Play Sequence"), NULL, NULL, &theMidiClient);
ItemCount destCount = MIDIGetNumberOfDestinations();
if (destCount == 0) {
fprintf (stderr, "No MIDI Endpoints to play to.\n");
exit(1);
}
FailIf ((result = MusicSequenceSetMIDIEndpoint (sequence, MIDIGetDestination(0))), fail, "MusicSequenceSetMIDIEndpoint");
}
else
{
if (shouldSetBank) {
CFURLRef soundBankURL = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault, (const UInt8*)bankPath, strlen(bankPath), false);
printf ("Setting Sound Bank:%s\n", bankPath);
result = AudioUnitSetProperty (theSynth,
kMusicDeviceProperty_SoundBankURL,
kAudioUnitScope_Global, 0,
&soundBankURL, sizeof(soundBankURL));
if (soundBankURL) CFRelease(soundBankURL);
FailIf (result, fail, "AudioUnitSetProperty: kMusicDeviceProperty_SoundBankURL");
}
if (diskStream) {
UInt32 value = diskStream;
FailIf ((result = AudioUnitSetProperty (theSynth,
kMusicDeviceProperty_StreamFromDisk,
kAudioUnitScope_Global, 0,
&value, sizeof(value))), fail, "AudioUnitSetProperty: kMusicDeviceProperty_StreamFromDisk");
}
if (outputFilePath) {
// need to tell synth that is going to render a file.
UInt32 value = 1;
FailIf ((result = AudioUnitSetProperty (theSynth,
kAudioUnitProperty_OfflineRender,
kAudioUnitScope_Global, 0,
&value, sizeof(value))), fail, "AudioUnitSetProperty: kAudioUnitProperty_OfflineRender");
}
FailIf ((result = SetUpGraph (graph, numFrames, srate, (outputFilePath != NULL))), fail, "SetUpGraph");
if (shouldPrint) {
printf ("Sample Rate: %.1f \n", srate);
printf ("Disk Streaming is enabled: %c\n", (diskStream ? 'T' : 'F'));
}
FailIf ((result = AUGraphInitialize (graph)), fail, "AUGraphInitialize");
if (shouldPrint)
CAShow (graph);
}
MusicPlayer player;
FailIf ((result = NewMusicPlayer (&player)), fail, "NewMusicPlayer");
FailIf ((result = MusicPlayerSetSequence (player, sequence)), fail, "MusicPlayerSetSequence");
// figure out sequence length
UInt32 ntracks;
FailIf ((MusicSequenceGetTrackCount (sequence, &ntracks)), fail, "MusicSequenceGetTrackCount");
MusicTimeStamp sequenceLength = 0;
bool shouldPrintTracks = shouldPrint && !trackSet.empty();
if (shouldPrintTracks)
printf ("Only playing specified tracks:\n\t");
for (UInt32 i = 0; i < ntracks; ++i) {
MusicTrack track;
MusicTimeStamp trackLength;
UInt32 propsize = sizeof(MusicTimeStamp);
FailIf ((result = MusicSequenceGetIndTrack(sequence, i, &track)), fail, "MusicSequenceGetIndTrack");
FailIf ((result = MusicTrackGetProperty(track, kSequenceTrackProperty_TrackLength,
&trackLength, &propsize)), fail, "MusicTrackGetProperty: kSequenceTrackProperty_TrackLength");
if (trackLength > sequenceLength)
sequenceLength = trackLength;
if (!trackSet.empty() && (trackSet.find(i) == trackSet.end()))
{
Boolean mute = true;
FailIf ((result = MusicTrackSetProperty(track, kSequenceTrackProperty_MuteStatus, &mute, sizeof(mute))), fail, "MusicTrackSetProperty: kSequenceTrackProperty_MuteStatus");
}
else if (shouldPrintTracks) {
printf ("%d, ", int(i+1));
}
}
if (shouldPrintTracks)
printf ("\n");
// now I'm going to add 8 beats on the end for the reverb/long releases to tail off...
sequenceLength += 8;
FailIf ((result = MusicPlayerSetTime (player, startTime)), fail, "MusicPlayerSetTime");
FailIf ((result = MusicPlayerPreroll (player)), fail, "MusicPlayerPreroll");
if (shouldPrint) {
printf ("Ready to play: %s, %.2f beats long\n\t<Enter> to continue: ", filePath, sequenceLength);
getc(stdin);
}
startRunningTime = CAHostTimeBase::GetTheCurrentTime();
/* if (waitAtEnd && graph)
AUGraphStart(graph);
*/
FailIf ((result = MusicPlayerStart (player)), fail, "MusicPlayerStart");
if (outputFilePath)
WriteOutputFile (outputFilePath, dataFormat, srate, sequenceLength, shouldPrint, graph, numFrames, player);
else
PlayLoop (player, graph, sequenceLength, shouldPrint, waitAtEnd);
FailIf ((result = MusicPlayerStop (player)), fail, "MusicPlayerStop");
if (shouldPrint) printf ("finished playing\n");
/* if (waitAtEnd) {
CFRunLoopRunInMode(kCFRunLoopDefaultMode, 10, false);
if (graph)
AUGraphStop(graph);
if (shouldPrint) printf ("disposing\n");
}
*/
// this shows you how you should dispose of everything
FailIf ((result = DisposeMusicPlayer (player)), fail, "DisposeMusicPlayer");
FailIf ((result = DisposeMusicSequence(sequence)), fail, "DisposeMusicSequence");
// don't own the graph so don't dispose it (the seq owns it as we never set it ourselves, we just got it....)
}
else {
FailIf ((result = DisposeMusicSequence(sequence)), fail, "DisposeMusicSequence");
}
while (waitAtEnd)
CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.25, false);
return 0;
fail:
if (shouldPrint) printf ("Error = %ld\n", (long)result);
return result;
}
int main( int argc, char *argv[])
{
char *p;
char *Switch, *Value;
char InputFileName[200];
int i;
XTL_FileStatus XTLFileStat;
/* initialize trace to off */
TraceInit( );
SetTraceOutput( stdout ); /* defaults to stderr if not set, we want stdout */
TraceOn( FALSE );
DL_CL_ProcessArgs( argc, argv );
p = DL_CL_GetProgName( );
printf( "%s", p );
for( i = 0; Copyright[i] != NULL; ++i )
puts( Copyright[i] );
if ( getcwd(CurrentDirectory, sizeof(CurrentDirectory) - 1) == NULL )
{
CurrentDirectory[0] = 0;
puts( "Failed to get current working directory" );
}
if ( DL_CL_GetArgCount() != 1 )
{
for( i = 0; Instructions[i] != NULL; ++i )
puts( Instructions[i] );
ErrorExit( "\n" );
}
strcpy( InputFileName, DL_CL_GetArg( 0 ) );
for ( i = 0; DL_CL_GetSwitch( i, &Switch, &Value ); i++ )
{
ProcessCommandLineSwitch( Switch, Value );
}
/* Process and envirnmant variables */
ProcessEnvVars();
/* initialize the XronosIO library */
XronosIOInit();
XTL_SubVars_Init();
/* init stuff from Conf file */
puts( "Processing Conf file" );
printf( "Conf File: %s\n", ConfFileName );
if ( DL_ReadIniFile(ConfFileName) != 0 )
ErrorExit( "Failed to read conf file" );
p = DL_GetIniValue( "XF_MaxQuestions", NULL );
if ( p != NULL )
{
SetMaxQuestions( atoi(p) );
}
QuestionsOnly = DL_GetIniBOOLValue( "XF_QuestionsOnly", QuestionsOnly );
TagsRequired = DL_GetIniBOOLValue( "XF_TagsRequired", TagsRequired );
SB_Texttt_removal = DL_GetIniBOOLValue( "SageBug_Texttt_removal", SB_Texttt_removal );
InitUserDefinedSubstitution( );
p = DL_GetIniStringValue( "XF_OutputFileHeader", NULL );
if ( p != NULL )
{
strcpy( FileForOutputHeader, p );
}
p = DL_GetIniStringValue( "XF_OutputFileFooter", NULL );
if ( p != NULL )
{
strcpy( FileForOutputFooter, p );
}
p = DL_GetIniStringValue( "XF_InputFileHeader", NULL );
if ( p != NULL )
{
if ( XronosIO_SetHeaderFile( p ) != 0 )
ErrorExit( "failed to set XF_InputFileHeader value" );
printf( "Set Input HeaderFile: %s\n", p );
}
p = DL_GetIniStringValue( "XF_InputFileFooter", NULL );
if ( p != NULL )
{
if ( XronosIO_SetFooterFile( p ) != 0 )
ErrorExit( "failed to set XF_InputFileFooter value" );
printf( "Set Input FooterFile: %s\n", p );
}
DL_DiscardIniFile();
puts( "Done Processing Conf file" );
/* end ini stuff */
strcpy( OutputFileName, InputFileName );
/* Load file into memory */
printf( "*** Reading input file: %s\n", InputFileName );
ReadInputFile( InputFileName );
/* kill dups */
puts( "*** Killing Dups" );
KillDups( );
/* deal with braces */
RecycleBuffers( ); /* recycle the previous pass output to the new pass input */
puts( "*** Braces processing" );
Braces( );
/* deal with question limit on file size */
RecycleBuffers( ); /* recycle the previous pass output to the new pass input */
puts( "*** Question Limit processing" );
QuestionLimit( );
if ( SB_Texttt_removal )
{
/* deal with \text{\texttt{}} sage bug */
RecycleBuffers( ); /* recycle the previous pass output to the new pass input */
puts( "*** Texttt Removal processing" );
TextttRemoval( );
}
/* deal with substitution processing - should be JUST before WriteOutputFile() */
RecycleBuffers( ); /* recycle the previous pass output to the new pass input */
puts( "*** Internal variable substitution processing" );
HandleSubstitution( );
/* write output file */
RecycleBuffers( ); /* recycle the previous pass output to the new pass input */
printf( "*** Writing Output file; %s\n", OutputFileName );
WriteOutputFile( OutputFileName );
puts( "*** Program Complete\n" );
return 0;
}
int main (int argc, const char * argv[])
{
if (argc == 1) {
fprintf (stderr, "%s\n", usageStr);
exit(0);
}
char* filePath = 0;
bool shouldPlay = false;
bool shouldSetBank = false;
bool shouldUseMIDIEndpoint = false;
bool shouldPrint = true;
bool waitAtEnd = false;
bool diskStream = false;
OSType dataFormat = 0;
Float64 srate = 0;
const char* outputFilePath = 0;
MusicSequenceLoadFlags loadFlags = 0;
char* bankPath = 0;
Float32 startTime = 0;
UInt32 numFrames = 512;
for (int i = 1; i < argc; ++i)
{
if (!strcmp ("-p", argv[i]))
{
shouldPlay = true;
}
else if (!strcmp ("-w", argv[i]))
{
waitAtEnd = true;
}
else if (!strcmp ("-d", argv[i]))
{
diskStream = true;
}
else if (!strcmp ("-b", argv[i]))
{
shouldSetBank = true;
if (++i == argc) goto malformedInput;
bankPath = const_cast<char*>(argv[i]);
}
else if (!strcmp ("-n", argv[i]))
{
shouldPrint = false;
}
else if ((filePath == 0) && (argv[i][0] == '/' || argv[i][0] == '~'))
{
filePath = const_cast<char*>(argv[i]);
}
else if (!strcmp ("-t", argv[i]))
{
if (++i == argc) goto malformedInput;
sscanf (argv[i], "%f", &startTime);
}
else if (!strcmp("-e", argv[i]))
{
shouldUseMIDIEndpoint = true;
}
else if (!strcmp("-c", argv[i]))
{
loadFlags = kMusicSequenceLoadSMF_ChannelsToTracks;
}
else if (!strcmp ("-i", argv[i]))
{
if (++i == argc) goto malformedInput;
sscanf (argv[i], "%ld", &numFrames);
}
else if (!strcmp ("-f", argv[i]))
{
if (i + 3 >= argc) goto malformedInput;
outputFilePath = argv[++i];
str2OSType (argv[++i], dataFormat);
sscanf (argv[++i], "%lf", &srate);
}
else
{
malformedInput:
fprintf (stderr, "%s\n", usageStr);
exit (1);
}
}
if (filePath == 0) {
fprintf (stderr, "You have to specify a MIDI file to print or play\n");
fprintf (stderr, "%s\n", usageStr);
exit (1);
}
if (shouldUseMIDIEndpoint && outputFilePath) {
printf ("can't write a file when you try to play out to a MIDI Endpoint\n");
exit (1);
}
MusicSequence sequence;
OSStatus result;
require_noerr (result = LoadSMF (filePath, sequence, loadFlags), fail);
if (shouldPrint)
CAShow (sequence);
if (shouldPlay)
{
AUGraph graph = 0;
AudioUnit theSynth = 0;
require_noerr (result = MusicSequenceGetAUGraph (sequence, &graph), fail);
require_noerr (result = AUGraphOpen (graph), fail);
require_noerr (result = GetSynthFromGraph (graph, theSynth), fail);
require_noerr (result = AudioUnitSetProperty (theSynth,
kAudioUnitProperty_CPULoad,
kAudioUnitScope_Global, 0,
&maxCPULoad, sizeof(maxCPULoad)), fail);
if (shouldUseMIDIEndpoint)
{
MIDIClientRef theMidiClient;
MIDIClientCreate(CFSTR("Play Sequence"), NULL, NULL, &theMidiClient);
ItemCount destCount = MIDIGetNumberOfDestinations();
if (destCount == 0) {
fprintf (stderr, "No MIDI Endpoints to play to.\n");
exit(1);
}
require_noerr (result = MusicSequenceSetMIDIEndpoint (sequence, MIDIGetDestination(0)), fail);
}
else
{
if (shouldSetBank) {
FSRef soundBankRef;
require_noerr (result = FSPathMakeRef ((const UInt8*)bankPath, &soundBankRef, 0), fail);
printf ("Setting Sound Bank:%s\n", bankPath);
require_noerr (result = AudioUnitSetProperty (theSynth,
kMusicDeviceProperty_SoundBankFSRef,
kAudioUnitScope_Global, 0,
&soundBankRef, sizeof(soundBankRef)), fail);
}
if (diskStream) {
UInt32 value = diskStream;
require_noerr (result = AudioUnitSetProperty (theSynth,
kMusicDeviceProperty_StreamFromDisk,
kAudioUnitScope_Global, 0,
&value, sizeof(value)), fail);
}
if (outputFilePath) {
// need to tell synth that is going to render a file.
UInt32 value = 1;
require_noerr (result = AudioUnitSetProperty (theSynth,
kAudioUnitProperty_OfflineRender,
kAudioUnitScope_Global, 0,
&value, sizeof(value)), fail);
}
require_noerr (result = SetUpGraph (graph, numFrames, srate, (outputFilePath != NULL)), fail);
if (shouldPrint) {
printf ("Sample Rate: %.1f \n", srate);
printf ("Disk Streaming is enabled: %c\n", (diskStream ? 'T' : 'F'));
}
require_noerr (result = AUGraphInitialize (graph), fail);
if (shouldPrint)
CAShow (graph);
}
MusicPlayer player;
require_noerr (result = NewMusicPlayer (&player), fail);
require_noerr (result = MusicPlayerSetSequence (player, sequence), fail);
// figure out sequence length
UInt32 ntracks;
require_noerr(MusicSequenceGetTrackCount (sequence, &ntracks), fail);
MusicTimeStamp sequenceLength = 0;
for (UInt32 i = 0; i < ntracks; ++i) {
MusicTrack track;
MusicTimeStamp trackLength;
UInt32 propsize = sizeof(MusicTimeStamp);
require_noerr (result = MusicSequenceGetIndTrack(sequence, i, &track), fail);
require_noerr (result = MusicTrackGetProperty(track, kSequenceTrackProperty_TrackLength,
&trackLength, &propsize), fail);
if (trackLength > sequenceLength)
sequenceLength = trackLength;
}
// now I'm going to add 8 beats on the end for the reverb/long releases to tail off...
sequenceLength += 8;
require_noerr (result = MusicPlayerSetTime (player, startTime), fail);
require_noerr (result = MusicPlayerPreroll (player), fail);
if (shouldPrint) {
printf ("Ready to play: %s, %.2f beats long\n\t<Enter> to continue: ", filePath, sequenceLength);
getc(stdin);
}
startRunningTime = AudioGetCurrentHostTime ();
require_noerr (result = MusicPlayerStart (player), fail);
if (outputFilePath)
WriteOutputFile (outputFilePath, dataFormat, srate, sequenceLength, shouldPrint, graph, numFrames, player);
else
PlayLoop (player, graph, sequenceLength, shouldPrint, waitAtEnd);
require_noerr (result = MusicPlayerStop (player), fail);
if (shouldPrint) printf ("finished playing\n");
// this shows you how you should dispose of everything
require_noerr (result = DisposeMusicPlayer (player), fail);
require_noerr (result = DisposeMusicSequence(sequence), fail);
// don't own the graph so don't dispose it (the seq owns it as we never set it ourselves, we just got it....)
}
else {
require_noerr (result = DisposeMusicSequence(sequence), fail);
}
while (waitAtEnd)
CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.25, false);
return 0;
fail:
if (shouldPrint) printf ("Error = %ld\n", result);
return result;
}
void TR()
{
#if defined(DEBUG) && defined(_MSC_VER)
_CrtSetDbgFlag(0); // too expensive
#endif
const char *HitFileName = RequiredValueOpt("tr");
const char *OutFileName = RequiredValueOpt("out");
const char *CandFileName = ValueOpt("cand");
const char *strMinTrSpacing = ValueOpt("mintrspacing");
const char *strMaxTrSpacing = ValueOpt("maxtrspacing");
const char *strMinTrLength = ValueOpt("mintrlength");
const char *strMaxTrLength = ValueOpt("minspacingratio");
const char *strMinFam = ValueOpt("minfam");
const char *strMinHitRatio = ValueOpt("minhitratio");
const char *strMinDistPairs = ValueOpt("mindistpairs");
if (0 != strMinTrSpacing)
MIN_LENGTH_LINE = atoi(strMinTrSpacing);
if (0 != strMaxTrSpacing)
MAX_LENGTH_LINE = atoi(strMaxTrSpacing);
if (0 != strMinTrLength)
MIN_LENGTH_LTR = atoi(strMinTrLength);
if (0 != strMaxTrLength)
MAX_LENGTH_LTR = atoi(strMaxTrLength);
if (0 != strMinFam)
MIN_FAM_SIZE = atoi(strMinFam);
if (0 != strMinHitRatio)
MIN_HIT_LENGTH_RATIO = atoi(strMinHitRatio);
if (0 != strMinDistPairs)
MIN_DIST_EDGE = atoi(strMinDistPairs);
FILE *fHit = OpenStdioFile(HitFileName, FILEIO_MODE_ReadOnly);
ProgressStart("Index hits");
GLIX HitGlix;
HitGlix.Init();
HitGlix.FromGFFFile(fHit);
HitGlix.MakeGlobalToLocalIndex();
ProgressDone();
const int GlobalLength = HitGlix.GetGlobalLength();
IIX IntervalIndex;
IntervalIndex.Init(GlobalLength);
ProgressStart("Find candidate TRs");
Rewind(fHit);
GFFRecord Rec;
while (GetNextGFFRecord(fHit, Rec))
{
HitData Hit;
GFFRecordToHit(HitGlix, Rec, Hit);
if (IsCandLTR(Hit))
AddCand(Hit, IntervalIndex);
}
ProgressDone();
Progress("%d candidates", CandCount);
if (0 != CandFileName)
{
ProgressStart("Write candidates");
FILE *fCand = OpenStdioFile(CandFileName, FILEIO_MODE_WriteOnly);
WriteCands(fCand, HitGlix);
ProgressDone();
}
ProgressStart("Make graph");
Rewind(fHit);
while (GetNextGFFRecord(fHit, Rec))
{
HitData Hit;
GFFRecordToHit(HitGlix, Rec, Hit);
FindEdges(Hit, HitGlix, IntervalIndex);
}
fclose(fHit);
fHit = 0;
ProgressDone();
Progress("%d edges", (int) Edges.size());
ProgressStart("Find families");
FamList Fams;
FindConnectedComponents(Edges, Fams, MIN_FAM_SIZE);
ProgressDone();
Progress("%d families", (int) Fams.size());
FILE *fOut = OpenStdioFile(OutFileName, FILEIO_MODE_WriteOnly);
WriteOutputFile(fOut, HitGlix, Fams);
}
ezApplication::ApplicationExecution ezTexConv2::Run()
{
if (ParseCommandLine().Failed())
return ezApplication::ApplicationExecution::Quit;
if (m_Processor.Process().Failed())
return ezApplication::ApplicationExecution::Quit;
if (m_Processor.m_Descriptor.m_OutputType == ezTexConvOutputType::Atlas)
{
ezDeferredFileWriter file;
file.SetOutput(m_sOutputFile);
ezAssetFileHeader header;
header.SetFileHashAndVersion(m_Processor.m_Descriptor.m_uiAssetHash, m_Processor.m_Descriptor.m_uiAssetVersion);
header.Write(file);
file.WriteBytes(m_Processor.m_TextureAtlas.GetData(), m_Processor.m_TextureAtlas.GetStorageSize());
return ezApplication::ApplicationExecution::Quit;
}
if (!m_sOutputFile.IsEmpty() && m_Processor.m_OutputImage.IsValid())
{
if (WriteOutputFile(m_sOutputFile, m_Processor.m_OutputImage).Failed())
{
ezLog::Error("Failed to write main result to '{}'", m_sOutputFile);
return ezApplication::ApplicationExecution::Quit;
}
ezLog::Success("Wrote main result to '{}'", m_sOutputFile);
}
if (!m_sOutputThumbnailFile.IsEmpty() && m_Processor.m_ThumbnailOutputImage.IsValid())
{
if (m_Processor.m_ThumbnailOutputImage.SaveTo(m_sOutputThumbnailFile).Failed())
{
ezLog::Error("Failed to write thumbnail result to '{}'", m_sOutputThumbnailFile);
return ezApplication::ApplicationExecution::Quit;
}
ezLog::Success("Wrote thumbnail to '{}'", m_sOutputThumbnailFile);
}
if (!m_sOutputLowResFile.IsEmpty())
{
// the image may not exist, if we do not have enough mips, so make sure any old low-res file is cleaned up
ezOSFile::DeleteFile(m_sOutputLowResFile);
if (m_Processor.m_LowResOutputImage.IsValid())
{
if (WriteOutputFile(m_sOutputLowResFile, m_Processor.m_LowResOutputImage).Failed())
{
ezLog::Error("Failed to write low-res result to '{}'", m_sOutputLowResFile);
return ezApplication::ApplicationExecution::Quit;
}
ezLog::Success("Wrote low-res result to '{}'", m_sOutputLowResFile);
}
}
return ezApplication::ApplicationExecution::Quit;
}
/*
============
Dmap
============
*/
void Dmap( const idCmdArgs &args ) {
int i;
int start, end;
char path[1024];
idStr passedName;
bool leaked = false;
bool noCM = false;
bool noAAS = false;
ResetDmapGlobals();
if ( args.Argc() < 2 ) {
DmapHelp();
return;
}
common->Printf("---- World Builder ----\n");
common->Printf("Processing compile options\n");
//dmapGlobals.fullCarve = true;
dmapGlobals.shadowOptLevel = SO_MERGE_SURFACES; // create shadows by merging all surfaces, but no super optimization
// dmapGlobals.shadowOptLevel = SO_CLIP_OCCLUDERS; // remove occluders that are completely covered
// dmapGlobals.shadowOptLevel = SO_SIL_OPTIMIZE;
// dmapGlobals.shadowOptLevel = SO_CULL_OCCLUDED;
dmapGlobals.mapCompileError = "";
dmapGlobals.noLightCarve = true;
for ( i = 1 ; i < args.Argc() ; i++ ) {
const char *s;
s = args.Argv(i);
if ( s[0] == '-' ) {
s++;
if ( s[0] == '\0' ) {
continue;
}
}
if ( !idStr::Icmp( s,"glview" ) ) {
dmapGlobals.glview = true;
} else if ( !idStr::Icmp( s, "v" ) ) {
common->Printf( "verbose = true\n" );
dmapGlobals.verbose = true;
} else if ( !idStr::Icmp( s, "draw" ) ) {
common->Printf( "drawflag = true\n" );
dmapGlobals.drawflag = true;
} else if ( !idStr::Icmp( s, "noFlood" ) ) {
common->Printf( "noFlood = true\n" );
dmapGlobals.noFlood = true;
} else if ( !idStr::Icmp( s, "noLightCarve" ) ) {
common->Printf( "noLightCarve = true\n" );
dmapGlobals.noLightCarve = true;
} else if ( !idStr::Icmp( s, "lightCarve" ) ) {
common->Printf( "noLightCarve = false\n" );
dmapGlobals.noLightCarve = false;
} else if ( !idStr::Icmp( s, "noOpt" ) ) {
common->Printf( "noOptimize = true\n" );
dmapGlobals.noOptimize = true;
} else if ( !idStr::Icmp( s, "verboseentities" ) ) {
common->Printf( "verboseentities = true\n");
dmapGlobals.verboseentities = true;
} else if ( !idStr::Icmp( s, "noCurves" ) ) {
common->Printf( "noCurves = true\n");
dmapGlobals.noCurves = true;
} else if ( !idStr::Icmp( s, "noModels" ) ) {
common->Printf( "noModels = true\n" );
dmapGlobals.noModelBrushes = true;
} else if ( !idStr::Icmp( s, "noClipSides" ) ) {
common->Printf( "noClipSides = true\n" );
dmapGlobals.noClipSides = true;
} else if ( !idStr::Icmp( s, "noCarve" ) ) {
common->Printf( "noCarve = true\n" );
dmapGlobals.fullCarve = false;
} else if ( !idStr::Icmp( s, "shadowOpt" ) ) {
dmapGlobals.shadowOptLevel = (shadowOptLevel_t)atoi( args.Argv( i+1 ) );
common->Printf( "shadowOpt = %i\n",dmapGlobals.shadowOptLevel );
i += 1;
} else if ( !idStr::Icmp( s, "noTjunc" ) ) {
// triangle optimization won't work properly without tjunction fixing
common->Printf ("noTJunc = true\n" );
dmapGlobals.noTJunc = true;
dmapGlobals.noOptimize = true;
common->Printf ("forcing noOptimize = true\n" );
} else if ( !idStr::Icmp( s, "noCM" ) ) {
noCM = true;
common->Printf( "noCM = true\n" );
} else if ( !idStr::Icmp( s, "noAAS" ) ) {
noAAS = true;
common->Printf( "noAAS = true\n" );
// jmarshall
} else if ( !idStr::Icmp( s, "novtupdate" ) ) {
dmapGlobals.novtupdate = true;
} else if ( !idStr::Icmp( s, "updateents" ) ) {
dmapGlobals.onlyEntities = true;
}
// jmarshall end
else {
break;
}
}
dmapGlobals.noOptimize = true;
if ( i >= args.Argc() ) {
common->Error( "usage: dmap [options] mapfile" );
}
// jmarshall - ensure bsp_inlinemesh_maxfacespertri cvar has good to go values.
if(bsp_inlinemesh_maxfacespertri.GetInteger() > 0 && (bsp_inlinemesh_maxfacespertri.GetInteger() % 3) != 0) {
common->Warning( "CVar bsp_inlinemesh_maxfacespertri has a invalid value, must be multiples of 3!\n");
return;
}
if(bsp_inlinemesh_maxfacespertri.GetInteger() <= 0) {
common->Warning( "InlineMesh face seperation is disabled! This will affect the quality of the UV map generation\n");
}
dmapGlobals.noOptimize = true;
//dmapGlobals.noLightCarve = true;
passedName = args.Argv(i); // may have an extension
passedName.BackSlashesToSlashes();
if ( passedName.Icmpn( "maps/", 4 ) != 0 ) {
passedName = "maps/" + passedName;
}
idStr stripped = passedName;
stripped.StripFileExtension();
idStr::Copynz( dmapGlobals.mapFileBase, stripped, sizeof(dmapGlobals.mapFileBase) );
bool region = false;
// if this isn't a regioned map, delete the last saved region map
if ( passedName.Right( 4 ) != ".reg" ) {
sprintf( path, "%s.reg", dmapGlobals.mapFileBase );
fileSystem->RemoveFile( path );
} else {
region = true;
}
passedName = stripped;
// delete any old line leak files
sprintf( path, "%s.lin", dmapGlobals.mapFileBase );
fileSystem->RemoveFile( path );
//
// start from scratch
//
start = sys->Milliseconds();
if ( !LoadDMapFile( passedName ) ) {
return;
}
if(dmapGlobals.onlyEntities) {
dmapGlobals.dmapFile->WriteGameEntities( dmapGlobals.mapFileBase, WORLD_ENTITIES_FILE_EXT );
noCM = true;
}
else
{
if ( ProcessModels() ) {
WriteOutputFile();
} else {
leaked = true;
}
}
// jmarshall end
common->Printf("Cleaning up temporary memory...\n");
FreeDMapFile();
end = sys->Milliseconds();
common->Printf( "-----------------------\n" );
common->Printf( "%5.0f seconds for dmap\n", ( end - start ) * 0.001f );
if ( !leaked ) {
if ( !noCM ) {
// make sure the collision model manager is not used by the game
cmdSystem->BufferCommandText( CMD_EXEC_NOW, "disconnect" );
// create the collision map
start = sys->Milliseconds();
collisionModelManager->LoadMap( dmapGlobals.dmapFile );
collisionModelManager->FreeMap();
end = sys->Milliseconds();
common->Printf( "-------------------------------------\n" );
common->Printf( "%5.0f seconds to create collision map\n", ( end - start ) * 0.001f );
}
if ( !noAAS && !region ) {
// create AAS files
RunAAS_f( args );
}
}
// free the common .map representation
delete dmapGlobals.dmapFile;
// clear the map plane list
dmapGlobals.mapPlanes.Clear();
// jmarshall
if(dmapGlobals.mapCompileError.Length() > 0) {
common->Warning("There was a problem building the world! The build process completed but it may not be complete/accurate\n");
common->Warning(dmapGlobals.mapCompileError.c_str());
dmapGlobals.mapCompileError = "";
}
// jmarshall end
// jmarshall
/*
#ifdef _WIN32
if ( com_outputMsg && com_hwndMsg != NULL ) {
unsigned int msg = ::RegisterWindowMessage( DMAP_DONE );
::PostMessage( com_hwndMsg, msg, 0, 0 );
}
#endif
*/
// jmarshall end
}
