q3map2: add missing help for q3map2 stage arguments 150/head
authorZack Middleton <zack@cloemail.com>
Wed, 24 Jul 2019 06:24:09 +0000 (01:24 -0500)
committerZack Middleton <zack@cloemail.com>
Fri, 26 Jul 2019 15:18:25 +0000 (10:18 -0500)
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
tools/quake3/q3map2/vis.c

index 3291709..1c99d3c 100644 (file)
@@ -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"},
                {"-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"},
                {"-hint", "Merge all but hint portals"},
                {"-mergeportals", "The less crude half of `-merge`, makes vis sometimes much faster but doesn't hurt fps usually"},
@@ -147,6 +157,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));
 }
@@ -154,8 +165,8 @@ void HelpVis()
 void HelpLight()
 {
        struct HelpOption light[] = {
-               {"-light <filename.map>", "Switch that enters this stage"},
-               {"-vlight <filename.map>", "Deprecated alias for `-light -fast` ... filename.map"},
+               {"-light [options] <filename.map>", "Switch that enters this stage"},
+               {"-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"},
@@ -192,6 +203,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)"},
                {"-lightmapsearchblocksize <N>", "Restrict lightmap search to block size <N>"},
                {"-lightmapsearchpower <N>", "Optimize for lightmap merge power <N>"},
@@ -216,25 +232,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"},
@@ -250,7 +280,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"},
        };
 
@@ -260,10 +290,10 @@ void HelpAnalyze()
 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"},
+               {"-scale [options] <S filename.bsp>", "Scale uniformly"},
+               {"-scale [options] <SX SY SZ filename.bsp>", "Scale non-uniformly"},
+               {"-tex", "Scale 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));
 }
@@ -271,11 +301,17 @@ void HelpScale()
 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"},
+               {"-convert [options] <filename.bsp>", "Switch that enters this mode"},
+               {"-deluxemapsastexcoord", "Save deluxemap names and texcoords instead of textures (only when writing ase and obj)"},
+               {"-de <F>", "Distance epsilon for the conversion (only when reading map)"},
+               {"-format <converter>", "Select the converter, default ase (available: map, map_bp, ase, obj, or game names)"},
+               {"-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));
@@ -328,13 +364,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`)"},
@@ -353,9 +393,11 @@ void HelpCommon()
                {"-connect <address>", "Talk to a " RADIANT_NAME " 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_homepath <path>", "Sets the given path as home directory name"},
+               {"-fs_home <dir>", "Specifies where the user home directory is on Linux"},
+               {"-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"},
index 7623590..bd33c49 100644 (file)
@@ -1142,7 +1142,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" );