quick/netradiant-custom
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Q3map2:

Browse Source 
* 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 <dir>: 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)
This commit is contained in:
Garux 2017-08-02 09:16:24 +03:00
parent 804c20949d
commit ed4c8c2044
9 changed files with 868 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@ -511,8 +511,10 @@ $(INSTALLDIR)/q3map2.$(EXE): \
tools/quake3/q3map2/convert_obj.o \ tools/quake3/q3map2/convert_obj.o \
tools/quake3/q3map2/convert_map.o \ tools/quake3/q3map2/convert_map.o \
tools/quake3/q3map2/decals.o \ tools/quake3/q3map2/decals.o \
tools/quake3/q3map2/exportents.o \
tools/quake3/q3map2/facebsp.o \ tools/quake3/q3map2/facebsp.o \
tools/quake3/q3map2/fog.o \ tools/quake3/q3map2/fog.o \
tools/quake3/q3map2/help.o \
tools/quake3/q3map2/image.o \ tools/quake3/q3map2/image.o \
tools/quake3/q3map2/leakfile.o \ tools/quake3/q3map2/leakfile.o \
tools/quake3/q3map2/light_bounce.o \ tools/quake3/q3map2/light_bounce.o \

9
tools/quake3/q3map2/bspfile_abstract.c
View File

@ -450,7 +450,12 @@ void PrintBSPFileSizes( void ){
if ( numEntities <= 0 ) { if ( numEntities <= 0 ) {
ParseEntities(); 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 */ /* note that this is abstracted */
Sys_Printf( "Abstracted BSP file components (*actual sizes may differ)\n" ); Sys_Printf( "Abstracted BSP file components (*actual sizes may differ)\n" );
@ -483,6 +488,8 @@ void PrintBSPFileSizes( void ){
Sys_Printf( "%9d drawsurfaces %9d *\n", Sys_Printf( "%9d drawsurfaces %9d *\n",
numBSPDrawSurfaces, (int) ( numBSPDrawSurfaces * sizeof( *bspDrawSurfaces ) ) ); numBSPDrawSurfaces, (int) ( numBSPDrawSurfaces * sizeof( *bspDrawSurfaces ) ) );
Sys_Printf( "%9d patchsurfaces \n",
patchCount );
Sys_Printf( "%9d drawverts %9d *\n", Sys_Printf( "%9d drawverts %9d *\n",
numBSPDrawVerts, (int) ( numBSPDrawVerts * sizeof( *bspDrawVerts ) ) ); numBSPDrawVerts, (int) ( numBSPDrawVerts * sizeof( *bspDrawVerts ) ) );
Sys_Printf( "%9d drawindexes %9d\n", Sys_Printf( "%9d drawindexes %9d\n",

112
tools/quake3/q3map2/exportents.c Normal file
View File

@ -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] <mapname>\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;
}

172
tools/quake3/q3map2/game_unvanquished.h Normal file
View File

@ -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

416
tools/quake3/q3map2/help.c Normal file
View File

@ -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 <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"},
{"-custinfoparms", "Read scripts/custinfoparms.txt"},
{"-debuginset", "Push all triangle vertexes towards the triangle center"},
{"-debugportals", "Make BSP portals visible in the map"},
{"-debugsurfaces", "Color the vertexes according to the index of the surface"},
{"-deep", "Use detail brushes in the BSP tree, but at lowest priority (should give more fps)"},
{"-de <F>", "Distance epsilon for plane snapping etc."},
{"-fakemap", "Write fakemap.map containing all world brushes"},
{"-flares", "Turn on support for flares (TEST?)"},
{"-flat", "Enable flat shading (good for combining with -celshader)"},
{"-fulldetail", "Treat detail brushes as structural ones"},
{"-leaktest", "Abort if a leak was found"},
{"-linefile <filename.lin>", "Line file to write"},
{"-meta", "Combine adjacent triangles of the same texture to surfaces (ALWAYS USE THIS)"},
{"-minsamplesize <N>", "Sets minimum lightmap resolution in luxels/qu"},
{"-mi <N>", "Sets the maximum number of indexes per surface"},
{"-mv <N>", "Sets the maximum number of vertices of a lightmapped surface"},
{"-ne <F>", "Normal epsilon for plane snapping etc."},
{"-nocurves", "Turn off support for patches"},
{"-nodetail", "Leave out detail brushes"},
{"-noflares", "Turn off support for flares"},
{"-nofog", "Turn off support for fog volumes"},
{"-nohint", "Turn off support for hint brushes"},
{"-nosubdivide", "Turn off support for `q3map_tessSize` (breaks water vertex deforms)"},
{"-notjunc", "Do not fix T-junctions (causes cracks between triangles, do not use)"},
{"-nowater", "Turn off support for water, slime or lava (Stef, this is for you)"},
{"-np <A>", "Force all surfaces to be nonplanar with a given shade angle"},
{"-onlyents", "Only update entities in the BSP"},
{"-patchmeta", "Turn patches into triangle meshes for display"},
{"-prtfile <filename.prt>", "Portal file to write"},
{"-rename", "Append suffix to miscmodel shaders (needed for SoF2)"},
{"-samplesize <N>", "Sets default lightmap resolution in luxels/qu"},
{"-skyfix", "Turn sky box into six surfaces to work around ATI problems"},
{"-snap <N>", "Snap brush bevel planes to the given number of units"},
{"-srffile <filename.srf>", "Surface file to write"},
{"-tempname <filename.map>", "Read the MAP file from the given file name"},
{"-texrange <N>", "Limit per-surface texture range to the given number of units, and subdivide surfaces like with `q3map_tessSize` if this is not met"},
{"-tmpout", "Write the BSP file to /tmp"},
{"-verboseentities", "Enable `-v` only for map entities, not for the world"},
};
HelpOptions("BSP Stage", 0, 80, bsp, sizeof(bsp)/sizeof(struct HelpOption));
}
void HelpVis()
{
struct HelpOption vis[] = {
{"-vis <filename.map>", "Switch that enters this stage"},
{"-fast", "Very fast and crude vis calculation"},
{"-mergeportals", "The less crude half of `-merge`, makes vis sometimes much faster but doesn't hurt fps usually"},
{"-merge", "Faster but still okay vis calculation"},
{"-nopassage", "Just use PortalFlow vis (usually less fps)"},
{"-nosort", "Do not sort the portals before calculating vis (usually slower)"},
{"-passageOnly", "Just use PassageFlow vis (usually less fps)"},
{"-prtfile <filename.prt>", "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 <filename.map>", "Switch that enters this stage"},
{"-vlight <filename.map>", "Deprecated alias for `-light -fast` ... filename.map"},
{"-approx <N>", "Vertex light approximation tolerance (never use in conjunction with deluxemapping)"},
{"-areascale <F, `-area` F>", "Scaling factor for area lights (surfacelight)"},
{"-border", "Add a red border to lightmaps for debugging"},
{"-bouncegrid", "Also compute radiosity on the light grid"},
{"-bounceonly", "Only compute radiosity"},
{"-bouncescale <F>", "Scaling factor for radiosity"},
{"-bounce <N>", "Number of bounces for radiosity"},
{"-bspfile <filename.bsp>", "BSP file to write"},
{"-cheapgrid", "Use `-cheap` style lighting for radiosity"},
{"-cheap", "Abort vertex light calculations when white is reached"},
{"-compensate <F>", "Lightmap compensate (darkening factor applied after everything else)"},
{"-cpma", "CPMA vertex lighting mode"},
{"-custinfoparms", "Read scripts/custinfoparms.txt"},
{"-dark", "Darken lightmap seams"},
{"-debugaxis", "Color the lightmaps according to the lightmap axis"},
{"-debugcluster", "Color the lightmaps according to the index of the cluster"},
{"-debugdeluxe", "Show deluxemaps on the lightmap"},
{"-debugnormals", "Color the lightmaps according to the direction of the surface normal"},
{"-debugorigin", "Color the lightmaps according to the origin of the luxels"},
{"-debugsurfaces, -debugsurface", "Color the lightmaps according to the index of the surface"},
{"-debugunused", "This option does nothing"},
{"-debug", "Mark the lightmaps according to the cluster: unmapped clusters get yellow, occluded ones get pink, flooded ones get blue overlay color, otherwise red"},
{"-deluxemode 0", "Use modelspace deluxemaps (DarkPlaces)"},
{"-deluxemode 1", "Use tangentspace deluxemaps"},
{"-deluxe, -deluxemap", "Enable deluxemapping (light direction maps)"},
{"-dirtdebug, -debugdirt", "Store the dirtmaps as lightmaps for debugging"},
{"-dirtdepth", "Dirtmapping depth"},
{"-dirtgain", "Dirtmapping exponent"},
{"-dirtmode 0", "Ordered direction dirtmapping"},
{"-dirtmode 1", "Randomized direction dirtmapping"},
{"-dirtscale", "Dirtmapping scaling factor"},
{"-dirty", "Enable dirtmapping"},
{"-dump", "Dump radiosity from `-bounce` into numbered MAP file prefabs"},
{"-export", "Export lightmaps when compile finished (like `-export` mode)"},
{"-exposure <F>", "Lightmap exposure to better support overbright spots"},
{"-external", "Force external lightmaps even if at size of internal lightmaps"},
{"-extravisnudge", "Broken feature to nudge the luxel origin to a better vis cluster"},
{"-extrawide", "Deprecated alias for `-super 2 -filter`"},
{"-extra", "Deprecated alias for `-super 2`"},
{"-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 <F>", "Lightmap gamma"},
{"-gridambientscale <F>", "Scaling factor for the light grid ambient components only"},
{"-gridscale <F>", "Scaling factor for the light grid only"},
{"-keeplights", "Keep light entities in the BSP file after compile"},
{"-lightmapdir <directory>", "Directory to store external lightmaps (default: same as map name without extension)"},
{"-lightmapsize <N>", "Size of lightmaps to generate (must be a power of two)"},
{"-lomem", "Low memory but slower lighting mode"},
{"-lowquality", "Low quality floodlight (appears to currently break floodlight)"},
{"-minsamplesize <N>", "Sets minimum lightmap resolution in luxels/qu"},
{"-nocollapse", "Do not collapse identical lightmaps"},
{"-nodeluxe, -nodeluxemap", "Disable deluxemapping"},
{"-nogrid", "Disable grid light calculation (makes all entities fullbright)"},
{"-nolightmapsearch", "Do not optimize lightmap packing for GPU memory usage (as doing so costs fps)"},
{"-normalmap", "Color the lightmaps according to the direction of the surface normal (TODO is this identical to `-debugnormals`?)"},
{"-nostyle, -nostyles", "Disable support for light styles"},
{"-nosurf", "Disable tracing against surfaces (only uses BSP nodes then)"},
{"-notrace", "Disable shadow occlusion"},
{"-novertex", "Disable vertex lighting"},
{"-patchshadows", "Cast shadows from patches"},
{"-pointscale <F, `-point` F>", "Scaling factor for point lights (light entities)"},
{"-q3", "Use nonlinear falloff curve by default (like Q3A)"},
{"-samplescale <F>", "Scales all lightmap resolutions"},
{"-samplesize <N>", "Sets default lightmap resolution in luxels/qu"},
{"-samples <N>", "Adaptive supersampling quality"},
{"-scale <F>", "Scaling factor for all light types"},
{"-shadeangle <A>", "Angle for phong shading"},
{"-shade", "Enable phong shading at default shade angle"},
{"-skyscale <F, `-sky` F>", "Scaling factor for sky and sun light"},
{"-smooth", "Deprecated alias for `-samples 2`"},
{"-srffile <filename.srf>", "Surface file to read"},
{"-style, -styles", "Enable support for light styles"},
{"-sunonly", "Only compute sun light"},
{"-super <N, `-supersample` N>", "Ordered grid supersampling quality"},
{"-thresh <F>", "Triangle subdivision threshold"},
{"-trianglecheck", "Broken check that should ensure luxels apply to the right triangle"},
{"-trisoup", "Convert brush faces to triangle soup"},
{"-wolf", "Use linear falloff curve by default (like W:ET)"},
};
HelpOptions("Light Stage", 0, 80, light, sizeof(light)/sizeof(struct HelpOption));
}
void HelpAnalyze()
{
struct HelpOption analyze[] = {
{"-analyze <filename.bsp>", "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 <S filename.bsp>", "Scale uniformly"},
{"-scale <SX SY SZ filename.bsp>", "Scale non-uniformly"},
{"-scale -tex <S filename.bsp>", "Scale uniformly without texture lock"},
{"-scale -tex <SX SY SZ filename.bsp>", "Scale non-uniformly without texture lock"},
};
HelpOptions("Scaling", 0, 80, scale, sizeof(scale)/sizeof(struct HelpOption));
}
void HelpConvert()
{
struct HelpOption convert[] = {
{"-convert <filename.bsp>", "Switch that enters this mode"},
{"-de <number>", "Distance epsilon for the conversion"},
{"-format <converter>", "Select the converter (available: map, ase, or game names)"},
{"-ne <F>", "Normal epsilon for the conversion"},
{"-shadersasbitmap", "(only for ase) use the shader names as \\*BITMAP key so they work as prefabs"},
};
HelpOptions("Converting & Decompiling", 0, 80, convert, sizeof(convert)/sizeof(struct HelpOption));
}
void HelpExport()
{
struct HelpOption exportl[] = {
{"-export <filename.bsp>", "Copies lightmaps from the BSP to `filename/lightmap_0000.tga` ff"}
};
HelpOptions("Exporting lightmaps", 0, 80, exportl, sizeof(exportl)/sizeof(struct HelpOption));
}
void HelpExportEnts()
{
struct HelpOption exportents[] = {
{"-exportents <filename.bsp>", "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 <filename.bsp>", "Switch that enters this mode"},
};
HelpOptions("Fixing AAS checksum", 0, 80, fixaas, sizeof(fixaas)/sizeof(struct HelpOption));
}
void HelpInfo()
{
struct HelpOption info[] = {
{"-info <filename.bsp>", "Switch that enters this mode"},
};
HelpOptions("Get info about BSP file", 0, 80, info, sizeof(info)/sizeof(struct HelpOption));
}
void HelpImport()
{
struct HelpOption import[] = {
{"-import <filename.bsp>", "Copies lightmaps from `filename/lightmap_0000.tga` ff into the BSP"},
};
HelpOptions("Importing lightmaps", 0, 80, import, sizeof(import)/sizeof(struct HelpOption));
}
void HelpMinimap()
{
struct HelpOption minimap[] = {
{"-minimap <filename.bsp>", "Creates a minimap of the BSP, by default writes to `../gfx/filename_mini.tga`"},
{"-black", "Write the minimap as a black-on-transparency RGBA32 image"},
{"-boost <F>", "Sets the contrast boost value (higher values make a brighter image); contrast boost is somewhat similar to gamma, but continuous even at zero"},
{"-border <F>", "Sets the amount of border pixels relative to the total image size"},
{"-gray", "Write the minimap as a white-on-black GRAY8 image"},
{"-keepaspect", "Ensure the aspect ratio is kept (the minimap is then letterboxed to keep aspect)"},
{"-minmax <xmin ymin zmin xmax ymax zmax>", "Forces specific map dimensions (note: the minimap actually uses these dimensions, scaled to the target size while keeping aspect with centering, and 1/64 of border appended to all sides)"},
{"-nokeepaspect", "Do not ensure the aspect ratio is kept (makes it easier to use the image in your code, but looks bad together with sharpening)"},
{"-o <filename.tga>", "Sets the output file name"},
{"-random <N>", "Sets the randomized supersampling count (cannot be combined with `-samples`)"},
{"-samples <N>", "Sets the ordered supersampling count (cannot be combined with `-random`)"},
{"-sharpen <F>", "Sets the sharpening coefficient"},
{"-size <N>", "Sets the width and height of the output image"},
{"-white", "Write the minimap as a white-on-transparency RGBA32 image"},
};
HelpOptions("MiniMap", 0, 80, minimap, sizeof(minimap)/sizeof(struct HelpOption));
}
void HelpCommon()
{
struct HelpOption common[] = {
{"-connect <address>", "Talk to a NetRadiant instance using a specific XML based protocol"},
{"-force", "Allow reading some broken/unsupported BSP files e.g. when decompiling, may also crash"},
{"-fs_basepath <path>", "Sets the given path as main directory of the game (can be used more than once to look in multiple paths)"},
{"-fs_game <gamename>", "Sets a different game directory name (default for Q3A: baseq3, can be used more than once)"},
{"-fs_homebase <dir>", "Specifies where the user home directory name is on Linux (default for Q3A: .q3a)"},
{"-fs_pakpath <dir>", "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"},
{"-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));
}

73
tools/quake3/q3map2/light_bounce.c
View File

@ -428,13 +428,15 @@ static void RadSample( int lightmapNum, bspDrawSurface_t *ds, rawLightmap_t *lm,
#define RADIOSITY_MIN 0.0001f #define RADIOSITY_MIN 0.0001f
#define RADIOSITY_CLIP_EPSILON 0.125f #define RADIOSITY_CLIP_EPSILON 0.125f
static void RadSubdivideDiffuseLight( int lightmapNum, bspDrawSurface_t *ds, rawLightmap_t *lm, shaderInfo_t *si, 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; int i, style = 0;
float dist, area, value; float dist, area, value;
vec3_t mins, maxs, normal, d1, d2, cross, color, gradient; vec3_t mins, maxs, normal, d1, d2, cross, color, gradient;
light_t *light, *splash; light_t *light, *splash;
winding_t *w; winding_t *w, *splash_w;
/* dummy check */ /* 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 ); RadClipWindingEpsilon( rw, normal, dist, RADIOSITY_CLIP_EPSILON, &front, &back, cw );
/* recurse */ /* recurse */
RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, qfalse, &front, cw ); RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, &front, cw );
RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, qfalse, &back, cw ); RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, &back, cw );
return; return;
} }
} }
@ -490,7 +492,7 @@ static void RadSubdivideDiffuseLight( int lightmapNum, bspDrawSurface_t *ds, raw
/* if color gradient is too high, subdivide again */ /* if color gradient is too high, subdivide again */
if ( subdivide > minDiffuseSubdivide && if ( subdivide > minDiffuseSubdivide &&
( gradient[ 0 ] > RADIOSITY_MAX_GRADIENT || gradient[ 1 ] > RADIOSITY_MAX_GRADIENT || gradient[ 2 ] > RADIOSITY_MAX_GRADIENT ) ) { ( 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; return;
} }
} }
@ -580,28 +582,78 @@ static void RadSubdivideDiffuseLight( int lightmapNum, bspDrawSurface_t *ds, raw
VectorMA( light->origin, 1.0f, light->normal, light->origin ); VectorMA( light->origin, 1.0f, light->normal, light->origin );
light->dist = DotProduct( light->origin, normal ); light->dist = DotProduct( light->origin, normal );
/* optionally create a point backsplash light for first pass */ #if 0
if ( original && si->backsplashFraction > 0 ) { /* optionally create a point backsplash light */
if ( si->backsplashFraction > 0 ) {
/* allocate a new point light */ /* allocate a new point light */
splash = safe_malloc( sizeof( *splash ) ); splash = safe_malloc( sizeof( *splash ) );
memset( splash, 0, sizeof( *splash ) ); memset( splash, 0, sizeof( *splash ) );
splash->next = lights; splash->next = lights;
lights = splash; lights = splash;
/* set it up */ /* set it up */
splash->flags = LIGHT_Q3A_DEFAULT; splash->flags = LIGHT_Q3A_DEFAULT;
splash->type = EMIT_POINT; splash->type = EMIT_POINT;
splash->photons = light->photons * si->backsplashFraction; splash->photons = light->photons * si->backsplashFraction;
splash->fade = 1.0f; splash->fade = 1.0f;
splash->si = si; splash->si = si;
VectorMA( light->origin, si->backsplashDistance, normal, splash->origin ); VectorMA( light->origin, si->backsplashDistance, normal, splash->origin );
VectorCopy( si->color, splash->color ); VectorCopy( si->color, splash->color );
splash->falloffTolerance = falloffTolerance; splash->falloffTolerance = falloffTolerance;
splash->style = noStyles ? LS_NORMAL : light->style; splash->style = noStyles ? LS_NORMAL : light->style;
/* add to counts */ /* add to counts */
numPointLights++; 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 else
{ {
@ -640,7 +692,6 @@ static void RadSubdivideDiffuseLight( int lightmapNum, bspDrawSurface_t *ds, raw
} }
/* /*
RadLightForTriangles() RadLightForTriangles()
creates unbounced diffuse lights for triangle soup (misc_models, etc) 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 */ /* 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 */ /* 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 */ /* generate 2 tris */
@ -817,7 +868,7 @@ void RadLightForPatch( int num, int lightmapNum, rawLightmap_t *lm, shaderInfo_t
} }
/* subdivide into area lights */ /* subdivide into area lights */
RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, qtrue, &rw, cw ); RadSubdivideDiffuseLight( lightmapNum, ds, lm, si, scale, subdivide, &rw, cw );
} }
} }
} }

14
tools/quake3/q3map2/main.c
View File

@ -3718,6 +3718,13 @@ int main( int argc, char **argv ){
/* read general options first */ /* read general options first */
for ( i = 1; i < argc; i++ ) 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 */ /* -connect */
if ( !strcmp( argv[ i ], "-connect" ) ) { if ( !strcmp( argv[ i ], "-connect" ) ) {
argv[ i ] = NULL; argv[ i ] = NULL;
@ -3807,7 +3814,7 @@ int main( int argc, char **argv ){
/* check if we have enough options left to attempt something */ /* check if we have enough options left to attempt something */
if ( argc < 2 ) { 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 */ /* fixaas */
@ -3842,6 +3849,11 @@ int main( int argc, char **argv ){
r = LightMain( argc, argv ); r = LightMain( argc, argv );
} }
/* QBall: export entities */
else if ( !strcmp( argv[ 1 ], "-exportents" ) ) {
r = ExportEntitiesMain( argc - 1, argv + 1 );
}
/* ydnar: lightmap export */ /* ydnar: lightmap export */
else if ( !strcmp( argv[ 1 ], "-export" ) ) { else if ( !strcmp( argv[ 1 ], "-export" ) ) {
r = ExportLightmapsMain( argc - 1, argv + 1 ); r = ExportLightmapsMain( argc - 1, argv + 1 );

80
tools/quake3/q3map2/path_init.c
View File

@ -41,6 +41,7 @@
/* path support */ /* path support */
#define MAX_BASE_PATHS 10 #define MAX_BASE_PATHS 10
#define MAX_GAME_PATHS 10 #define MAX_GAME_PATHS 10
#define MAX_PAK_PATHS 200
char *homePath; char *homePath;
char installPath[ MAX_OS_PATH ]; char installPath[ MAX_OS_PATH ];
@ -49,6 +50,8 @@ int numBasePaths;
char *basePaths[ MAX_BASE_PATHS ]; char *basePaths[ MAX_BASE_PATHS ];
int numGamePaths; int numGamePaths;
char *gamePaths[ MAX_GAME_PATHS ]; char *gamePaths[ MAX_GAME_PATHS ];
int numPakPaths;
char *pakPaths[ MAX_PAK_PATHS ];
char *homeBasePath = NULL; char *homeBasePath = NULL;
@ -119,7 +122,6 @@ void LokiInitPaths( char *argv0 ){
strcpy( installPath, "../" ); strcpy( installPath, "../" );
#else #else
char temp[ MAX_OS_PATH ]; char temp[ MAX_OS_PATH ];
char last0[ 2 ];
char *path; char *path;
char *last; char *last;
qboolean found; qboolean found;
@ -133,6 +135,25 @@ void LokiInitPaths( char *argv0 ){
argv0 = strrchr( argv0, '/' ) + 1; argv0 = strrchr( argv0, '/' ) + 1;
} }
else if ( path ) { 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; found = qfalse;
last = path; last = path;
@ -154,17 +175,20 @@ void LokiInitPaths( char *argv0 ){
path++; path++;
} }
/* concatenate */ /* concatenate */
if ( last > ( path + 1 ) ) { 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 ), "./" );
Q_strcat( temp, sizeof( temp ), argv0 ); Q_strcat( temp, sizeof( temp ), argv0 );
/* verify the path */ /* verify the path */
if ( access( temp, X_OK ) == 0 ) { if ( access( temp, X_OK ) == 0 ) {
found++; found = qtrue;
} }
path = last + 1; path = last + 1;
} }
@ -172,9 +196,12 @@ void LokiInitPaths( char *argv0 ){
/* flake */ /* flake */
if ( realpath( temp, installPath ) ) { 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, '/' ) ) = '\0';
*( strrchr( installPath, '/' ) + 1 ) = '\0';
} }
#endif #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 = "."; homeBasePath = ".";
argv[ i ] = NULL; 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 */ /* 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 */ /* done */
Sys_Printf( "\n" ); Sys_Printf( "\n" );
} }

9
tools/quake3/q3map2/q3map2.h
View File

@ -1521,6 +1521,8 @@ int ScaleBSPMain( int argc, char **argv );
int ShiftBSPMain( int argc, char **argv ); int ShiftBSPMain( int argc, char **argv );
int ConvertMain( int argc, char **argv ); int ConvertMain( int argc, char **argv );
/* help.c */
void HelpMain(const char* arg);
/* path_init.c */ /* path_init.c */
game_t *GetGame( char *arg ); game_t *GetGame( char *arg );
@ -1841,6 +1843,11 @@ void StitchSurfaceLightmaps( void );
void StoreSurfaceLightmaps( void ); void StoreSurfaceLightmaps( void );
/* exportents.c */
void ExportEntities( void );
int ExportEntitiesMain( int argc, char **argv );
/* image.c */ /* image.c */
void ImageFree( image_t *image ); void ImageFree( image_t *image );
image_t *ImageFind( const char *filename ); 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_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_tremulous.h" /*LinuxManMikeC: must be after game_quake3.h, depends on #define's set in it */
,
#include "game_unvanquished.h"
, ,
#include "game_tenebrae.h" #include "game_tenebrae.h"
, ,