ioquake/gtkradiant
0
0
Fork 0
mirror of https://github.com/TTimo/GtkRadiant.git synced 2025-01-10 03:51:18 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge remote-tracking branch 'refs/remotes/TTimo/master'

Browse source
This commit is contained in:
Christophe Mateos 2016-12-03 23:17:26 +01:00
commit 3fb0a994e2
11 changed files with 742 additions and 505 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
CONTRIBUTING.md Normal file
View file

@ -0,0 +1,15 @@
Here is a quick checklist for any new contributor to the project:
- Please read the [mission statement](http://icculus.org/gtkradiant/) on the project homepage.
- This project is mostly coordinated via IRC. We recommend joining the [#radiant channel on QuakeNet IRC](http://webchat.quakenet.org/#radiant) to ask questions there.
- The [mailing list](http://icculus.org/mailman/listinfo/gtkradiant) is another channel of communication with the developers.
Ok, I want to write some code! Where do I start?
- Check the list of [known issues](https://github.com/TTimo/GtkRadiant/issues).
- Use the milestones filter to find tasks that need to be worked on in priority.
- Send in pull requests!

195
tools/quake3/q3map2/bsp_analyze.c Normal file
View file

@ -0,0 +1,195 @@
/* -------------------------------------------------------------------------------
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"
/*
AnalyzeBSPMain() - ydnar
analyzes a Quake engine BSP file
*/
typedef struct abspHeader_s
{
char ident[ 4 ];
int version;
bspLump_t lumps[ 1 ]; /* unknown size */
}
abspHeader_t;
typedef struct abspLumpTest_s
{
int radix, minCount;
char *name;
}
abspLumpTest_t;
int AnalyzeBSPMain( int argc, char **argv ){
abspHeader_t *header;
int size, i, version, offset, length, lumpInt, count;
char ident[ 5 ];
void *lump;
float lumpFloat;
char lumpString[ 1024 ], source[ 1024 ];
qboolean lumpSwap = qfalse;
abspLumpTest_t *lumpTest;
static abspLumpTest_t lumpTests[] =
{
{ sizeof( bspPlane_t ), 6, "IBSP LUMP_PLANES" },
{ sizeof( bspBrush_t ), 1, "IBSP LUMP_BRUSHES" },
{ 8, 6, "IBSP LUMP_BRUSHSIDES" },
{ sizeof( bspBrushSide_t ), 6, "RBSP LUMP_BRUSHSIDES" },
{ sizeof( bspModel_t ), 1, "IBSP LUMP_MODELS" },
{ sizeof( bspNode_t ), 2, "IBSP LUMP_NODES" },
{ sizeof( bspLeaf_t ), 1, "IBSP LUMP_LEAFS" },
{ 104, 3, "IBSP LUMP_DRAWSURFS" },
{ 44, 3, "IBSP LUMP_DRAWVERTS" },
{ 4, 6, "IBSP LUMP_DRAWINDEXES" },
{ 128 * 128 * 3, 1, "IBSP LUMP_LIGHTMAPS" },
{ 256 * 256 * 3, 1, "IBSP LUMP_LIGHTMAPS (256 x 256)" },
{ 512 * 512 * 3, 1, "IBSP LUMP_LIGHTMAPS (512 x 512)" },
{ 0, 0, NULL }
};
/* arg checking */
if ( argc < 1 ) {
Sys_Printf( "Usage: q3map -analyze [-lumpswap] [-v] <mapname>\n" );
return 0;
}
/* process arguments */
for ( i = 1; i < ( argc - 1 ); i++ )
{
/* -format map|ase|... */
if ( !strcmp( argv[ i ], "-lumpswap" ) ) {
Sys_Printf( "Swapped lump structs enabled\n" );
lumpSwap = qtrue;
}
}
/* clean up map name */
strcpy( source, ExpandArg( argv[ i ] ) );
Sys_Printf( "Loading %s\n", source );
/* load the file */
size = LoadFile( source, (void**) &header );
if ( size == 0 || header == NULL ) {
Sys_Printf( "Unable to load %s.\n", source );
return -1;
}
/* analyze ident/version */
memcpy( ident, header->ident, 4 );
ident[ 4 ] = '\0';
version = LittleLong( header->version );
Sys_Printf( "Identity: %s\n", ident );
Sys_Printf( "Version: %d\n", version );
Sys_Printf( "---------------------------------------\n" );
/* analyze each lump */
for ( i = 0; i < 100; i++ )
{
/* call of duty swapped lump pairs */
if ( lumpSwap ) {
offset = LittleLong( header->lumps[ i ].length );
length = LittleLong( header->lumps[ i ].offset );
}
/* standard lump pairs */
else
{
offset = LittleLong( header->lumps[ i ].offset );
length = LittleLong( header->lumps[ i ].length );
}
/* extract data */
lump = (byte*) header + offset;
lumpInt = LittleLong( (int) *( (int*) lump ) );
lumpFloat = LittleFloat( (float) *( (float*) lump ) );
memcpy( lumpString, (char*) lump, ( length < 1024 ? length : 1024 ) );
lumpString[ 1023 ] = '\0';
/* print basic lump info */
Sys_Printf( "Lump: %d\n", i );
Sys_Printf( "Offset: %d bytes\n", offset );
Sys_Printf( "Length: %d bytes\n", length );
/* only operate on valid lumps */
if ( length > 0 ) {
/* print data in 4 formats */
Sys_Printf( "As hex: %08X\n", lumpInt );
Sys_Printf( "As int: %d\n", lumpInt );
Sys_Printf( "As float: %f\n", lumpFloat );
Sys_Printf( "As string: %s\n", lumpString );
/* guess lump type */
if ( lumpString[ 0 ] == '{' && lumpString[ 2 ] == '"' ) {
Sys_Printf( "Type guess: IBSP LUMP_ENTITIES\n" );
}
else if ( strstr( lumpString, "textures/" ) ) {
Sys_Printf( "Type guess: IBSP LUMP_SHADERS\n" );
}
else
{
/* guess based on size/count */
for ( lumpTest = lumpTests; lumpTest->radix > 0; lumpTest++ )
{
if ( ( length % lumpTest->radix ) != 0 ) {
continue;
}
count = length / lumpTest->radix;
if ( count < lumpTest->minCount ) {
continue;
}
Sys_Printf( "Type guess: %s (%d x %d)\n", lumpTest->name, count, lumpTest->radix );
}
}
}
Sys_Printf( "---------------------------------------\n" );
/* end of file */
if ( offset + length >= size ) {
break;
}
}
/* last stats */
Sys_Printf( "Lump count: %d\n", i + 1 );
Sys_Printf( "File size: %d bytes\n", size );
/* return to caller */
return 0;
}

94
tools/quake3/q3map2/bsp_info.c Normal file
View file

@ -0,0 +1,94 @@
/* -------------------------------------------------------------------------------
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"
/*
BSPInfoMain()
emits statistics about the bsp file
*/
int BSPInfoMain( int count, char **fileNames ){
int i;
char source[ 1024 ], ext[ 64 ];
int size;
FILE *f;
/* dummy check */
if ( count < 1 ) {
Sys_Printf( "No files to dump info for.\n" );
return -1;
}
/* enable info mode */
infoMode = qtrue;
/* walk file list */
for ( i = 0; i < count; i++ )
{
Sys_Printf( "---------------------------------\n" );
/* mangle filename and get size */
strcpy( source, fileNames[ i ] );
ExtractFileExtension( source, ext );
if ( !Q_stricmp( ext, "map" ) ) {
StripExtension( source );
}
DefaultExtension( source, ".bsp" );
f = fopen( source, "rb" );
if ( f ) {
size = Q_filelength( f );
fclose( f );
}
else{
size = 0;
}
/* load the bsp file and print lump sizes */
Sys_Printf( "%s\n", source );
LoadBSPFile( source );
PrintBSPFileSizes();
/* print sizes */
Sys_Printf( "\n" );
Sys_Printf( " total %9d\n", size );
Sys_Printf( " %9d KB\n", size / 1024 );
Sys_Printf( " %9d MB\n", size / ( 1024 * 1024 ) );
Sys_Printf( "---------------------------------\n" );
}
/* return count */
return i;
}

143
tools/quake3/q3map2/bsp_scale.c Normal file
View file

@ -0,0 +1,143 @@
/* -------------------------------------------------------------------------------
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"
/*
ScaleBSPMain()
amaze and confuse your enemies with wierd scaled maps!
*/
int ScaleBSPMain( int argc, char **argv ){
int i;
float f, scale;
vec3_t vec;
char str[ 1024 ];
/* arg checking */
if ( argc < 2 ) {
Sys_Printf( "Usage: q3map -scale <value> [-v] <mapname>\n" );
return 0;
}
/* get scale */
scale = atof( argv[ argc - 2 ] );
if ( scale == 0.0f ) {
Sys_Printf( "Usage: q3map -scale <value> [-v] <mapname>\n" );
Sys_Printf( "Non-zero scale value required.\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 );
ParseEntities();
/* note it */
Sys_Printf( "--- ScaleBSP ---\n" );
Sys_FPrintf( SYS_VRB, "%9d entities\n", numEntities );
/* scale entity keys */
for ( i = 0; i < numBSPEntities && i < numEntities; i++ )
{
/* scale origin */
GetVectorForKey( &entities[ i ], "origin", vec );
if ( ( vec[ 0 ] + vec[ 1 ] + vec[ 2 ] ) ) {
VectorScale( vec, scale, vec );
sprintf( str, "%f %f %f", vec[ 0 ], vec[ 1 ], vec[ 2 ] );
SetKeyValue( &entities[ i ], "origin", str );
}
/* scale door lip */
f = FloatForKey( &entities[ i ], "lip" );
if ( f ) {
f *= scale;
sprintf( str, "%f", f );
SetKeyValue( &entities[ i ], "lip", str );
}
}
/* scale models */
for ( i = 0; i < numBSPModels; i++ )
{
VectorScale( bspModels[ i ].mins, scale, bspModels[ i ].mins );
VectorScale( bspModels[ i ].maxs, scale, bspModels[ i ].maxs );
}
/* scale nodes */
for ( i = 0; i < numBSPNodes; i++ )
{
VectorScale( bspNodes[ i ].mins, scale, bspNodes[ i ].mins );
VectorScale( bspNodes[ i ].maxs, scale, bspNodes[ i ].maxs );
}
/* scale leafs */
for ( i = 0; i < numBSPLeafs; i++ )
{
VectorScale( bspLeafs[ i ].mins, scale, bspLeafs[ i ].mins );
VectorScale( bspLeafs[ i ].maxs, scale, bspLeafs[ i ].maxs );
}
/* scale drawverts */
for ( i = 0; i < numBSPDrawVerts; i++ )
VectorScale( bspDrawVerts[ i ].xyz, scale, bspDrawVerts[ i ].xyz );
/* scale planes */
for ( i = 0; i < numBSPPlanes; i++ )
bspPlanes[ i ].dist *= scale;
/* scale gridsize */
GetVectorForKey( &entities[ 0 ], "gridsize", vec );
if ( ( vec[ 0 ] + vec[ 1 ] + vec[ 2 ] ) == 0.0f ) {
VectorCopy( gridSize, vec );
}
VectorScale( vec, scale, vec );
sprintf( str, "%f %f %f", vec[ 0 ], vec[ 1 ], vec[ 2 ] );
SetKeyValue( &entities[ 0 ], "gridsize", str );
/* write the bsp */
UnparseEntities();
StripExtension( source );
DefaultExtension( source, "_s.bsp" );
Sys_Printf( "Writing %s\n", source );
WriteBSPFile( source );
/* return to sender */
return 0;
}

113
tools/quake3/q3map2/convert_bsp.c Normal file
View file

@ -0,0 +1,113 @@
/* -------------------------------------------------------------------------------
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"
/*
ConvertBSPMain()
main argument processing function for bsp conversion
*/
int ConvertBSPMain( int argc, char **argv ){
int i;
int ( *convertFunc )( char * );
game_t *convertGame;
/* set default */
convertFunc = ConvertBSPToASE;
convertGame = NULL;
/* arg checking */
if ( argc < 1 ) {
Sys_Printf( "Usage: q3map -convert [-format <ase|map>] [-v] <mapname>\n" );
return 0;
}
/* process arguments */
for ( i = 1; i < ( argc - 1 ); i++ )
{
/* -format map|ase|... */
if ( !strcmp( argv[ i ], "-format" ) ) {
i++;
if ( !Q_stricmp( argv[ i ], "ase" ) ) {
convertFunc = ConvertBSPToASE;
}
else if ( !Q_stricmp( argv[ i ], "map" ) ) {
convertFunc = ConvertBSPToMap;
}
else
{
convertGame = GetGame( argv[ i ] );
if ( convertGame == NULL ) {
Sys_Printf( "Unknown conversion format \"%s\". Defaulting to ASE.\n", argv[ i ] );
}
}
}
}
/* clean up map name */
strcpy( source, ExpandArg( argv[ i ] ) );
StripExtension( source );
DefaultExtension( source, ".bsp" );
LoadShaderInfo();
Sys_Printf( "Loading %s\n", source );
/* ydnar: load surface file */
//% LoadSurfaceExtraFile( source );
LoadBSPFile( source );
/* parse bsp entities */
ParseEntities();
/* bsp format convert? */
if ( convertGame != NULL ) {
/* set global game */
game = convertGame;
/* write bsp */
StripExtension( source );
DefaultExtension( source, "_c.bsp" );
Sys_Printf( "Writing %s\n", source );
WriteBSPFile( source );
/* return to sender */
return 0;
}
/* normal convert */
return convertFunc( source );
}

119
tools/quake3/q3map2/fixaas.c Normal file
View file

@ -0,0 +1,119 @@
/* -------------------------------------------------------------------------------
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"
/*
MD4BlockChecksum()
calculates an md4 checksum for a block of data
*/
static int MD4BlockChecksum( void * buffer, int length ) {
unsigned char digest[16];
int checksum;
md4_get_digest( buffer, length, digest );
/* I suppose it has to be done that way for legacy reasons? */
checksum = digest[0] & ( digest[1] << 8 ) & ( digest[2] << 16 ) & ( digest[3] << 24 );
checksum ^= digest[4] & ( digest[5] << 8 ) & ( digest[6] << 16 ) & ( digest[7] << 24 );
checksum ^= digest[8] & ( digest[9] << 8 ) & ( digest[10] << 16 ) & ( digest[11] << 24 );
checksum ^= digest[12] & ( digest[13] << 8 ) & ( digest[14] << 16 ) & ( digest[15] << 24 );
return checksum;
}
/*
FixAASMain()
resets an aas checksum to match the given BSP
*/
int FixAASMain( int argc, char **argv ){
int length, checksum;
void *buffer;
FILE *file;
char aas[ 1024 ], **ext;
char *exts[] =
{
".aas",
"_b0.aas",
"_b1.aas",
NULL
};
/* arg checking */
if ( argc < 2 ) {
Sys_Printf( "Usage: q3map -fixaas [-v] <mapname>\n" );
return 0;
}
/* do some path mangling */
strcpy( source, ExpandArg( argv[ argc - 1 ] ) );
StripExtension( source );
DefaultExtension( source, ".bsp" );
/* note it */
Sys_Printf( "--- FixAAS ---\n" );
/* load the bsp */
Sys_Printf( "Loading %s\n", source );
length = LoadFile( source, &buffer );
/* create bsp checksum */
Sys_Printf( "Creating checksum...\n" );
checksum = LittleLong( MD4BlockChecksum( buffer, length ) );
/* write checksum to aas */
ext = exts;
while ( *ext )
{
/* mangle name */
strcpy( aas, source );
StripExtension( aas );
strcat( aas, *ext );
Sys_Printf( "Trying %s\n", aas );
ext++;
/* fix it */
file = fopen( aas, "r+b" );
if ( !file ) {
continue;
}
if ( fwrite( &checksum, 4, 1, file ) != 1 ) {
Error( "Error writing checksum to %s", aas );
}
fclose( file );
}
/* return to sender */
return 0;
}

504
tools/quake3/q3map2/main.c
View file

@ -91,504 +91,6 @@ static void ExitQ3Map( void ){
}
}
static int MD4BlockChecksum( void * buffer, int length ) {
unsigned char digest[16];
int checksum;
md4_get_digest( buffer, length, digest );
/* I suppose it has to be done that way for legacy reasons? */
checksum = digest[0] & ( digest[1] << 8 ) & ( digest[2] << 16 ) & ( digest[3] << 24 );
checksum ^= digest[4] & ( digest[5] << 8 ) & ( digest[6] << 16 ) & ( digest[7] << 24 );
checksum ^= digest[8] & ( digest[9] << 8 ) & ( digest[10] << 16 ) & ( digest[11] << 24 );
checksum ^= digest[12] & ( digest[13] << 8 ) & ( digest[14] << 16 ) & ( digest[15] << 24 );
return checksum;
}
/*
FixAAS()
resets an aas checksum to match the given BSP
*/
int FixAAS( int argc, char **argv ){
int length, checksum;
void *buffer;
FILE *file;
char aas[ 1024 ], **ext;
char *exts[] =
{
".aas",
"_b0.aas",
"_b1.aas",
NULL
};
/* arg checking */
if ( argc < 2 ) {
Sys_Printf( "Usage: q3map -fixaas [-v] <mapname>\n" );
return 0;
}
/* do some path mangling */
strcpy( source, ExpandArg( argv[ argc - 1 ] ) );
StripExtension( source );
DefaultExtension( source, ".bsp" );
/* note it */
Sys_Printf( "--- FixAAS ---\n" );
/* load the bsp */
Sys_Printf( "Loading %s\n", source );
length = LoadFile( source, &buffer );
/* create bsp checksum */
Sys_Printf( "Creating checksum...\n" );
checksum = LittleLong( MD4BlockChecksum( buffer, length ) );
/* write checksum to aas */
ext = exts;
while ( *ext )
{
/* mangle name */
strcpy( aas, source );
StripExtension( aas );
strcat( aas, *ext );
Sys_Printf( "Trying %s\n", aas );
ext++;
/* fix it */
file = fopen( aas, "r+b" );
if ( !file ) {
continue;
}
if ( fwrite( &checksum, 4, 1, file ) != 1 ) {
Error( "Error writing checksum to %s", aas );
}
fclose( file );
}
/* return to sender */
return 0;
}
/*
AnalyzeBSP() - ydnar
analyzes a Quake engine BSP file
*/
typedef struct abspHeader_s
{
char ident[ 4 ];
int version;
bspLump_t lumps[ 1 ]; /* unknown size */
}
abspHeader_t;
typedef struct abspLumpTest_s
{
int radix, minCount;
char *name;
}
abspLumpTest_t;
int AnalyzeBSP( int argc, char **argv ){
abspHeader_t *header;
int size, i, version, offset, length, lumpInt, count;
char ident[ 5 ];
void *lump;
float lumpFloat;
char lumpString[ 1024 ], source[ 1024 ];
qboolean lumpSwap = qfalse;
abspLumpTest_t *lumpTest;
static abspLumpTest_t lumpTests[] =
{
{ sizeof( bspPlane_t ), 6, "IBSP LUMP_PLANES" },
{ sizeof( bspBrush_t ), 1, "IBSP LUMP_BRUSHES" },
{ 8, 6, "IBSP LUMP_BRUSHSIDES" },
{ sizeof( bspBrushSide_t ), 6, "RBSP LUMP_BRUSHSIDES" },
{ sizeof( bspModel_t ), 1, "IBSP LUMP_MODELS" },
{ sizeof( bspNode_t ), 2, "IBSP LUMP_NODES" },
{ sizeof( bspLeaf_t ), 1, "IBSP LUMP_LEAFS" },
{ 104, 3, "IBSP LUMP_DRAWSURFS" },
{ 44, 3, "IBSP LUMP_DRAWVERTS" },
{ 4, 6, "IBSP LUMP_DRAWINDEXES" },
{ 128 * 128 * 3, 1, "IBSP LUMP_LIGHTMAPS" },
{ 256 * 256 * 3, 1, "IBSP LUMP_LIGHTMAPS (256 x 256)" },
{ 512 * 512 * 3, 1, "IBSP LUMP_LIGHTMAPS (512 x 512)" },
{ 0, 0, NULL }
};
/* arg checking */
if ( argc < 1 ) {
Sys_Printf( "Usage: q3map -analyze [-lumpswap] [-v] <mapname>\n" );
return 0;
}
/* process arguments */
for ( i = 1; i < ( argc - 1 ); i++ )
{
/* -format map|ase|... */
if ( !strcmp( argv[ i ], "-lumpswap" ) ) {
Sys_Printf( "Swapped lump structs enabled\n" );
lumpSwap = qtrue;
}
}
/* clean up map name */
strcpy( source, ExpandArg( argv[ i ] ) );
Sys_Printf( "Loading %s\n", source );
/* load the file */
size = LoadFile( source, (void**) &header );
if ( size == 0 || header == NULL ) {
Sys_Printf( "Unable to load %s.\n", source );
return -1;
}
/* analyze ident/version */
memcpy( ident, header->ident, 4 );
ident[ 4 ] = '\0';
version = LittleLong( header->version );
Sys_Printf( "Identity: %s\n", ident );
Sys_Printf( "Version: %d\n", version );
Sys_Printf( "---------------------------------------\n" );
/* analyze each lump */
for ( i = 0; i < 100; i++ )
{
/* call of duty swapped lump pairs */
if ( lumpSwap ) {
offset = LittleLong( header->lumps[ i ].length );
length = LittleLong( header->lumps[ i ].offset );
}
/* standard lump pairs */
else
{
offset = LittleLong( header->lumps[ i ].offset );
length = LittleLong( header->lumps[ i ].length );
}
/* extract data */
lump = (byte*) header + offset;
lumpInt = LittleLong( (int) *( (int*) lump ) );
lumpFloat = LittleFloat( (float) *( (float*) lump ) );
memcpy( lumpString, (char*) lump, ( length < 1024 ? length : 1024 ) );
lumpString[ 1023 ] = '\0';
/* print basic lump info */
Sys_Printf( "Lump: %d\n", i );
Sys_Printf( "Offset: %d bytes\n", offset );
Sys_Printf( "Length: %d bytes\n", length );
/* only operate on valid lumps */
if ( length > 0 ) {
/* print data in 4 formats */
Sys_Printf( "As hex: %08X\n", lumpInt );
Sys_Printf( "As int: %d\n", lumpInt );
Sys_Printf( "As float: %f\n", lumpFloat );
Sys_Printf( "As string: %s\n", lumpString );
/* guess lump type */
if ( lumpString[ 0 ] == '{' && lumpString[ 2 ] == '"' ) {
Sys_Printf( "Type guess: IBSP LUMP_ENTITIES\n" );
}
else if ( strstr( lumpString, "textures/" ) ) {
Sys_Printf( "Type guess: IBSP LUMP_SHADERS\n" );
}
else
{
/* guess based on size/count */
for ( lumpTest = lumpTests; lumpTest->radix > 0; lumpTest++ )
{
if ( ( length % lumpTest->radix ) != 0 ) {
continue;
}
count = length / lumpTest->radix;
if ( count < lumpTest->minCount ) {
continue;
}
Sys_Printf( "Type guess: %s (%d x %d)\n", lumpTest->name, count, lumpTest->radix );
}
}
}
Sys_Printf( "---------------------------------------\n" );
/* end of file */
if ( offset + length >= size ) {
break;
}
}
/* last stats */
Sys_Printf( "Lump count: %d\n", i + 1 );
Sys_Printf( "File size: %d bytes\n", size );
/* return to caller */
return 0;
}
/*
BSPInfo()
emits statistics about the bsp file
*/
int BSPInfo( int count, char **fileNames ){
int i;
char source[ 1024 ], ext[ 64 ];
int size;
FILE *f;
/* dummy check */
if ( count < 1 ) {
Sys_Printf( "No files to dump info for.\n" );
return -1;
}
/* enable info mode */
infoMode = qtrue;
/* walk file list */
for ( i = 0; i < count; i++ )
{
Sys_Printf( "---------------------------------\n" );
/* mangle filename and get size */
strcpy( source, fileNames[ i ] );
ExtractFileExtension( source, ext );
if ( !Q_stricmp( ext, "map" ) ) {
StripExtension( source );
}
DefaultExtension( source, ".bsp" );
f = fopen( source, "rb" );
if ( f ) {
size = Q_filelength( f );
fclose( f );
}
else{
size = 0;
}
/* load the bsp file and print lump sizes */
Sys_Printf( "%s\n", source );
LoadBSPFile( source );
PrintBSPFileSizes();
/* print sizes */
Sys_Printf( "\n" );
Sys_Printf( " total %9d\n", size );
Sys_Printf( " %9d KB\n", size / 1024 );
Sys_Printf( " %9d MB\n", size / ( 1024 * 1024 ) );
Sys_Printf( "---------------------------------\n" );
}
/* return count */
return i;
}
/*
ScaleBSPMain()
amaze and confuse your enemies with wierd scaled maps!
*/
int ScaleBSPMain( int argc, char **argv ){
int i;
float f, scale;
vec3_t vec;
char str[ 1024 ];
/* arg checking */
if ( argc < 2 ) {
Sys_Printf( "Usage: q3map -scale <value> [-v] <mapname>\n" );
return 0;
}
/* get scale */
scale = atof( argv[ argc - 2 ] );
if ( scale == 0.0f ) {
Sys_Printf( "Usage: q3map -scale <value> [-v] <mapname>\n" );
Sys_Printf( "Non-zero scale value required.\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 );
ParseEntities();
/* note it */
Sys_Printf( "--- ScaleBSP ---\n" );
Sys_FPrintf( SYS_VRB, "%9d entities\n", numEntities );
/* scale entity keys */
for ( i = 0; i < numBSPEntities && i < numEntities; i++ )
{
/* scale origin */
GetVectorForKey( &entities[ i ], "origin", vec );
if ( ( vec[ 0 ] + vec[ 1 ] + vec[ 2 ] ) ) {
VectorScale( vec, scale, vec );
sprintf( str, "%f %f %f", vec[ 0 ], vec[ 1 ], vec[ 2 ] );
SetKeyValue( &entities[ i ], "origin", str );
}
/* scale door lip */
f = FloatForKey( &entities[ i ], "lip" );
if ( f ) {
f *= scale;
sprintf( str, "%f", f );
SetKeyValue( &entities[ i ], "lip", str );
}
}
/* scale models */
for ( i = 0; i < numBSPModels; i++ )
{
VectorScale( bspModels[ i ].mins, scale, bspModels[ i ].mins );
VectorScale( bspModels[ i ].maxs, scale, bspModels[ i ].maxs );
}
/* scale nodes */
for ( i = 0; i < numBSPNodes; i++ )
{
VectorScale( bspNodes[ i ].mins, scale, bspNodes[ i ].mins );
VectorScale( bspNodes[ i ].maxs, scale, bspNodes[ i ].maxs );
}
/* scale leafs */
for ( i = 0; i < numBSPLeafs; i++ )
{
VectorScale( bspLeafs[ i ].mins, scale, bspLeafs[ i ].mins );
VectorScale( bspLeafs[ i ].maxs, scale, bspLeafs[ i ].maxs );
}
/* scale drawverts */
for ( i = 0; i < numBSPDrawVerts; i++ )
VectorScale( bspDrawVerts[ i ].xyz, scale, bspDrawVerts[ i ].xyz );
/* scale planes */
for ( i = 0; i < numBSPPlanes; i++ )
bspPlanes[ i ].dist *= scale;
/* scale gridsize */
GetVectorForKey( &entities[ 0 ], "gridsize", vec );
if ( ( vec[ 0 ] + vec[ 1 ] + vec[ 2 ] ) == 0.0f ) {
VectorCopy( gridSize, vec );
}
VectorScale( vec, scale, vec );
sprintf( str, "%f %f %f", vec[ 0 ], vec[ 1 ], vec[ 2 ] );
SetKeyValue( &entities[ 0 ], "gridsize", str );
/* write the bsp */
UnparseEntities();
StripExtension( source );
DefaultExtension( source, "_s.bsp" );
Sys_Printf( "Writing %s\n", source );
WriteBSPFile( source );
/* return to sender */
return 0;
}
/*
ConvertBSPMain()
main argument processing function for bsp conversion
*/
int ConvertBSPMain( int argc, char **argv ){
int i;
int ( *convertFunc )( char * );
game_t *convertGame;
/* set default */
convertFunc = ConvertBSPToASE;
convertGame = NULL;
/* arg checking */
if ( argc < 1 ) {
Sys_Printf( "Usage: q3map -convert [-format <ase|map>] [-v] <mapname>\n" );
return 0;
}
/* process arguments */
for ( i = 1; i < ( argc - 1 ); i++ )
{
/* -format map|ase|... */
if ( !strcmp( argv[ i ], "-format" ) ) {
i++;
if ( !Q_stricmp( argv[ i ], "ase" ) ) {
convertFunc = ConvertBSPToASE;
}
else if ( !Q_stricmp( argv[ i ], "map" ) ) {
convertFunc = ConvertBSPToMap;
}
else
{
convertGame = GetGame( argv[ i ] );
if ( convertGame == NULL ) {
Sys_Printf( "Unknown conversion format \"%s\". Defaulting to ASE.\n", argv[ i ] );
}
}
}
}
/* clean up map name */
strcpy( source, ExpandArg( argv[ i ] ) );
StripExtension( source );
DefaultExtension( source, ".bsp" );
LoadShaderInfo();
Sys_Printf( "Loading %s\n", source );
/* ydnar: load surface file */
//% LoadSurfaceExtraFile( source );
LoadBSPFile( source );
/* parse bsp entities */
ParseEntities();
/* bsp format convert? */
if ( convertGame != NULL ) {
/* set global game */
game = convertGame;
/* write bsp */
StripExtension( source );
DefaultExtension( source, "_c.bsp" );
Sys_Printf( "Writing %s\n", source );
WriteBSPFile( source );
/* return to sender */
return 0;
}
/* normal convert */
return convertFunc( source );
}
/*
main()
@ -691,17 +193,17 @@ int main( int argc, char **argv ){
/* fixaas */
if ( !strcmp( argv[ 1 ], "-fixaas" ) ) {
r = FixAAS( argc - 1, argv + 1 );
r = FixAASMain( argc - 1, argv + 1 );
}
/* analyze */
else if ( !strcmp( argv[ 1 ], "-analyze" ) ) {
r = AnalyzeBSP( argc - 1, argv + 1 );
r = AnalyzeBSPMain( argc - 1, argv + 1 );
}
/* info */
else if ( !strcmp( argv[ 1 ], "-info" ) ) {
r = BSPInfo( argc - 2, argv + 2 );
r = BSPInfoMain( argc - 2, argv + 2 );
}
/* vis */

24
tools/quake3/q3map2/q3map2.h
View file

@ -1465,20 +1465,36 @@ vec_t Random( void );
char *Q_strncpyz( char *dst, const char *src, size_t len );
char *Q_strcat( char *dst, size_t dlen, const char *src );
char *Q_strncat( char *dst, size_t dlen, const char *src, size_t slen );
int BSPInfo( int count, char **fileNames );
int ScaleBSPMain( int argc, char **argv );
int ConvertMain( int argc, char **argv );
/* path_init.c */
game_t *GetGame( char *arg );
void InitPaths( int *argc, char **argv );
/* fixaas.c */
int FixAASMain( int argc, char **argv );
/* bsp.c */
int BSPMain( int argc, char **argv );
/* bsp_analyze.c */
int AnalyzeBSPMain( int argc, char **argv );
/* bsp_info.c */
int BSPInfoMain( int argc, char **argv );
/* bsp_scale.c */
int ScaleBSPMain( int argc, char **argv );
/* convert_bsp.c */
int ConvertBSPMain( int argc, char **argv );
/* convert_map.c */
int ConvertBSPToMap( char *bspName );

20
tools/quake3/q3map2/q3map2.vcproj
View file

@ -222,6 +222,18 @@
RelativePath=".\bsp.c"
>
</File>
<File
RelativePath=".\bsp_analyze.c"
>
</File>
<File
RelativePath=".\bsp_scale.c"
>
</File>
<File
RelativePath=".\bsp_info.c"
>
</File>
<File
RelativePath=".\decals.c"
>
@ -230,6 +242,10 @@
RelativePath=".\facebsp.c"
>
</File>
<File
RelativePath=".\fixaas.c"
>
</File>
<File
RelativePath=".\fog.c"
>
@ -318,6 +334,10 @@
RelativePath=".\convert_ase.c"
>
</File>
<File
RelativePath=".\convert_bsp.c"
>
</File>
<File
RelativePath=".\convert_map.c"
>

5
tools/quake3/q3map2/q3map2.vcxproj
View file

@ -174,8 +174,12 @@
<ClCompile Include="brush.c" />
<ClCompile Include="brush_primit.c" />
<ClCompile Include="bsp.c" />
<ClCompile Include="bsp_analyze.c" />
<ClCompile Include="bsp_scale.c" />
<ClCompile Include="bsp_info.c" />
<ClCompile Include="decals.c" />
<ClCompile Include="facebsp.c" />
<ClCompile Include="fixaas.c" />
<ClCompile Include="fog.c" />
<ClCompile Include="leakfile.c" />
<ClCompile Include="map.c" />
@ -198,6 +202,7 @@
<ClCompile Include="vis.c" />
<ClCompile Include="visflow.c" />
<ClCompile Include="convert_ase.c" />
<ClCompile Include="convert_bsp.c" />
<ClCompile Include="convert_map.c" />
</ItemGroup>
<ItemGroup>

15
tools/quake3/q3map2/q3map2.vcxproj.filters
View file

@ -50,12 +50,24 @@
<ClCompile Include="bsp.c">
<Filter>src</Filter>
</ClCompile>
<ClCompile Include="bsp_analyze.c">
<Filter>src</Filter>
</ClCompile>
<ClCompile Include="bsp_scale.c">
<Filter>src</Filter>
</ClCompile>
<ClCompile Include="bsp_info.c">
<Filter>src</Filter>
</ClCompile>
<ClCompile Include="decals.c">
<Filter>src</Filter>
</ClCompile>
<ClCompile Include="facebsp.c">
<Filter>src</Filter>
</ClCompile>
<ClCompile Include="fixaas.c">
<Filter>src</Filter>
</ClCompile>
<ClCompile Include="fog.c">
<Filter>src</Filter>
</ClCompile>
@ -122,6 +134,9 @@
<ClCompile Include="convert_ase.c">
<Filter>src</Filter>
</ClCompile>
<ClCompile Include="convert_bsp.c">
<Filter>src</Filter>
</ClCompile>
<ClCompile Include="convert_map.c">
<Filter>src</Filter>
</ClCompile>