]> git.xonotic.org Git - xonotic/netradiant.git/blobdiff - tools/quake3/q3map2/main.c
set stack size to 8 MB explicitly, should fix light compile crash on OS X
[xonotic/netradiant.git] / tools / quake3 / q3map2 / main.c
index 09e73bd3c8c9e2accc04076e8618a52b46734b90..213a975bfde537da6eb0deaf287c526bba3d2e09 100644 (file)
@@ -66,8 +66,6 @@ static void ExitQ3Map( void )
 
 /* minimap stuff */
 
-/* borrowed from light.c */
-void WriteTGA24( char *filename, byte *data, int width, int height, qboolean flip );
 typedef struct minimap_s
 {
        bspModel_t *model;
@@ -77,6 +75,7 @@ typedef struct minimap_s
        float *sample_offsets;
        float sharpen_boxmult;
        float sharpen_centermult;
+       float boost;
        float *data1f;
        float *sharpendata1f;
        vec3_t mins, size;
@@ -137,6 +136,7 @@ static float MiniMapSample(float x, float y)
        float t0, t1;
        float samp;
        bspBrush_t *b;
+       bspBrushSide_t *s;
        int cnt;
 
        org[0] = x;
@@ -156,7 +156,7 @@ static float MiniMapSample(float x, float y)
                        b = &bspBrushes[bi];
 
                        // sort out mins/maxs of the brush
-                       bspBrushSide_t *s = &bspBrushSides[b->firstSide];
+                       s = &bspBrushSides[b->firstSide];
                        if(x < -bspPlanes[s[0].planeNum].dist)
                                continue;
                        if(x > +bspPlanes[s[1].planeNum].dist)
@@ -195,6 +195,7 @@ static void MiniMapRandomlySupersampled(int y)
        float dx   =                   minimap.size[0]      / (float) minimap.width;
        float dy   =                   minimap.size[1]      / (float) minimap.height;
        float uv[2];
+       float thisval;
 
        for(x = 0; x < minimap.width; ++x)
        {
@@ -204,7 +205,7 @@ static void MiniMapRandomlySupersampled(int y)
                for(i = 0; i < minimap.samples; ++i)
                {
                        RandomVector2f(uv);
-                       float thisval = MiniMapSample(
+                       thisval = MiniMapSample(
                                xmin + (uv[0] + 0.5) * dx, /* exaggerated random pattern for better results */
                                ymin + (uv[1] + 0.5) * dy  /* exaggerated random pattern for better results */
                        );
@@ -245,11 +246,11 @@ static void MiniMapNoSupersampling(int y)
 {
        int x;
        float *p = &minimap.data1f[y * minimap.width];
-       float ymin = minimap.mins[1] + minimap.size[1] * (y / (float) minimap.height);
+       float ymin = minimap.mins[1] + minimap.size[1] * ((y + 0.5) / (float) minimap.height);
 
        for(x = 0; x < minimap.width; ++x)
        {
-               float xmin = minimap.mins[0] + minimap.size[0] * (x / (float) minimap.width);
+               float xmin = minimap.mins[0] + minimap.size[0] * ((x + 0.5) / (float) minimap.width);
                *p++ = MiniMapSample(xmin, ymin) / minimap.size[2];
        }
 }
@@ -291,7 +292,18 @@ static void MiniMapSharpen(int y)
        }
 }
 
-void MiniMapMakeMinsMaxs(vec3_t mins_in, vec3_t maxs_in)
+static void MiniMapContrastBoost(int y)
+{
+       int x;
+       float *q = &minimap.data1f[y * minimap.width];
+       for(x = 0; x < minimap.width; ++x)
+       {
+               *q = *q * minimap.boost / ((minimap.boost - 1) * *q + 1);
+               ++q;
+       }
+}
+
+void MiniMapMakeMinsMaxs(vec3_t mins_in, vec3_t maxs_in, float border, qboolean keepaspect)
 {
        vec3_t mins, maxs, extend;
        VectorCopy(mins_in, mins);
@@ -300,21 +312,26 @@ void MiniMapMakeMinsMaxs(vec3_t mins_in, vec3_t maxs_in)
        // line compatible to nexuiz mapinfo
        Sys_Printf("size %f %f %f %f %f %f\n", mins[0], mins[1], mins[2], maxs[0], maxs[1], maxs[2]);
 
-       VectorSubtract(maxs, mins, extend);
-
-       if(extend[1] > extend[0])
+       if(keepaspect)
        {
-               mins[0] -= (extend[1] - extend[0]) * 0.5;
-               maxs[0] += (extend[1] - extend[0]) * 0.5;
-       }
-       else
-       {
-               mins[1] -= (extend[0] - extend[1]) * 0.5;
-               maxs[1] += (extend[0] - extend[1]) * 0.5;
+               VectorSubtract(maxs, mins, extend);
+               if(extend[1] > extend[0])
+               {
+                       mins[0] -= (extend[1] - extend[0]) * 0.5;
+                       maxs[0] += (extend[1] - extend[0]) * 0.5;
+               }
+               else
+               {
+                       mins[1] -= (extend[0] - extend[1]) * 0.5;
+                       maxs[1] += (extend[0] - extend[1]) * 0.5;
+               }
        }
 
+       /* border: amount of black area around the image */
+       /* input: border, 1-2*border, border but we need border/(1-2*border) */
+
        VectorSubtract(maxs, mins, extend);
-       VectorScale(extend, 1.0 / 64.0, extend);
+       VectorScale(extend, border / (1 - 2 * border), extend);
 
        VectorSubtract(mins, extend, mins);
        VectorAdd(maxs, extend, maxs);
@@ -333,9 +350,8 @@ determines solid non-sky brushes in the world
 
 void MiniMapSetupBrushes( void )
 {
-       int                             i, j, b, compileFlags;
+       int                             i, b, compileFlags;
        bspBrush_t              *brush;
-       bspBrushSide_t  *side;
        bspShader_t             *shader;
        shaderInfo_t    *si;
        
@@ -429,7 +445,7 @@ qboolean MiniMapEvaluateSampleOffsets(int *bestj, int *bestk, float *bestval)
 void MiniMapMakeSampleOffsets()
 {
        int i, j, k, jj, kk;
-       float val, valj, valk, dx, dy, sx, sy, rx, ry;
+       float val, valj, valk, sx, sy, rx, ry;
 
        Sys_Printf( "Generating good sample offsets (this may take a while)...\n" );
 
@@ -470,7 +486,6 @@ void MiniMapMakeSampleOffsets()
                                        minimap.sample_offsets[2*j+0] = rx;
                                        minimap.sample_offsets[2*j+1] = ry;
                                        i = -1;
-                                       Sys_Printf("%f\n", val);
                                }
                                else
                                {
@@ -485,7 +500,6 @@ void MiniMapMakeSampleOffsets()
                                        minimap.sample_offsets[2*k+0] = rx;
                                        minimap.sample_offsets[2*k+1] = ry;
                                        i = -1;
-                                       Sys_Printf("%f\n", val);
                                }
                                else
                                {
@@ -498,18 +512,43 @@ void MiniMapMakeSampleOffsets()
        }
 }
 
+void MergeRelativePath(char *out, const char *absolute, const char *relative)
+{
+       const char *endpos = absolute + strlen(absolute);
+       while(endpos != absolute && (endpos[-1] == '/' || endpos[-1] == '\\'))
+               --endpos;
+       while(relative[0] == '.' && relative[1] == '.' && (relative[2] == '/' || relative[2] == '\\'))
+       {
+               relative += 3;
+               while(endpos != absolute)
+               {
+                       --endpos;
+                       if(*endpos == '/' || *endpos == '\\')
+                               break;
+               }
+               while(endpos != absolute && (endpos[-1] == '/' || endpos[-1] == '\\'))
+                       --endpos;
+       }
+       memcpy(out, absolute, endpos - absolute);
+       out[endpos - absolute] = '/';
+       strcpy(out + (endpos - absolute + 1), relative);
+}
+
 int MiniMapBSPMain( int argc, char **argv )
 {
        char minimapFilename[1024];
        char basename[1024];
        char path[1024];
-       char parentpath[1024];
+       char relativeMinimapFilename[1024];
        float minimapSharpen;
-       byte *data3b, *p;
+       float border;
+       byte *data4b, *p;
        float *q;
        int x, y;
        int i;
+       miniMapMode_t mode;
        vec3_t mins, maxs;
+       qboolean keepaspect;
 
        /* arg checking */
        if( argc < 2 )
@@ -530,11 +569,17 @@ int MiniMapBSPMain( int argc, char **argv )
        minimap.model = &bspModels[0];
        VectorCopy(minimap.model->mins, mins);
        VectorCopy(minimap.model->maxs, maxs);
+
        *minimapFilename = 0;
-       minimapSharpen = 1;
-       minimap.width = minimap.height = 512;
+       minimapSharpen = game->miniMapSharpen;
+       minimap.width = minimap.height = game->miniMapSize;
+       border = game->miniMapBorder;
+       keepaspect = game->miniMapKeepAspect;
+       mode = game->miniMapMode;
+
        minimap.samples = 1;
        minimap.sample_offsets = NULL;
+       minimap.boost = 1.0;
 
        /* process arguments */
        for( i = 1; i < (argc - 1); i++ )
@@ -570,6 +615,22 @@ int MiniMapBSPMain( int argc, char **argv )
                                free(minimap.sample_offsets);
                        minimap.sample_offsets = NULL;
                }
+               else if( !strcmp( argv[ i ],  "-border" ) )
+               {
+                       border = atof(argv[i + 1]);
+                       i++;
+                       Sys_Printf( "Border set to %f\n", border );
+               }
+               else if( !strcmp( argv[ i ],  "-keepaspect" ) )
+               {
+                       keepaspect = qtrue;
+                       Sys_Printf( "Keeping aspect ratio by letterboxing\n", border );
+               }
+               else if( !strcmp( argv[ i ],  "-nokeepaspect" ) )
+               {
+                       keepaspect = qfalse;
+                       Sys_Printf( "Not keeping aspect ratio\n", border );
+               }
                else if( !strcmp( argv[ i ],  "-o" ) )
                {
                        strcpy(minimapFilename, argv[i + 1]);
@@ -587,22 +648,41 @@ int MiniMapBSPMain( int argc, char **argv )
                        i += 6;
                        Sys_Printf( "Map mins/maxs overridden\n" );
                }
+               else if( !strcmp( argv[ i ],  "-gray" ) )
+               {
+                       mode = MINIMAP_MODE_GRAY;
+                       Sys_Printf( "Writing as white-on-black image\n" );
+               }
+               else if( !strcmp( argv[ i ],  "-black" ) )
+               {
+                       mode = MINIMAP_MODE_BLACK;
+                       Sys_Printf( "Writing as black alpha image\n" );
+               }
+               else if( !strcmp( argv[ i ],  "-white" ) )
+               {
+                       mode = MINIMAP_MODE_WHITE;
+                       Sys_Printf( "Writing as white alpha image\n" );
+               }
+               else if( !strcmp( argv[ i ],  "-boost" ) )
+               {
+                       minimap.boost = atof(argv[i + 1]);
+                       i++;
+                       Sys_Printf( "Contrast boost set to %f\n", minimap.boost );
+               }
        }
 
-       MiniMapMakeMinsMaxs(mins, maxs);
+       MiniMapMakeMinsMaxs(mins, maxs, border, keepaspect);
 
        if(!*minimapFilename)
        {
                ExtractFileBase(source, basename);
                ExtractFilePath(source, path);
-               if(*path)
-                       path[strlen(path)-1] = 0;
-               ExtractFilePath(path, parentpath);
-               sprintf(minimapFilename, "%sgfx", parentpath);
-               Q_mkdir(minimapFilename);
-               sprintf(minimapFilename, "%sgfx/%s_mini.tga", parentpath, basename);
+               sprintf(relativeMinimapFilename, game->miniMapNameFormat, basename);
+               MergeRelativePath(minimapFilename, path, relativeMinimapFilename);
                Sys_Printf("Output file name automatically set to %s\n", minimapFilename);
        }
+       ExtractFilePath(minimapFilename, path);
+       Q_mkdir(path);
 
        if(minimapSharpen >= 0)
        {
@@ -611,7 +691,7 @@ int MiniMapBSPMain( int argc, char **argv )
        }
 
        minimap.data1f = safe_malloc(minimap.width * minimap.height * sizeof(*minimap.data1f));
-       data3b = safe_malloc(minimap.width * minimap.height * 3);
+       data4b = safe_malloc(minimap.width * minimap.height * 4);
        if(minimapSharpen >= 0)
                minimap.sharpendata1f = safe_malloc(minimap.width * minimap.height * sizeof(*minimap.data1f));
 
@@ -636,6 +716,12 @@ int MiniMapBSPMain( int argc, char **argv )
                }
        }
 
+       if(minimap.boost != 1.0)
+       {
+               Sys_Printf( "\n--- MiniMapContrastBoost (%d) ---\n", minimap.height );
+               RunThreadsOnIndividual(minimap.height, qtrue, MiniMapContrastBoost);
+       }
+
        if(minimap.sharpendata1f)
        {
                Sys_Printf( "\n--- MiniMapSharpen (%d) ---\n", minimap.height );
@@ -648,22 +734,61 @@ int MiniMapBSPMain( int argc, char **argv )
        }
 
        Sys_Printf( "\nConverting...");
-       p = data3b;
-       for(y = 0; y < minimap.height; ++y)
-               for(x = 0; x < minimap.width; ++x)
-               {
-                       byte b;
-                       float v = *q++;
-                       if(v < 0) v = 0;
-                       if(v > 255.0/256.0) v = 255.0/256.0;
-                       b = v * 256;
-                       *p++ = b;
-                       *p++ = b;
-                       *p++ = b;
-               }
 
-       Sys_Printf( " writing to %s...", minimapFilename );
-       WriteTGA24(minimapFilename, data3b, minimap.width, minimap.height, qfalse);
+       switch(mode)
+       {
+               case MINIMAP_MODE_GRAY:
+                       p = data4b;
+                       for(y = 0; y < minimap.height; ++y)
+                               for(x = 0; x < minimap.width; ++x)
+                               {
+                                       byte b;
+                                       float v = *q++;
+                                       if(v < 0) v = 0;
+                                       if(v > 255.0/256.0) v = 255.0/256.0;
+                                       b = v * 256;
+                                       *p++ = b;
+                               }
+                       Sys_Printf( " writing to %s...", minimapFilename );
+                       WriteTGAGray(minimapFilename, data4b, minimap.width, minimap.height);
+                       break;
+               case MINIMAP_MODE_BLACK:
+                       p = data4b;
+                       for(y = 0; y < minimap.height; ++y)
+                               for(x = 0; x < minimap.width; ++x)
+                               {
+                                       byte b;
+                                       float v = *q++;
+                                       if(v < 0) v = 0;
+                                       if(v > 255.0/256.0) v = 255.0/256.0;
+                                       b = v * 256;
+                                       *p++ = 0;
+                                       *p++ = 0;
+                                       *p++ = 0;
+                                       *p++ = b;
+                               }
+                       Sys_Printf( " writing to %s...", minimapFilename );
+                       WriteTGA(minimapFilename, data4b, minimap.width, minimap.height);
+                       break;
+               case MINIMAP_MODE_WHITE:
+                       p = data4b;
+                       for(y = 0; y < minimap.height; ++y)
+                               for(x = 0; x < minimap.width; ++x)
+                               {
+                                       byte b;
+                                       float v = *q++;
+                                       if(v < 0) v = 0;
+                                       if(v > 255.0/256.0) v = 255.0/256.0;
+                                       b = v * 256;
+                                       *p++ = 255;
+                                       *p++ = 255;
+                                       *p++ = 255;
+                                       *p++ = b;
+                               }
+                       Sys_Printf( " writing to %s...", minimapFilename );
+                       WriteTGA(minimapFilename, data4b, minimap.width, minimap.height);
+                       break;
+       }
 
        Sys_Printf( " done.\n" );
 
@@ -1454,7 +1579,7 @@ int main( int argc, char **argv )
                        argv[ i ] = NULL;
                }
        }
-       
+
        /* init model library */
        PicoInit();
        PicoSetMallocFunc( safe_malloc );