From ed4c8c204443726e852a4c8927b3f8d2571cc522 Mon Sep 17 00:00:00 2001 From: Garux Date: Wed, 2 Aug 2017 09:16:24 +0300 Subject: [PATCH] Q3map2: * new area lights backsplash algorithm ( by Jelvan ), hijacking temp area lights ( to simulate volumetric behavior of source ones ) * fix: create backsplash for area lights, while q3map_lightsubdivide'ing too * no backsplash for area lights, if surf == sky * report patches count in -info * -exportents to exports entities to a .ent file * unvanquished game support * -fs_basepath: can be used more than once to look in multiple paths (Sets the given path as main directory of the game) * -fs_game: can be used more than once (Sets a different game directory name (default for Q3A: baseq3)) * -fs_pakpath : Specify additional custom path to assets (can be used more than once to look in multiple paths) * fix undocumented unexpected LokiInitPaths * -help option (-h, --help) --- Makefile | 2 + tools/quake3/q3map2/bspfile_abstract.c | 9 +- tools/quake3/q3map2/exportents.c | 112 +++++++ tools/quake3/q3map2/game_unvanquished.h | 172 ++++++++++ tools/quake3/q3map2/help.c | 416 ++++++++++++++++++++++++ tools/quake3/q3map2/light_bounce.c | 73 ++++- tools/quake3/q3map2/main.c | 14 +- tools/quake3/q3map2/path_init.c | 80 ++++- tools/quake3/q3map2/q3map2.h | 9 + 9 files changed, 868 insertions(+), 19 deletions(-) create mode 100644 tools/quake3/q3map2/exportents.c create mode 100644 tools/quake3/q3map2/game_unvanquished.h create mode 100644 tools/quake3/q3map2/help.c diff --git a/Makefile b/Makefile index bcb1f6f6..48081b15 100644 --- a/Makefile +++ b/Makefile @@ -511,8 +511,10 @@ $(INSTALLDIR)/q3map2.$(EXE): \ tools/quake3/q3map2/convert_obj.o \ tools/quake3/q3map2/convert_map.o \ tools/quake3/q3map2/decals.o \ + tools/quake3/q3map2/exportents.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/bspfile_abstract.c b/tools/quake3/q3map2/bspfile_abstract.c index 6ec7e21c..8aad9091 100644 --- a/tools/quake3/q3map2/bspfile_abstract.c +++ b/tools/quake3/q3map2/bspfile_abstract.c @@ -450,7 +450,12 @@ void PrintBSPFileSizes( void ){ if ( numEntities <= 0 ) { ParseEntities(); } - + int patchCount = 0; + bspDrawSurface_t *s; + for ( s = bspDrawSurfaces; s != bspDrawSurfaces + numBSPDrawSurfaces; ++s ){ + if ( s->surfaceType == MST_PATCH ) + ++patchCount; + } /* note that this is abstracted */ Sys_Printf( "Abstracted BSP file components (*actual sizes may differ)\n" ); @@ -483,6 +488,8 @@ void PrintBSPFileSizes( void ){ Sys_Printf( "%9d drawsurfaces %9d *\n", numBSPDrawSurfaces, (int) ( numBSPDrawSurfaces * sizeof( *bspDrawSurfaces ) ) ); + Sys_Printf( "%9d patchsurfaces \n", + patchCount ); Sys_Printf( "%9d drawverts %9d *\n", numBSPDrawVerts, (int) ( numBSPDrawVerts * sizeof( *bspDrawVerts ) ) ); Sys_Printf( "%9d drawindexes %9d\n", diff --git a/tools/quake3/q3map2/exportents.c b/tools/quake3/q3map2/exportents.c new file mode 100644 index 00000000..578f9e42 --- /dev/null +++ b/tools/quake3/q3map2/exportents.c @@ -0,0 +1,112 @@ +/* ------------------------------------------------------------------------------- + + Copyright (C) 1999-2013 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." + + ------------------------------------------------------------------------------- */ + + + +/* marker */ +#define EXPORTENTS_C + + + +/* dependencies */ +#include "q3map2.h" + + + + +/* ------------------------------------------------------------------------------- + + this file contains code that exports entities to a .ent file. + + ------------------------------------------------------------------------------- */ + +/* + ExportEntities() + exports the entities to a text file (.ent) + */ + +void ExportEntities( void ){ + char filename[ 1024 ]; + FILE *file; + + /* note it */ + Sys_FPrintf( SYS_VRB, "--- ExportEntities ---\n" ); + + /* do some path mangling */ + strcpy( filename, source ); + StripExtension( filename ); + strcat( filename, ".ent" ); + + /* sanity check */ + if ( bspEntData == NULL || bspEntDataSize == 0 ) { + Sys_Printf( "WARNING: No BSP entity data. aborting...\n" ); + return; + } + + /* write it */ + Sys_Printf( "Writing %s\n", filename ); + Sys_FPrintf( SYS_VRB, "(%d bytes)\n", bspEntDataSize ); + file = fopen( filename, "w" ); + + if ( file == NULL ) { + Error( "Unable to open %s for writing", filename ); + } + + fprintf( file, "%s\n", bspEntData ); + fclose( file ); +} + + + +/* + ExportEntitiesMain() + exports the entities to a text file (.ent) + */ + +int ExportEntitiesMain( int argc, char **argv ){ + /* arg checking */ + if ( argc < 1 ) { + Sys_Printf( "Usage: q3map -exportents [-v] \n" ); + return 0; + } + + /* do some path mangling */ + strcpy( source, ExpandArg( argv[ argc - 1 ] ) ); + StripExtension( source ); + DefaultExtension( source, ".bsp" ); + + /* load the bsp */ + Sys_Printf( "Loading %s\n", source ); + LoadBSPFile( source ); + + /* export the lightmaps */ + ExportEntities(); + + /* return to sender */ + return 0; +} \ No newline at end of file diff --git a/tools/quake3/q3map2/game_unvanquished.h b/tools/quake3/q3map2/game_unvanquished.h new file mode 100644 index 00000000..d623a24b --- /dev/null +++ b/tools/quake3/q3map2/game_unvanquished.h @@ -0,0 +1,172 @@ +/* ------------------------------------------------------------------------------- + +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." + +------------------------------------------------------------------------------- */ + +/* Derived from Tremulous support by LinuxManMikeC */ + + +/* marker */ +#ifndef GAME_UNVANQUISHED_H +#define GAME_UNVANQUISHED_H + + + +/* ------------------------------------------------------------------------------- + +content and surface flags - also uses defines from game_quake3.h + +------------------------------------------------------------------------------- */ + +#define UNV_CONT_NOALIENBUILD 0x1000 +#define UNV_CONT_NOHUMANBUILD 0x2000 +#define UNV_CONT_NOBUILD 0x4000 + +#define UNV_SURF_NOALIENBUILDSURFACE 0x80000 +#define UNV_SURF_NOHUMANBUILDSURFACE 0x100000 +#define UNV_SURF_NOBUILDSURFACE 0x200000 + + + +/* ------------------------------------------------------------------------------- + +game_t struct + +------------------------------------------------------------------------------- */ + +{ + "unvanquished", /* -game x */ + "pkg", /* default base game data dir */ + ".unvanquished", /* unix home sub-dir */ + "unvanquished", /* magic path word */ + "scripts", /* shader directory */ + 1048575, /* max lightmapped surface verts */ + 1048575, /* max surface verts */ + 1048575, /* max surface indexes */ + qfalse, /* flares */ + "flareshader", /* default flare shader */ + qfalse, /* wolf lighting model? */ + 128, /* lightmap width/height */ + 1.0f, /* lightmap gamma */ + qfalse, /* lightmap sRGB */ + qfalse, /* texture sRGB */ + qfalse, /* color sRGB */ + 0.0f, /* lightmap exposure */ + 1.0f, /* lightmap compensate */ + 1.0f, /* lightgrid scale */ + 1.0f, /* lightgrid ambient scale */ + qfalse, /* light angle attenuation uses half-lambert curve */ + qfalse, /* disable shader lightstyles hack */ + qtrue, /* keep light entities on bsp */ + 8, /* default patchMeta subdivisions tolerance */ + qfalse, /* patch casting enabled */ + qfalse, /* compile deluxemaps */ + 1, /* deluxemaps default mode */ + 512, /* minimap size */ + 1.0f, /* minimap sharpener */ + 0.0f, /* minimap border */ + qtrue, /* minimap keep aspect */ + MINIMAP_MODE_BLACK, /* minimap mode */ + "../minimaps/%s.tga", /* minimap name format */ + "IBSP", /* bsp file prefix */ + 46, /* bsp file version */ + qfalse, /* cod-style lump len/ofs order */ + LoadIBSPFile, /* bsp load function */ + WriteIBSPFile, /* bsp write function */ + + { + /* name contentFlags contentFlagsClear surfaceFlags surfaceFlagsClear compileFlags compileFlagsClear */ + + /* default */ + { "default", Q_CONT_SOLID, -1, 0, -1, C_SOLID, -1 }, + + /* ydnar */ + { "lightgrid", 0, 0, 0, 0, C_LIGHTGRID, 0 }, + { "antiportal", 0, 0, 0, 0, C_ANTIPORTAL, 0 }, + { "skip", 0, 0, 0, 0, C_SKIP, 0 }, + + /* compiler */ + { "origin", Q_CONT_ORIGIN, Q_CONT_SOLID, 0, 0, C_ORIGIN | C_TRANSLUCENT, C_SOLID }, + { "areaportal", Q_CONT_AREAPORTAL, Q_CONT_SOLID, 0, 0, C_AREAPORTAL | C_TRANSLUCENT, C_SOLID }, + { "trans", Q_CONT_TRANSLUCENT, 0, 0, 0, C_TRANSLUCENT, 0 }, + { "detail", Q_CONT_DETAIL, 0, 0, 0, C_DETAIL, 0 }, + { "structural", Q_CONT_STRUCTURAL, 0, 0, 0, C_STRUCTURAL, 0 }, + { "hint", 0, 0, Q_SURF_HINT, 0, C_HINT, 0 }, + { "nodraw", 0, 0, Q_SURF_NODRAW, 0, C_NODRAW, 0 }, + + { "alphashadow", 0, 0, Q_SURF_ALPHASHADOW, 0, C_ALPHASHADOW | C_TRANSLUCENT, 0 }, + { "lightfilter", 0, 0, Q_SURF_LIGHTFILTER, 0, C_LIGHTFILTER | C_TRANSLUCENT, 0 }, + { "nolightmap", 0, 0, Q_SURF_VERTEXLIT, 0, C_VERTEXLIT, 0 }, + { "pointlight", 0, 0, Q_SURF_VERTEXLIT, 0, C_VERTEXLIT, 0 }, + + /* game */ + { "nonsolid", 0, Q_CONT_SOLID, Q_SURF_NONSOLID, 0, 0, C_SOLID }, + + { "trigger", Q_CONT_TRIGGER, Q_CONT_SOLID, 0, 0, C_TRANSLUCENT, C_SOLID }, + + { "water", Q_CONT_WATER, Q_CONT_SOLID, 0, 0, C_LIQUID | C_TRANSLUCENT, C_SOLID }, + { "slime", Q_CONT_SLIME, Q_CONT_SOLID, 0, 0, C_LIQUID | C_TRANSLUCENT, C_SOLID }, + { "lava", Q_CONT_LAVA, Q_CONT_SOLID, 0, 0, C_LIQUID | C_TRANSLUCENT, C_SOLID }, + + { "playerclip", Q_CONT_PLAYERCLIP, Q_CONT_SOLID, 0, 0, C_DETAIL | C_TRANSLUCENT, C_SOLID }, + { "monsterclip", Q_CONT_MONSTERCLIP, Q_CONT_SOLID, 0, 0, C_DETAIL | C_TRANSLUCENT, C_SOLID }, + { "nodrop", Q_CONT_NODROP, Q_CONT_SOLID, 0, 0, C_TRANSLUCENT, C_SOLID }, + + { "clusterportal", Q_CONT_CLUSTERPORTAL, Q_CONT_SOLID, 0, 0, C_TRANSLUCENT, C_SOLID }, + { "donotenter", Q_CONT_DONOTENTER, Q_CONT_SOLID, 0, 0, C_TRANSLUCENT, C_SOLID }, + { "botclip", Q_CONT_BOTCLIP, Q_CONT_SOLID, 0, 0, C_TRANSLUCENT, C_SOLID }, + + { "fog", Q_CONT_FOG, Q_CONT_SOLID, 0, 0, C_FOG, C_SOLID }, + { "sky", 0, 0, Q_SURF_SKY, 0, C_SKY, 0 }, + + { "slick", 0, 0, Q_SURF_SLICK, 0, 0, 0 }, + + { "noimpact", 0, 0, Q_SURF_NOIMPACT, 0, 0, 0 }, + { "nomarks", 0, 0, Q_SURF_NOMARKS, 0, C_NOMARKS, 0 }, + { "ladder", 0, 0, Q_SURF_LADDER, 0, 0, 0 }, + { "nodamage", 0, 0, Q_SURF_NODAMAGE, 0, 0, 0 }, + { "metalsteps", 0, 0, Q_SURF_METALSTEPS, 0, 0, 0 }, + { "flesh", 0, 0, Q_SURF_FLESH, 0, 0, 0 }, + { "nosteps", 0, 0, Q_SURF_NOSTEPS, 0, 0, 0 }, + { "nodlight", 0, 0, Q_SURF_NODLIGHT, 0, 0, 0 }, + { "dust", 0, 0, Q_SURF_DUST, 0, 0, 0 }, + + /* unvanquished */ + {"noalienbuild", UNV_CONT_NOALIENBUILD, 0, 0, 0, 0, 0 }, + {"nohumanbuild", UNV_CONT_NOHUMANBUILD, 0, 0, 0, 0, 0 }, + {"nobuild", UNV_CONT_NOBUILD, 0, 0, 0, 0, 0 }, + + {"noalienbuildsurface", 0, 0, UNV_SURF_NOALIENBUILDSURFACE, 0, 0, 0 }, + {"nohumanbuildsurface", 0, 0, UNV_SURF_NOHUMANBUILDSURFACE, 0, 0, 0 }, + {"nobuildsurface", 0, 0, UNV_SURF_NOBUILDSURFACE, 0, 0, 0 }, + + /* null */ + { NULL, 0, 0, 0, 0, 0, 0 } + } +} + +/* end marker */ +#endif diff --git a/tools/quake3/q3map2/help.c b/tools/quake3/q3map2/help.c new file mode 100644 index 00000000..5cc81ab9 --- /dev/null +++ b/tools/quake3/q3map2/help.c @@ -0,0 +1,416 @@ +/* ------------------------------------------------------------------------------- + + 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 ", "Switch that enters this stage"}, + {"-altsplit", "Alternate BSP tree splitting weights (should give more fps)"}, + {"-bspfile ", "BSP file to write"}, + {"-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"}, + {"-linefile ", "Line file to write"}, + {"-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"}, + {"-prtfile ", "Portal file to write"}, + {"-rename", "Append 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"}, + {"-srffile ", "Surface file to write"}, + {"-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)"}, + {"-prtfile ", "Portal file to read"}, + {"-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"}, + }; + 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"}, + {"-bspfile ", "BSP file to write"}, + {"-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`"}, + {"-fastallocate", "Use `-fastallocate` to trade lightmap size against allocation time (useful with hi res lightmaps on large maps: reduce allocation time from days to minutes for only some extra bytes)"}, + {"-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`"}, + {"-srffile ", "Surface file to read"}, + {"-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 HelpAnalyze() +{ + struct HelpOption analyze[] = { + {"-analyze ", "Switch that enters this mode"}, + {"-lumpswap", "Swap byte order in the lumps"}, + }; + + HelpOptions("Analyzing BSP-like file structure", 0, 80, analyze, sizeof(analyze)/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 HelpExportEnts() +{ + struct HelpOption exportents[] = { + {"-exportents ", "Exports the entities to a text file (.ent)"}, + }; + HelpOptions("ExportEnts Stage", 0, 80, exportents, sizeof(exportents)/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, can be used more than once)"}, + {"-fs_homebase ", "Specifies where the user home directory name is on Linux (default for Q3A: .q3a)"}, + {"-fs_pakpath ", "Specify a package directory (can be used more than once to look in multiple paths)"}, + {"-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 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"}, + {"-analyze", "Analyzing BSP-like file structure"}, + {"-scale", "Scaling"}, + {"-convert", "Converting & Decompiling"}, + {"-export", "Exporting lightmaps"}, + {"-exportents", "Exporting entities"}, + {"-fixaas", "Fixing AAS checksum"}, + {"-info", "Get info about BSP file"}, + {"-import", "Importing lightmaps"}, + {"-minimap", "MiniMap"}, + }; + void(*help_funcs[])() = { + HelpBsp, + HelpVis, + HelpLight, + HelpAnalyze, + HelpScale, + HelpConvert, + HelpExport, + HelpExportEnts, + 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)); +} diff --git a/tools/quake3/q3map2/light_bounce.c b/tools/quake3/q3map2/light_bounce.c index cca3e601..bddbe674 100644 --- a/tools/quake3/q3map2/light_bounce.c +++ b/tools/quake3/q3map2/light_bounce.c @@ -428,13 +428,15 @@ static void RadSample( int lightmapNum, bspDrawSurface_t *ds, rawLightmap_t *lm, #define RADIOSITY_MIN 0.0001f #define RADIOSITY_CLIP_EPSILON 0.125f + + static void RadSubdivideDiffuseLight( int lightmapNum, bspDrawSurface_t *ds, rawLightmap_t *lm, shaderInfo_t *si, - float scale, float subdivide, qboolean original, radWinding_t *rw, clipWork_t *cw ){ + float scale, float subdivide, radWinding_t *rw, clipWork_t *cw ){ int i, style = 0; float dist, area, value; vec3_t mins, maxs, normal, d1, d2, cross, color, gradient; light_t *light, *splash; - winding_t *w; + winding_t *w, *splash_w; /* dummy check */ @@ -463,8 +465,8 @@ static void RadSubdivideDiffuseLight( int lightmapNum, bspDrawSurface_t *ds, raw RadClipWindingEpsilon( rw, normal, dist, RADIOSITY_CLIP_EPSILON, &front, &back, cw ); /* recurse */ - RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, qfalse, &front, cw ); - RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, qfalse, &back, cw ); + RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, &front, cw ); + RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, &back, cw ); return; } } @@ -490,7 +492,7 @@ static void RadSubdivideDiffuseLight( int lightmapNum, bspDrawSurface_t *ds, raw /* if color gradient is too high, subdivide again */ if ( subdivide > minDiffuseSubdivide && ( gradient[ 0 ] > RADIOSITY_MAX_GRADIENT || gradient[ 1 ] > RADIOSITY_MAX_GRADIENT || gradient[ 2 ] > RADIOSITY_MAX_GRADIENT ) ) { - RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, ( subdivide / 2.0f ), qfalse, rw, cw ); + RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, ( subdivide / 2.0f ), rw, cw ); return; } } @@ -580,28 +582,78 @@ static void RadSubdivideDiffuseLight( int lightmapNum, bspDrawSurface_t *ds, raw VectorMA( light->origin, 1.0f, light->normal, light->origin ); light->dist = DotProduct( light->origin, normal ); - /* optionally create a point backsplash light for first pass */ - if ( original && si->backsplashFraction > 0 ) { +#if 0 + /* optionally create a point backsplash light */ + if ( si->backsplashFraction > 0 ) { + /* allocate a new point light */ splash = safe_malloc( sizeof( *splash ) ); memset( splash, 0, sizeof( *splash ) ); + splash->next = lights; lights = splash; + /* set it up */ splash->flags = LIGHT_Q3A_DEFAULT; splash->type = EMIT_POINT; splash->photons = light->photons * si->backsplashFraction; + splash->fade = 1.0f; splash->si = si; VectorMA( light->origin, si->backsplashDistance, normal, splash->origin ); VectorCopy( si->color, splash->color ); + splash->falloffTolerance = falloffTolerance; splash->style = noStyles ? LS_NORMAL : light->style; /* add to counts */ numPointLights++; } +#endif + +#if 1 + /* optionally create area backsplash light */ + //if ( original && si->backsplashFraction > 0 ) { + if ( si->backsplashFraction > 0 && !( si->compileFlags & C_SKY ) ) { + /* allocate a new area light */ + splash = safe_malloc( sizeof( *splash ) ); + memset( splash, 0, sizeof( *splash ) ); + ThreadLock(); + splash->next = lights; + lights = splash; + ThreadUnlock(); + + /* set it up */ + splash->flags = LIGHT_AREA_DEFAULT; + splash->type = EMIT_AREA; + splash->photons = light->photons * 7.0f * si->backsplashFraction; + splash->add = light->add * 7.0f * si->backsplashFraction; + splash->fade = 1.0f; + splash->si = si; + VectorCopy( si->color, splash->color ); + VectorScale( splash->color, splash->add, splash->emitColor ); + splash->falloffTolerance = falloffTolerance; + splash->style = noStyles ? LS_NORMAL : si->lightStyle; + if ( splash->style < LS_NORMAL || splash->style >= LS_NONE ) { + splash->style = LS_NORMAL; + } + + /* create a regular winding */ + splash_w = AllocWinding( rw->numVerts ); + splash_w->numpoints = rw->numVerts; + for ( i = 0; i < rw->numVerts; i++ ) + VectorMA( rw->verts[rw->numVerts - 1 - i].xyz, si->backsplashDistance, normal, splash_w->p[ i ] ); + splash->w = splash_w; + + VectorMA( light->origin, si->backsplashDistance, normal, splash->origin ); + VectorNegate( normal, splash->normal ); + splash->dist = DotProduct( splash->origin, splash->normal ); + +// splash->flags |= LIGHT_TWOSIDED; + } +#endif + } else { @@ -640,7 +692,6 @@ static void RadSubdivideDiffuseLight( int lightmapNum, bspDrawSurface_t *ds, raw } - /* RadLightForTriangles() creates unbounced diffuse lights for triangle soup (misc_models, etc) @@ -679,7 +730,7 @@ void RadLightForTriangles( int num, int lightmapNum, rawLightmap_t *lm, shaderIn } /* subdivide into area lights */ - RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, qtrue, &rw, cw ); + RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, &rw, cw ); } } @@ -788,7 +839,7 @@ void RadLightForPatch( int num, int lightmapNum, rawLightmap_t *lm, shaderInfo_t } /* subdivide into area lights */ - RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, qtrue, &rw, cw ); + RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, &rw, cw ); } /* generate 2 tris */ @@ -817,7 +868,7 @@ void RadLightForPatch( int num, int lightmapNum, rawLightmap_t *lm, shaderInfo_t } /* subdivide into area lights */ - RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, qtrue, &rw, cw ); + RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, &rw, cw ); } } } diff --git a/tools/quake3/q3map2/main.c b/tools/quake3/q3map2/main.c index 753e5070..1b8275df 100644 --- a/tools/quake3/q3map2/main.c +++ b/tools/quake3/q3map2/main.c @@ -3718,6 +3718,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" ) ) { + HelpMain(argv[i+1]); + return 0; + } + /* -connect */ if ( !strcmp( argv[ i ], "-connect" ) ) { argv[ i ] = NULL; @@ -3807,7 +3814,7 @@ int main( int argc, char **argv ){ /* check if we have enough options left to attempt something */ if ( argc < 2 ) { - Error( "Usage: %s [general options] [options] mapfile", argv[ 0 ] ); + Error( "Usage: %s [general options] [options] mapfile\n%s -help for help", argv[ 0 ] , argv[ 0 ] ); } /* fixaas */ @@ -3842,6 +3849,11 @@ int main( int argc, char **argv ){ r = LightMain( argc, argv ); } + /* QBall: export entities */ + else if ( !strcmp( argv[ 1 ], "-exportents" ) ) { + r = ExportEntitiesMain( argc - 1, argv + 1 ); + } + /* ydnar: lightmap export */ else if ( !strcmp( argv[ 1 ], "-export" ) ) { r = ExportLightmapsMain( argc - 1, argv + 1 ); diff --git a/tools/quake3/q3map2/path_init.c b/tools/quake3/q3map2/path_init.c index 8f1b179a..b953377a 100644 --- a/tools/quake3/q3map2/path_init.c +++ b/tools/quake3/q3map2/path_init.c @@ -41,6 +41,7 @@ /* path support */ #define MAX_BASE_PATHS 10 #define MAX_GAME_PATHS 10 +#define MAX_PAK_PATHS 200 char *homePath; char installPath[ MAX_OS_PATH ]; @@ -49,6 +50,8 @@ int numBasePaths; char *basePaths[ MAX_BASE_PATHS ]; int numGamePaths; char *gamePaths[ MAX_GAME_PATHS ]; +int numPakPaths; +char *pakPaths[ MAX_PAK_PATHS ]; char *homeBasePath = NULL; @@ -119,7 +122,6 @@ void LokiInitPaths( char *argv0 ){ strcpy( installPath, "../" ); #else char temp[ MAX_OS_PATH ]; - char last0[ 2 ]; char *path; char *last; qboolean found; @@ -133,6 +135,25 @@ void LokiInitPaths( char *argv0 ){ argv0 = strrchr( argv0, '/' ) + 1; } else if ( path ) { + + /* + This code has a special behavior when q3map2 is a symbolic link. + + For each dir in ${PATH} (example: "/usr/bin", "/usr/local/bin" if ${PATH} == "/usr/bin:/usr/local/bin"), + it looks for "${dir}/q3map2" (file exists and is executable), + then it uses "dirname(realpath("${dir}/q3map2"))/../" as installPath. + + So, if "/usr/bin/q3map2" is a symbolic link to "/opt/radiant/tools/q3map2", + it will find the installPath "/usr/share/radiant/", + so q3map2 will look for "/opt/radiant/baseq3" to find paks. + + More precisely, it looks for "${dir}/${argv[0]}", + so if "/usr/bin/q3map2" is a symbolic link to "/opt/radiant/tools/q3map2", + and if "/opt/radiant/tools/q3ma2" is a symbolic link to "/opt/radiant/tools/q3map2.x86_64", + it will use "dirname("/opt/radiant/tools/q3map2.x86_64")/../" as path, + so it will use "/opt/radiant/" as installPath, which will be expanded later to "/opt/radiant/baseq3" to find paks. + */ + found = qfalse; last = path; @@ -154,17 +175,20 @@ void LokiInitPaths( char *argv0 ){ path++; } + /* concatenate */ if ( last > ( path + 1 ) ) { - Q_strncat( temp, sizeof( temp ), path, ( last - path ) ); + // +1 hack: Q_strncat calls Q_strncpyz that expects a len including '\0' + // so that extraneous char will be rewritten by '\0', so it's ok. + // Also, in this case this extraneous char is always ':' or '\0', so it's ok. + Q_strncat( temp, sizeof( temp ), path, ( last - path + 1) ); Q_strcat( temp, sizeof( temp ), "/" ); } - Q_strcat( temp, sizeof( temp ), "./" ); Q_strcat( temp, sizeof( temp ), argv0 ); /* verify the path */ if ( access( temp, X_OK ) == 0 ) { - found++; + found = qtrue; } path = last + 1; } @@ -172,9 +196,12 @@ void LokiInitPaths( char *argv0 ){ /* flake */ if ( realpath( temp, installPath ) ) { - /* q3map is in "tools/" */ + /* + if "q3map2" is "/opt/radiant/tools/q3map2", + installPath is "/opt/radiant" + */ + *( strrchr( installPath, '/' ) ) = '\0'; *( strrchr( installPath, '/' ) ) = '\0'; - *( strrchr( installPath, '/' ) + 1 ) = '\0'; } #endif } @@ -351,6 +378,24 @@ void AddGamePath( char *path ){ } +/* + AddPakPath() + adds a pak path to the list + */ + +void AddPakPath( char *path ){ + /* dummy check */ + if ( path == NULL || path[ 0 ] == '\0' || numPakPaths >= MAX_PAK_PATHS ) { + return; + } + + /* add it to the list */ + pakPaths[ numPakPaths ] = safe_malloc( strlen( path ) + 1 ); + strcpy( pakPaths[ numPakPaths ], path ); + CleanPath( pakPaths[ numPakPaths ] ); + numPakPaths++; +} + /* @@ -462,6 +507,17 @@ void InitPaths( int *argc, char **argv ){ homeBasePath = "."; argv[ i ] = NULL; } + + /* -fs_pakpath */ + else if ( strcmp( argv[ i ], "-fs_pakpath" ) == 0 ) { + if ( ++i >= *argc ) { + Error( "Out of arguments: No path specified after %s.", argv[ i - 1 ] ); + } + argv[ i - 1 ] = NULL; + AddPakPath( argv[ i ] ); + argv[ i ] = NULL; + } + } /* remove processed arguments */ @@ -545,6 +601,18 @@ void InitPaths( int *argc, char **argv ){ } } + /* initialize vfs paths */ + if ( numPakPaths > MAX_PAK_PATHS ) { + numPakPaths = MAX_PAK_PATHS; + } + + /* walk the list of pak paths */ + for ( i = 0; i < numPakPaths; i++ ) + { + /* initialize this pak path */ + vfsInitDirectory( pakPaths[ i ] ); + } + /* done */ Sys_Printf( "\n" ); } diff --git a/tools/quake3/q3map2/q3map2.h b/tools/quake3/q3map2/q3map2.h index 0629d442..e6d0e1f7 100644 --- a/tools/quake3/q3map2/q3map2.h +++ b/tools/quake3/q3map2/q3map2.h @@ -1521,6 +1521,8 @@ int ScaleBSPMain( int argc, char **argv ); int ShiftBSPMain( 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 ); @@ -1841,6 +1843,11 @@ void StitchSurfaceLightmaps( void ); void StoreSurfaceLightmaps( void ); +/* exportents.c */ +void ExportEntities( void ); +int ExportEntitiesMain( int argc, char **argv ); + + /* image.c */ void ImageFree( image_t *image ); image_t *ImageFind( const char *filename ); @@ -1949,6 +1956,8 @@ Q_EXTERN game_t games[] #include "game_xonotic.h" /* most be after game_quake3.h as they share defines! */ , #include "game_tremulous.h" /*LinuxManMikeC: must be after game_quake3.h, depends on #define's set in it */ + , + #include "game_unvanquished.h" , #include "game_tenebrae.h" , -- 2.39.2