tools/quake3/q3map2/main.c

   1 /* -------------------------------------------------------------------------------
   2
   3 Copyright (C) 1999-2007 id Software, Inc. and contributors.
   4 For a list of contributors, see the accompanying CONTRIBUTORS file.
   5
   6 This file is part of GtkRadiant.
   7
   8 GtkRadiant is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 GtkRadiant is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GtkRadiant; if not, write to the Free Software
  20 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  21
  22 -------------------------------------------------------------------------------
  23
  24 This code has been altered significantly from its original form, to support
  25 several games based on the Quake III Arena engine, in the form of "Q3Map2."
  26
  27 ------------------------------------------------------------------------------- */
  28
  29
  30
  31 /* marker */
  32 #define MAIN_C
  33
  34
  35
  36 /* dependencies */
  37 #include "q3map2.h"
  38
  39 /*
  40 Random()
  41 returns a pseudorandom number between 0 and 1
  42 */
  43
  44 vec_t Random( void )
  45 {
  46         return (vec_t) rand() / RAND_MAX;
  47 }
  48
  49
  50
  51 /*
  52 ExitQ3Map()
  53 cleanup routine
  54 */
  55
  56 static void ExitQ3Map( void )
  57 {
  58         BSPFilesCleanup();
  59         if( mapDrawSurfs != NULL )
  60                 free( mapDrawSurfs );
  61 }
  62
  63 static int MD4BlockChecksum( void * buffer, int length ) {
  64         unsigned char digest[16];
  65         int checksum;
  66
  67         md4_get_digest( buffer, length, digest );
  68         /* I suppose it has to be done that way for legacy reasons? */
  69         checksum = digest[0] & ( digest[1] << 8 ) & ( digest[2] << 16 ) & ( digest[3] << 24 );
  70         checksum ^= digest[4] & ( digest[5] << 8 ) & ( digest[6] << 16 ) & ( digest[7] << 24 );
  71         checksum ^= digest[8] & ( digest[9] << 8 ) & ( digest[10] << 16 ) & ( digest[11] << 24 );
  72         checksum ^= digest[12] & ( digest[13] << 8 ) & ( digest[14] << 16 ) & ( digest[15] << 24 );
  73         return checksum;
  74 }
  75
  76 /*
  77 FixAAS()
  78 resets an aas checksum to match the given BSP
  79 */
  80
  81 int FixAAS( int argc, char **argv )
  82 {
  83         int                     length, checksum;
  84         void            *buffer;
  85         FILE            *file;
  86         char            aas[ 1024 ], **ext;
  87         char            *exts[] =
  88                                 {
  89                                         ".aas",
  90                                         "_b0.aas",
  91                                         "_b1.aas",
  92                                         NULL
  93                                 };
  94
  95
  96         /* arg checking */
  97         if( argc < 2 )
  98         {
  99                 Sys_Printf( "Usage: q3map -fixaas [-v] <mapname>\n" );
 100                 return 0;
 101         }
 102
 103         /* do some path mangling */
 104         strcpy( source, ExpandArg( argv[ argc - 1 ] ) );
 105         StripExtension( source );
 106         DefaultExtension( source, ".bsp" );
 107
 108         /* note it */
 109         Sys_Printf( "--- FixAAS ---\n" );
 110
 111         /* load the bsp */
 112         Sys_Printf( "Loading %s\n", source );
 113         length = LoadFile( source, &buffer );
 114
 115         /* create bsp checksum */
 116         Sys_Printf( "Creating checksum...\n" );
 117         checksum = LittleLong( MD4BlockChecksum( buffer, length ) );
 118
 119         /* write checksum to aas */
 120         ext = exts;
 121         while( *ext )
 122         {
 123                 /* mangle name */
 124                 strcpy( aas, source );
 125                 StripExtension( aas );
 126                 strcat( aas, *ext );
 127                 Sys_Printf( "Trying %s\n", aas );
 128                 ext++;
 129
 130                 /* fix it */
 131                 file = fopen( aas, "r+b" );
 132                 if( !file )
 133                         continue;
 134                 if( fwrite( &checksum, 4, 1, file ) != 1 )
 135                         Error( "Error writing checksum to %s", aas );
 136                 fclose( file );
 137         }
 138
 139         /* return to sender */
 140         return 0;
 141 }
 142
 143
 144
 145 /*
 146 AnalyzeBSP() - ydnar
 147 analyzes a Quake engine BSP file
 148 */
 149
 150 typedef struct abspHeader_s
 151 {
 152         char                    ident[ 4 ];
 153         int                             version;
 154
 155         bspLump_t               lumps[ 1 ];     /* unknown size */
 156 }
 157 abspHeader_t;
 158
 159 typedef struct abspLumpTest_s
 160 {
 161         int                             radix, minCount;
 162         char                    *name;
 163 }
 164 abspLumpTest_t;
 165
 166 int AnalyzeBSP( int argc, char **argv )
 167 {
 168         abspHeader_t                    *header;
 169         int                                             size, i, version, offset, length, lumpInt, count;
 170         char                                    ident[ 5 ];
 171         void                                    *lump;
 172         float                                   lumpFloat;
 173         char                                    lumpString[ 1024 ], source[ 1024 ];
 174         qboolean                                lumpSwap = qfalse;
 175         abspLumpTest_t                  *lumpTest;
 176         static abspLumpTest_t   lumpTests[] =
 177                                                         {
 178                                                                 { sizeof( bspPlane_t ),                 6,              "IBSP LUMP_PLANES" },
 179                                                                 { sizeof( bspBrush_t ),                 1,              "IBSP LUMP_BRUSHES" },
 180                                                                 { 8,                                                    6,              "IBSP LUMP_BRUSHSIDES" },
 181                                                                 { sizeof( bspBrushSide_t ),             6,              "RBSP LUMP_BRUSHSIDES" },
 182                                                                 { sizeof( bspModel_t ),                 1,              "IBSP LUMP_MODELS" },
 183                                                                 { sizeof( bspNode_t ),                  2,              "IBSP LUMP_NODES" },
 184                                                                 { sizeof( bspLeaf_t ),                  1,              "IBSP LUMP_LEAFS" },
 185                                                                 { 104,                                                  3,              "IBSP LUMP_DRAWSURFS" },
 186                                                                 { 44,                                                   3,              "IBSP LUMP_DRAWVERTS" },
 187                                                                 { 4,                                                    6,              "IBSP LUMP_DRAWINDEXES" },
 188                                                                 { 128 * 128 * 3,                                1,              "IBSP LUMP_LIGHTMAPS" },
 189                                                                 { 256 * 256 * 3,                                1,              "IBSP LUMP_LIGHTMAPS (256 x 256)" },
 190                                                                 { 512 * 512 * 3,                                1,              "IBSP LUMP_LIGHTMAPS (512 x 512)" },
 191                                                                 { 0, 0, NULL }
 192                                                         };
 193
 194
 195         /* arg checking */
 196         if( argc < 1 )
 197         {
 198                 Sys_Printf( "Usage: q3map -analyze [-lumpswap] [-v] <mapname>\n" );
 199                 return 0;
 200         }
 201
 202         /* process arguments */
 203         for( i = 1; i < (argc - 1); i++ )
 204         {
 205                 /* -format map|ase|... */
 206                 if( !strcmp( argv[ i ],  "-lumpswap" ) )
 207                 {
 208                         Sys_Printf( "Swapped lump structs enabled\n" );
 209                         lumpSwap = qtrue;
 210                 }
 211         }
 212
 213         /* clean up map name */
 214         strcpy( source, ExpandArg( argv[ i ] ) );
 215         Sys_Printf( "Loading %s\n", source );
 216
 217         /* load the file */
 218         size = LoadFile( source, (void**) &header );
 219         if( size == 0 || header == NULL )
 220         {
 221                 Sys_Printf( "Unable to load %s.\n", source );
 222                 return -1;
 223         }
 224
 225         /* analyze ident/version */
 226         memcpy( ident, header->ident, 4 );
 227         ident[ 4 ] = '\0';
 228         version = LittleLong( header->version );
 229
 230         Sys_Printf( "Identity:      %s\n", ident );
 231         Sys_Printf( "Version:       %d\n", version );
 232         Sys_Printf( "---------------------------------------\n" );
 233
 234         /* analyze each lump */
 235         for( i = 0; i < 100; i++ )
 236         {
 237                 /* call of duty swapped lump pairs */
 238                 if( lumpSwap )
 239                 {
 240                         offset = LittleLong( header->lumps[ i ].length );
 241                         length = LittleLong( header->lumps[ i ].offset );
 242                 }
 243
 244                 /* standard lump pairs */
 245                 else
 246                 {
 247                         offset = LittleLong( header->lumps[ i ].offset );
 248                         length = LittleLong( header->lumps[ i ].length );
 249                 }
 250
 251                 /* extract data */
 252                 lump = (byte*) header + offset;
 253                 lumpInt = LittleLong( (int) *((int*) lump) );
 254                 lumpFloat = LittleFloat( (float) *((float*) lump) );
 255                 memcpy( lumpString, (char*) lump, (length < 1024 ? length : 1024) );
 256                 lumpString[ 1024 ] = '\0';
 257
 258                 /* print basic lump info */
 259                 Sys_Printf( "Lump:          %d\n", i );
 260                 Sys_Printf( "Offset:        %d bytes\n", offset );
 261                 Sys_Printf( "Length:        %d bytes\n", length );
 262
 263                 /* only operate on valid lumps */
 264                 if( length > 0 )
 265                 {
 266                         /* print data in 4 formats */
 267                         Sys_Printf( "As hex:        %08X\n", lumpInt );
 268                         Sys_Printf( "As int:        %d\n", lumpInt );
 269                         Sys_Printf( "As float:      %f\n", lumpFloat );
 270                         Sys_Printf( "As string:     %s\n", lumpString );
 271
 272                         /* guess lump type */
 273                         if( lumpString[ 0 ] == '{' && lumpString[ 2 ] == '"' )
 274                                 Sys_Printf( "Type guess:    IBSP LUMP_ENTITIES\n" );
 275                         else if( strstr( lumpString, "textures/" ) )
 276                                 Sys_Printf( "Type guess:    IBSP LUMP_SHADERS\n" );
 277                         else
 278                         {
 279                                 /* guess based on size/count */
 280                                 for( lumpTest = lumpTests; lumpTest->radix > 0; lumpTest++ )
 281                                 {
 282                                         if( (length % lumpTest->radix) != 0 )
 283                                                 continue;
 284                                         count = length / lumpTest->radix;
 285                                         if( count < lumpTest->minCount )
 286                                                 continue;
 287                                         Sys_Printf( "Type guess:    %s (%d x %d)\n", lumpTest->name, count, lumpTest->radix );
 288                                 }
 289                         }
 290                 }
 291
 292                 Sys_Printf( "---------------------------------------\n" );
 293
 294                 /* end of file */
 295                 if( offset + length >= size )
 296                         break;
 297         }
 298
 299         /* last stats */
 300         Sys_Printf( "Lump count:    %d\n", i + 1 );
 301         Sys_Printf( "File size:     %d bytes\n", size );
 302
 303         /* return to caller */
 304         return 0;
 305 }
 306
 307
 308
 309 /*
 310 BSPInfo()
 311 emits statistics about the bsp file
 312 */
 313
 314 int BSPInfo( int count, char **fileNames )
 315 {
 316         int                     i;
 317         char            source[ 1024 ], ext[ 64 ];
 318         int                     size;
 319         FILE            *f;
 320
 321
 322         /* dummy check */
 323         if( count < 1 )
 324         {
 325                 Sys_Printf( "No files to dump info for.\n");
 326                 return -1;
 327         }
 328
 329         /* enable info mode */
 330         infoMode = qtrue;
 331
 332         /* walk file list */
 333         for( i = 0; i < count; i++ )
 334         {
 335                 Sys_Printf( "---------------------------------\n" );
 336
 337                 /* mangle filename and get size */
 338                 strcpy( source, fileNames[ i ] );
 339                 ExtractFileExtension( source, ext );
 340                 if( !Q_stricmp( ext, "map" ) )
 341                         StripExtension( source );
 342                 DefaultExtension( source, ".bsp" );
 343                 f = fopen( source, "rb" );
 344                 if( f )
 345                 {
 346                         size = Q_filelength (f);
 347                         fclose( f );
 348                 }
 349                 else
 350                         size = 0;
 351
 352                 /* load the bsp file and print lump sizes */
 353                 Sys_Printf( "%s\n", source );
 354                 LoadBSPFile( source );
 355                 PrintBSPFileSizes();
 356
 357                 /* print sizes */
 358                 Sys_Printf( "\n" );
 359                 Sys_Printf( "          total         %9d\n", size );
 360                 Sys_Printf( "                        %9d KB\n", size / 1024 );
 361                 Sys_Printf( "                        %9d MB\n", size / (1024 * 1024) );
 362
 363                 Sys_Printf( "---------------------------------\n" );
 364         }
 365
 366         /* return count */
 367         return i;
 368 }
 369
 370
 371
 372 /*
 373 ScaleBSPMain()
 374 amaze and confuse your enemies with wierd scaled maps!
 375 */
 376
 377 int ScaleBSPMain( int argc, char **argv )
 378 {
 379         int                     i;
 380         float           f, scale;
 381         vec3_t          vec;
 382         char            str[ 1024 ];
 383
 384
 385         /* arg checking */
 386         if( argc < 2 )
 387         {
 388                 Sys_Printf( "Usage: q3map -scale <value> [-v] <mapname>\n" );
 389                 return 0;
 390         }
 391
 392         /* get scale */
 393         scale = atof( argv[ argc - 2 ] );
 394         if( scale == 0.0f )
 395         {
 396                 Sys_Printf( "Usage: q3map -scale <value> [-v] <mapname>\n" );
 397                 Sys_Printf( "Non-zero scale value required.\n" );
 398                 return 0;
 399         }
 400
 401         /* do some path mangling */
 402         strcpy( source, ExpandArg( argv[ argc - 1 ] ) );
 403         StripExtension( source );
 404         DefaultExtension( source, ".bsp" );
 405
 406         /* load the bsp */
 407         Sys_Printf( "Loading %s\n", source );
 408         LoadBSPFile( source );
 409         ParseEntities();
 410
 411         /* note it */
 412         Sys_Printf( "--- ScaleBSP ---\n" );
 413         Sys_FPrintf( SYS_VRB, "%9d entities\n", numEntities );
 414
 415         /* scale entity keys */
 416         for( i = 0; i < numBSPEntities && i < numEntities; i++ )
 417         {
 418                 /* scale origin */
 419                 GetVectorForKey( &entities[ i ], "origin", vec );
 420                 if( (vec[ 0 ] + vec[ 1 ] + vec[ 2 ]) )
 421                 {
 422                         VectorScale( vec, scale, vec );
 423                         sprintf( str, "%f %f %f", vec[ 0 ], vec[ 1 ], vec[ 2 ] );
 424                         SetKeyValue( &entities[ i ], "origin", str );
 425                 }
 426
 427                 /* scale door lip */
 428                 f = FloatForKey( &entities[ i ], "lip" );
 429                 if( f )
 430                 {
 431                         f *= scale;
 432                         sprintf( str, "%f", f );
 433                         SetKeyValue( &entities[ i ], "lip", str );
 434                 }
 435         }
 436
 437         /* scale models */
 438         for( i = 0; i < numBSPModels; i++ )
 439         {
 440                 VectorScale( bspModels[ i ].mins, scale, bspModels[ i ].mins );
 441                 VectorScale( bspModels[ i ].maxs, scale, bspModels[ i ].maxs );
 442         }
 443
 444         /* scale nodes */
 445         for( i = 0; i < numBSPNodes; i++ )
 446         {
 447                 VectorScale( bspNodes[ i ].mins, scale, bspNodes[ i ].mins );
 448                 VectorScale( bspNodes[ i ].maxs, scale, bspNodes[ i ].maxs );
 449         }
 450
 451         /* scale leafs */
 452         for( i = 0; i < numBSPLeafs; i++ )
 453         {
 454                 VectorScale( bspLeafs[ i ].mins, scale, bspLeafs[ i ].mins );
 455                 VectorScale( bspLeafs[ i ].maxs, scale, bspLeafs[ i ].maxs );
 456         }
 457
 458         /* scale drawverts */
 459         for( i = 0; i < numBSPDrawVerts; i++ )
 460                 VectorScale( bspDrawVerts[ i ].xyz, scale, bspDrawVerts[ i ].xyz );
 461
 462         /* scale planes */
 463         for( i = 0; i < numBSPPlanes; i++ )
 464                 bspPlanes[ i ].dist *= scale;
 465
 466         /* scale gridsize */
 467         GetVectorForKey( &entities[ 0 ], "gridsize", vec );
 468         if( (vec[ 0 ] + vec[ 1 ] + vec[ 2 ]) == 0.0f )
 469                 VectorCopy( gridSize, vec );
 470         VectorScale( vec, scale, vec );
 471         sprintf( str, "%f %f %f", vec[ 0 ], vec[ 1 ], vec[ 2 ] );
 472         SetKeyValue( &entities[ 0 ], "gridsize", str );
 473
 474         /* write the bsp */
 475         UnparseEntities();
 476         StripExtension( source );
 477         DefaultExtension( source, "_s.bsp" );
 478         Sys_Printf( "Writing %s\n", source );
 479         WriteBSPFile( source );
 480
 481         /* return to sender */
 482         return 0;
 483 }
 484
 485
 486
 487 /*
 488 ConvertBSPMain()
 489 main argument processing function for bsp conversion
 490 */
 491
 492 int ConvertBSPMain( int argc, char **argv )
 493 {
 494         int             i;
 495         int             (*convertFunc)( char * );
 496         game_t  *convertGame;
 497
 498
 499         /* set default */
 500         convertFunc = ConvertBSPToASE;
 501         convertGame = NULL;
 502
 503         /* arg checking */
 504         if( argc < 1 )
 505         {
 506                 Sys_Printf( "Usage: q3map -scale <value> [-v] <mapname>\n" );
 507                 return 0;
 508         }
 509
 510         /* process arguments */
 511         for( i = 1; i < (argc - 1); i++ )
 512         {
 513                 /* -format map|ase|... */
 514                 if( !strcmp( argv[ i ],  "-format" ) )
 515                 {
 516                         i++;
 517                         if( !Q_stricmp( argv[ i ], "ase" ) )
 518                                 convertFunc = ConvertBSPToASE;
 519                         else if( !Q_stricmp( argv[ i ], "map" ) )
 520                                 convertFunc = ConvertBSPToMap;
 521                         else
 522                         {
 523                                 convertGame = GetGame( argv[ i ] );
 524                                 if( convertGame == NULL )
 525                                         Sys_Printf( "Unknown conversion format \"%s\". Defaulting to ASE.\n", argv[ i ] );
 526                         }
 527                 }
 528         }
 529
 530         /* clean up map name */
 531         strcpy( source, ExpandArg( argv[ i ] ) );
 532         StripExtension( source );
 533         DefaultExtension( source, ".bsp" );
 534
 535         LoadShaderInfo();
 536
 537         Sys_Printf( "Loading %s\n", source );
 538
 539         /* ydnar: load surface file */
 540         //%     LoadSurfaceExtraFile( source );
 541
 542         LoadBSPFile( source );
 543
 544         /* parse bsp entities */
 545         ParseEntities();
 546
 547         /* bsp format convert? */
 548         if( convertGame != NULL )
 549         {
 550                 /* set global game */
 551                 game = convertGame;
 552
 553                 /* write bsp */
 554                 StripExtension( source );
 555                 DefaultExtension( source, "_c.bsp" );
 556                 Sys_Printf( "Writing %s\n", source );
 557                 WriteBSPFile( source );
 558
 559                 /* return to sender */
 560                 return 0;
 561         }
 562
 563         /* normal convert */
 564         return convertFunc( source );
 565 }
 566
 567
 568
 569 /*
 570 main()
 571 q3map mojo...
 572 */
 573
 574 int main( int argc, char **argv )
 575 {
 576         int             i, r;
 577         double  start, end;
 578
 579
 580         /* we want consistent 'randomness' */
 581         srand( 0 );
 582
 583         /* start timer */
 584         start = I_FloatTime();
 585
 586         /* this was changed to emit version number over the network */
 587         printf( Q3MAP_VERSION "\n" );
 588
 589         /* set exit call */
 590         atexit( ExitQ3Map );
 591
 592         /* read general options first */
 593         for( i = 1; i < argc; i++ )
 594         {
 595                 /* -connect */
 596                 if( !strcmp( argv[ i ], "-connect" ) )
 597                 {
 598                         argv[ i ] = NULL;
 599                         i++;
 600                         Broadcast_Setup( argv[ i ] );
 601                         argv[ i ] = NULL;
 602                 }
 603
 604                 /* verbose */
 605                 else if( !strcmp( argv[ i ], "-v" ) )
 606                 {
 607                         verbose = qtrue;
 608                         argv[ i ] = NULL;
 609                 }
 610
 611                 /* force */
 612                 else if( !strcmp( argv[ i ], "-force" ) )
 613                 {
 614                         force = qtrue;
 615                         argv[ i ] = NULL;
 616                 }
 617
 618                 /* patch subdivisions */
 619                 else if( !strcmp( argv[ i ], "-subdivisions" ) )
 620                 {
 621                         argv[ i ] = NULL;
 622                         i++;
 623                         patchSubdivisions = atoi( argv[ i ] );
 624                         argv[ i ] = NULL;
 625                         if( patchSubdivisions <= 0 )
 626                                 patchSubdivisions = 1;
 627                 }
 628
 629                 /* threads */
 630                 else if( !strcmp( argv[ i ], "-threads" ) )
 631                 {
 632                         argv[ i ] = NULL;
 633                         i++;
 634                         numthreads = atoi( argv[ i ] );
 635                         argv[ i ] = NULL;
 636                 }
 637         }
 638
 639         /* init model library */
 640         PicoInit();
 641         PicoSetMallocFunc( safe_malloc );
 642         PicoSetFreeFunc( free );
 643         PicoSetPrintFunc( PicoPrintFunc );
 644         PicoSetLoadFileFunc( PicoLoadFileFunc );
 645         PicoSetFreeFileFunc( free );
 646
 647         /* set number of threads */
 648         ThreadSetDefault();
 649
 650         /* generate sinusoid jitter table */
 651         for( i = 0; i < MAX_JITTERS; i++ )
 652         {
 653                 jitters[ i ] = sin( i * 139.54152147 );
 654                 //%     Sys_Printf( "Jitter %4d: %f\n", i, jitters[ i ] );
 655         }
 656
 657         /* we print out two versions, q3map's main version (since it evolves a bit out of GtkRadiant)
 658            and we put the GtkRadiant version to make it easy to track with what version of Radiant it was built with */
 659
 660         Sys_Printf( "Q3Map         - v1.0r (c) 1999 Id Software Inc.\n" );
 661         Sys_Printf( "Q3Map (ydnar) - v" Q3MAP_VERSION "\n" );
 662         Sys_Printf( "GtkRadiant    - v" RADIANT_VERSION " " __DATE__ " " __TIME__ "\n" );
 663         Sys_Printf( "%s\n", Q3MAP_MOTD );
 664
 665         /* ydnar: new path initialization */
 666         InitPaths( &argc, argv );
 667
 668         /* check if we have enough options left to attempt something */
 669         if( argc < 2 )
 670                 Error( "Usage: %s [general options] [options] mapfile", argv[ 0 ] );
 671
 672         /* fixaas */
 673         if( !strcmp( argv[ 1 ], "-fixaas" ) )
 674                 r = FixAAS( argc - 1, argv + 1 );
 675
 676         /* analyze */
 677         else if( !strcmp( argv[ 1 ], "-analyze" ) )
 678                 r = AnalyzeBSP( argc - 1, argv + 1 );
 679
 680         /* info */
 681         else if( !strcmp( argv[ 1 ], "-info" ) )
 682                 r = BSPInfo( argc - 2, argv + 2 );
 683
 684         /* vis */
 685         else if( !strcmp( argv[ 1 ], "-vis" ) )
 686                 r = VisMain( argc - 1, argv + 1 );
 687
 688         /* light */
 689         else if( !strcmp( argv[ 1 ], "-light" ) )
 690                 r = LightMain( argc - 1, argv + 1 );
 691
 692         /* vlight */
 693         else if( !strcmp( argv[ 1 ], "-vlight" ) )
 694         {
 695                 Sys_Printf( "WARNING: VLight is no longer supported, defaulting to -light -fast instead\n\n" );
 696                 argv[ 1 ] = "-fast";    /* eek a hack */
 697                 r = LightMain( argc, argv );
 698         }
 699
 700         /* ydnar: lightmap export */
 701         else if( !strcmp( argv[ 1 ], "-export" ) )
 702                 r = ExportLightmapsMain( argc - 1, argv + 1 );
 703
 704         /* ydnar: lightmap import */
 705         else if( !strcmp( argv[ 1 ], "-import" ) )
 706                 r = ImportLightmapsMain( argc - 1, argv + 1 );
 707
 708         /* ydnar: bsp scaling */
 709         else if( !strcmp( argv[ 1 ], "-scale" ) )
 710                 r = ScaleBSPMain( argc - 1, argv + 1 );
 711
 712         /* ydnar: bsp conversion */
 713         else if( !strcmp( argv[ 1 ], "-convert" ) )
 714                 r = ConvertBSPMain( argc - 1, argv + 1 );
 715
 716         /* ydnar: otherwise create a bsp */
 717         else
 718                 r = BSPMain( argc, argv );
 719
 720         /* emit time */
 721         end = I_FloatTime();
 722         Sys_Printf( "%9.0f seconds elapsed\n", end - start );
 723
 724         /* shut down connection */
 725         Broadcast_Shutdown();
 726
 727         /* return any error code */
 728         return r;
 729 }