]> git.rm.cloudns.org Git - xonotic/netradiant.git/commitdiff
Merge commit '1132fe233cd201e0f8eb17cb1b96313f6a5cf3ec' into master-merge
authorThomas Debesse <dev@illwieckz.net>
Mon, 20 Jun 2022 02:31:43 +0000 (04:31 +0200)
committerThomas Debesse <dev@illwieckz.net>
Mon, 20 Jun 2022 02:31:43 +0000 (04:31 +0200)
1  2 
radiant/mru.cpp
tools/quake3/common/vfs.c
tools/quake3/common/vfs.h
tools/quake3/q3map2/bspfile_abstract.c
tools/quake3/q3map2/bspfile_ibsp.c
tools/quake3/q3map2/main.c
tools/quake3/q3map2/q3map2.h

diff --cc radiant/mru.cpp
Simple merge
Simple merge
Simple merge
Simple merge
index bddc2c240f1a9edbc57e8887f72bdf95f6f5452d,10c1d0a814dfc4430bc509fc078b75684c7f8508..b88a5390c27d1eeb4e1f5b4845a7f30077ae2162
@@@ -1046,155 -1079,1115 +1079,1121 @@@ skipEXfile
  
  
  /*
-    main()
-    q3map mojo...
+    repackBSPMain()
+    repack multiple maps, strip only required shaders
+    works for Q3 type of shaders and ents
   */
  
- int main( int argc, char **argv ){
-       int i, r;
-       double start, end;
-       extern qboolean werror;
+ int repackBSPMain( int argc, char **argv ){
+       int i, j, len, compLevel = 0;
+       qboolean dbg = qfalse, png = qfalse;
  
+       /* process arguments */
+       for ( i = 1; i < ( argc - 1 ); i++ ){
+               if ( !strcmp( argv[ i ],  "-dbg" ) ) {
+                       dbg = qtrue;
+               }
+               else if ( !strcmp( argv[ i ],  "-png" ) ) {
+                       png = qtrue;
+               }
+               else if ( !strcmp( argv[ i ],  "-complevel" ) ) {
+                       compLevel = atoi( argv[ i + 1 ] );
+                       i++;
+                       if ( compLevel < -1 ) compLevel = -1;
+                       if ( compLevel > 10 ) compLevel = 10;
+                       Sys_Printf( "Compression level set to %i\n", compLevel );
+               }
+       }
  
-       /* we want consistent 'randomness' */
-       srand( 0 );
+ /* load exclusions file */
+       int ExTexturesN = 0;
+       char* ExTextures = (char *)calloc( 4096*65, sizeof( char ) );
+       int ExShadersN = 0;
+       char* ExShaders = (char *)calloc( 4096*65, sizeof( char ) );
+       int ExSoundsN = 0;
+       char* ExSounds = (char *)calloc( 4096*65, sizeof( char ) );
+       int ExShaderfilesN = 0;
+       char* ExShaderfiles = (char *)calloc( 4096*65, sizeof( char ) );
+       int ExVideosN = 0;
+       char* ExVideos = (char *)calloc( 4096*65, sizeof( char ) );
+       int ExPureTexturesN = 0;
+       char* ExPureTextures = (char *)calloc( 4096*65, sizeof( char ) );
  
-       /* start timer */
-       start = I_FloatTime();
  
-       /* this was changed to emit version number over the network */
-       printf( Q3MAP_VERSION "\n" );
+       char exName[ 1024 ];
+       byte *buffer;
+       int size;
  
-       /* set exit call */
-       atexit( ExitQ3Map );
+       strcpy( exName, q3map2path );
+       char *cut = strrchr( exName, '\\' );
+       char *cut2 = strrchr( exName, '/' );
+       if ( cut == NULL && cut2 == NULL ){
+               Sys_Printf( "WARNING: Unable to load exclusions file.\n" );
+               goto skipEXfile;
+       }
+       if ( cut2 > cut ) cut = cut2;
+       cut[1] = '\0';
+       strcat( exName, game->arg );
+       strcat( exName, ".exclude" );
  
-       /* read general options first */
-       for ( i = 1; i < argc; i++ )
+       Sys_Printf( "Loading %s\n", exName );
+       size = TryLoadFile( exName, (void**) &buffer );
+       if ( size <= 0 ) {
+               Sys_Printf( "WARNING: Unable to find exclusions file %s.\n", exName );
+               goto skipEXfile;
+       }
+       /* parse the file */
+       ParseFromMemory( (char *) buffer, size );
+       /* tokenize it */
+       while ( 1 )
        {
-               /* -help */
-               if ( !strcmp( argv[ i ], "-h" ) || !strcmp( argv[ i ], "--help" )
-                       || !strcmp( argv[ i ], "-help" ) ) {
-                       HelpMain( ( i + 1 < argc ) ? argv[ i + 1 ] : NULL );
-                       return 0;
+               /* test for end of file */
+               if ( !GetToken( qtrue ) ) {
+                       break;
                }
  
-               /* -connect */
-               if ( !strcmp( argv[ i ], "-connect" ) ) {
-                       if ( ++i >= argc || !argv[ i ] ) {
-                               Error( "Out of arguments: No address specified after %s", argv[ i - 1 ] );
-                       }
-                       argv[ i - 1 ] = NULL;
-                       Broadcast_Setup( argv[ i ] );
-                       argv[ i ] = NULL;
+               /* blocks */
+               if ( !Q_stricmp( token, "textures" ) ){
+                       parseEXblock ( ExTextures, &ExTexturesN, exName );
                }
-               /* verbose */
-               else if ( !strcmp( argv[ i ], "-v" ) ) {
-                       if ( !verbose ) {
-                               verbose = qtrue;
-                               argv[ i ] = NULL;
-                       }
+               else if ( !Q_stricmp( token, "shaders" ) ){
+                       parseEXblock ( ExShaders, &ExShadersN, exName );
                }
-               /* force */
-               else if ( !strcmp( argv[ i ], "-force" ) ) {
-                       force = qtrue;
-                       argv[ i ] = NULL;
+               else if ( !Q_stricmp( token, "shaderfiles" ) ){
+                       parseEXblock ( ExShaderfiles, &ExShaderfilesN, exName );
                }
-               /* make all warnings into errors */
-               else if ( !strcmp( argv[ i ], "-werror" ) ) {
-                       werror = qtrue;
-                       argv[ i ] = NULL;
+               else if ( !Q_stricmp( token, "sounds" ) ){
+                       parseEXblock ( ExSounds, &ExSoundsN, exName );
                }
-               /* patch subdivisions */
-               else if ( !strcmp( argv[ i ], "-subdivisions" ) ) {
-                       if ( ++i >= argc || !argv[ i ] ) {
-                               Error( "Out of arguments: No value specified after %s", argv[ i - 1 ] );
-                       }
-                       argv[ i - 1 ] = NULL;
-                       patchSubdivisions = atoi( argv[ i ] );
-                       argv[ i ] = NULL;
-                       if ( patchSubdivisions <= 0 ) {
-                               patchSubdivisions = 1;
-                       }
+               else if ( !Q_stricmp( token, "videos" ) ){
+                       parseEXblock ( ExVideos, &ExVideosN, exName );
+               }
+               else{
+                       Error( "ReadExclusionsFile: %s, line %d: unknown block name!\nValid ones are: textures, shaders, shaderfiles, sounds, videos.", exName, scriptline );
                }
+       }
  
-               /* threads */
-               else if ( !strcmp( argv[ i ], "-threads" ) ) {
-                       if ( ++i >= argc || !argv[ i ] ) {
-                               Error( "Out of arguments: No value specified after %s", argv[ i - 1 ] );
+       /* free the buffer */
+       free( buffer );
+       for ( i = 0; i < ExTexturesN; i++ ){
+               for ( j = 0; j < ExShadersN; j++ ){
+                       if ( !Q_stricmp( ExTextures + i*65, ExShaders + j*65 ) ){
+                               break;
                        }
-                       argv[ i - 1 ] = NULL;
-                       numthreads = atoi( argv[ i ] );
-                       argv[ i ] = NULL;
                }
-               else if( !strcmp( argv[ i ], "-nocmdline" ) )
-               {
-                       Sys_Printf( "noCmdLine\n" );
-                       nocmdline = qtrue;
-                       argv[ i ] = NULL;
+               if ( j == ExShadersN ){
+                       strcpy ( ExPureTextures + ExPureTexturesN*65, ExTextures + i*65 );
+                       ExPureTexturesN++;
                }
        }
  
-       /* init model library */
-       PicoInit();
-       PicoSetMallocFunc( safe_malloc );
-       PicoSetFreeFunc( free );
-       PicoSetPrintFunc( PicoPrintFunc );
-       PicoSetLoadFileFunc( PicoLoadFileFunc );
-       PicoSetFreeFileFunc( free );
-       /* set number of threads */
-       ThreadSetDefault();
+ skipEXfile:
  
-       /* generate sinusoid jitter table */
-       for ( i = 0; i < MAX_JITTERS; i++ )
-       {
-               jitters[ i ] = sin( i * 139.54152147 );
-               //%     Sys_Printf( "Jitter %4d: %f\n", i, jitters[ i ] );
+       if( dbg ){
+               Sys_Printf( "\n\tExTextures....%i\n", ExTexturesN );
+               for ( i = 0; i < ExTexturesN; i++ ) Sys_Printf( "%s\n", ExTextures + i*65 );
+               Sys_Printf( "\n\tExPureTextures....%i\n", ExPureTexturesN );
+               for ( i = 0; i < ExPureTexturesN; i++ ) Sys_Printf( "%s\n", ExPureTextures + i*65 );
+               Sys_Printf( "\n\tExShaders....%i\n", ExShadersN );
+               for ( i = 0; i < ExShadersN; i++ ) Sys_Printf( "%s\n", ExShaders + i*65 );
+               Sys_Printf( "\n\tExShaderfiles....%i\n", ExShaderfilesN );
+               for ( i = 0; i < ExShaderfilesN; i++ ) Sys_Printf( "%s\n", ExShaderfiles + i*65 );
+               Sys_Printf( "\n\tExSounds....%i\n", ExSoundsN );
+               for ( i = 0; i < ExSoundsN; i++ ) Sys_Printf( "%s\n", ExSounds + i*65 );
+               Sys_Printf( "\n\tExVideos....%i\n", ExVideosN );
+               for ( i = 0; i < ExVideosN; i++ ) Sys_Printf( "%s\n", ExVideos + i*65 );
        }
  
-       /* we print out two versions, q3map's main version (since it evolves a bit out of GtkRadiant)
-          and we put the GtkRadiant version to make it easy to track with what version of Radiant it was built with */
  
-       Sys_Printf( "Q3Map         - v1.0r (c) 1999 Id Software Inc.\n" );
-       Sys_Printf( "Q3Map (ydnar) - v" Q3MAP_VERSION "\n" );
-       Sys_Printf( RADIANT_NAME "    - v" RADIANT_VERSION " " __DATE__ " " __TIME__ "\n" );
-       Sys_Printf( "%s\n", Q3MAP_MOTD );
-       Sys_Printf( "%s\n", argv[0] );
  
-       strcpy( q3map2path, argv[0] );//fuer autoPack func
  
-       /* ydnar: new path initialization */
-       InitPaths( &argc, argv );
+ /* load repack.exclude */
+       int rExTexturesN = 0;
+       char* rExTextures = (char *)calloc( 65536*65, sizeof( char ) );
+       int rExShadersN = 0;
+       char* rExShaders = (char *)calloc( 32768*65, sizeof( char ) );
+       int rExSoundsN = 0;
+       char* rExSounds = (char *)calloc( 8192*65, sizeof( char ) );
+       int rExShaderfilesN = 0;
+       char* rExShaderfiles = (char *)calloc( 4096*65, sizeof( char ) );
+       int rExVideosN = 0;
+       char* rExVideos = (char *)calloc( 4096*65, sizeof( char ) );
  
-       /* set game options */
-       if ( !patchSubdivisions ) {
-               patchSubdivisions = game->patchSubdivisions;
+       strcpy( exName, q3map2path );
+       cut = strrchr( exName, '\\' );
+       cut2 = strrchr( exName, '/' );
+       if ( cut == NULL && cut2 == NULL ){
+               Sys_Printf( "WARNING: Unable to load repack exclusions file.\n" );
+               goto skipEXrefile;
        }
+       if ( cut2 > cut ) cut = cut2;
+       cut[1] = '\0';
+       strcat( exName, "repack.exclude" );
  
-       /* check if we have enough options left to attempt something */
-       if ( argc < 2 ) {
-               Error( "Usage: %s [general options] [options] mapfile", argv[ 0 ] );
+       Sys_Printf( "Loading %s\n", exName );
+       size = TryLoadFile( exName, (void**) &buffer );
+       if ( size <= 0 ) {
+               Sys_Printf( "WARNING: Unable to find repack exclusions file %s.\n", exName );
+               goto skipEXrefile;
        }
  
-       /* fixaas */
-       if ( !strcmp( argv[ 1 ], "-fixaas" ) ) {
-               r = FixAASMain( argc - 1, argv + 1 );
-       }
+       /* parse the file */
+       ParseFromMemory( (char *) buffer, size );
  
-       /* analyze */
-       else if ( !strcmp( argv[ 1 ], "-analyze" ) ) {
-               r = AnalyzeBSPMain( argc - 1, argv + 1 );
-       }
+       /* tokenize it */
+       while ( 1 )
+       {
+               /* test for end of file */
+               if ( !GetToken( qtrue ) ) {
+                       break;
+               }
  
-       /* info */
-       else if ( !strcmp( argv[ 1 ], "-info" ) ) {
-               r = BSPInfoMain( argc - 2, argv + 2 );
+               /* blocks */
+               if ( !Q_stricmp( token, "textures" ) ){
+                       parseEXblock ( rExTextures, &rExTexturesN, exName );
+               }
+               else if ( !Q_stricmp( token, "shaders" ) ){
+                       parseEXblock ( rExShaders, &rExShadersN, exName );
+               }
+               else if ( !Q_stricmp( token, "shaderfiles" ) ){
+                       parseEXblock ( rExShaderfiles, &rExShaderfilesN, exName );
+               }
+               else if ( !Q_stricmp( token, "sounds" ) ){
+                       parseEXblock ( rExSounds, &rExSoundsN, exName );
+               }
+               else if ( !Q_stricmp( token, "videos" ) ){
+                       parseEXblock ( rExVideos, &rExVideosN, exName );
+               }
+               else{
+                       Error( "ReadExclusionsFile: %s, line %d: unknown block name!\nValid ones are: textures, shaders, shaderfiles, sounds, videos.", exName, scriptline );
+               }
+       }
+       /* free the buffer */
+       free( buffer );
+ skipEXrefile:
+       if( dbg ){
+               Sys_Printf( "\n\trExTextures....%i\n", rExTexturesN );
+               for ( i = 0; i < rExTexturesN; i++ ) Sys_Printf( "%s\n", rExTextures + i*65 );
+               Sys_Printf( "\n\trExShaders....%i\n", rExShadersN );
+               for ( i = 0; i < rExShadersN; i++ ) Sys_Printf( "%s\n", rExShaders + i*65 );
+               Sys_Printf( "\n\trExShaderfiles....%i\n", rExShaderfilesN );
+               for ( i = 0; i < rExShaderfilesN; i++ ) Sys_Printf( "%s\n", rExShaderfiles + i*65 );
+               Sys_Printf( "\n\trExSounds....%i\n", rExSoundsN );
+               for ( i = 0; i < rExSoundsN; i++ ) Sys_Printf( "%s\n", rExSounds + i*65 );
+               Sys_Printf( "\n\trExVideos....%i\n", rExVideosN );
+               for ( i = 0; i < rExVideosN; i++ ) Sys_Printf( "%s\n", rExVideos + i*65 );
+       }
+       int bspListN = 0;
+       char* bspList = (char *)calloc( 8192*1024, sizeof( char ) );
+       /* do some path mangling */
+       strcpy( source, ExpandArg( argv[ argc - 1 ] ) );
+       if ( !Q_stricmp( strrchr( source, '.' ), ".bsp" ) ){
+               strcpy( bspList, source );
+               bspListN++;
+       }
+       else{
+               /* load bsps paths list */
+               Sys_Printf( "Loading %s\n", source );
+               size = TryLoadFile( source, (void**) &buffer );
+               if ( size <= 0 ) {
+                       Sys_Printf( "WARNING: Unable to open bsps paths list file %s.\n", source );
+               }
+               /* parse the file */
+               ParseFromMemory( (char *) buffer, size );
+               /* tokenize it */
+               while ( 1 )
+               {
+                       /* test for end of file */
+                       if ( !GetToken( qtrue ) ) {
+                               break;
+                       }
+                       strcpy( bspList + bspListN * 1024 , token );
+                       bspListN++;
+               }
+               /* free the buffer */
+               free( buffer );
+       }
+       char packname[ 1024 ], nameOFrepack[ 1024 ], nameOFmap[ 1024 ], temp[ 1024 ];
+       /* copy input file name */
+       strcpy( temp, source );
+       StripExtension( temp );
+       /* extract input file name */
+       len = strlen( temp ) - 1;
+       while ( len > 0 && temp[ len ] != '/' && temp[ len ] != '\\' )
+               len--;
+       strcpy( nameOFrepack, &temp[ len + 1 ] );
+ /* load bsps */
+       int pk3ShadersN = 0;
+       char* pk3Shaders = (char *)calloc( 65536*65, sizeof( char ) );
+       int pk3SoundsN = 0;
+       char* pk3Sounds = (char *)calloc( 4096*65, sizeof( char ) );
+       int pk3ShaderfilesN = 0;
+       char* pk3Shaderfiles = (char *)calloc( 4096*65, sizeof( char ) );
+       int pk3TexturesN = 0;
+       char* pk3Textures = (char *)calloc( 65536*65, sizeof( char ) );
+       int pk3VideosN = 0;
+       char* pk3Videos = (char *)calloc( 1024*65, sizeof( char ) );
+       for( j = 0; j < bspListN; j++ ){
+               int pk3SoundsNold = pk3SoundsN;
+               int pk3ShadersNold = pk3ShadersN;
+               strcpy( source, bspList + j*1024 );
+               StripExtension( source );
+               DefaultExtension( source, ".bsp" );
+               /* load the bsp */
+               Sys_Printf( "\nLoading %s\n", source );
+               PartialLoadBSPFile( source );
+               ParseEntities();
+               /* copy map name */
+               strcpy( temp, source );
+               StripExtension( temp );
+               /* extract map name */
+               len = strlen( temp ) - 1;
+               while ( len > 0 && temp[ len ] != '/' && temp[ len ] != '\\' )
+                       len--;
+               strcpy( nameOFmap, &temp[ len + 1 ] );
+               qboolean drawsurfSHs[1024] = { qfalse };
+               for ( i = 0; i < numBSPDrawSurfaces; i++ ){
+                       drawsurfSHs[ bspDrawSurfaces[i].shaderNum ] = qtrue;
+               }
+               for ( i = 0; i < numBSPShaders; i++ ){
+                       if ( drawsurfSHs[i] ){
+                               strcpy( pk3Shaders + pk3ShadersN*65, bspShaders[i].shader );
+                               res2list( pk3Shaders, &pk3ShadersN );
+                       }
+               }
+               /* Ent keys */
+               epair_t *ep;
+               for ( ep = entities[0].epairs; ep != NULL; ep = ep->next )
+               {
+                       if ( !!Q_strncasecmp( ep->key, "vertexremapshader", 17 ) ) {
+                               sscanf( ep->value, "%*[^;] %*[;] %s", pk3Shaders + pk3ShadersN*65 );
+                               res2list( pk3Shaders, &pk3ShadersN );
+                       }
+               }
+               strcpy( pk3Sounds + pk3SoundsN*65, ValueForKey( &entities[0], "music" ) );
+               if ( *( pk3Sounds + pk3SoundsN*65 ) != '\0' ){
+                       FixDOSName( pk3Sounds + pk3SoundsN*65 );
+                       DefaultExtension( pk3Sounds + pk3SoundsN*65, ".wav" );
+                       res2list( pk3Sounds, &pk3SoundsN );
+               }
+               for ( i = 0; i < numBSPEntities && i < numEntities; i++ )
+               {
+                       strcpy( pk3Sounds + pk3SoundsN*65, ValueForKey( &entities[i], "noise" ) );
+                       if ( *( pk3Sounds + pk3SoundsN*65 ) != '\0' && *( pk3Sounds + pk3SoundsN*65 ) != '*' ){
+                               FixDOSName( pk3Sounds + pk3SoundsN*65 );
+                               DefaultExtension( pk3Sounds + pk3SoundsN*65, ".wav" );
+                               res2list( pk3Sounds, &pk3SoundsN );
+                       }
+                       if ( !Q_stricmp( ValueForKey( &entities[i], "classname" ), "func_plat" ) ){
+                               strcpy( pk3Sounds + pk3SoundsN*65, "sound/movers/plats/pt1_strt.wav");
+                               res2list( pk3Sounds, &pk3SoundsN );
+                               strcpy( pk3Sounds + pk3SoundsN*65, "sound/movers/plats/pt1_end.wav");
+                               res2list( pk3Sounds, &pk3SoundsN );
+                       }
+                       if ( !Q_stricmp( ValueForKey( &entities[i], "classname" ), "target_push" ) ){
+                               if ( !(IntForKey( &entities[i], "spawnflags") & 1) ){
+                                       strcpy( pk3Sounds + pk3SoundsN*65, "sound/misc/windfly.wav");
+                                       res2list( pk3Sounds, &pk3SoundsN );
+                               }
+                       }
+                       strcpy( pk3Shaders + pk3ShadersN*65, ValueForKey( &entities[i], "targetShaderNewName" ) );
+                       res2list( pk3Shaders, &pk3ShadersN );
+               }
+               //levelshot
+               sprintf( pk3Shaders + pk3ShadersN*65, "levelshots/%s", nameOFmap );
+               res2list( pk3Shaders, &pk3ShadersN );
+               Sys_Printf( "\n\t+Drawsurface+ent calls....%i\n", pk3ShadersN - pk3ShadersNold );
+               for ( i = pk3ShadersNold; i < pk3ShadersN; i++ ){
+                       Sys_Printf( "%s\n", pk3Shaders + i*65 );
+               }
+               Sys_Printf( "\n\t+Sounds....%i\n", pk3SoundsN - pk3SoundsNold );
+               for ( i = pk3SoundsNold; i < pk3SoundsN; i++ ){
+                       Sys_Printf( "%s\n", pk3Sounds + i*65 );
+               }
+               /* free bsp data */
+ /*
+               if ( bspDrawVerts != 0 ) {
+                       free( bspDrawVerts );
+                       bspDrawVerts = NULL;
+                       //numBSPDrawVerts = 0;
+                       Sys_Printf( "freed BSPDrawVerts\n" );
+               }
+ */            if ( bspDrawSurfaces != 0 ) {
+                       free( bspDrawSurfaces );
+                       bspDrawSurfaces = NULL;
+                       //numBSPDrawSurfaces = 0;
+                       //Sys_Printf( "freed bspDrawSurfaces\n" );
+               }
+ /*            if ( bspLightBytes != 0 ) {
+                       free( bspLightBytes );
+                       bspLightBytes = NULL;
+                       //numBSPLightBytes = 0;
+                       Sys_Printf( "freed BSPLightBytes\n" );
+               }
+               if ( bspGridPoints != 0 ) {
+                       free( bspGridPoints );
+                       bspGridPoints = NULL;
+                       //numBSPGridPoints = 0;
+                       Sys_Printf( "freed BSPGridPoints\n" );
+               }
+               if ( bspPlanes != 0 ) {
+                       free( bspPlanes );
+                       bspPlanes = NULL;
+                       Sys_Printf( "freed bspPlanes\n" );
+                       //numBSPPlanes = 0;
+                       //allocatedBSPPlanes = 0;
+               }
+               if ( bspBrushes != 0 ) {
+                       free( bspBrushes );
+                       bspBrushes = NULL;
+                       Sys_Printf( "freed bspBrushes\n" );
+                       //numBSPBrushes = 0;
+                       //allocatedBSPBrushes = 0;
+               }
+ */            if ( entities != 0 ) {
+                       epair_t *ep2free;
+                       for ( i = 0; i < numBSPEntities && i < numEntities; i++ ){
+                               ep = entities[i].epairs;
+                               while( ep != NULL){
+                                       ep2free = ep;
+                                       ep = ep->next;
+                                       free( ep2free );
+                               }
+                       }
+                       free( entities );
+                       entities = NULL;
+                       //Sys_Printf( "freed entities\n" );
+                       numEntities = 0;
+                       numBSPEntities = 0;
+                       allocatedEntities = 0;
+               }
+ /*            if ( bspModels != 0 ) {
+                       free( bspModels );
+                       bspModels = NULL;
+                       Sys_Printf( "freed bspModels\n" );
+                       //numBSPModels = 0;
+                       //allocatedBSPModels = 0;
+               }
+ */            if ( bspShaders != 0 ) {
+                       free( bspShaders );
+                       bspShaders = NULL;
+                       //Sys_Printf( "freed bspShaders\n" );
+                       //numBSPShaders = 0;
+                       //allocatedBSPShaders = 0;
+               }
+               if ( bspEntData != 0 ) {
+                       free( bspEntData );
+                       bspEntData = NULL;
+                       //Sys_Printf( "freed bspEntData\n" );
+                       //bspEntDataSize = 0;
+                       //allocatedBSPEntData = 0;
+               }
+ /*            if ( bspNodes != 0 ) {
+                       free( bspNodes );
+                       bspNodes = NULL;
+                       Sys_Printf( "freed bspNodes\n" );
+                       //numBSPNodes = 0;
+                       //allocatedBSPNodes = 0;
+               }
+               if ( bspDrawIndexes != 0 ) {
+                       free( bspDrawIndexes );
+                       bspDrawIndexes = NULL;
+                       Sys_Printf( "freed bspDrawIndexes\n" );
+                       //numBSPDrawIndexes = 0;
+                       //allocatedBSPDrawIndexes = 0;
+               }
+               if ( bspLeafSurfaces != 0 ) {
+                       free( bspLeafSurfaces );
+                       bspLeafSurfaces = NULL;
+                       Sys_Printf( "freed bspLeafSurfaces\n" );
+                       //numBSPLeafSurfaces = 0;
+                       //allocatedBSPLeafSurfaces = 0;
+               }
+               if ( bspLeafBrushes != 0 ) {
+                       free( bspLeafBrushes );
+                       bspLeafBrushes = NULL;
+                       Sys_Printf( "freed bspLeafBrushes\n" );
+                       //numBSPLeafBrushes = 0;
+                       //allocatedBSPLeafBrushes = 0;
+               }
+               if ( bspBrushSides != 0 ) {
+                       free( bspBrushSides );
+                       bspBrushSides = NULL;
+                       Sys_Printf( "freed bspBrushSides\n" );
+                       numBSPBrushSides = 0;
+                       allocatedBSPBrushSides = 0;
+               }
+               if ( numBSPFogs != 0 ) {
+                       Sys_Printf( "freed numBSPFogs\n" );
+                       numBSPFogs = 0;
+               }
+               if ( numBSPAds != 0 ) {
+                       Sys_Printf( "freed numBSPAds\n" );
+                       numBSPAds = 0;
+               }
+               if ( numBSPLeafs != 0 ) {
+                       Sys_Printf( "freed numBSPLeafs\n" );
+                       numBSPLeafs = 0;
+               }
+               if ( numBSPVisBytes != 0 ) {
+                       Sys_Printf( "freed numBSPVisBytes\n" );
+                       numBSPVisBytes = 0;
+               }
+ */    }
+       vfsListShaderFiles( pk3Shaderfiles, &pk3ShaderfilesN );
+       if( dbg ){
+               Sys_Printf( "\n\tSchroider fileses.....%i\n", pk3ShaderfilesN );
+               for ( i = 0; i < pk3ShaderfilesN; i++ ){
+                       Sys_Printf( "%s\n", pk3Shaderfiles + i*65 );
+               }
+       }
+       /* can exclude pure *base* textures right now, shouldn't create shaders for them anyway */
+       for ( i = 0; i < pk3ShadersN ; i++ ){
+               for ( j = 0; j < ExPureTexturesN ; j++ ){
+                       if ( !Q_stricmp( pk3Shaders + i*65, ExPureTextures + j*65 ) ){
+                               *( pk3Shaders + i*65 ) = '\0';
+                               break;
+                       }
+               }
+       }
+       /* can exclude repack.exclude shaders, assuming they got all their images */
+       for ( i = 0; i < pk3ShadersN ; i++ ){
+               for ( j = 0; j < rExShadersN ; j++ ){
+                       if ( !Q_stricmp( pk3Shaders + i*65, rExShaders + j*65 ) ){
+                               *( pk3Shaders + i*65 ) = '\0';
+                               break;
+                       }
+               }
+       }
+       //Parse Shader Files
+       Sys_Printf( "\t\nParsing shaders....\n\n" );
+       char shaderText[ 8192 ];
+       char* allShaders = (char *)calloc( 16777216, sizeof( char ) );
+        /* hack */
+       endofscript = qtrue;
+       for ( i = 0; i < pk3ShaderfilesN; i++ ){
+               qboolean wantShader = qfalse;
+               int shader;
+               /* load the shader */
+               sprintf( temp, "%s/%s", game->shaderPath, pk3Shaderfiles + i*65 );
+               if ( dbg ) Sys_Printf( "\n\tentering %s\n", pk3Shaderfiles + i*65 );
+               SilentLoadScriptFile( temp, 0 );
+               /* tokenize it */
+               while ( 1 )
+               {
+                       int line = scriptline;
+                       /* test for end of file */
+                       if ( !GetToken( qtrue ) ) {
+                               break;
+                       }
+                       //dump shader names
+                       if( dbg ) Sys_Printf( "%s\n", token );
+                       strcpy( shaderText, token );
+                       if ( strchr( token, '\\') != NULL  ){
+                               Sys_Printf( "WARNING1: %s : %s : shader name with backslash\n", pk3Shaderfiles + i*65, token );
+                       }
+                       /* do wanna le shader? */
+                       wantShader = qfalse;
+                       for ( j = 0; j < pk3ShadersN; j++ ){
+                               if ( !Q_stricmp( pk3Shaders + j*65, token) ){
+                                       shader = j;
+                                       wantShader = qtrue;
+                                       break;
+                               }
+                       }
+                       if ( wantShader ){
+                               for ( j = 0; j < rExTexturesN ; j++ ){
+                                       if ( !Q_stricmp( pk3Shaders + shader*65, rExTextures + j*65 ) ){
+                                               Sys_Printf( "WARNING3: %s : about to include shader for excluded texture\n", pk3Shaders + shader*65 );
+                                               break;
+                                       }
+                               }
+                       }
+                       /* handle { } section */
+                       if ( !GetToken( qtrue ) ) {
+                               break;
+                       }
+                       if ( strcmp( token, "{" ) ) {
+                                       Error( "ParseShaderFile: %s, line %d: { not found!\nFound instead: %s",
+                                               temp, scriptline, token );
+                       }
+                       strcat( shaderText, "\n{" );
+                       qboolean hasmap = qfalse;
+                       while ( 1 )
+                       {
+                               line = scriptline;
+                               /* get the next token */
+                               if ( !GetToken( qtrue ) ) {
+                                       break;
+                               }
+                               if ( !strcmp( token, "}" ) ) {
+                                       strcat( shaderText, "\n}\n\n" );
+                                       break;
+                               }
+                               /* parse stage directives */
+                               if ( !strcmp( token, "{" ) ) {
+                                       qboolean tokenready = qfalse;
+                                       strcat( shaderText, "\n\t{" );
+                                       while ( 1 )
+                                       {
+                                               /* detour of TokenAvailable() '~' */
+                                               if ( tokenready ) tokenready = qfalse;
+                                               else line = scriptline;
+                                               if ( !GetToken( qtrue ) ) {
+                                                       break;
+                                               }
+                                               if ( !strcmp( token, "}" ) ) {
+                                                       strcat( shaderText, "\n\t}" );
+                                                       break;
+                                               }
+                                               /* skip the shader */
+                                               if ( !wantShader ) continue;
+                                               /* digest any images */
+                                               if ( !Q_stricmp( token, "map" ) ||
+                                                       !Q_stricmp( token, "clampMap" ) ) {
+                                                       strcat( shaderText, "\n\t\t" );
+                                                       strcat( shaderText, token );
+                                                       hasmap = qtrue;
+                                                       /* get an image */
+                                                       GetToken( qfalse );
+                                                       if ( token[ 0 ] != '*' && token[ 0 ] != '$' ) {
+                                                               tex2list2( pk3Textures, &pk3TexturesN, ExTextures, &ExTexturesN, rExTextures, &rExTexturesN );
+                                                       }
+                                                       strcat( shaderText, " " );
+                                                       strcat( shaderText, token );
+                                               }
+                                               else if ( !Q_stricmp( token, "animMap" ) ||
+                                                       !Q_stricmp( token, "clampAnimMap" ) ) {
+                                                       strcat( shaderText, "\n\t\t" );
+                                                       strcat( shaderText, token );
+                                                       hasmap = qtrue;
+                                                       GetToken( qfalse );// skip num
+                                                       strcat( shaderText, " " );
+                                                       strcat( shaderText, token );
+                                                       while ( TokenAvailable() ){
+                                                               GetToken( qfalse );
+                                                               tex2list2( pk3Textures, &pk3TexturesN, ExTextures, &ExTexturesN, rExTextures, &rExTexturesN );
+                                                               strcat( shaderText, " " );
+                                                               strcat( shaderText, token );
+                                                       }
+                                                       tokenready = qtrue;
+                                               }
+                                               else if ( !Q_stricmp( token, "videoMap" ) ){
+                                                       strcat( shaderText, "\n\t\t" );
+                                                       strcat( shaderText, token );
+                                                       hasmap = qtrue;
+                                                       GetToken( qfalse );
+                                                       strcat( shaderText, " " );
+                                                       strcat( shaderText, token );
+                                                       FixDOSName( token );
+                                                       if ( strchr( token, '/' ) == NULL && strchr( token, '\\' ) == NULL ){
+                                                               sprintf( temp, "video/%s", token );
+                                                               strcpy( token, temp );
+                                                       }
+                                                       FixDOSName( token );
+                                                       for ( j = 0; j < pk3VideosN; j++ ){
+                                                               if ( !Q_stricmp( pk3Videos + j*65, token ) ){
+                                                                       goto away;
+                                                               }
+                                                       }
+                                                       for ( j = 0; j < ExVideosN; j++ ){
+                                                               if ( !Q_stricmp( ExVideos + j*65, token ) ){
+                                                                       goto away;
+                                                               }
+                                                       }
+                                                       for ( j = 0; j < rExVideosN; j++ ){
+                                                               if ( !Q_stricmp( rExVideos + j*65, token ) ){
+                                                                       goto away;
+                                                               }
+                                                       }
+                                                       strcpy ( pk3Videos + pk3VideosN*65, token );
+                                                       pk3VideosN++;
+                                                       away:
+                                                       j = 0;
+                                               }
+                                               else if ( !Q_stricmp( token, "mapComp" ) || !Q_stricmp( token, "mapNoComp" ) || !Q_stricmp( token, "animmapcomp" ) || !Q_stricmp( token, "animmapnocomp" ) ){
+                                                       Sys_Printf( "WARNING7: %s : %s shader\n", pk3Shaders + shader*65, token );
+                                                       hasmap = qtrue;
+                                                       if ( line == scriptline ){
+                                                               strcat( shaderText, " " );
+                                                               strcat( shaderText, token );
+                                                       }
+                                                       else{
+                                                               strcat( shaderText, "\n\t\t" );
+                                                               strcat( shaderText, token );
+                                                       }
+                                               }
+                                               else if ( line == scriptline ){
+                                                       strcat( shaderText, " " );
+                                                       strcat( shaderText, token );
+                                               }
+                                               else{
+                                                       strcat( shaderText, "\n\t\t" );
+                                                       strcat( shaderText, token );
+                                               }
+                                       }
+                               }
+                               /* skip the shader */
+                               else if ( !wantShader ) continue;
+                               /* -----------------------------------------------------------------
+                               surfaceparm * directives
+                               ----------------------------------------------------------------- */
+                               /* match surfaceparm */
+                               else if ( !Q_stricmp( token, "surfaceparm" ) ) {
+                                       strcat( shaderText, "\n\tsurfaceparm " );
+                                       GetToken( qfalse );
+                                       strcat( shaderText, token );
+                                       if ( !Q_stricmp( token, "nodraw" ) ) {
+                                               wantShader = qfalse;
+                                               *( pk3Shaders + shader*65 ) = '\0';
+                                       }
+                               }
+                               /* skyparms <outer image> <cloud height> <inner image> */
+                               else if ( !Q_stricmp( token, "skyParms" ) ) {
+                                       strcat( shaderText, "\n\tskyParms " );
+                                       hasmap = qtrue;
+                                       /* get image base */
+                                       GetToken( qfalse );
+                                       strcat( shaderText, token );
+                                       /* ignore bogus paths */
+                                       if ( Q_stricmp( token, "-" ) && Q_stricmp( token, "full" ) ) {
+                                               strcpy ( temp, token );
+                                               sprintf( token, "%s_up", temp );
+                                               tex2list2( pk3Textures, &pk3TexturesN, ExTextures, &ExTexturesN, rExTextures, &rExTexturesN );
+                                               sprintf( token, "%s_dn", temp );
+                                               tex2list2( pk3Textures, &pk3TexturesN, ExTextures, &ExTexturesN, rExTextures, &rExTexturesN );
+                                               sprintf( token, "%s_lf", temp );
+                                               tex2list2( pk3Textures, &pk3TexturesN, ExTextures, &ExTexturesN, rExTextures, &rExTexturesN );
+                                               sprintf( token, "%s_rt", temp );
+                                               tex2list2( pk3Textures, &pk3TexturesN, ExTextures, &ExTexturesN, rExTextures, &rExTexturesN );
+                                               sprintf( token, "%s_bk", temp );
+                                               tex2list2( pk3Textures, &pk3TexturesN, ExTextures, &ExTexturesN, rExTextures, &rExTexturesN );
+                                               sprintf( token, "%s_ft", temp );
+                                               tex2list2( pk3Textures, &pk3TexturesN, ExTextures, &ExTexturesN, rExTextures, &rExTexturesN );
+                                       }
+                                       /* skip rest of line */
+                                       GetToken( qfalse );
+                                       strcat( shaderText, " " );
+                                       strcat( shaderText, token );
+                                       GetToken( qfalse );
+                                       strcat( shaderText, " " );
+                                       strcat( shaderText, token );
+                               }
+                               else if ( !!Q_strncasecmp( token, "implicit", 8 ) ){
+                                       Sys_Printf( "WARNING5: %s : %s shader\n", pk3Shaders + shader*65, token );
+                                       hasmap = qtrue;
+                                       if ( line == scriptline ){
+                                               strcat( shaderText, " " );
+                                               strcat( shaderText, token );
+                                       }
+                                       else{
+                                               strcat( shaderText, "\n\t" );
+                                               strcat( shaderText, token );
+                                       }
+                               }
+                               else if ( !Q_stricmp( token, "fogparms" ) ){
+                                       hasmap = qtrue;
+                                       if ( line == scriptline ){
+                                               strcat( shaderText, " " );
+                                               strcat( shaderText, token );
+                                       }
+                                       else{
+                                               strcat( shaderText, "\n\t" );
+                                               strcat( shaderText, token );
+                                       }
+                               }
+                               else if ( line == scriptline ){
+                                       strcat( shaderText, " " );
+                                       strcat( shaderText, token );
+                               }
+                               else{
+                                       strcat( shaderText, "\n\t" );
+                                       strcat( shaderText, token );
+                               }
+                       }
+                       //exclude shader
+                       if ( wantShader && !hasmap ){
+                               Sys_Printf( "WARNING8: %s : shader has no known maps\n", pk3Shaders + shader*65 );
+                               wantShader = qfalse;
+                               *( pk3Shaders + shader*65 ) = '\0';
+                       }
+                       if ( wantShader ){
+                               for ( j = 0; j < ExShadersN; j++ ){
+                                       if ( !Q_stricmp( ExShaders + j*65, pk3Shaders + shader*65 ) ){
+                                               wantShader = qfalse;
+                                               *( pk3Shaders + shader*65 ) = '\0';
+                                               break;
+                                       }
+                               }
+                               if ( wantShader ){
+                                       strcat( allShaders, shaderText );
+                                       *( pk3Shaders + shader*65 ) = '\0';
+                               }
+                       }
+               }
+       }
+ /* TODO: RTCW's mapComp, mapNoComp, animmapcomp, animmapnocomp; nocompress?; ET's implicitmap, implicitblend, implicitmask */
+ /* exclude stuff */
+ //pure textures (shader ones are done)
+       for ( i = 0; i < pk3ShadersN; i++ ){
+               if ( *( pk3Shaders + i*65 ) != '\0' ){
+                       if ( strchr( pk3Shaders + i*65, '\\') != NULL  ){
+                               Sys_Printf( "WARNING2: %s : bsp shader path with backslash\n", pk3Shaders + i*65 );
+                               FixDOSName( pk3Shaders + i*65 );
+                               //what if theres properly slashed one in the list?
+                               for ( j = 0; j < pk3ShadersN; j++ ){
+                                       if ( !Q_stricmp( pk3Shaders + i*65, pk3Shaders + j*65 ) && (i != j) ){
+                                               *( pk3Shaders + i*65 ) = '\0';
+                                               break;
+                                       }
+                               }
+                       }
+                       if ( *( pk3Shaders + i*65 ) == '\0' ) continue;
+                       for ( j = 0; j < pk3TexturesN; j++ ){
+                               if ( !Q_stricmp( pk3Shaders + i*65, pk3Textures + j*65 ) ){
+                                       *( pk3Shaders + i*65 ) = '\0';
+                                       break;
+                               }
+                       }
+                       if ( *( pk3Shaders + i*65 ) == '\0' ) continue;
+                       for ( j = 0; j < ExTexturesN; j++ ){
+                               if ( !Q_stricmp( pk3Shaders + i*65, ExTextures + j*65 ) ){
+                                       *( pk3Shaders + i*65 ) = '\0';
+                                       break;
+                               }
+                       }
+                       if ( *( pk3Shaders + i*65 ) == '\0' ) continue;
+                       for ( j = 0; j < rExTexturesN; j++ ){
+                               if ( !Q_stricmp( pk3Shaders + i*65, rExTextures + j*65 ) ){
+                                       *( pk3Shaders + i*65 ) = '\0';
+                                       break;
+                               }
+                       }
+               }
+       }
+ //snds
+       for ( i = 0; i < pk3SoundsN; i++ ){
+               for ( j = 0; j < ExSoundsN; j++ ){
+                       if ( !Q_stricmp( pk3Sounds + i*65, ExSounds + j*65 ) ){
+                               *( pk3Sounds + i*65 ) = '\0';
+                               break;
+                       }
+               }
+               if ( *( pk3Sounds + i*65 ) == '\0' ) continue;
+               for ( j = 0; j < rExSoundsN; j++ ){
+                       if ( !Q_stricmp( pk3Sounds + i*65, rExSounds + j*65 ) ){
+                               *( pk3Sounds + i*65 ) = '\0';
+                               break;
+                       }
+               }
+       }
+       /* write shader */
+       sprintf( temp, "%s/%s_strippedBYrepacker.shader", EnginePath, nameOFrepack );
+       FILE *f;
+       f = fopen( temp, "wb" );
+       fwrite( allShaders, sizeof( char ), strlen( allShaders ), f );
+       fclose( f );
+       Sys_Printf( "Shaders saved to %s\n", temp );
+       /* make a pack */
+       sprintf( packname, "%s/%s_repacked.pk3", EnginePath, nameOFrepack );
+       remove( packname );
+       Sys_Printf( "\n--- ZipZip ---\n" );
+       Sys_Printf( "\n\tShader referenced textures....\n" );
+       for ( i = 0; i < pk3TexturesN; i++ ){
+               if ( png ){
+                       sprintf( temp, "%s.png", pk3Textures + i*65 );
+                       if ( vfsPackFile( temp, packname, compLevel ) ){
+                               Sys_Printf( "++%s\n", temp );
+                               continue;
+                       }
+               }
+               sprintf( temp, "%s.tga", pk3Textures + i*65 );
+               if ( vfsPackFile( temp, packname, compLevel ) ){
+                       Sys_Printf( "++%s\n", temp );
+                       continue;
+               }
+               sprintf( temp, "%s.jpg", pk3Textures + i*65 );
+               if ( vfsPackFile( temp, packname, compLevel ) ){
+                       Sys_Printf( "++%s\n", temp );
+                       continue;
+               }
+               Sys_Printf( "  !FAIL! %s\n", pk3Textures + i*65 );
+       }
+       Sys_Printf( "\n\tPure textures....\n" );
+       for ( i = 0; i < pk3ShadersN; i++ ){
+               if ( *( pk3Shaders + i*65 ) != '\0' ){
+                       if ( png ){
+                               sprintf( temp, "%s.png", pk3Shaders + i*65 );
+                               if ( vfsPackFile( temp, packname, compLevel ) ){
+                                       Sys_Printf( "++%s\n", temp );
+                                       continue;
+                               }
+                       }
+                       sprintf( temp, "%s.tga", pk3Shaders + i*65 );
+                       if ( vfsPackFile( temp, packname, compLevel ) ){
+                               Sys_Printf( "++%s\n", temp );
+                               continue;
+                       }
+                       sprintf( temp, "%s.jpg", pk3Shaders + i*65 );
+                       if ( vfsPackFile( temp, packname, compLevel ) ){
+                               Sys_Printf( "++%s\n", temp );
+                               continue;
+                       }
+                       Sys_Printf( "  !FAIL! %s\n", pk3Shaders + i*65 );
+               }
+       }
+       Sys_Printf( "\n\tSounds....\n" );
+       for ( i = 0; i < pk3SoundsN; i++ ){
+               if ( *( pk3Sounds + i*65 ) != '\0' ){
+                       if ( vfsPackFile( pk3Sounds + i*65, packname, compLevel ) ){
+                               Sys_Printf( "++%s\n", pk3Sounds + i*65 );
+                               continue;
+                       }
+                       Sys_Printf( "  !FAIL! %s\n", pk3Sounds + i*65 );
+               }
+       }
+       Sys_Printf( "\n\tVideos....\n" );
+       for ( i = 0; i < pk3VideosN; i++ ){
+               if ( vfsPackFile( pk3Videos + i*65, packname, compLevel ) ){
+                       Sys_Printf( "++%s\n", pk3Videos + i*65 );
+                       continue;
+               }
+               Sys_Printf( "  !FAIL! %s\n", pk3Videos + i*65 );
+       }
+       Sys_Printf( "\nSaved to %s\n", packname );
+       /* return to sender */
+       return 0;
+ }
+ /*
+    main()
+    q3map mojo...
+  */
+ int main( int argc, char **argv ){
+       int i, r;
+       double start, end;
+       extern qboolean werror;
+       /* we want consistent 'randomness' */
+       srand( 0 );
+       /* start timer */
+       start = I_FloatTime();
+       /* this was changed to emit version number over the network */
+       printf( Q3MAP_VERSION "\n" );
+       /* set exit call */
+       atexit( ExitQ3Map );
+       /* read general options first */
+       for ( i = 1; i < argc; i++ )
+       {
+               /* -help */
+               if ( !strcmp( argv[ i ], "-h" ) || !strcmp( argv[ i ], "--help" )
+                       || !strcmp( argv[ i ], "-help" ) ) {
 -                      HelpMain(argv[i+1]);
++                      HelpMain( ( i + 1 < argc ) ? argv[ i + 1 ] : NULL );
+                       return 0;
+               }
+               /* -connect */
+               if ( !strcmp( argv[ i ], "-connect" ) ) {
 -                      argv[ i ] = NULL;
 -                      i++;
++                      if ( ++i >= argc || !argv[ i ] ) {
++                              Error( "Out of arguments: No address specified after %s", argv[ i - 1 ] );
++                      }
++                      argv[ i - 1 ] = NULL;
+                       Broadcast_Setup( argv[ i ] );
+                       argv[ i ] = NULL;
+               }
+               /* verbose */
+               else if ( !strcmp( argv[ i ], "-v" ) ) {
+                       if ( !verbose ) {
+                               verbose = qtrue;
+                               argv[ i ] = NULL;
+                       }
+               }
+               /* force */
+               else if ( !strcmp( argv[ i ], "-force" ) ) {
+                       force = qtrue;
+                       argv[ i ] = NULL;
+               }
+               /* make all warnings into errors */
+               else if ( !strcmp( argv[ i ], "-werror" ) ) {
+                       werror = qtrue;
+                       argv[ i ] = NULL;
+               }
+               /* patch subdivisions */
+               else if ( !strcmp( argv[ i ], "-subdivisions" ) ) {
 -                      argv[ i ] = NULL;
 -                      i++;
++                      if ( ++i >= argc || !argv[ i ] ) {
++                              Error( "Out of arguments: No value specified after %s", argv[ i - 1 ] );
++                      }
++                      argv[ i - 1 ] = NULL;
+                       patchSubdivisions = atoi( argv[ i ] );
+                       argv[ i ] = NULL;
+                       if ( patchSubdivisions <= 0 ) {
+                               patchSubdivisions = 1;
+                       }
+               }
+               /* threads */
+               else if ( !strcmp( argv[ i ], "-threads" ) ) {
 -                      argv[ i ] = NULL;
 -                      i++;
++                      if ( ++i >= argc || !argv[ i ] ) {
++                              Error( "Out of arguments: No value specified after %s", argv[ i - 1 ] );
++                      }
++                      argv[ i - 1 ] = NULL;
+                       numthreads = atoi( argv[ i ] );
+                       argv[ i ] = NULL;
+               }
+               else if( !strcmp( argv[ i ], "-nocmdline" ) )
+               {
+                       Sys_Printf( "noCmdLine\n" );
+                       nocmdline = qtrue;
+                       argv[ i ] = NULL;
+               }
+       }
+       /* init model library */
+       PicoInit();
+       PicoSetMallocFunc( safe_malloc );
+       PicoSetFreeFunc( free );
+       PicoSetPrintFunc( PicoPrintFunc );
+       PicoSetLoadFileFunc( PicoLoadFileFunc );
+       PicoSetFreeFileFunc( free );
+       /* set number of threads */
+       ThreadSetDefault();
+       /* generate sinusoid jitter table */
+       for ( i = 0; i < MAX_JITTERS; i++ )
+       {
+               jitters[ i ] = sin( i * 139.54152147 );
+               //%     Sys_Printf( "Jitter %4d: %f\n", i, jitters[ i ] );
+       }
+       /* we print out two versions, q3map's main version (since it evolves a bit out of GtkRadiant)
+          and we put the GtkRadiant version to make it easy to track with what version of Radiant it was built with */
+       Sys_Printf( "Q3Map         - v1.0r (c) 1999 Id Software Inc.\n" );
+       Sys_Printf( "Q3Map (ydnar) - v" Q3MAP_VERSION "\n" );
 -      Sys_Printf( "NetRadiant    - v" RADIANT_VERSION " " __DATE__ " " __TIME__ "\n" );
++      Sys_Printf( RADIANT_NAME "    - v" RADIANT_VERSION " " __DATE__ " " __TIME__ "\n" );
+       Sys_Printf( "%s\n", Q3MAP_MOTD );
+       Sys_Printf( "%s\n", argv[0] );
+       strcpy( q3map2path, argv[0] );//fuer autoPack func
+       /* ydnar: new path initialization */
+       InitPaths( &argc, argv );
+       /* set game options */
+       if ( !patchSubdivisions ) {
+               patchSubdivisions = game->patchSubdivisions;
+       }
+       /* check if we have enough options left to attempt something */
+       if ( argc < 2 ) {
+               Error( "Usage: %s [general options] [options] mapfile", argv[ 0 ] );
+       }
+       /* fixaas */
+       if ( !strcmp( argv[ 1 ], "-fixaas" ) ) {
+               r = FixAASMain( argc - 1, argv + 1 );
+       }
+       /* analyze */
+       else if ( !strcmp( argv[ 1 ], "-analyze" ) ) {
+               r = AnalyzeBSPMain( argc - 1, argv + 1 );
+       }
+       /* info */
+       else if ( !strcmp( argv[ 1 ], "-info" ) ) {
+               r = BSPInfoMain( argc - 2, argv + 2 );
        }
  
        /* vis */
        }
  
        /* ydnar: otherwise create a bsp */
-       else {
+       else{
 +              /* used to write Smokin'Guns like tex file */
 +              compile_map = qtrue;
 +
                r = BSPMain( argc, argv );
        }
  
Simple merge