split help stuff from q3map2
authorThomas Debesse <dev@illwieckz.net>
Mon, 20 Jul 2015 18:10:23 +0000 (20:10 +0200)
committerThomas Debesse <dev@illwieckz.net>
Wed, 13 Apr 2016 23:00:15 +0000 (01:00 +0200)
Makefile
tools/quake3/q3map2/help.c [new file with mode: 0644]
tools/quake3/q3map2/main.c
tools/quake3/q3map2/q3map2.h

index 9cde277..c5b8cc6 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -508,6 +508,7 @@ $(INSTALLDIR)/q3map2.$(EXE): \
        tools/quake3/q3map2/decals.o \
        tools/quake3/q3map2/facebsp.o \
        tools/quake3/q3map2/fog.o \
+       tools/quake3/q3map2/help.o \
        tools/quake3/q3map2/image.o \
        tools/quake3/q3map2/leakfile.o \
        tools/quake3/q3map2/light_bounce.o \
diff --git a/tools/quake3/q3map2/help.c b/tools/quake3/q3map2/help.c
new file mode 100644 (file)
index 0000000..f40ea46
--- /dev/null
@@ -0,0 +1,393 @@
+/* -------------------------------------------------------------------------------
+
+   Copyright (C) 1999-2007 id Software, Inc. and contributors.
+   For a list of contributors, see the accompanying CONTRIBUTORS file.
+
+   This file is part of GtkRadiant.
+
+   GtkRadiant is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   GtkRadiant is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with GtkRadiant; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+   -------------------------------------------------------------------------------
+
+   This code has been altered significantly from its original form, to support
+   several games based on the Quake III Arena engine, in the form of "Q3Map2."
+
+   ------------------------------------------------------------------------------- */
+
+
+
+/* dependencies */
+#include "q3map2.h"
+
+
+
+struct HelpOption
+{
+       const char* name;
+       const char* description;
+};
+
+void HelpOptions(const char* group_name, int indentation, int width, struct HelpOption* options, int count)
+{
+       indentation *= 2;
+       char* indent = malloc(indentation+1);
+       memset(indent, ' ', indentation);
+       indent[indentation] = 0;
+       printf("%s%s:\n", indent, group_name);
+       indentation += 2;
+       indent = realloc(indent, indentation+1);
+       memset(indent, ' ', indentation);
+       indent[indentation] = 0;
+
+       int i;
+       for ( i = 0; i < count; i++ )
+       {
+               int printed = printf("%s%-24s  ", indent, options[i].name);
+               int descsz = strlen(options[i].description);
+               int j = 0;
+               while ( j < descsz && descsz-j > width - printed )
+               {
+                       if ( j != 0 )
+                               printf("%s%26c",indent,' ');
+                       int fragment = width - printed;
+                       while ( fragment > 0 && options[i].description[j+fragment-1] != ' ')
+                                       fragment--;
+                       j += fwrite(options[i].description+j, sizeof(char), fragment, stdout);
+                       putchar('\n');
+                       printed = indentation+26;
+               }
+               if ( j == 0 )
+               {
+                       printf("%s\n",options[i].description+j);
+               }
+               else if ( j < descsz )
+               {
+                       printf("%s%26c%s\n",indent,' ',options[i].description+j);
+               }
+       }
+
+       putchar('\n');
+
+       free(indent);
+}
+
+void HelpBsp()
+{
+       struct HelpOption bsp[] = {
+               {"-bsp <filename.map>", "Switch that enters this stage"},
+               {"-altsplit", "Alternate BSP tree splitting weights (should give more fps)"},
+               {"-celshader <shadername>", "Sets a global cel shader name"},
+               {"-custinfoparms", "Read scripts/custinfoparms.txt"},
+               {"-debuginset", "Push all triangle vertexes towards the triangle center"},
+               {"-debugportals", "Make BSP portals visible in the map"},
+               {"-debugsurfaces", "Color the vertexes according to the index of the surface"},
+               {"-deep", "Use detail brushes in the BSP tree, but at lowest priority (should give more fps)"},
+               {"-de <F>", "Distance epsilon for plane snapping etc."},
+               {"-fakemap", "Write fakemap.map containing all world brushes"},
+               {"-flares", "Turn on support for flares (TEST?)"},
+               {"-flat", "Enable flat shading (good for combining with -celshader)"},
+               {"-fulldetail", "Treat detail brushes as structural ones"},
+               {"-leaktest", "Abort if a leak was found"},
+               {"-meta", "Combine adjacent triangles of the same texture to surfaces (ALWAYS USE THIS)"},
+               {"-minsamplesize <N>", "Sets minimum lightmap resolution in luxels/qu"},
+               {"-mi <N>", "Sets the maximum number of indexes per surface"},
+               {"-mv <N>", "Sets the maximum number of vertices of a lightmapped surface"},
+               {"-ne <F>", "Normal epsilon for plane snapping etc."},
+               {"-nocurves", "Turn off support for patches"},
+               {"-nodetail", "Leave out detail brushes"},
+               {"-noflares", "Turn off support for flares"},
+               {"-nofog", "Turn off support for fog volumes"},
+               {"-nohint", "Turn off support for hint brushes"},
+               {"-nosubdivide", "Turn off support for `q3map_tessSize` (breaks water vertex deforms)"},
+               {"-notjunc", "Do not fix T-junctions (causes cracks between triangles, do not use)"},
+               {"-nowater", "Turn off support for water, slime or lava (Stef, this is for you)"},
+               {"-np <A>", "Force all surfaces to be nonplanar with a given shade angle"},
+               {"-onlyents", "Only update entities in the BSP"},
+               {"-patchmeta", "Turn patches into triangle meshes for display"},
+               {"-rename", "Append â€œbspâ€\9d suffix to miscmodel shaders (needed for SoF2)"},
+               {"-samplesize <N>", "Sets default lightmap resolution in luxels/qu"},
+               {"-skyfix", "Turn sky box into six surfaces to work around ATI problems"},
+               {"-snap <N>", "Snap brush bevel planes to the given number of units"},
+               {"-tempname <filename.map>", "Read the MAP file from the given file name"},
+               {"-texrange <N>", "Limit per-surface texture range to the given number of units, and subdivide surfaces like with `q3map_tessSize` if this is not met"},
+               {"-tmpout", "Write the BSP file to /tmp"},
+               {"-verboseentities", "Enable `-v` only for map entities, not for the world"},
+       };
+       HelpOptions("BSP Stage", 0, 80, bsp, sizeof(bsp)/sizeof(struct HelpOption));
+}
+void HelpVis()
+{
+       struct HelpOption vis[] = {
+               {"-vis <filename.map>", "Switch that enters this stage"},
+               {"-fast", "Very fast and crude vis calculation"},
+               {"-mergeportals", "The less crude half of `-merge`, makes vis sometimes much faster but doesn't hurt fps usually"},
+               {"-merge", "Faster but still okay vis calculation"},
+               {"-nopassage", "Just use PortalFlow vis (usually less fps)"},
+               {"-nosort", "Do not sort the portals before calculating vis (usually slower)"},
+               {"-passageOnly", "Just use PassageFlow vis (usually less fps)"},
+               {"-saveprt", "Keep the PRT file after running vis (so you can run vis again)"},
+               {"-tmpin", "Use /tmp folder for input"},
+               {"-tmpout", "Use /tmp folder for output"},
+       };
+       HelpOptions("VIS Stage", 0, 80, vis, sizeof(vis)/sizeof(struct HelpOption));
+}
+void HelpLight()
+{
+       struct HelpOption light[] = {
+               {"-light <filename.map>", "Switch that enters this stage"},
+               {"-vlight <filename.map>", "Deprecated alias for `-light -fast` ... filename.map"},
+               {"-approx <N>", "Vertex light approximation tolerance (never use in conjunction with deluxemapping)"},
+               {"-areascale <F, `-area` F>", "Scaling factor for area lights (surfacelight)"},
+               {"-border", "Add a red border to lightmaps for debugging"},
+               {"-bouncegrid", "Also compute radiosity on the light grid"},
+               {"-bounceonly", "Only compute radiosity"},
+               {"-bouncescale <F>", "Scaling factor for radiosity"},
+               {"-bounce <N>", "Number of bounces for radiosity"},
+               {"-cheapgrid", "Use `-cheap` style lighting for radiosity"},
+               {"-cheap", "Abort vertex light calculations when white is reached"},
+               {"-compensate <F>", "Lightmap compensate (darkening factor applied after everything else)"},
+               {"-cpma", "CPMA vertex lighting mode"},
+               {"-custinfoparms", "Read scripts/custinfoparms.txt"},
+               {"-dark", "Darken lightmap seams"},
+               {"-debugaxis", "Color the lightmaps according to the lightmap axis"},
+               {"-debugcluster", "Color the lightmaps according to the index of the cluster"},
+               {"-debugdeluxe", "Show deluxemaps on the lightmap"},
+               {"-debugnormals", "Color the lightmaps according to the direction of the surface normal"},
+               {"-debugorigin", "Color the lightmaps according to the origin of the luxels"},
+               {"-debugsurfaces, -debugsurface", "Color the lightmaps according to the index of the surface"},
+               {"-debugunused", "This option does nothing"},
+               {"-debug", "Mark the lightmaps according to the cluster: unmapped clusters get yellow, occluded ones get pink, flooded ones get blue overlay color, otherwise red"},
+               {"-deluxemode 0", "Use modelspace deluxemaps (DarkPlaces)"},
+               {"-deluxemode 1", "Use tangentspace deluxemaps"},
+               {"-deluxe, -deluxemap", "Enable deluxemapping (light direction maps)"},
+               {"-dirtdebug, -debugdirt", "Store the dirtmaps as lightmaps for debugging"},
+               {"-dirtdepth", "Dirtmapping depth"},
+               {"-dirtgain", "Dirtmapping exponent"},
+               {"-dirtmode 0", "Ordered direction dirtmapping"},
+               {"-dirtmode 1", "Randomized direction dirtmapping"},
+               {"-dirtscale", "Dirtmapping scaling factor"},
+               {"-dirty", "Enable dirtmapping"},
+               {"-dump", "Dump radiosity from `-bounce` into numbered MAP file prefabs"},
+               {"-export", "Export lightmaps when compile finished (like `-export` mode)"},
+               {"-exposure <F>", "Lightmap exposure to better support overbright spots"},
+               {"-external", "Force external lightmaps even if at size of internal lightmaps"},
+               {"-extravisnudge", "Broken feature to nudge the luxel origin to a better vis cluster"},
+               {"-extrawide", "Deprecated alias for `-super 2 -filter`"},
+               {"-extra", "Deprecated alias for `-super 2`"},
+               {"-fastbounce", "Use `-fast` style lighting for radiosity"},
+               {"-faster", "Use a faster falloff curve for lighting; also implies `-fast`"},
+               {"-fastgrid", "Use `-fast` style lighting for the light grid"},
+               {"-fast", "Ignore tiny light contributions"},
+               {"-filter", "Lightmap filtering"},
+               {"-floodlight", "Enable floodlight (zero-effort somewhat decent lighting)"},
+               {"-gamma <F>", "Lightmap gamma"},
+               {"-gridambientscale <F>", "Scaling factor for the light grid ambient components only"},
+               {"-gridscale <F>", "Scaling factor for the light grid only"},
+               {"-keeplights", "Keep light entities in the BSP file after compile"},
+               {"-lightmapdir <directory>", "Directory to store external lightmaps (default: same as map name without extension)"},
+               {"-lightmapsize <N>", "Size of lightmaps to generate (must be a power of two)"},
+               {"-lomem", "Low memory but slower lighting mode"},
+               {"-lowquality", "Low quality floodlight (appears to currently break floodlight)"},
+               {"-minsamplesize <N>", "Sets minimum lightmap resolution in luxels/qu"},
+               {"-nocollapse", "Do not collapse identical lightmaps"},
+               {"-nodeluxe, -nodeluxemap", "Disable deluxemapping"},
+               {"-nogrid", "Disable grid light calculation (makes all entities fullbright)"},
+               {"-nolightmapsearch", "Do not optimize lightmap packing for GPU memory usage (as doing so costs fps)"},
+               {"-normalmap", "Color the lightmaps according to the direction of the surface normal (TODO is this identical to `-debugnormals`?)"},
+               {"-nostyle, -nostyles", "Disable support for light styles"},
+               {"-nosurf", "Disable tracing against surfaces (only uses BSP nodes then)"},
+               {"-notrace", "Disable shadow occlusion"},
+               {"-novertex", "Disable vertex lighting"},
+               {"-patchshadows", "Cast shadows from patches"},
+               {"-pointscale <F, `-point` F>", "Scaling factor for point lights (light entities)"},
+               {"-q3", "Use nonlinear falloff curve by default (like Q3A)"},
+               {"-samplescale <F>", "Scales all lightmap resolutions"},
+               {"-samplesize <N>", "Sets default lightmap resolution in luxels/qu"},
+               {"-samples <N>", "Adaptive supersampling quality"},
+               {"-scale <F>", "Scaling factor for all light types"},
+               {"-shadeangle <A>", "Angle for phong shading"},
+               {"-shade", "Enable phong shading at default shade angle"},
+               {"-skyscale <F, `-sky` F>", "Scaling factor for sky and sun light"},
+               {"-smooth", "Deprecated alias for `-samples 2`"},
+               {"-style, -styles", "Enable support for light styles"},
+               {"-sunonly", "Only compute sun light"},
+               {"-super <N, `-supersample` N>", "Ordered grid supersampling quality"},
+               {"-thresh <F>", "Triangle subdivision threshold"},
+               {"-trianglecheck", "Broken check that should ensure luxels apply to the right triangle"},
+               {"-trisoup", "Convert brush faces to triangle soup"},
+               {"-wolf", "Use linear falloff curve by default (like W:ET)"},
+       };
+
+       HelpOptions("Light Stage", 0, 80, light, sizeof(light)/sizeof(struct HelpOption));
+}
+
+void HelpAnalize()
+{
+       struct HelpOption analize[] = {
+               {"-analyze <filename.bsp>", "Switch that enters this mode"},
+               {"-lumpswap", "Swap byte order in the lumps"},
+       };
+
+       HelpOptions("Analyzing BSP-like file structure", 0, 80, analize, sizeof(analize)/sizeof(struct HelpOption));
+}
+void HelpScale()
+{
+       struct HelpOption scale[] = {
+               {"-scale <S filename.bsp>", "Scale uniformly"},
+               {"-scale <SX SY SZ filename.bsp>", "Scale non-uniformly"},
+               {"-scale -tex <S filename.bsp>", "Scale uniformly without texture lock"},
+               {"-scale -tex <SX SY SZ filename.bsp>", "Scale non-uniformly without texture lock"},
+       };
+       HelpOptions("Scaling", 0, 80, scale, sizeof(scale)/sizeof(struct HelpOption));
+}
+void HelpConvert()
+{
+       struct HelpOption convert[] = {
+               {"-convert <filename.bsp>", "Switch that enters this mode"},
+               {"-de <number>", "Distance epsilon for the conversion"},
+               {"-format <converter>", "Select the converter (available: map, ase, or game names)"},
+               {"-ne <F>", "Normal epsilon for the conversion"},
+               {"-shadersasbitmap", "(only for ase) use the shader names as \\*BITMAP key so they work as prefabs"},
+       };
+
+       HelpOptions("Converting & Decompiling", 0, 80, convert, sizeof(convert)/sizeof(struct HelpOption));
+}
+
+void HelpExport()
+{
+       struct HelpOption exportl[] = {
+               {"-export <filename.bsp>", "Copies lightmaps from the BSP to `filename/lightmap_0000.tga` ff"}
+       };
+
+       HelpOptions("Exporting lightmaps", 0, 80, exportl, sizeof(exportl)/sizeof(struct HelpOption));
+}
+
+void HelpFixaas()
+{
+       struct HelpOption fixaas[] = {
+               {"-fixaas <filename.bsp>", "Switch that enters this mode"},
+       };
+
+       HelpOptions("Fixing AAS checksum", 0, 80, fixaas, sizeof(fixaas)/sizeof(struct HelpOption));
+}
+
+void HelpInfo()
+{
+       struct HelpOption info[] = {
+               {"-info <filename.bsp>", "Switch that enters this mode"},
+       };
+
+       HelpOptions("Get info about BSP file", 0, 80, info, sizeof(info)/sizeof(struct HelpOption));
+}
+
+void HelpImport()
+{
+       struct HelpOption import[] = {
+               {"-import <filename.bsp>", "Copies lightmaps from `filename/lightmap_0000.tga` ff into the BSP"},
+       };
+
+       HelpOptions("Importing lightmaps", 0, 80, import, sizeof(import)/sizeof(struct HelpOption));
+}
+
+void HelpMinimap()
+{
+       struct HelpOption minimap[] = {
+               {"-minimap <filename.bsp>", "Creates a minimap of the BSP, by default writes to `../gfx/filename_mini.tga`"},
+               {"-black", "Write the minimap as a black-on-transparency RGBA32 image"},
+               {"-boost <F>", "Sets the contrast boost value (higher values make a brighter image); contrast boost is somewhat similar to gamma, but continuous even at zero"},
+               {"-border <F>", "Sets the amount of border pixels relative to the total image size"},
+               {"-gray", "Write the minimap as a white-on-black GRAY8 image"},
+               {"-keepaspect", "Ensure the aspect ratio is kept (the minimap is then letterboxed to keep aspect)"},
+               {"-minmax <xmin ymin zmin xmax ymax zmax>", "Forces specific map dimensions (note: the minimap actually uses these dimensions, scaled to the target size while keeping aspect with centering, and 1/64 of border appended to all sides)"},
+               {"-nokeepaspect", "Do not ensure the aspect ratio is kept (makes it easier to use the image in your code, but looks bad together with sharpening)"},
+               {"-o <filename.tga>", "Sets the output file name"},
+               {"-random <N>", "Sets the randomized supersampling count (cannot be combined with `-samples`)"},
+               {"-samples <N>", "Sets the ordered supersampling count (cannot be combined with `-random`)"},
+               {"-sharpen <F>", "Sets the sharpening coefficient"},
+               {"-size <N>", "Sets the width and height of the output image"},
+               {"-white", "Write the minimap as a white-on-transparency RGBA32 image"},
+       };
+
+       HelpOptions("MiniMap", 0, 80, minimap, sizeof(minimap)/sizeof(struct HelpOption));
+}
+
+void HelpCommon()
+{
+       struct HelpOption common[] = {
+               {"-connect <address>", "Talk to a NetRadiant instance using a specific XML based protocol"},
+               {"-force", "Allow reading some broken/unsupported BSP files e.g. when decompiling, may also crash"},
+               {"-fs_basepath <path>", "Sets the given path as main directory of the game (can be used more than once to look in multiple paths)"},
+               {"-fs_game <gamename>", "Sets a different game directory name (default for Q3A: baseq3)"},
+               {"-fs_homebase <dir>", "Specifies where the user home directory name is on Linux (default for Q3A: .q3a)"},
+               {"-game <gamename>", "Load settings for the given game (default: quake3)"},
+               {"-subdivisions <F>", "multiplier for patch subdivisions quality"},
+               {"-threads <N>", "number of threads to use"},
+               {"-v", "Verbose mode"}
+       };
+
+       HelpOptions("Common Options", 0, 80, common, sizeof(common)/sizeof(struct HelpOption));
+
+}
+
+void HelpMain(const char* arg)
+{
+       printf("Usage: q3map2 [stage] [common options...] [stage options...] [stage source file]\n");
+       printf("       q3map2 -help [stage]\n\n");
+
+       HelpCommon();
+
+       struct HelpOption stages[] = {
+               {"-bsp", "BSP Stage"},
+               {"-vis", "VIS Stage"},
+               {"-light", "Light Stage"},
+               {"-analize", "Analyzing BSP-like file structure"},
+               {"-scale", "Scaling"},
+               {"-convert", "Converting & Decompiling"},
+               {"-export", "Exporting lightmaps"},
+               {"-fixaas", "Fixing AAS checksum"},
+               {"-info", "Get info about BSP file"},
+               {"-import", "Importing lightmaps"},
+               {"-minimap", "MiniMap"},
+       };
+       void(*help_funcs[])() = {
+               HelpBsp,
+               HelpVis,
+               HelpLight,
+               HelpAnalize,
+               HelpScale,
+               HelpConvert,
+               HelpExport,
+               HelpFixaas,
+               HelpInfo,
+               HelpImport,
+               HelpMinimap,
+       };
+
+       if ( arg && strlen(arg) > 0 )
+       {
+               if ( arg[0] == '-' )
+                       arg++;
+
+               unsigned i;
+               for ( i = 0; i < sizeof(stages)/sizeof(struct HelpOption); i++ )
+                       if ( strcmp(arg, stages[i].name+1) == 0 )
+                       {
+                               help_funcs[i]();
+                               return;
+                       }
+       }
+
+       HelpOptions("Stages", 0, 80, stages, sizeof(stages)/sizeof(struct HelpOption));
+}
index 6c3b165..e5bc033 100644 (file)
@@ -168,365 +168,6 @@ int FixAAS( int argc, char **argv ){
        return 0;
 }
 
-struct HelpOption
-{
-       const char* name;
-       const char* description;
-};
-
-void HelpOptions(const char* group_name, int indentation, int width, struct HelpOption* options, int count)
-{
-       indentation *= 2;
-       char* indent = malloc(indentation+1);
-       memset(indent, ' ', indentation);
-       indent[indentation] = 0;
-       printf("%s%s:\n", indent, group_name);
-       indentation += 2;
-       indent = realloc(indent, indentation+1);
-       memset(indent, ' ', indentation);
-       indent[indentation] = 0;
-
-       int i;
-       for ( i = 0; i < count; i++ )
-       {
-               int printed = printf("%s%-24s  ", indent, options[i].name);
-               int descsz = strlen(options[i].description);
-               int j = 0;
-               while ( j < descsz && descsz-j > width - printed )
-               {
-                       if ( j != 0 )
-                               printf("%s%26c",indent,' ');
-                       int fragment = width - printed;
-                       while ( fragment > 0 && options[i].description[j+fragment-1] != ' ')
-                                       fragment--;
-                       j += fwrite(options[i].description+j, sizeof(char), fragment, stdout);
-                       putchar('\n');
-                       printed = indentation+26;
-               }
-               if ( j == 0 )
-               {
-                       printf("%s\n",options[i].description+j);
-               }
-               else if ( j < descsz )
-               {
-                       printf("%s%26c%s\n",indent,' ',options[i].description+j);
-               }
-       }
-
-       putchar('\n');
-
-       free(indent);
-}
-
-void HelpBsp()
-{
-       struct HelpOption bsp[] = {
-               {"-bsp <filename.map>", "Switch that enters this stage"},
-               {"-altsplit", "Alternate BSP tree splitting weights (should give more fps)"},
-               {"-celshader <shadername>", "Sets a global cel shader name"},
-               {"-custinfoparms", "Read scripts/custinfoparms.txt"},
-               {"-debuginset", "Push all triangle vertexes towards the triangle center"},
-               {"-debugportals", "Make BSP portals visible in the map"},
-               {"-debugsurfaces", "Color the vertexes according to the index of the surface"},
-               {"-deep", "Use detail brushes in the BSP tree, but at lowest priority (should give more fps)"},
-               {"-de <F>", "Distance epsilon for plane snapping etc."},
-               {"-fakemap", "Write fakemap.map containing all world brushes"},
-               {"-flares", "Turn on support for flares (TEST?)"},
-               {"-flat", "Enable flat shading (good for combining with -celshader)"},
-               {"-fulldetail", "Treat detail brushes as structural ones"},
-               {"-leaktest", "Abort if a leak was found"},
-               {"-meta", "Combine adjacent triangles of the same texture to surfaces (ALWAYS USE THIS)"},
-               {"-minsamplesize <N>", "Sets minimum lightmap resolution in luxels/qu"},
-               {"-mi <N>", "Sets the maximum number of indexes per surface"},
-               {"-mv <N>", "Sets the maximum number of vertices of a lightmapped surface"},
-               {"-ne <F>", "Normal epsilon for plane snapping etc."},
-               {"-nocurves", "Turn off support for patches"},
-               {"-nodetail", "Leave out detail brushes"},
-               {"-noflares", "Turn off support for flares"},
-               {"-nofog", "Turn off support for fog volumes"},
-               {"-nohint", "Turn off support for hint brushes"},
-               {"-nosubdivide", "Turn off support for `q3map_tessSize` (breaks water vertex deforms)"},
-               {"-notjunc", "Do not fix T-junctions (causes cracks between triangles, do not use)"},
-               {"-nowater", "Turn off support for water, slime or lava (Stef, this is for you)"},
-               {"-np <A>", "Force all surfaces to be nonplanar with a given shade angle"},
-               {"-onlyents", "Only update entities in the BSP"},
-               {"-patchmeta", "Turn patches into triangle meshes for display"},
-               {"-rename", "Append â€œbspâ€\9d suffix to miscmodel shaders (needed for SoF2)"},
-               {"-samplesize <N>", "Sets default lightmap resolution in luxels/qu"},
-               {"-skyfix", "Turn sky box into six surfaces to work around ATI problems"},
-               {"-snap <N>", "Snap brush bevel planes to the given number of units"},
-               {"-tempname <filename.map>", "Read the MAP file from the given file name"},
-               {"-texrange <N>", "Limit per-surface texture range to the given number of units, and subdivide surfaces like with `q3map_tessSize` if this is not met"},
-               {"-tmpout", "Write the BSP file to /tmp"},
-               {"-verboseentities", "Enable `-v` only for map entities, not for the world"},
-       };
-       HelpOptions("BSP Stage", 0, 80, bsp, sizeof(bsp)/sizeof(struct HelpOption));
-}
-void HelpVis()
-{
-       struct HelpOption vis[] = {
-               {"-vis <filename.map>", "Switch that enters this stage"},
-               {"-fast", "Very fast and crude vis calculation"},
-               {"-mergeportals", "The less crude half of `-merge`, makes vis sometimes much faster but doesn't hurt fps usually"},
-               {"-merge", "Faster but still okay vis calculation"},
-               {"-nopassage", "Just use PortalFlow vis (usually less fps)"},
-               {"-nosort", "Do not sort the portals before calculating vis (usually slower)"},
-               {"-passageOnly", "Just use PassageFlow vis (usually less fps)"},
-               {"-saveprt", "Keep the PRT file after running vis (so you can run vis again)"},
-               {"-tmpin", "Use /tmp folder for input"},
-               {"-tmpout", "Use /tmp folder for output"},
-       };
-       HelpOptions("VIS Stage", 0, 80, vis, sizeof(vis)/sizeof(struct HelpOption));
-}
-void HelpLight()
-{
-       struct HelpOption light[] = {
-               {"-light <filename.map>", "Switch that enters this stage"},
-               {"-vlight <filename.map>", "Deprecated alias for `-light -fast` ... filename.map"},
-               {"-approx <N>", "Vertex light approximation tolerance (never use in conjunction with deluxemapping)"},
-               {"-areascale <F, `-area` F>", "Scaling factor for area lights (surfacelight)"},
-               {"-border", "Add a red border to lightmaps for debugging"},
-               {"-bouncegrid", "Also compute radiosity on the light grid"},
-               {"-bounceonly", "Only compute radiosity"},
-               {"-bouncescale <F>", "Scaling factor for radiosity"},
-               {"-bounce <N>", "Number of bounces for radiosity"},
-               {"-cheapgrid", "Use `-cheap` style lighting for radiosity"},
-               {"-cheap", "Abort vertex light calculations when white is reached"},
-               {"-compensate <F>", "Lightmap compensate (darkening factor applied after everything else)"},
-               {"-cpma", "CPMA vertex lighting mode"},
-               {"-custinfoparms", "Read scripts/custinfoparms.txt"},
-               {"-dark", "Darken lightmap seams"},
-               {"-debugaxis", "Color the lightmaps according to the lightmap axis"},
-               {"-debugcluster", "Color the lightmaps according to the index of the cluster"},
-               {"-debugdeluxe", "Show deluxemaps on the lightmap"},
-               {"-debugnormals", "Color the lightmaps according to the direction of the surface normal"},
-               {"-debugorigin", "Color the lightmaps according to the origin of the luxels"},
-               {"-debugsurfaces, -debugsurface", "Color the lightmaps according to the index of the surface"},
-               {"-debugunused", "This option does nothing"},
-               {"-debug", "Mark the lightmaps according to the cluster: unmapped clusters get yellow, occluded ones get pink, flooded ones get blue overlay color, otherwise red"},
-               {"-deluxemode 0", "Use modelspace deluxemaps (DarkPlaces)"},
-               {"-deluxemode 1", "Use tangentspace deluxemaps"},
-               {"-deluxe, -deluxemap", "Enable deluxemapping (light direction maps)"},
-               {"-dirtdebug, -debugdirt", "Store the dirtmaps as lightmaps for debugging"},
-               {"-dirtdepth", "Dirtmapping depth"},
-               {"-dirtgain", "Dirtmapping exponent"},
-               {"-dirtmode 0", "Ordered direction dirtmapping"},
-               {"-dirtmode 1", "Randomized direction dirtmapping"},
-               {"-dirtscale", "Dirtmapping scaling factor"},
-               {"-dirty", "Enable dirtmapping"},
-               {"-dump", "Dump radiosity from `-bounce` into numbered MAP file prefabs"},
-               {"-export", "Export lightmaps when compile finished (like `-export` mode)"},
-               {"-exposure <F>", "Lightmap exposure to better support overbright spots"},
-               {"-external", "Force external lightmaps even if at size of internal lightmaps"},
-               {"-extravisnudge", "Broken feature to nudge the luxel origin to a better vis cluster"},
-               {"-extrawide", "Deprecated alias for `-super 2 -filter`"},
-               {"-extra", "Deprecated alias for `-super 2`"},
-               {"-fastbounce", "Use `-fast` style lighting for radiosity"},
-               {"-faster", "Use a faster falloff curve for lighting; also implies `-fast`"},
-               {"-fastgrid", "Use `-fast` style lighting for the light grid"},
-               {"-fast", "Ignore tiny light contributions"},
-               {"-filter", "Lightmap filtering"},
-               {"-floodlight", "Enable floodlight (zero-effort somewhat decent lighting)"},
-               {"-gamma <F>", "Lightmap gamma"},
-               {"-gridambientscale <F>", "Scaling factor for the light grid ambient components only"},
-               {"-gridscale <F>", "Scaling factor for the light grid only"},
-               {"-keeplights", "Keep light entities in the BSP file after compile"},
-               {"-lightmapdir <directory>", "Directory to store external lightmaps (default: same as map name without extension)"},
-               {"-lightmapsize <N>", "Size of lightmaps to generate (must be a power of two)"},
-               {"-lomem", "Low memory but slower lighting mode"},
-               {"-lowquality", "Low quality floodlight (appears to currently break floodlight)"},
-               {"-minsamplesize <N>", "Sets minimum lightmap resolution in luxels/qu"},
-               {"-nocollapse", "Do not collapse identical lightmaps"},
-               {"-nodeluxe, -nodeluxemap", "Disable deluxemapping"},
-               {"-nogrid", "Disable grid light calculation (makes all entities fullbright)"},
-               {"-nolightmapsearch", "Do not optimize lightmap packing for GPU memory usage (as doing so costs fps)"},
-               {"-normalmap", "Color the lightmaps according to the direction of the surface normal (TODO is this identical to `-debugnormals`?)"},
-               {"-nostyle, -nostyles", "Disable support for light styles"},
-               {"-nosurf", "Disable tracing against surfaces (only uses BSP nodes then)"},
-               {"-notrace", "Disable shadow occlusion"},
-               {"-novertex", "Disable vertex lighting"},
-               {"-patchshadows", "Cast shadows from patches"},
-               {"-pointscale <F, `-point` F>", "Scaling factor for point lights (light entities)"},
-               {"-q3", "Use nonlinear falloff curve by default (like Q3A)"},
-               {"-samplescale <F>", "Scales all lightmap resolutions"},
-               {"-samplesize <N>", "Sets default lightmap resolution in luxels/qu"},
-               {"-samples <N>", "Adaptive supersampling quality"},
-               {"-scale <F>", "Scaling factor for all light types"},
-               {"-shadeangle <A>", "Angle for phong shading"},
-               {"-shade", "Enable phong shading at default shade angle"},
-               {"-skyscale <F, `-sky` F>", "Scaling factor for sky and sun light"},
-               {"-smooth", "Deprecated alias for `-samples 2`"},
-               {"-style, -styles", "Enable support for light styles"},
-               {"-sunonly", "Only compute sun light"},
-               {"-super <N, `-supersample` N>", "Ordered grid supersampling quality"},
-               {"-thresh <F>", "Triangle subdivision threshold"},
-               {"-trianglecheck", "Broken check that should ensure luxels apply to the right triangle"},
-               {"-trisoup", "Convert brush faces to triangle soup"},
-               {"-wolf", "Use linear falloff curve by default (like W:ET)"},
-       };
-
-       HelpOptions("Light Stage", 0, 80, light, sizeof(light)/sizeof(struct HelpOption));
-}
-
-void HelpAnalize()
-{
-       struct HelpOption analize[] = {
-               {"-analyze <filename.bsp>", "Switch that enters this mode"},
-               {"-lumpswap", "Swap byte order in the lumps"},
-       };
-
-       HelpOptions("Analyzing BSP-like file structure", 0, 80, analize, sizeof(analize)/sizeof(struct HelpOption));
-}
-void HelpScale()
-{
-       struct HelpOption scale[] = {
-               {"-scale <S filename.bsp>", "Scale uniformly"},
-               {"-scale <SX SY SZ filename.bsp>", "Scale non-uniformly"},
-               {"-scale -tex <S filename.bsp>", "Scale uniformly without texture lock"},
-               {"-scale -tex <SX SY SZ filename.bsp>", "Scale non-uniformly without texture lock"},
-       };
-       HelpOptions("Scaling", 0, 80, scale, sizeof(scale)/sizeof(struct HelpOption));
-}
-void HelpConvert()
-{
-       struct HelpOption convert[] = {
-               {"-convert <filename.bsp>", "Switch that enters this mode"},
-               {"-de <number>", "Distance epsilon for the conversion"},
-               {"-format <converter>", "Select the converter (available: map, ase, or game names)"},
-               {"-ne <F>", "Normal epsilon for the conversion"},
-               {"-shadersasbitmap", "(only for ase) use the shader names as \\*BITMAP key so they work as prefabs"},
-       };
-
-       HelpOptions("Converting & Decompiling", 0, 80, convert, sizeof(convert)/sizeof(struct HelpOption));
-}
-
-void HelpExport()
-{
-       struct HelpOption exportl[] = {
-               {"-export <filename.bsp>", "Copies lightmaps from the BSP to `filename/lightmap_0000.tga` ff"}
-       };
-
-       HelpOptions("Exporting lightmaps", 0, 80, exportl, sizeof(exportl)/sizeof(struct HelpOption));
-}
-
-void HelpFixaas()
-{
-       struct HelpOption fixaas[] = {
-               {"-fixaas <filename.bsp>", "Switch that enters this mode"},
-       };
-
-       HelpOptions("Fixing AAS checksum", 0, 80, fixaas, sizeof(fixaas)/sizeof(struct HelpOption));
-}
-
-void HelpInfo()
-{
-       struct HelpOption info[] = {
-               {"-info <filename.bsp>", "Switch that enters this mode"},
-       };
-
-       HelpOptions("Get info about BSP file", 0, 80, info, sizeof(info)/sizeof(struct HelpOption));
-}
-
-void HelpImport()
-{
-       struct HelpOption import[] = {
-               {"-import <filename.bsp>", "Copies lightmaps from `filename/lightmap_0000.tga` ff into the BSP"},
-       };
-
-       HelpOptions("Importing lightmaps", 0, 80, import, sizeof(import)/sizeof(struct HelpOption));
-}
-
-void HelpMinimap()
-{
-       struct HelpOption minimap[] = {
-               {"-minimap <filename.bsp>", "Creates a minimap of the BSP, by default writes to `../gfx/filename_mini.tga`"},
-               {"-black", "Write the minimap as a black-on-transparency RGBA32 image"},
-               {"-boost <F>", "Sets the contrast boost value (higher values make a brighter image); contrast boost is somewhat similar to gamma, but continuous even at zero"},
-               {"-border <F>", "Sets the amount of border pixels relative to the total image size"},
-               {"-gray", "Write the minimap as a white-on-black GRAY8 image"},
-               {"-keepaspect", "Ensure the aspect ratio is kept (the minimap is then letterboxed to keep aspect)"},
-               {"-minmax <xmin ymin zmin xmax ymax zmax>", "Forces specific map dimensions (note: the minimap actually uses these dimensions, scaled to the target size while keeping aspect with centering, and 1/64 of border appended to all sides)"},
-               {"-nokeepaspect", "Do not ensure the aspect ratio is kept (makes it easier to use the image in your code, but looks bad together with sharpening)"},
-               {"-o <filename.tga>", "Sets the output file name"},
-               {"-random <N>", "Sets the randomized supersampling count (cannot be combined with `-samples`)"},
-               {"-samples <N>", "Sets the ordered supersampling count (cannot be combined with `-random`)"},
-               {"-sharpen <F>", "Sets the sharpening coefficient"},
-               {"-size <N>", "Sets the width and height of the output image"},
-               {"-white", "Write the minimap as a white-on-transparency RGBA32 image"},
-       };
-
-       HelpOptions("MiniMap", 0, 80, minimap, sizeof(minimap)/sizeof(struct HelpOption));
-}
-
-void HelpCommon()
-{
-       struct HelpOption common[] = {
-               {"-connect <address>", "Talk to a NetRadiant instance using a specific XML based protocol"},
-               {"-force", "Allow reading some broken/unsupported BSP files e.g. when decompiling, may also crash"},
-               {"-fs_basepath <path>", "Sets the given path as main directory of the game (can be used more than once to look in multiple paths)"},
-               {"-fs_game <gamename>", "Sets a different game directory name (default for Q3A: baseq3)"},
-               {"-fs_homebase <dir>", "Specifies where the user home directory name is on Linux (default for Q3A: .q3a)"},
-               {"-game <gamename>", "Load settings for the given game (default: quake3)"},
-               {"-subdivisions <F>", "multiplier for patch subdivisions quality"},
-               {"-threads <N>", "number of threads to use"},
-               {"-v", "Verbose mode"}
-       };
-
-       HelpOptions("Common Options", 0, 80, common, sizeof(common)/sizeof(struct HelpOption));
-
-}
-
-void Help(const char* arg)
-{
-       printf("Usage: q3map2 [stage] [common options...] [stage options...] [stage source file]\n");
-       printf("       q3map2 -help [stage]\n\n");
-
-       HelpCommon();
-
-       struct HelpOption stages[] = {
-               {"-bsp", "BSP Stage"},
-               {"-vis", "VIS Stage"},
-               {"-light", "Light Stage"},
-               {"-analize", "Analyzing BSP-like file structure"},
-               {"-scale", "Scaling"},
-               {"-convert", "Converting & Decompiling"},
-               {"-export", "Exporting lightmaps"},
-               {"-fixaas", "Fixing AAS checksum"},
-               {"-info", "Get info about BSP file"},
-               {"-import", "Importing lightmaps"},
-               {"-minimap", "MiniMap"},
-       };
-       void(*help_funcs[])() = {
-               HelpBsp,
-               HelpVis,
-               HelpLight,
-               HelpAnalize,
-               HelpScale,
-               HelpConvert,
-               HelpExport,
-               HelpFixaas,
-               HelpInfo,
-               HelpImport,
-               HelpMinimap
-       };
-
-       if ( arg && strlen(arg) > 0 )
-       {
-               if ( arg[0] == '-' )
-                       arg++;
-
-               unsigned i;
-               for ( i = 0; i < sizeof(stages)/sizeof(struct HelpOption); i++ )
-                       if ( strcmp(arg, stages[i].name+1) == 0 )
-                       {
-                               help_funcs[i]();
-                               return;
-                       }
-       }
-
-       HelpOptions("Stages", 0, 80, stages, sizeof(stages)/sizeof(struct HelpOption));
-}
-
 /*
    main()
    q3map mojo...
@@ -555,7 +196,7 @@ int main( int argc, char **argv ){
                /* -help */
                if ( !strcmp( argv[ i ], "-h" ) || !strcmp( argv[ i ], "--help" )
                        || !strcmp( argv[ i ], "-help" ) ) {
-                       Help(argv[i+1]);
+                       HelpMain(argv[i+1]);
                        return 0;
                }
 
index 36e8fc9..46a9252 100644 (file)
@@ -1519,6 +1519,8 @@ int                         BSPInfo( int count, char **fileNames );
 int                         ScaleBSPMain( int argc, char **argv );
 int                         ConvertMain( int argc, char **argv );
 
+/* help.c */
+void                        HelpMain(const char* arg);
 
 /* path_init.c */
 game_t                      *GetGame( char *arg );
@@ -1540,7 +1542,6 @@ int                         ConvertBSPMain( int argc, char **argv );
 int                         ConvertBSPToMap( char *bspName );
 int                         ConvertBSPToMap_BP( char *bspName );
 
-
 /* convert_ase.c */
 int                         ConvertBSPToASE( char *bspName );