Bart/bullet3
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Code-style consistency improvement:

Browse Source 
Apply clang-format-all.sh using the _clang-format file through all the cpp/.h files.
make sure not to apply it to certain serialization structures, since some parser expects the * as part of the name, instead of type.
This commit contains no other changes aside from adding and applying clang-format-all.sh
This commit is contained in:
erwincoumans
2018-09-23 14:17:31 -07:00
parent b73b05e9fb
commit ab8f16961e
1773 changed files with 1081087 additions and 474249 deletions
Download Patch File Download Diff File Expand all files Collapse all files

507
examples/Importers/ImportBsp/BspLoader.cpp
View File

@@ -20,26 +20,25 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
===========================================================================
*/
#include "BspLoader.h"
#include <stdio.h>
#include <string.h>
typedef struct
{
char filename[1024];
char *buffer,*script_p,*end_p;
int line;
char filename[1024];
char *buffer, *script_p, *end_p;
int line;
} BSPScript;
#define MAX_INCLUDES 8
BSPScript scriptstack[MAX_INCLUDES];
BSPScript *script;
int scriptline;
#define MAX_INCLUDES 8
BSPScript scriptstack[MAX_INCLUDES];
BSPScript *script;
int scriptline;
char token[BSPMAXTOKEN];
char token[BSPMAXTOKEN];
bool endofscript;
bool tokenready; // only true if UnGetToken was just called
bool tokenready; // only true if UnGetToken was just called
//
//loadBSPFile
@@ -48,143 +47,137 @@ bool tokenready; // only true if UnGetToken was just called
int extrasize = 100;
BspLoader::BspLoader()
:m_num_entities(0)
: m_num_entities(0)
{
m_Endianness = getMachineEndianness();
if (m_Endianness == BSP_BIG_ENDIAN)
{
printf("Machine is BIG_ENDIAN\n");
} else
}
else
{
printf("Machine is Little Endian\n");
}
}
bool BspLoader::loadBSPFile( void* memoryBuffer) {
BSPHeader *header = (BSPHeader*) memoryBuffer;
bool BspLoader::loadBSPFile(void *memoryBuffer)
{
BSPHeader *header = (BSPHeader *)memoryBuffer;
// load the file header
if (header)
{
// swap the header
swapBlock( (int *)header, sizeof(*header) );
swapBlock((int *)header, sizeof(*header));
int length = (header->lumps[BSPLUMP_SHADERS].filelen) / sizeof(BSPShader);
m_dshaders.resize(length+extrasize);
m_numShaders = copyLump( header, BSPLUMP_SHADERS, &m_dshaders[0], sizeof(BSPShader) );
m_dshaders.resize(length + extrasize);
m_numShaders = copyLump(header, BSPLUMP_SHADERS, &m_dshaders[0], sizeof(BSPShader));
length = (header->lumps[LUMP_MODELS].filelen) / sizeof(BSPModel);
m_dmodels.resize(length+extrasize);
m_nummodels = copyLump( header, LUMP_MODELS, &m_dmodels[0], sizeof(BSPModel) );
m_dmodels.resize(length + extrasize);
m_nummodels = copyLump(header, LUMP_MODELS, &m_dmodels[0], sizeof(BSPModel));
length = (header->lumps[BSPLUMP_PLANES].filelen) / sizeof(BSPPlane);
m_dplanes.resize(length+extrasize);
m_numplanes = copyLump( header, BSPLUMP_PLANES, &m_dplanes[0], sizeof(BSPPlane) );
m_dplanes.resize(length + extrasize);
m_numplanes = copyLump(header, BSPLUMP_PLANES, &m_dplanes[0], sizeof(BSPPlane));
length = (header->lumps[BSPLUMP_LEAFS].filelen) / sizeof(BSPLeaf);
m_dleafs.resize(length+extrasize);
m_numleafs = copyLump( header, BSPLUMP_LEAFS, &m_dleafs[0], sizeof(BSPLeaf) );
m_dleafs.resize(length + extrasize);
m_numleafs = copyLump(header, BSPLUMP_LEAFS, &m_dleafs[0], sizeof(BSPLeaf));
length = (header->lumps[BSPLUMP_NODES].filelen) / sizeof(BSPNode);
m_dnodes.resize(length+extrasize);
m_numnodes = copyLump( header, BSPLUMP_NODES, &m_dnodes[0], sizeof(BSPNode) );
m_dnodes.resize(length + extrasize);
m_numnodes = copyLump(header, BSPLUMP_NODES, &m_dnodes[0], sizeof(BSPNode));
length = (header->lumps[BSPLUMP_LEAFSURFACES].filelen) / sizeof(m_dleafsurfaces[0]);
m_dleafsurfaces.resize(length+extrasize);
m_numleafsurfaces = copyLump( header, BSPLUMP_LEAFSURFACES, &m_dleafsurfaces[0], sizeof(m_dleafsurfaces[0]) );
m_dleafsurfaces.resize(length + extrasize);
m_numleafsurfaces = copyLump(header, BSPLUMP_LEAFSURFACES, &m_dleafsurfaces[0], sizeof(m_dleafsurfaces[0]));
length = (header->lumps[BSPLUMP_LEAFBRUSHES].filelen) / sizeof(m_dleafbrushes[0]) ;
m_dleafbrushes.resize(length+extrasize);
m_numleafbrushes = copyLump( header, BSPLUMP_LEAFBRUSHES, &m_dleafbrushes[0], sizeof(m_dleafbrushes[0]) );
length = (header->lumps[BSPLUMP_LEAFBRUSHES].filelen) / sizeof(m_dleafbrushes[0]);
m_dleafbrushes.resize(length + extrasize);
m_numleafbrushes = copyLump(header, BSPLUMP_LEAFBRUSHES, &m_dleafbrushes[0], sizeof(m_dleafbrushes[0]));
length = (header->lumps[LUMP_BRUSHES].filelen) / sizeof(BSPBrush);
m_dbrushes.resize(length+extrasize);
m_numbrushes = copyLump( header, LUMP_BRUSHES, &m_dbrushes[0], sizeof(BSPBrush) );
m_dbrushes.resize(length + extrasize);
m_numbrushes = copyLump(header, LUMP_BRUSHES, &m_dbrushes[0], sizeof(BSPBrush));
length = (header->lumps[LUMP_BRUSHSIDES].filelen) / sizeof(BSPBrushSide);
m_dbrushsides.resize(length+extrasize);
m_numbrushsides = copyLump( header, LUMP_BRUSHSIDES, &m_dbrushsides[0], sizeof(BSPBrushSide) );
m_dbrushsides.resize(length + extrasize);
m_numbrushsides = copyLump(header, LUMP_BRUSHSIDES, &m_dbrushsides[0], sizeof(BSPBrushSide));
length = (header->lumps[LUMP_SURFACES].filelen) / sizeof(BSPSurface);
m_drawSurfaces.resize(length+extrasize);
m_numDrawSurfaces = copyLump( header, LUMP_SURFACES, &m_drawSurfaces[0], sizeof(BSPSurface) );
m_drawSurfaces.resize(length + extrasize);
m_numDrawSurfaces = copyLump(header, LUMP_SURFACES, &m_drawSurfaces[0], sizeof(BSPSurface));
length = (header->lumps[LUMP_DRAWINDEXES].filelen) / sizeof(m_drawIndexes[0]);
m_drawIndexes.resize(length+extrasize);
m_numDrawIndexes = copyLump( header, LUMP_DRAWINDEXES, &m_drawIndexes[0], sizeof(m_drawIndexes[0]) );
m_drawIndexes.resize(length + extrasize);
m_numDrawIndexes = copyLump(header, LUMP_DRAWINDEXES, &m_drawIndexes[0], sizeof(m_drawIndexes[0]));
length = (header->lumps[LUMP_VISIBILITY].filelen) / 1;
m_visBytes.resize(length+extrasize);
m_numVisBytes = copyLump( header, LUMP_VISIBILITY, &m_visBytes[0], 1 );
m_visBytes.resize(length + extrasize);
m_numVisBytes = copyLump(header, LUMP_VISIBILITY, &m_visBytes[0], 1);
length = (header->lumps[LUMP_LIGHTMAPS].filelen) / 1;
m_lightBytes.resize(length+extrasize);
m_numLightBytes = copyLump( header, LUMP_LIGHTMAPS, &m_lightBytes[0], 1 );
m_lightBytes.resize(length + extrasize);
m_numLightBytes = copyLump(header, LUMP_LIGHTMAPS, &m_lightBytes[0], 1);
length = (header->lumps[BSPLUMP_ENTITIES].filelen) / 1;
m_dentdata.resize(length+extrasize);
m_entdatasize = copyLump( header, BSPLUMP_ENTITIES, &m_dentdata[0], 1);
m_dentdata.resize(length + extrasize);
m_entdatasize = copyLump(header, BSPLUMP_ENTITIES, &m_dentdata[0], 1);
length = (header->lumps[LUMP_LIGHTGRID].filelen) / 1;
m_gridData.resize(length+extrasize);
m_numGridPoints = copyLump( header, LUMP_LIGHTGRID, &m_gridData[0], 8 );
m_gridData.resize(length + extrasize);
m_numGridPoints = copyLump(header, LUMP_LIGHTGRID, &m_gridData[0], 8);
// swap everything
swapBSPFile();
return true;
}
return false;
}
const char *BspLoader::getValueForKey(const BSPEntity *ent, const char *key) const
{
const BSPKeyValuePair *ep;
const char* BspLoader::getValueForKey( const BSPEntity* ent, const char* key ) const {
const BSPKeyValuePair* ep;
for (ep=ent->epairs ; ep ; ep=ep->next) {
if (!strcmp(ep->key, key) ) {
for (ep = ent->epairs; ep; ep = ep->next)
{
if (!strcmp(ep->key, key))
{
return ep->value;
}
}
return "";
}
float BspLoader::getFloatForKey( const BSPEntity *ent, const char *key ) {
const char *k;
k = getValueForKey( ent, key );
float BspLoader::getFloatForKey(const BSPEntity *ent, const char *key)
{
const char *k;
k = getValueForKey(ent, key);
return float(atof(k));
}
bool BspLoader::getVectorForKey( const BSPEntity *ent, const char *key, BSPVector3 vec ) {
const char *k;
k = getValueForKey (ent, key);
bool BspLoader::getVectorForKey(const BSPEntity *ent, const char *key, BSPVector3 vec)
{
const char *k;
k = getValueForKey(ent, key);
if (strcmp(k, ""))
{
sscanf (k, "%f %f %f", &vec[0], &vec[1], &vec[2]);
sscanf(k, "%f %f %f", &vec[0], &vec[1], &vec[2]);
return true;
}
return false;
}
/*
==============
parseFromMemory
==============
*/
void BspLoader::parseFromMemory (char *buffer, int size)
void BspLoader::parseFromMemory(char *buffer, int size)
{
script = scriptstack;
script++;
@@ -192,7 +185,7 @@ void BspLoader::parseFromMemory (char *buffer, int size)
{
//printf("script file exceeded MAX_INCLUDES");
}
strcpy (script->filename, "memory buffer" );
strcpy(script->filename, "memory buffer");
script->buffer = buffer;
script->line = 1;
@@ -203,20 +196,19 @@ void BspLoader::parseFromMemory (char *buffer, int size)
tokenready = false;
}
bool BspLoader::isEndOfScript (bool crossline)
bool BspLoader::isEndOfScript(bool crossline)
{
if (!crossline)
//printf("Line %i is incomplete\n",scriptline);
if (!strcmp (script->filename, "memory buffer"))
{
endofscript = true;
return false;
}
if (!strcmp(script->filename, "memory buffer"))
{
endofscript = true;
return false;
}
//free (script->buffer);
if (script == scriptstack+1)
if (script == scriptstack + 1)
{
endofscript = true;
return false;
@@ -224,7 +216,7 @@ bool BspLoader::isEndOfScript (bool crossline)
script--;
scriptline = script->line;
//printf ("returning to %s\n", script->filename);
return getToken (crossline);
return getToken(crossline);
}
/*
@@ -233,18 +225,18 @@ bool BspLoader::isEndOfScript (bool crossline)
getToken
==============
*/
bool BspLoader::getToken (bool crossline)
bool BspLoader::getToken(bool crossline)
{
char *token_p;
char *token_p;
if (tokenready) // is a token allready waiting?
if (tokenready) // is a token allready waiting?
{
tokenready = false;
return true;
}
if (script->script_p >= script->end_p)
return isEndOfScript (crossline);
return isEndOfScript(crossline);
//
// skip space
@@ -253,7 +245,7 @@ skipspace:
while (*script->script_p <= 32)
{
if (script->script_p >= script->end_p)
return isEndOfScript (crossline);
return isEndOfScript(crossline);
if (*script->script_p++ == '\n')
{
if (!crossline)
@@ -265,11 +257,10 @@ skipspace:
}
if (script->script_p >= script->end_p)
return isEndOfScript (crossline);
return isEndOfScript(crossline);
// ; # // comments
if (*script->script_p == ';' || *script->script_p == '#'
|| ( script->script_p[0] == '/' && script->script_p[1] == '/') )
if (*script->script_p == ';' || *script->script_p == '#' || (script->script_p[0] == '/' && script->script_p[1] == '/'))
{
if (!crossline)
{
@@ -277,7 +268,7 @@ skipspace:
}
while (*script->script_p++ != '\n')
if (script->script_p >= script->end_p)
return isEndOfScript (crossline);
return isEndOfScript(crossline);
scriptline = script->line++;
goto skipspace;
}
@@ -289,23 +280,24 @@ skipspace:
{
//printf("Line %i is incomplete\n",scriptline);
}
script->script_p+=2;
script->script_p += 2;
while (script->script_p[0] != '*' && script->script_p[1] != '/')
{
if ( *script->script_p == '\n' ) {
if (*script->script_p == '\n')
{
scriptline = script->line++;
}
script->script_p++;
if (script->script_p >= script->end_p)
return isEndOfScript (crossline);
return isEndOfScript(crossline);
}
script->script_p += 2;
goto skipspace;
}
//
// copy token
//
//
// copy token
//
token_p = token;
if (*script->script_p == '"')
@@ -324,25 +316,25 @@ skipspace:
}
script->script_p++;
}
else // regular token
while ( *script->script_p > 32 && *script->script_p != ';')
{
*token_p++ = *script->script_p++;
if (script->script_p == script->end_p)
break;
if (token_p == &token[BSPMAXTOKEN])
else // regular token
while (*script->script_p > 32 && *script->script_p != ';')
{
//printf ("Token too large on line %i\n",scriptline);
*token_p++ = *script->script_p++;
if (script->script_p == script->end_p)
break;
if (token_p == &token[BSPMAXTOKEN])
{
//printf ("Token too large on line %i\n",scriptline);
}
}
}
*token_p = 0;
if (!strcmp (token, "$include"))
if (!strcmp(token, "$include"))
{
//getToken (false);
//AddScriptToStack (token);
return false;//getToken (crossline);
return false; //getToken (crossline);
}
return true;
@@ -350,16 +342,17 @@ skipspace:
char *BspLoader::copystring(const char *s)
{
char *b;
b = (char*) malloc( strlen(s)+1);
strcpy (b, s);
char *b;
b = (char *)malloc(strlen(s) + 1);
strcpy(b, s);
return b;
}
void BspLoader::stripTrailing( char *e ) {
char *s;
void BspLoader::stripTrailing(char *e)
{
char *s;
s = e + strlen(e)-1;
s = e + strlen(e) - 1;
while (s >= e && *s <= 32)
{
*s = 0;
@@ -371,47 +364,50 @@ void BspLoader::stripTrailing( char *e ) {
parseEpair
=================
*/
BSPKeyValuePair *BspLoader::parseEpair( void ) {
BSPKeyValuePair *e;
BSPKeyValuePair *BspLoader::parseEpair(void)
{
BSPKeyValuePair *e;
e = (struct BSPPair*) malloc( sizeof(BSPKeyValuePair));
memset( e, 0, sizeof(BSPKeyValuePair) );
if ( strlen(token) >= BSPMAX_KEY-1 ) {
e = (struct BSPPair *)malloc(sizeof(BSPKeyValuePair));
memset(e, 0, sizeof(BSPKeyValuePair));
if (strlen(token) >= BSPMAX_KEY - 1)
{
//printf ("ParseEpar: token too long");
}
e->key = copystring( token );
getToken( false );
if ( strlen(token) >= BSPMAX_VALUE-1 ) {
e->key = copystring(token);
getToken(false);
if (strlen(token) >= BSPMAX_VALUE - 1)
{
//printf ("ParseEpar: token too long");
}
e->value = copystring( token );
e->value = copystring(token);
// strip trailing spaces that sometimes get accidentally
// added in the editor
stripTrailing( e->key );
stripTrailing( e->value );
stripTrailing(e->key);
stripTrailing(e->value);
return e;
}
/*
================
parseEntity
================
*/
bool BspLoader::parseEntity( void ) {
BSPKeyValuePair *e;
BSPEntity *mapent;
bool BspLoader::parseEntity(void)
{
BSPKeyValuePair *e;
BSPEntity *mapent;
if ( !getToken (true) ) {
if (!getToken(true))
{
return false;
}
if ( strcmp (token, "{") ) {
if (strcmp(token, "{"))
{
//printf ("parseEntity: { not found");
}
@@ -425,21 +421,24 @@ bool BspLoader::parseEntity( void ) {
bla.patches = 0;
m_entities.push_back(bla);
mapent = &m_entities[m_entities.size()-1];
mapent = &m_entities[m_entities.size() - 1];
m_num_entities++;
do {
if ( !getToken (true) ) {
do
{
if (!getToken(true))
{
//printf("parseEntity: EOF without closing brace");
}
if ( !strcmp (token, "}") ) {
if (!strcmp(token, "}"))
{
break;
}
e = (struct BSPPair*)parseEpair ();
e = (struct BSPPair *)parseEpair();
e->next = mapent->epairs;
mapent->epairs = e;
} while (1);
return true;
}
@@ -450,113 +449,108 @@ parseEntities
Parses the dentdata string into entities
================
*/
void BspLoader::parseEntities( void ) {
void BspLoader::parseEntities(void)
{
m_num_entities = 0;
m_entities.clear();
parseFromMemory( &m_dentdata[0], m_entdatasize );
parseFromMemory(&m_dentdata[0], m_entdatasize);
while ( parseEntity () ) {
}
while (parseEntity())
{
}
}
int BspLoader::getMachineEndianness()
{
long int i = 1;
const char *p = (const char *) &i;
if (p[0] == 1) // Lowest address contains the least significant byte
return BSP_LITTLE_ENDIAN;
else
return BSP_BIG_ENDIAN;
long int i = 1;
const char *p = (const char *)&i;
if (p[0] == 1) // Lowest address contains the least significant byte
return BSP_LITTLE_ENDIAN;
else
return BSP_BIG_ENDIAN;
}
short BspLoader::isLittleShort (short l)
short BspLoader::isLittleShort(short l)
{
if (machineEndianness() == BSP_BIG_ENDIAN)
{
unsigned char b1,b2;
unsigned char b1, b2;
b1 = l&255;
b2 = (l>>8)&255;
b1 = l & 255;
b2 = (l >> 8) & 255;
return (b1<<8) + b2;
return (b1 << 8) + b2;
}
//little endian
return l;
}
short BspLoader::isBigShort (short l)
short BspLoader::isBigShort(short l)
{
if (machineEndianness() == BSP_BIG_ENDIAN)
{
return l;
}
unsigned char b1,b2;
b1 = l&255;
b2 = (l>>8)&255;
return (b1<<8) + b2;
unsigned char b1, b2;
b1 = l & 255;
b2 = (l >> 8) & 255;
return (b1 << 8) + b2;
}
int BspLoader::isLittleLong (int l)
int BspLoader::isLittleLong(int l)
{
if (machineEndianness() == BSP_BIG_ENDIAN)
{
unsigned char b1,b2,b3,b4;
unsigned char b1, b2, b3, b4;
b1 = l&255;
b2 = (l>>8)&255;
b3 = (l>>16)&255;
b4 = (l>>24)&255;
b1 = l & 255;
b2 = (l >> 8) & 255;
b3 = (l >> 16) & 255;
b4 = (l >> 24) & 255;
return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
return ((int)b1 << 24) + ((int)b2 << 16) + ((int)b3 << 8) + b4;
}
//little endian
return l;
}
int BspLoader::isBigLong (int l)
int BspLoader::isBigLong(int l)
{
if (machineEndianness() == BSP_BIG_ENDIAN)
{
return l;
}
unsigned char b1, b2, b3, b4;
unsigned char b1,b2,b3,b4;
b1 = l&255;
b2 = (l>>8)&255;
b3 = (l>>16)&255;
b4 = (l>>24)&255;
return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
b1 = l & 255;
b2 = (l >> 8) & 255;
b3 = (l >> 16) & 255;
b4 = (l >> 24) & 255;
return ((int)b1 << 24) + ((int)b2 << 16) + ((int)b3 << 8) + b4;
}
float BspLoader::isLittleFloat (float l)
float BspLoader::isLittleFloat(float l)
{
if (machineEndianness() == BSP_BIG_ENDIAN)
{
union {unsigned char b[4]; float f;} in, out;
union {
unsigned char b[4];
float f;
} in, out;
in.f = l;
out.b[0] = in.b[3];
out.b[1] = in.b[2];
out.b[2] = in.b[1];
out.b[3] = in.b[0];
return out.f;
}
@@ -564,40 +558,40 @@ float BspLoader::isLittleFloat (float l)
return l;
}
float BspLoader::isBigFloat (float l)
float BspLoader::isBigFloat(float l)
{
if (machineEndianness() == BSP_BIG_ENDIAN)
{
return l;
}
//little endian
union {unsigned char b[4]; float f;} in, out;
union {
unsigned char b[4];
float f;
} in, out;
in.f = l;
out.b[0] = in.b[3];
out.b[1] = in.b[2];
out.b[2] = in.b[1];
out.b[3] = in.b[0];
return out.f;
}
//
// swapBlock
// If all values are 32 bits, this can be used to swap everything
//
void BspLoader::swapBlock( int *block, int sizeOfBlock ) {
int i;
void BspLoader::swapBlock(int *block, int sizeOfBlock)
{
int i;
sizeOfBlock >>= 2;
for ( i = 0 ; i < sizeOfBlock ; i++ ) {
block[i] = isLittleLong( block[i] );
for (i = 0; i < sizeOfBlock; i++)
{
block[i] = isLittleLong(block[i]);
}
}
@@ -605,99 +599,96 @@ void BspLoader::swapBlock( int *block, int sizeOfBlock ) {
// copyLump
//
int BspLoader::copyLump( BSPHeader *header, int lump, void *dest, int size ) {
int length, ofs;
int BspLoader::copyLump(BSPHeader *header, int lump, void *dest, int size)
{
int length, ofs;
length = header->lumps[lump].filelen;
ofs = header->lumps[lump].fileofs;
//if ( length % size ) {
// printf ("loadBSPFile: odd lump size");
//}
memcpy( dest, (unsigned char *)header + ofs, length );
memcpy(dest, (unsigned char *)header + ofs, length);
return length / size;
}
//
// swapBSPFile
//
void BspLoader::swapBSPFile( void ) {
int i;
// models
swapBlock( (int *) &m_dmodels[0], m_nummodels * sizeof( m_dmodels[0] ) );
void BspLoader::swapBSPFile(void)
{
int i;
// models
swapBlock((int *)&m_dmodels[0], m_nummodels * sizeof(m_dmodels[0]));
// shaders (don't swap the name)
for ( i = 0 ; i < m_numShaders ; i++ ) {
m_dshaders[i].contentFlags = isLittleLong( m_dshaders[i].contentFlags );
m_dshaders[i].surfaceFlags = isLittleLong( m_dshaders[i].surfaceFlags );
for (i = 0; i < m_numShaders; i++)
{
m_dshaders[i].contentFlags = isLittleLong(m_dshaders[i].contentFlags);
m_dshaders[i].surfaceFlags = isLittleLong(m_dshaders[i].surfaceFlags);
}
// planes
swapBlock( (int *)&m_dplanes[0], m_numplanes * sizeof( m_dplanes[0] ) );
swapBlock((int *)&m_dplanes[0], m_numplanes * sizeof(m_dplanes[0]));
// nodes
swapBlock( (int *)&m_dnodes[0], m_numnodes * sizeof( m_dnodes[0] ) );
swapBlock((int *)&m_dnodes[0], m_numnodes * sizeof(m_dnodes[0]));
// leafs
swapBlock( (int *)&m_dleafs[0], m_numleafs * sizeof( m_dleafs[0] ) );
swapBlock((int *)&m_dleafs[0], m_numleafs * sizeof(m_dleafs[0]));
// leaffaces
swapBlock( (int *)&m_dleafsurfaces[0], m_numleafsurfaces * sizeof( m_dleafsurfaces[0] ) );
swapBlock((int *)&m_dleafsurfaces[0], m_numleafsurfaces * sizeof(m_dleafsurfaces[0]));
// leafbrushes
swapBlock( (int *)&m_dleafbrushes[0], m_numleafbrushes * sizeof( m_dleafbrushes[0] ) );
swapBlock((int *)&m_dleafbrushes[0], m_numleafbrushes * sizeof(m_dleafbrushes[0]));
// brushes
swapBlock( (int *)&m_dbrushes[0], m_numbrushes * sizeof( m_dbrushes[0] ) );
swapBlock((int *)&m_dbrushes[0], m_numbrushes * sizeof(m_dbrushes[0]));
// brushsides
swapBlock( (int *)&m_dbrushsides[0], m_numbrushsides * sizeof( m_dbrushsides[0] ) );
swapBlock((int *)&m_dbrushsides[0], m_numbrushsides * sizeof(m_dbrushsides[0]));
// vis
((int *)&m_visBytes)[0] = isLittleLong( ((int *)&m_visBytes)[0] );
((int *)&m_visBytes)[1] = isLittleLong( ((int *)&m_visBytes)[1] );
((int *)&m_visBytes)[0] = isLittleLong(((int *)&m_visBytes)[0]);
((int *)&m_visBytes)[1] = isLittleLong(((int *)&m_visBytes)[1]);
// drawindexes
swapBlock( (int *)&m_drawIndexes[0], m_numDrawIndexes * sizeof( m_drawIndexes[0] ) );
swapBlock((int *)&m_drawIndexes[0], m_numDrawIndexes * sizeof(m_drawIndexes[0]));
// drawsurfs
swapBlock( (int *)&m_drawSurfaces[0], m_numDrawSurfaces * sizeof( m_drawSurfaces[0] ) );
swapBlock((int *)&m_drawSurfaces[0], m_numDrawSurfaces * sizeof(m_drawSurfaces[0]));
}
bool BspLoader::findVectorByName(float* outvec,const char* name)
bool BspLoader::findVectorByName(float *outvec, const char *name)
{
const char *cl;
BSPVector3 origin;
bool found = false;
parseEntities();
for ( int i = 1; i < m_num_entities; i++ ) {
cl = getValueForKey (&m_entities[i], "classname");
if ( !strcmp( cl, "info_player_start" ) ) {
getVectorForKey( &m_entities[i], "origin", origin );
found = true;
break;
}
if ( !strcmp( cl, "info_player_deathmatch" ) ) {
getVectorForKey( &m_entities[i], "origin", origin );
found = true;
break;
}
for (int i = 1; i < m_num_entities; i++)
{
cl = getValueForKey(&m_entities[i], "classname");
if (!strcmp(cl, "info_player_start"))
{
getVectorForKey(&m_entities[i], "origin", origin);
found = true;
break;
}
if (!strcmp(cl, "info_player_deathmatch"))
{
getVectorForKey(&m_entities[i], "origin", origin);
found = true;
break;
}
}
if (found)
@@ -708,23 +699,21 @@ bool BspLoader::findVectorByName(float* outvec,const char* name)
}
return found;
}
const BSPEntity * BspLoader::getEntityByValue( const char* name, const char* value)
const BSPEntity *BspLoader::getEntityByValue(const char *name, const char *value)
{
const BSPEntity* entity = NULL;
const BSPEntity *entity = NULL;
for ( int i = 1; i < m_num_entities; i++ ) {
for (int i = 1; i < m_num_entities; i++)
{
const BSPEntity &ent = m_entities[i];
const BSPEntity& ent = m_entities[i];
const char* cl = getValueForKey (&m_entities[i], name);
if ( !strcmp( cl, value ) ) {
const char *cl = getValueForKey(&m_entities[i], name);
if (!strcmp(cl, value))
{
entity = &ent;
break;
}
}
return entity;
}