mirror of
https://github.com/bulletphysics/bullet3
synced 2024-12-13 21:30:09 +00:00
ab8f16961e
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
720 lines
15 KiB
C++
720 lines
15 KiB
C++
/*
|
|
===========================================================================
|
|
Copyright (C) 1999-2005 Id Software, Inc.
|
|
|
|
This file is part of Quake III Arena source code.
|
|
|
|
Quake III Arena source code is free software; you can redistribute it
|
|
and/or modify it under the terms of the GNU bteral Public License as
|
|
published by the Free Software Foundation; either version 2 of the License,
|
|
or (at your option) any later version.
|
|
|
|
Quake III Arena source code 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 bteral Public License for more details.
|
|
|
|
You should have received a copy of the GNU bteral Public License
|
|
along with Foobar; if not, write to the Free Software
|
|
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;
|
|
} BSPScript;
|
|
|
|
#define MAX_INCLUDES 8
|
|
BSPScript scriptstack[MAX_INCLUDES];
|
|
BSPScript *script;
|
|
int scriptline;
|
|
|
|
char token[BSPMAXTOKEN];
|
|
bool endofscript;
|
|
bool tokenready; // only true if UnGetToken was just called
|
|
|
|
//
|
|
//loadBSPFile
|
|
//
|
|
|
|
int extrasize = 100;
|
|
|
|
BspLoader::BspLoader()
|
|
: m_num_entities(0)
|
|
{
|
|
m_Endianness = getMachineEndianness();
|
|
if (m_Endianness == BSP_BIG_ENDIAN)
|
|
{
|
|
printf("Machine is BIG_ENDIAN\n");
|
|
}
|
|
else
|
|
{
|
|
printf("Machine is Little Endian\n");
|
|
}
|
|
}
|
|
|
|
bool BspLoader::loadBSPFile(void *memoryBuffer)
|
|
{
|
|
BSPHeader *header = (BSPHeader *)memoryBuffer;
|
|
|
|
// load the file header
|
|
if (header)
|
|
{
|
|
// swap the 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));
|
|
|
|
length = (header->lumps[LUMP_MODELS].filelen) / 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));
|
|
|
|
length = (header->lumps[BSPLUMP_LEAFS].filelen) / 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));
|
|
|
|
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]));
|
|
|
|
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));
|
|
|
|
length = (header->lumps[LUMP_BRUSHSIDES].filelen) / 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));
|
|
|
|
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]));
|
|
|
|
length = (header->lumps[LUMP_VISIBILITY].filelen) / 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);
|
|
|
|
length = (header->lumps[BSPLUMP_ENTITIES].filelen) / 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);
|
|
|
|
// swap everything
|
|
swapBSPFile();
|
|
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
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))
|
|
{
|
|
return ep->value;
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
|
|
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);
|
|
if (strcmp(k, ""))
|
|
{
|
|
sscanf(k, "%f %f %f", &vec[0], &vec[1], &vec[2]);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
==============
|
|
parseFromMemory
|
|
==============
|
|
*/
|
|
void BspLoader::parseFromMemory(char *buffer, int size)
|
|
{
|
|
script = scriptstack;
|
|
script++;
|
|
if (script == &scriptstack[MAX_INCLUDES])
|
|
{
|
|
//printf("script file exceeded MAX_INCLUDES");
|
|
}
|
|
strcpy(script->filename, "memory buffer");
|
|
|
|
script->buffer = buffer;
|
|
script->line = 1;
|
|
script->script_p = script->buffer;
|
|
script->end_p = script->buffer + size;
|
|
|
|
endofscript = false;
|
|
tokenready = false;
|
|
}
|
|
|
|
bool BspLoader::isEndOfScript(bool crossline)
|
|
{
|
|
if (!crossline)
|
|
//printf("Line %i is incomplete\n",scriptline);
|
|
|
|
if (!strcmp(script->filename, "memory buffer"))
|
|
{
|
|
endofscript = true;
|
|
return false;
|
|
}
|
|
|
|
//free (script->buffer);
|
|
if (script == scriptstack + 1)
|
|
{
|
|
endofscript = true;
|
|
return false;
|
|
}
|
|
script--;
|
|
scriptline = script->line;
|
|
//printf ("returning to %s\n", script->filename);
|
|
return getToken(crossline);
|
|
}
|
|
|
|
/*
|
|
|
|
==============
|
|
getToken
|
|
==============
|
|
*/
|
|
bool BspLoader::getToken(bool crossline)
|
|
{
|
|
char *token_p;
|
|
|
|
if (tokenready) // is a token allready waiting?
|
|
{
|
|
tokenready = false;
|
|
return true;
|
|
}
|
|
|
|
if (script->script_p >= script->end_p)
|
|
return isEndOfScript(crossline);
|
|
|
|
//
|
|
// skip space
|
|
//
|
|
skipspace:
|
|
while (*script->script_p <= 32)
|
|
{
|
|
if (script->script_p >= script->end_p)
|
|
return isEndOfScript(crossline);
|
|
if (*script->script_p++ == '\n')
|
|
{
|
|
if (!crossline)
|
|
{
|
|
//printf("Line %i is incomplete\n",scriptline);
|
|
}
|
|
scriptline = script->line++;
|
|
}
|
|
}
|
|
|
|
if (script->script_p >= script->end_p)
|
|
return isEndOfScript(crossline);
|
|
|
|
// ; # // comments
|
|
if (*script->script_p == ';' || *script->script_p == '#' || (script->script_p[0] == '/' && script->script_p[1] == '/'))
|
|
{
|
|
if (!crossline)
|
|
{
|
|
//printf("Line %i is incomplete\n",scriptline);
|
|
}
|
|
while (*script->script_p++ != '\n')
|
|
if (script->script_p >= script->end_p)
|
|
return isEndOfScript(crossline);
|
|
scriptline = script->line++;
|
|
goto skipspace;
|
|
}
|
|
|
|
// /* */ comments
|
|
if (script->script_p[0] == '/' && script->script_p[1] == '*')
|
|
{
|
|
if (!crossline)
|
|
{
|
|
//printf("Line %i is incomplete\n",scriptline);
|
|
}
|
|
script->script_p += 2;
|
|
while (script->script_p[0] != '*' && script->script_p[1] != '/')
|
|
{
|
|
if (*script->script_p == '\n')
|
|
{
|
|
scriptline = script->line++;
|
|
}
|
|
script->script_p++;
|
|
if (script->script_p >= script->end_p)
|
|
return isEndOfScript(crossline);
|
|
}
|
|
script->script_p += 2;
|
|
goto skipspace;
|
|
}
|
|
|
|
//
|
|
// copy token
|
|
//
|
|
token_p = token;
|
|
|
|
if (*script->script_p == '"')
|
|
{
|
|
// quoted token
|
|
script->script_p++;
|
|
while (*script->script_p != '"')
|
|
{
|
|
*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);
|
|
}
|
|
}
|
|
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])
|
|
{
|
|
//printf ("Token too large on line %i\n",scriptline);
|
|
}
|
|
}
|
|
|
|
*token_p = 0;
|
|
|
|
if (!strcmp(token, "$include"))
|
|
{
|
|
//getToken (false);
|
|
//AddScriptToStack (token);
|
|
return false; //getToken (crossline);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
char *BspLoader::copystring(const char *s)
|
|
{
|
|
char *b;
|
|
b = (char *)malloc(strlen(s) + 1);
|
|
strcpy(b, s);
|
|
return b;
|
|
}
|
|
|
|
void BspLoader::stripTrailing(char *e)
|
|
{
|
|
char *s;
|
|
|
|
s = e + strlen(e) - 1;
|
|
while (s >= e && *s <= 32)
|
|
{
|
|
*s = 0;
|
|
s--;
|
|
}
|
|
}
|
|
/*
|
|
=================
|
|
parseEpair
|
|
=================
|
|
*/
|
|
BSPKeyValuePair *BspLoader::parseEpair(void)
|
|
{
|
|
BSPKeyValuePair *e;
|
|
|
|
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)
|
|
{
|
|
//printf ("ParseEpar: token too long");
|
|
}
|
|
e->value = copystring(token);
|
|
|
|
// strip trailing spaces that sometimes get accidentally
|
|
// added in the editor
|
|
stripTrailing(e->key);
|
|
stripTrailing(e->value);
|
|
|
|
return e;
|
|
}
|
|
|
|
/*
|
|
================
|
|
parseEntity
|
|
================
|
|
*/
|
|
bool BspLoader::parseEntity(void)
|
|
{
|
|
BSPKeyValuePair *e;
|
|
BSPEntity *mapent;
|
|
|
|
if (!getToken(true))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (strcmp(token, "{"))
|
|
{
|
|
//printf ("parseEntity: { not found");
|
|
}
|
|
|
|
BSPEntity bla;
|
|
bla.brushes = 0;
|
|
bla.epairs = 0;
|
|
bla.firstDrawSurf = 0;
|
|
bla.origin[0] = 0.f;
|
|
bla.origin[1] = 0.f;
|
|
bla.origin[2] = 0.f;
|
|
bla.patches = 0;
|
|
|
|
m_entities.push_back(bla);
|
|
mapent = &m_entities[m_entities.size() - 1];
|
|
m_num_entities++;
|
|
|
|
do
|
|
{
|
|
if (!getToken(true))
|
|
{
|
|
//printf("parseEntity: EOF without closing brace");
|
|
}
|
|
if (!strcmp(token, "}"))
|
|
{
|
|
break;
|
|
}
|
|
e = (struct BSPPair *)parseEpair();
|
|
e->next = mapent->epairs;
|
|
mapent->epairs = e;
|
|
} while (1);
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
parseEntities
|
|
|
|
Parses the dentdata string into entities
|
|
================
|
|
*/
|
|
void BspLoader::parseEntities(void)
|
|
{
|
|
m_num_entities = 0;
|
|
m_entities.clear();
|
|
|
|
parseFromMemory(&m_dentdata[0], m_entdatasize);
|
|
|
|
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;
|
|
}
|
|
|
|
short BspLoader::isLittleShort(short l)
|
|
{
|
|
if (machineEndianness() == BSP_BIG_ENDIAN)
|
|
{
|
|
unsigned char b1, b2;
|
|
|
|
b1 = l & 255;
|
|
b2 = (l >> 8) & 255;
|
|
|
|
return (b1 << 8) + b2;
|
|
}
|
|
//little endian
|
|
return 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;
|
|
}
|
|
|
|
int BspLoader::isLittleLong(int l)
|
|
{
|
|
if (machineEndianness() == BSP_BIG_ENDIAN)
|
|
{
|
|
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;
|
|
}
|
|
|
|
//little endian
|
|
return l;
|
|
}
|
|
|
|
int BspLoader::isBigLong(int l)
|
|
{
|
|
if (machineEndianness() == BSP_BIG_ENDIAN)
|
|
{
|
|
return l;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
float BspLoader::isLittleFloat(float l)
|
|
{
|
|
if (machineEndianness() == BSP_BIG_ENDIAN)
|
|
{
|
|
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;
|
|
}
|
|
|
|
//little endian
|
|
return l;
|
|
}
|
|
|
|
float BspLoader::isBigFloat(float l)
|
|
{
|
|
if (machineEndianness() == BSP_BIG_ENDIAN)
|
|
{
|
|
return l;
|
|
}
|
|
//little endian
|
|
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;
|
|
|
|
sizeOfBlock >>= 2;
|
|
for (i = 0; i < sizeOfBlock; i++)
|
|
{
|
|
block[i] = isLittleLong(block[i]);
|
|
}
|
|
}
|
|
|
|
//
|
|
// copyLump
|
|
//
|
|
|
|
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);
|
|
|
|
return length / size;
|
|
}
|
|
|
|
//
|
|
// swapBSPFile
|
|
//
|
|
|
|
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);
|
|
}
|
|
|
|
// planes
|
|
swapBlock((int *)&m_dplanes[0], m_numplanes * sizeof(m_dplanes[0]));
|
|
|
|
// nodes
|
|
swapBlock((int *)&m_dnodes[0], m_numnodes * sizeof(m_dnodes[0]));
|
|
|
|
// leafs
|
|
swapBlock((int *)&m_dleafs[0], m_numleafs * sizeof(m_dleafs[0]));
|
|
|
|
// leaffaces
|
|
swapBlock((int *)&m_dleafsurfaces[0], m_numleafsurfaces * sizeof(m_dleafsurfaces[0]));
|
|
|
|
// leafbrushes
|
|
swapBlock((int *)&m_dleafbrushes[0], m_numleafbrushes * sizeof(m_dleafbrushes[0]));
|
|
|
|
// brushes
|
|
swapBlock((int *)&m_dbrushes[0], m_numbrushes * sizeof(m_dbrushes[0]));
|
|
|
|
// brushsides
|
|
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]);
|
|
|
|
// drawindexes
|
|
swapBlock((int *)&m_drawIndexes[0], m_numDrawIndexes * sizeof(m_drawIndexes[0]));
|
|
|
|
// drawsurfs
|
|
swapBlock((int *)&m_drawSurfaces[0], m_numDrawSurfaces * sizeof(m_drawSurfaces[0]));
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
if (found)
|
|
{
|
|
outvec[0] = origin[0];
|
|
outvec[1] = origin[1];
|
|
outvec[2] = origin[2];
|
|
}
|
|
return found;
|
|
}
|
|
|
|
const BSPEntity *BspLoader::getEntityByValue(const char *name, const char *value)
|
|
{
|
|
const BSPEntity *entity = NULL;
|
|
|
|
for (int i = 1; i < m_num_entities; i++)
|
|
{
|
|
const BSPEntity &ent = m_entities[i];
|
|
|
|
const char *cl = getValueForKey(&m_entities[i], name);
|
|
if (!strcmp(cl, value))
|
|
{
|
|
entity = &ent;
|
|
break;
|
|
}
|
|
}
|
|
return entity;
|
|
}
|