q3map2: add missing help for q3map2 stage arguments

Move -keeplights help from -light stage to -bsp. Add other ~40 arguments
that were missing from help. My main focus was on the -convert stage
but I tried to document the rest as well. Some descriptions are copied
from message when enabling the option.

tools/quake3/q3map2/help.c

@@ -86,7 +86,7 @@ void HelpOptions(const char* group_name, int indentation, int width, struct Help
 void HelpBsp()
 {
 	struct HelpOption bsp[] = {
-		{"-bsp <filename.map>", "Switch that enters this stage"},
+		{"-bsp [options] <filename.map>", "Switch that enters this stage"},
 		{"-altsplit", "Alternate BSP tree splitting weights (should give more fps)"},
 		{"-bspfile <filename.bsp>", "BSP file to write"},
 		{"-celshader <shadername>", "Sets a global cel shader name"},
@@ -97,12 +97,17 @@ void HelpBsp()
 		{"-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?)"},
+		{"-flares", "Turn on support for flares"},
 		{"-flat", "Enable flat shading (good for combining with -celshader)"},
 		{"-fulldetail", "Treat detail brushes as structural ones"},
+		{"-keeplights", "Keep light entities in the BSP file after compile"},
 		{"-leaktest", "Abort if a leak was found"},
-		{"-linefile <filename.lin>", "Line file to write"},
+		{"-linfile <filename.lin>", "Line file to write"},
+		{"-maxarea", "Use Max Area face surface generation"},
 		{"-meta", "Combine adjacent triangles of the same texture to surfaces (ALWAYS USE THIS)"},
+		{"-metaadequatescore <N>", "Adequate score for adding triangles to meta surfaces"},
+		{"-metagoodscore <N>", "Good score for adding triangles to meta surfaces"},
+		{"-metamaxbboxdistance <F>", "Maximum bounding box distance for meta surfaces"},
 		{"-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"},
@@ -112,6 +117,9 @@ void HelpBsp()
 		{"-noflares", "Turn off support for flares"},
 		{"-nofog", "Turn off support for fog volumes"},
 		{"-nohint", "Turn off support for hint brushes"},
+		{"-nosRGB", "Treat colors and textures as linear colorspace"},
+		{"-nosRGBcolor", "Treat shader and light entity colors as linear colorspace"},
+		{"-nosRGBtex", "Treat textures as linear colorspace"},
 		{"-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)"},
@@ -124,6 +132,8 @@ void HelpBsp()
 		{"-skyfix", "Turn sky box into six surfaces to work around ATI problems"},
 		{"-snap <N>", "Snap brush bevel planes to the given number of units"},
 		{"-srffile <filename.srf>", "Surface file to write"},
+		{"-sRGBcolor", "Treat shader and light entity colors as sRGB colorspace"},
+		{"-sRGBtex", "Treat textures as sRGB colorspace"},
 		{"-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"},
@@ -135,7 +145,7 @@ void HelpBsp()
 void HelpVis()
 {
 	struct HelpOption vis[] = {
-		{"-vis <filename.map>", "Switch that enters this stage"},
+		{"-vis [options] <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"},
@@ -146,6 +156,7 @@ void HelpVis()
 		{"-saveprt", "Keep the Portal file after running vis (so you can run vis again)"},
 		{"-tmpin", "Use /tmp folder for input"},
 		{"-tmpout", "Use /tmp folder for output"},
+		{"-v -v", "Extra verbose mode for cluster debug"}, // q3map2 common takes first -v
 	};
 	HelpOptions("VIS Stage", 0, 80, vis, sizeof(vis)/sizeof(struct HelpOption));
 }
@@ -153,8 +164,8 @@ void HelpVis()
 void HelpLight()
 {
 	struct HelpOption light[] = {
-		{"-light <filename.map>", "Switch that enters this stage"},
+		{"-light [options] <filename.map>", "Switch that enters this stage"},
-		{"-vlight <filename.map>", "Deprecated alias for `-light -fast` ... filename.map"},
+		{"-vlight [options] <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"},
@@ -191,6 +202,7 @@ void HelpLight()
 		{"-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"},
+		{"-extradist <F>", "Extra distance for lights in map units"},
 		{"-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`"},
@@ -200,12 +212,16 @@ void HelpLight()
 		{"-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"},
+		{"-fill", "Fill lightmap colors from surrounding pixels to improve JPEG compression"},
 		{"-filter", "Lightmap filtering"},
 		{"-floodlight", "Enable floodlight (zero-effort somewhat decent lighting)"},
 		{"-gamma <F>", "Lightmap gamma"},
+		{"-gridambientdirectionality <F>", "Ambient directional lighting received (default: 0.0)"},
 		{"-gridambientscale <F>", "Scaling factor for the light grid ambient components only"},
+		{"-griddirectionality <F>", "Directional lighting received (default: 1.0)"},
 		{"-gridscale <F>", "Scaling factor for the light grid only"},
-		{"-keeplights", "Keep light entities in the BSP file after compile"},
+		{"-lightanglehl 0", "Disable half lambert light angle attenuation"},
+		{"-lightanglehl 1", "Enable half lambert light angle attenuation"},
 		{"-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"},
@@ -213,25 +229,39 @@ void HelpLight()
 		{"-minsamplesize <N>", "Sets minimum lightmap resolution in luxels/qu"},
 		{"-nocollapse", "Do not collapse identical lightmaps"},
 		{"-nodeluxe, -nodeluxemap", "Disable deluxemapping"},
+		{"-nofastpoint", "Disable fast point light calculation"},
 		{"-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`?)"},
+		{"-nosRGB", "Treat colors, textures, and lightmaps as linear colorspace"},
+		{"-nosRGBcolor", "Treat shader and light entity colors as linear colorspace"},
+		{"-nosRGBlight", "Write lightmaps as linear colorspace"},
+		{"-nosRGBtex", "Treat textures as linear colorspace"},
 		{"-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)"},
+		{"-pointscale <F, `-point` F>", "Scaling factor for spherical and spot point lights (light entities)"},
 		{"-q3", "Use nonlinear falloff curve by default (like Q3A)"},
+		{"-randomsamples", "Use random sampling for lightmaps"},
+		{"-rawlightmapsizelimit <N>", "Sets maximum lightmap resolution in luxels/qu (only affects patches if used -patchmeta in BSP stage)"},
 		{"-samplescale <F>", "Scales all lightmap resolutions"},
 		{"-samplesize <N>", "Sets default lightmap resolution in luxels/qu"},
+		{"-samplessearchboxsize <N>", "Search box size (1 to 4) for lightmap adaptive supersampling"},
 		{"-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`"},
+		{"-sphericalscale <F, `-spherical` F>", "Scaling factor for spherical point light entities"},
+		{"-spotscale <F, `-spot` F>", "Scaling factor for spot point light entities"},
 		{"-srffile <filename.srf>", "Surface file to read"},
+		{"-sRGB", "Treat colors, textures, and lightmaps as sRGB colorspace"},
+		{"-sRGBcolor", "Treat shader and light entity colors as sRGB colorspace"},
+		{"-sRGBlight", "Write lightmaps as sRGB colorspace"},
+		{"-sRGBtex", "Treat textures as sRGB colorspace"},
 		{"-style, -styles", "Enable support for light styles"},
 		{"-sunonly", "Only compute sun light"},
 		{"-super <N, `-supersample` N>", "Ordered grid supersampling quality"},
@@ -247,7 +277,7 @@ void HelpLight()
 void HelpAnalyze()
 {
 	struct HelpOption analyze[] = {
-		{"-analyze <filename.bsp>", "Switch that enters this mode"},
+		{"-analyze [options] <filename.bsp>", "Switch that enters this mode"},
 		{"-lumpswap", "Swap byte order in the lumps"},
 	};
 
@@ -257,10 +287,10 @@ void HelpAnalyze()
 void HelpScale()
 {
 	struct HelpOption scale[] = {
-		{"-scale <S filename.bsp>", "Scale uniformly"},
+		{"-scale [options] <S filename.bsp>", "Scale uniformly"},
-		{"-scale <SX SY SZ filename.bsp>", "Scale non-uniformly"},
+		{"-scale [options] <SX SY SZ filename.bsp>", "Scale non-uniformly"},
-		{"-scale -tex <S filename.bsp>", "Scale uniformly without texture lock"},
+		{"-tex", "Scale without texture lock"},
-		{"-scale -tex <SX SY SZ filename.bsp>", "Scale non-uniformly without texture lock"},
+		{"-spawn_ref <F>", "Vertical offset for info_player_* entities (adds spawn_ref, scales, subtracts spawn_ref)"},
 	};
 	HelpOptions("Scaling", 0, 80, scale, sizeof(scale)/sizeof(struct HelpOption));
 }
@@ -268,11 +298,17 @@ void HelpScale()
 void HelpConvert()
 {
 	struct HelpOption convert[] = {
-		{"-convert <filename.bsp>", "Switch that enters this mode"},
+		{"-convert [options] <filename.bsp>", "Switch that enters this mode"},
-		{"-de <number>", "Distance epsilon for the conversion"},
+		{"-deluxemapsastexcoord", "Save deluxemap names and texcoords instead of textures (only when writing ase and obj)"},
-		{"-format <converter>", "Select the converter (available: map, ase, or game names)"},
+		{"-de <F>", "Distance epsilon for the conversion (only when reading map)"},
-		{"-ne <F>", "Normal epsilon for the conversion"},
+		{"-format <converter>", "Select the converter, default ase (available: map, map_bp, ase, obj, or game names)"},
-		{"-shadersasbitmap", "(only for ase) use the shader names as \\*BITMAP key so they work as prefabs"},
+		{"-lightmapsastexcoord", "Save lightmap names and texcoords instead of textures (only when writing ase and obj)"},
+		{"-meta", "Combine adjacent triangles of the same texture to surfaces (only when reading map)"},
+		{"-ne <F>", "Normal epsilon for the conversion (only when reading map)"},
+		{"-patchmeta", "Turn patches into triangle meshes for display (only when reading map)"},
+		{"-readbsp", "Force converting bsp to selected format"},
+		{"-readmap", "Force converting map to selected format"},
+		{"-shadersasbitmap", "Save shader names as bitmap names in the model so it works as a prefab (only when writing ase and obj)"},
 	};
 
 	HelpOptions("Converting & Decompiling", 0, 80, convert, sizeof(convert)/sizeof(struct HelpOption));
@@ -325,13 +361,17 @@ void HelpImport()
 void HelpMinimap()
 {
 	struct HelpOption minimap[] = {
-		{"-minimap <filename.bsp>", "Creates a minimap of the BSP, by default writes to `../gfx/filename_mini.tga`"},
+		{"-minimap [options] <filename.bsp>", "Creates a minimap of the BSP, by default writes to `../gfx/filename_mini.tga`"},
+		{"-autolevel", "Automatically level brightness and contrast"},
 		{"-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"},
+		{"-brightness <F>", "Sets brightness value to add to minimap values"},
+		{"-contrast <F>", "Sets contrast value to scale minimap values (doesn't affect brightness)"},
 		{"-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)"},
+		{"-noautolevel", "Do not automatically level brightness and contrast"},
 		{"-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`)"},
@@ -350,9 +390,15 @@ void HelpCommon()
 		{"-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_forbiddenpath <pattern>", "Pattern to ignore directories, pk3, and pk3dir; example pak?.pk3 (can be used more than once to look for multiple patterns)"},
 		{"-fs_game <gamename>", "Sets a different game directory name (default for Q3A: baseq3, can be used more than once)"},
-		{"-fs_homebase <dir>", "Specifies where the user home directory name is on Linux (default for Q3A: .q3a)"},
+		{"-fs_home <dir>", "Specifies where the user home directory is on Linux"},
-		{"-fs_pakpath <dir>", "Specify a package directory (can be used more than once to look in multiple paths)"},
+		{"-fs_homebase <dir>", "Specifies game home directory relative to user home directory on Linux (default for Q3A: .q3a)"},
+		{"-fs_homepath <path>", "Sets the given path as the game home directory name (fs_home + fs_homebase)"},
+		{"-fs_nobasepath", "Do not load base paths in VFS, imply -fs_nomagicpath"},
+		{"-fs_nomagicpath", "Do not try to guess base path magically"},
+		{"-fs_nohomepath", "Do not load home path in VFS"},
+		{"-fs_pakpath <path>", "Specify a package directory (can be used more than once to look in multiple paths)"},
 		{"-game <gamename>", "Load settings for the given game (default: quake3)"},
 		{"-subdivisions <F>", "multiplier for patch subdivisions quality"},
 		{"-threads <N>", "number of threads to use"},

tools/quake3/q3map2/vis.c

@@ -1148,7 +1148,7 @@ int VisMain( int argc, char **argv ){
 		}
 		else if ( !strcmp( argv[ i ], "-v" ) ) {
 			debugCluster = qtrue;
-			Sys_Printf( "Extra verbous mode enabled\n" );
+			Sys_Printf( "Extra verbose mode enabled\n" );
 		}
 		else if ( !strcmp( argv[i], "-tmpin" ) ) {
 			strcpy( inbase, "/tmp" );