From: Mattia Basaglia Date: Mon, 20 Jul 2015 09:37:51 +0000 (+0200) Subject: Add help options to q3map2 X-Git-Tag: xonotic-v0.8.1~1^2~2^2 X-Git-Url: https://git.rm.cloudns.org/?a=commitdiff_plain;h=13d728bd47e001094424eaa5f19239f63936b248;p=xonotic%2Fnetradiant.git Add help options to q3map2 Closes #9 --- diff --git a/tools/quake3/q3map2/main.c b/tools/quake3/q3map2/main.c index 76591a2a..8517b0bc 100644 --- a/tools/quake3/q3map2/main.c +++ b/tools/quake3/q3map2/main.c @@ -1705,6 +1705,364 @@ int ConvertBSPMain( int argc, char **argv ){ } +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 ", "Switch that enters this stage"}, + {"-altsplit", "Alternate BSP tree splitting weights (should give more fps)"}, + {"-celshader ", "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 ", "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 ", "Sets minimum lightmap resolution in luxels/qu"}, + {"-mi ", "Sets the maximum number of indexes per surface"}, + {"-mv ", "Sets the maximum number of vertices of a lightmapped surface"}, + {"-ne ", "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 ", "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” suffix to miscmodel shaders (needed for SoF2)"}, + {"-samplesize ", "Sets default lightmap resolution in luxels/qu"}, + {"-skyfix", "Turn sky box into six surfaces to work around ATI problems"}, + {"-snap ", "Snap brush bevel planes to the given number of units"}, + {"-tempname ", "Read the MAP file from the given file name"}, + {"-texrange ", "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 ", "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 ", "Switch that enters this stage"}, + {"-vlight ", "Deprecated alias for `-light -fast` ... filename.map"}, + {"-approx ", "Vertex light approximation tolerance (never use in conjunction with deluxemapping)"}, + {"-areascale ", "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 ", "Scaling factor for radiosity"}, + {"-bounce ", "Number of bounces for radiosity"}, + {"-cheapgrid", "Use `-cheap` style lighting for radiosity"}, + {"-cheap", "Abort vertex light calculations when white is reached"}, + {"-compensate ", "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 ", "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 ", "Lightmap gamma"}, + {"-gridambientscale ", "Scaling factor for the light grid ambient components only"}, + {"-gridscale ", "Scaling factor for the light grid only"}, + {"-keeplights", "Keep light entities in the BSP file after compile"}, + {"-lightmapdir ", "Directory to store external lightmaps (default: same as map name without extension)"}, + {"-lightmapsize ", "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 ", "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 ", "Scaling factor for point lights (light entities)"}, + {"-q3", "Use nonlinear falloff curve by default (like Q3A)"}, + {"-samplescale ", "Scales all lightmap resolutions"}, + {"-samplesize ", "Sets default lightmap resolution in luxels/qu"}, + {"-samples ", "Adaptive supersampling quality"}, + {"-scale ", "Scaling factor for all light types"}, + {"-shadeangle ", "Angle for phong shading"}, + {"-shade", "Enable phong shading at default shade angle"}, + {"-skyscale ", "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 ", "Ordered grid supersampling quality"}, + {"-thresh ", "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 ", "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 ", "Scale uniformly"}, + {"-scale ", "Scale non-uniformly"}, + {"-scale -tex ", "Scale uniformly without texture lock"}, + {"-scale -tex ", "Scale non-uniformly without texture lock"}, + }; + HelpOptions("Scaling", 0, 80, scale, sizeof(scale)/sizeof(struct HelpOption)); +} +void HelpConvert() +{ + struct HelpOption convert[] = { + {"-convert ", "Switch that enters this mode"}, + {"-de ", "Distance epsilon for the conversion"}, + {"-format ", "Select the converter (available: map, ase, or game names)"}, + {"-ne ", "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 ", "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 ", "Switch that enters this mode"}, + }; + + HelpOptions("Fixing AAS checksum", 0, 80, fixaas, sizeof(fixaas)/sizeof(struct HelpOption)); +} + +void HelpInfo() +{ + struct HelpOption info[] = { + {"-info ", "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 ", "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 ", "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 ", "Sets the contrast boost value (higher values make a brighter image); contrast boost is somewhat similar to gamma, but continuous even at zero"}, + {"-border ", "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 ", "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 ", "Sets the output file name"}, + {"-random ", "Sets the randomized supersampling count (cannot be combined with `-samples`)"}, + {"-samples ", "Sets the ordered supersampling count (cannot be combined with `-random`)"}, + {"-sharpen ", "Sets the sharpening coefficient"}, + {"-size ", "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
", "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 ", "Sets the given path as main directory of the game (can be used more than once to look in multiple paths)"}, + {"-fs_game ", "Sets a different game directory name (default for Q3A: baseq3)"}, + {"-fs_homebase ", "Specifies where the user home directory name is on Linux (default for Q3A: .q3a)"}, + {"-game ", "Load settings for the given game (default: quake3)"}, + {"-subdivisions ", "multiplier for patch subdivisions quality"}, + {"-threads ", "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() @@ -1731,6 +2089,13 @@ int main( int argc, char **argv ){ /* read general options first */ for ( i = 1; i < argc; i++ ) { + /* -help */ + if ( !strcmp( argv[ i ], "-h" ) || !strcmp( argv[ i ], "--help" ) + || !strcmp( argv[ i ], "-help" ) ) { + Help(argv[i+1]); + return 0; + } + /* -connect */ if ( !strcmp( argv[ i ], "-connect" ) ) { argv[ i ] = NULL;