nullprop/halflife-photomode
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

Remove bsplib.h & bsplib.cpp

Browse source 
Resolves #143
This commit is contained in:
Sam V 2022-03-18 13:59:07 +01:00
parent 33eac13fc3
commit 82f8b266fa
6 changed files with 10 additions and 1051 deletions
Download patch file Download diff file Expand all files Collapse all files

4
projects/vs2019/qbsp2.vcxproj
View file

@ -11,7 +11,7 @@
</ProjectConfiguration>
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\..\utils\common\bsplib.h" />
<ClInclude Include="..\..\utils\common\bspfile.h" />
<ClInclude Include="..\..\utils\common\cmdlib.h" />
<ClInclude Include="..\..\utils\common\mathlib.h" />
<ClInclude Include="..\..\utils\common\scriplib.h" />
@ -19,7 +19,7 @@
<ClInclude Include="..\..\utils\qbsp2\bsp5.h" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\..\utils\common\bsplib.cpp" />
<ClCompile Include="..\..\utils\common\bspfile.cpp" />
<ClCompile Include="..\..\utils\common\cmdlib.cpp" />
<ClCompile Include="..\..\utils\common\mathlib.cpp" />
<ClCompile Include="..\..\utils\common\scriplib.cpp" />

12
projects/vs2019/qbsp2.vcxproj.filters
View file

@ -36,9 +36,6 @@
<ClInclude Include="..\..\utils\qbsp2\bsp5.h">
<Filter>Header Files\utils\qbsp2</Filter>
</ClInclude>
<ClInclude Include="..\..\utils\common\bsplib.h">
<Filter>Header Files\utils\common</Filter>
</ClInclude>
<ClInclude Include="..\..\utils\common\threads.h">
<Filter>Header Files\utils\common</Filter>
</ClInclude>
@ -51,11 +48,11 @@
<ClInclude Include="..\..\utils\common\scriplib.h">
<Filter>Header Files\utils\common</Filter>
</ClInclude>
<ClInclude Include="..\..\utils\common\bspfile.h">
<Filter>Header Files\utils\common</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\..\utils\common\bsplib.cpp">
<Filter>Source Files\utils\common</Filter>
</ClCompile>
<ClCompile Include="..\..\utils\common\cmdlib.cpp">
<Filter>Source Files\utils\common</Filter>
</ClCompile>
@ -95,5 +92,8 @@
<ClCompile Include="..\..\utils\qbsp2\tjunc.cpp">
<Filter>Source Files\utils\qbsp2</Filter>
</ClCompile>
<ClCompile Include="..\..\utils\common\bspfile.cpp">
<Filter>Source Files\utils\common</Filter>
</ClCompile>
</ItemGroup>
</Project>

2
utils/bspinfo/bspinfo.cpp
View file

@ -10,7 +10,7 @@
#include "cmdlib.h"
#include "mathlib.h"
#include "bsplib.h"
#include "bspfile.h"
void main(int argc, char** argv)
{

709
utils/common/bsplib.cpp
View file

@ -1,709 +0,0 @@
/***
*
* Copyright (c) 1998, Valve LLC. All rights reserved.
*
* This product contains software technology licensed from Id
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
* All Rights Reserved.
*
****/
#include "cmdlib.h"
#include "mathlib.h"
#include "bsplib.h"
#include "scriplib.h"
//=============================================================================
int nummodels;
dmodel_t dmodels[MAX_MAP_MODELS];
int dmodels_checksum;
int visdatasize;
byte dvisdata[MAX_MAP_VISIBILITY];
int dvisdata_checksum;
int lightdatasize;
byte dlightdata[MAX_MAP_LIGHTING];
int dlightdata_checksum;
int texdatasize;
byte dtexdata[MAX_MAP_MIPTEX]; // (dmiptexlump_t)
int dtexdata_checksum;
int entdatasize;
char dentdata[MAX_MAP_ENTSTRING];
int dentdata_checksum;
int numleafs;
dleaf_t dleafs[MAX_MAP_LEAFS];
int dleafs_checksum;
int numplanes;
dplane_t dplanes[MAX_MAP_PLANES];
int dplanes_checksum;
int numvertexes;
dvertex_t dvertexes[MAX_MAP_VERTS];
int dvertexes_checksum;
int numnodes;
dnode_t dnodes[MAX_MAP_NODES];
int dnodes_checksum;
int numtexinfo;
texinfo_t texinfo[MAX_MAP_TEXINFO];
int texinfo_checksum;
int numfaces;
dface_t dfaces[MAX_MAP_FACES];
int dfaces_checksum;
int numclipnodes;
dclipnode_t dclipnodes[MAX_MAP_CLIPNODES];
int dclipnodes_checksum;
int numedges;
dedge_t dedges[MAX_MAP_EDGES];
int dedges_checksum;
int nummarksurfaces;
unsigned short dmarksurfaces[MAX_MAP_MARKSURFACES];
int dmarksurfaces_checksum;
int numsurfedges;
int dsurfedges[MAX_MAP_SURFEDGES];
int dsurfedges_checksum;
int num_entities;
entity_t entities[MAX_MAP_ENTITIES];
/*
===============
FastChecksum
===============
*/
int FastChecksum(void* buffer, int bytes)
{
char* byteBuffer = reinterpret_cast<char*>(buffer);
int checksum = 0;
while (bytes--)
checksum = _rotl(checksum, 4) ^ *byteBuffer++;
return checksum;
}
/*
===============
CompressVis
===============
*/
int CompressVis(byte* vis, byte* dest)
{
int j;
int rep;
int visrow;
byte* dest_p;
dest_p = dest;
visrow = (numleafs + 7) >> 3;
for (j = 0; j < visrow; j++)
{
*dest_p++ = vis[j];
if (vis[j])
continue;
rep = 1;
for (j++; j < visrow; j++)
if (vis[j] || rep == 255)
break;
else
rep++;
*dest_p++ = rep;
j--;
}
return dest_p - dest;
}
/*
===================
DecompressVis
===================
*/
void DecompressVis(byte* in, byte* decompressed)
{
int c;
byte* out;
int row;
row = (numleafs + 7) >> 3;
out = decompressed;
do
{
if (*in)
{
*out++ = *in++;
continue;
}
c = in[1];
in += 2;
while (c)
{
*out++ = 0;
c--;
}
} while (out - decompressed < row);
}
//=============================================================================
/*
=============
SwapBSPFile
Byte swaps all data in a bsp file.
=============
*/
void SwapBSPFile(qboolean todisk)
{
int i, j, c;
dmodel_t* d;
dmiptexlump_t* mtl;
// models
for (i = 0; i < nummodels; i++)
{
d = &dmodels[i];
for (j = 0; j < MAX_MAP_HULLS; j++)
d->headnode[j] = LittleLong(d->headnode[j]);
d->visleafs = LittleLong(d->visleafs);
d->firstface = LittleLong(d->firstface);
d->numfaces = LittleLong(d->numfaces);
for (j = 0; j < 3; j++)
{
d->mins[j] = LittleFloat(d->mins[j]);
d->maxs[j] = LittleFloat(d->maxs[j]);
d->origin[j] = LittleFloat(d->origin[j]);
}
}
//
// vertexes
//
for (i = 0; i < numvertexes; i++)
{
for (j = 0; j < 3; j++)
dvertexes[i].point[j] = LittleFloat(dvertexes[i].point[j]);
}
//
// planes
//
for (i = 0; i < numplanes; i++)
{
for (j = 0; j < 3; j++)
dplanes[i].normal[j] = LittleFloat(dplanes[i].normal[j]);
dplanes[i].dist = LittleFloat(dplanes[i].dist);
dplanes[i].type = LittleLong(dplanes[i].type);
}
//
// texinfos
//
for (i = 0; i < numtexinfo; i++)
{
for (j = 0; j < 8; j++)
texinfo[i].vecs[0][j] = LittleFloat(texinfo[i].vecs[0][j]);
texinfo[i].miptex = LittleLong(texinfo[i].miptex);
texinfo[i].flags = LittleLong(texinfo[i].flags);
}
//
// faces
//
for (i = 0; i < numfaces; i++)
{
dfaces[i].texinfo = LittleShort(dfaces[i].texinfo);
dfaces[i].planenum = LittleShort(dfaces[i].planenum);
dfaces[i].side = LittleShort(dfaces[i].side);
dfaces[i].lightofs = LittleLong(dfaces[i].lightofs);
dfaces[i].firstedge = LittleLong(dfaces[i].firstedge);
dfaces[i].numedges = LittleShort(dfaces[i].numedges);
}
//
// nodes
//
for (i = 0; i < numnodes; i++)
{
dnodes[i].planenum = LittleLong(dnodes[i].planenum);
for (j = 0; j < 3; j++)
{
dnodes[i].mins[j] = LittleShort(dnodes[i].mins[j]);
dnodes[i].maxs[j] = LittleShort(dnodes[i].maxs[j]);
}
dnodes[i].children[0] = LittleShort(dnodes[i].children[0]);
dnodes[i].children[1] = LittleShort(dnodes[i].children[1]);
dnodes[i].firstface = LittleShort(dnodes[i].firstface);
dnodes[i].numfaces = LittleShort(dnodes[i].numfaces);
}
//
// leafs
//
for (i = 0; i < numleafs; i++)
{
dleafs[i].contents = LittleLong(dleafs[i].contents);
for (j = 0; j < 3; j++)
{
dleafs[i].mins[j] = LittleShort(dleafs[i].mins[j]);
dleafs[i].maxs[j] = LittleShort(dleafs[i].maxs[j]);
}
dleafs[i].firstmarksurface = LittleShort(dleafs[i].firstmarksurface);
dleafs[i].nummarksurfaces = LittleShort(dleafs[i].nummarksurfaces);
dleafs[i].visofs = LittleLong(dleafs[i].visofs);
}
//
// clipnodes
//
for (i = 0; i < numclipnodes; i++)
{
dclipnodes[i].planenum = LittleLong(dclipnodes[i].planenum);
dclipnodes[i].children[0] = LittleShort(dclipnodes[i].children[0]);
dclipnodes[i].children[1] = LittleShort(dclipnodes[i].children[1]);
}
//
// miptex
//
if (texdatasize)
{
mtl = (dmiptexlump_t*)dtexdata;
if (todisk)
c = mtl->nummiptex;
else
c = LittleLong(mtl->nummiptex);
mtl->nummiptex = LittleLong(mtl->nummiptex);
for (i = 0; i < c; i++)
mtl->dataofs[i] = LittleLong(mtl->dataofs[i]);
}
//
// marksurfaces
//
for (i = 0; i < nummarksurfaces; i++)
dmarksurfaces[i] = LittleShort(dmarksurfaces[i]);
//
// surfedges
//
for (i = 0; i < numsurfedges; i++)
dsurfedges[i] = LittleLong(dsurfedges[i]);
//
// edges
//
for (i = 0; i < numedges; i++)
{
dedges[i].v[0] = LittleShort(dedges[i].v[0]);
dedges[i].v[1] = LittleShort(dedges[i].v[1]);
}
}
dheader_t* header;
int CopyLump(int lump, void* dest, int size)
{
int length, ofs;
length = header->lumps[lump].filelen;
ofs = header->lumps[lump].fileofs;
if (length % size)
Error("LoadBSPFile: odd lump size");
memcpy(dest, (byte*)header + ofs, length);
return length / size;
}
/*
=============
LoadBSPFile
=============
*/
void LoadBSPFile(char* filename)
{
int i;
//
// load the file header
//
LoadFile(filename, (void**)&header);
// swap the header
for (i = 0; i < sizeof(dheader_t) / 4; i++)
((int*)header)[i] = LittleLong(((int*)header)[i]);
if (header->version != BSPVERSION)
Error("%s is version %i, not %i", filename, header->version, BSPVERSION);
nummodels = CopyLump(LUMP_MODELS, dmodels, sizeof(dmodel_t));
numvertexes = CopyLump(LUMP_VERTEXES, dvertexes, sizeof(dvertex_t));
numplanes = CopyLump(LUMP_PLANES, dplanes, sizeof(dplane_t));
numleafs = CopyLump(LUMP_LEAFS, dleafs, sizeof(dleaf_t));
numnodes = CopyLump(LUMP_NODES, dnodes, sizeof(dnode_t));
numtexinfo = CopyLump(LUMP_TEXINFO, texinfo, sizeof(texinfo_t));
numclipnodes = CopyLump(LUMP_CLIPNODES, dclipnodes, sizeof(dclipnode_t));
numfaces = CopyLump(LUMP_FACES, dfaces, sizeof(dface_t));
nummarksurfaces = CopyLump(LUMP_MARKSURFACES, dmarksurfaces, sizeof(dmarksurfaces[0]));
numsurfedges = CopyLump(LUMP_SURFEDGES, dsurfedges, sizeof(dsurfedges[0]));
numedges = CopyLump(LUMP_EDGES, dedges, sizeof(dedge_t));
texdatasize = CopyLump(LUMP_TEXTURES, dtexdata, 1);
visdatasize = CopyLump(LUMP_VISIBILITY, dvisdata, 1);
lightdatasize = CopyLump(LUMP_LIGHTING, dlightdata, 1);
entdatasize = CopyLump(LUMP_ENTITIES, dentdata, 1);
free(header); // everything has been copied out
//
// swap everything
//
SwapBSPFile(false);
dmodels_checksum = FastChecksum(dmodels, nummodels * sizeof(dmodels[0]));
dvertexes_checksum = FastChecksum(dvertexes, numvertexes * sizeof(dvertexes[0]));
dplanes_checksum = FastChecksum(dplanes, numplanes * sizeof(dplanes[0]));
dleafs_checksum = FastChecksum(dleafs, numleafs * sizeof(dleafs[0]));
dnodes_checksum = FastChecksum(dnodes, numnodes * sizeof(dnodes[0]));
texinfo_checksum = FastChecksum(texinfo, numtexinfo * sizeof(texinfo[0]));
dclipnodes_checksum = FastChecksum(dclipnodes, numclipnodes * sizeof(dclipnodes[0]));
dfaces_checksum = FastChecksum(dfaces, numfaces * sizeof(dfaces[0]));
dmarksurfaces_checksum = FastChecksum(dmarksurfaces, nummarksurfaces * sizeof(dmarksurfaces[0]));
dsurfedges_checksum = FastChecksum(dsurfedges, numsurfedges * sizeof(dsurfedges[0]));
dedges_checksum = FastChecksum(dedges, numedges * sizeof(dedges[0]));
dtexdata_checksum = FastChecksum(dtexdata, numedges * sizeof(dtexdata[0]));
dvisdata_checksum = FastChecksum(dvisdata, visdatasize * sizeof(dvisdata[0]));
dlightdata_checksum = FastChecksum(dlightdata, lightdatasize * sizeof(dlightdata[0]));
dentdata_checksum = FastChecksum(dentdata, entdatasize * sizeof(dentdata[0]));
}
//============================================================================
FILE* wadfile;
dheader_t outheader;
void AddLump(int lumpnum, void* data, int len)
{
lump_t* lump;
lump = &header->lumps[lumpnum];
lump->fileofs = LittleLong(ftell(wadfile));
lump->filelen = LittleLong(len);
SafeWrite(wadfile, data, (len + 3) & ~3);
}
/*
=============
WriteBSPFile
Swaps the bsp file in place, so it should not be referenced again
=============
*/
void WriteBSPFile(char* filename)
{
header = &outheader;
memset(header, 0, sizeof(dheader_t));
SwapBSPFile(true);
header->version = LittleLong(BSPVERSION);
wadfile = SafeOpenWrite(filename);
SafeWrite(wadfile, header, sizeof(dheader_t)); // overwritten later
AddLump(LUMP_PLANES, dplanes, numplanes * sizeof(dplane_t));
AddLump(LUMP_LEAFS, dleafs, numleafs * sizeof(dleaf_t));
AddLump(LUMP_VERTEXES, dvertexes, numvertexes * sizeof(dvertex_t));
AddLump(LUMP_NODES, dnodes, numnodes * sizeof(dnode_t));
AddLump(LUMP_TEXINFO, texinfo, numtexinfo * sizeof(texinfo_t));
AddLump(LUMP_FACES, dfaces, numfaces * sizeof(dface_t));
AddLump(LUMP_CLIPNODES, dclipnodes, numclipnodes * sizeof(dclipnode_t));
AddLump(LUMP_MARKSURFACES, dmarksurfaces, nummarksurfaces * sizeof(dmarksurfaces[0]));
AddLump(LUMP_SURFEDGES, dsurfedges, numsurfedges * sizeof(dsurfedges[0]));
AddLump(LUMP_EDGES, dedges, numedges * sizeof(dedge_t));
AddLump(LUMP_MODELS, dmodels, nummodels * sizeof(dmodel_t));
AddLump(LUMP_LIGHTING, dlightdata, lightdatasize);
AddLump(LUMP_VISIBILITY, dvisdata, visdatasize);
AddLump(LUMP_ENTITIES, dentdata, entdatasize);
AddLump(LUMP_TEXTURES, dtexdata, texdatasize);
fseek(wadfile, 0, SEEK_SET);
SafeWrite(wadfile, header, sizeof(dheader_t));
fclose(wadfile);
}
//============================================================================
#define ENTRIES(a) (sizeof(a) / sizeof(*(a)))
#define ENTRYSIZE(a) (sizeof(*(a)))
int ArrayUsage(char* szItem, int items, int maxitems, int itemsize)
{
float percentage = maxitems ? items * 100.0 / maxitems : 0.0;
printf("%-12s %7i/%-7i %7i/%-7i (%4.1f%%)",
szItem, items, maxitems, items * itemsize, maxitems * itemsize, percentage);
if (percentage > 80.0)
printf("VERY FULL!\n");
else if (percentage > 95.0)
printf("SIZE DANGER!\n");
else if (percentage > 99.9)
printf("SIZE OVERFLOW!!!\n");
else
printf("\n");
return items * itemsize;
}
int GlobUsage(char* szItem, int itemstorage, int maxstorage)
{
float percentage = maxstorage ? itemstorage * 100.0 / maxstorage : 0.0;
printf("%-12s [variable] %7i/%-7i (%4.1f%%)",
szItem, itemstorage, maxstorage, percentage);
if (percentage > 80.0)
printf("VERY FULL!\n");
else if (percentage > 95.0)
printf("SIZE DANGER!\n");
else if (percentage > 99.9)
printf("SIZE OVERFLOW!!!\n");
else
printf("\n");
return itemstorage;
}
/*
=============
PrintBSPFileSizes
Dumps info about current file
=============
*/
void PrintBSPFileSizes(void)
{
//int numtextures = texdatasize ? ((dmiptexlump_t*)dtexdata)->nummiptex : 0;
int totalmemory = 0;
printf("\n");
printf("Object names Objects/Maxobjs Memory / Maxmem Fullness\n");
printf("------------ --------------- --------------- --------\n");
totalmemory += ArrayUsage("models", nummodels, ENTRIES(dmodels), ENTRYSIZE(dmodels));
totalmemory += ArrayUsage("planes", numplanes, ENTRIES(dplanes), ENTRYSIZE(dplanes));
totalmemory += ArrayUsage("vertexes", numvertexes, ENTRIES(dvertexes), ENTRYSIZE(dvertexes));
totalmemory += ArrayUsage("nodes", numnodes, ENTRIES(dnodes), ENTRYSIZE(dnodes));
totalmemory += ArrayUsage("texinfos", numtexinfo, ENTRIES(texinfo), ENTRYSIZE(texinfo));
totalmemory += ArrayUsage("faces", numfaces, ENTRIES(dfaces), ENTRYSIZE(dfaces));
totalmemory += ArrayUsage("clipnodes", numclipnodes, ENTRIES(dclipnodes), ENTRYSIZE(dclipnodes));
totalmemory += ArrayUsage("leaves", numleafs, ENTRIES(dleafs), ENTRYSIZE(dleafs));
totalmemory += ArrayUsage("marksurfaces", nummarksurfaces, ENTRIES(dmarksurfaces), ENTRYSIZE(dmarksurfaces));
totalmemory += ArrayUsage("surfedges", numsurfedges, ENTRIES(dsurfedges), ENTRYSIZE(dsurfedges));
totalmemory += ArrayUsage("edges", numedges, ENTRIES(dedges), ENTRYSIZE(dedges));
totalmemory += GlobUsage("texdata", texdatasize, sizeof(dtexdata));
totalmemory += GlobUsage("lightdata", lightdatasize, sizeof(dlightdata));
totalmemory += GlobUsage("visdata", visdatasize, sizeof(dvisdata));
totalmemory += GlobUsage("entdata", entdatasize, sizeof(dentdata));
printf("=== Total BSP file data space used: %d bytes ===\n", totalmemory);
}
/*
=================
ParseEpair
=================
*/
epair_t* ParseEpair(void)
{
epair_t* e;
e = reinterpret_cast<epair_t*>(malloc(sizeof(epair_t)));
memset(e, 0, sizeof(epair_t));
if (strlen(token) >= MAX_KEY - 1)
Error("ParseEpar: token too long");
e->key = copystring(token);
GetToken(false);
if (strlen(token) >= MAX_VALUE - 1)
Error("ParseEpar: token too long");
e->value = copystring(token);
return e;
}
/*
================
ParseEntity
================
*/
qboolean ParseEntity(void)
{
epair_t* e;
entity_t* mapent;
if (!GetToken(true))
return false;
if (strcmp(token, "{"))
Error("ParseEntity: { not found");
if (num_entities == MAX_MAP_ENTITIES)
Error("num_entities == MAX_MAP_ENTITIES");
mapent = &entities[num_entities];
num_entities++;
do
{
if (!GetToken(true))
Error("ParseEntity: EOF without closing brace");
if (!strcmp(token, "}"))
break;
e = ParseEpair();
e->next = mapent->epairs;
mapent->epairs = e;
} while (1);
return true;
}
/*
================
ParseEntities
Parses the dentdata string into entities
================
*/
void ParseEntities(void)
{
num_entities = 0;
ParseFromMemory(dentdata, entdatasize);
while (ParseEntity())
{
}
}
/*
================
UnparseEntities
Generates the dentdata string from all the entities
================
*/
void UnparseEntities(void)
{
char *buf, *end;
epair_t* ep;
char line[2048];
int i;
buf = dentdata;
end = buf;
*end = 0;
for (i = 0; i < num_entities; i++)
{
ep = entities[i].epairs;
if (!ep)
continue; // ent got removed
strcat(end, "{\n");
end += 2;
for (ep = entities[i].epairs; ep; ep = ep->next)
{
sprintf(line, "\"%s\" \"%s\"\n", ep->key, ep->value);
strcat(end, line);
end += strlen(line);
}
strcat(end, "}\n");
end += 2;
if (end > buf + MAX_MAP_ENTSTRING)
Error("Entity text too long");
}
entdatasize = end - buf + 1;
}
void SetKeyValue(entity_t* ent, char* key, char* value)
{
epair_t* ep;
for (ep = ent->epairs; ep; ep = ep->next)
if (!strcmp(ep->key, key))
{
free(ep->value);
ep->value = copystring(value);
return;
}
ep = reinterpret_cast<epair_t*>(malloc(sizeof(*ep)));
ep->next = ent->epairs;
ent->epairs = ep;
ep->key = copystring(key);
ep->value = copystring(value);
}
char* ValueForKey(entity_t* ent, char* key)
{
epair_t* ep;
for (ep = ent->epairs; ep; ep = ep->next)
if (!strcmp(ep->key, key))
return ep->value;
return "";
}
vec_t FloatForKey(entity_t* ent, char* key)
{
char* k;
k = ValueForKey(ent, key);
return atof(k);
}
void GetVectorForKey(entity_t* ent, char* key, vec3_t vec)
{
char* k;
double v1, v2, v3;
k = ValueForKey(ent, key);
// scanf into doubles, then assign, so it is vec_t size independent
v1 = v2 = v3 = 0;
sscanf(k, "%lf %lf %lf", &v1, &v2, &v3);
vec[0] = v1;
vec[1] = v2;
vec[2] = v3;
}

332
utils/common/bsplib.h
View file

@ -1,332 +0,0 @@
/***
*
* Copyright (c) 1998, Valve LLC. All rights reserved.
*
* This product contains software technology licensed from Id
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
* All Rights Reserved.
*
****/
// upper design bounds
#define MAX_MAP_HULLS 4
#define MAX_MAP_MODELS 400
#define MAX_MAP_BRUSHES 4096
#define MAX_MAP_ENTITIES 1024
#define MAX_MAP_ENTSTRING (128 * 1024)
#define MAX_MAP_PLANES 32767
#define MAX_MAP_NODES 32767 // because negative shorts are contents
#define MAX_MAP_CLIPNODES 32767 //
#define MAX_MAP_LEAFS 8192
#define MAX_MAP_VERTS 65535
#define MAX_MAP_FACES 65535
#define MAX_MAP_MARKSURFACES 65535
#define MAX_MAP_TEXINFO 8192
#define MAX_MAP_EDGES 256000
#define MAX_MAP_SURFEDGES 512000
#define MAX_MAP_TEXTURES 512
#define MAX_MAP_MIPTEX 0x200000
#define MAX_MAP_LIGHTING 0x200000
#define MAX_MAP_VISIBILITY 0x200000
#define MAX_MAP_PORTALS 65536
// key / value pair sizes
#define MAX_KEY 32
#define MAX_VALUE 1024
//=============================================================================
#define BSPVERSION 30
#define TOOLVERSION 2
typedef struct
{
int fileofs, filelen;
} lump_t;
#define LUMP_ENTITIES 0
#define LUMP_PLANES 1
#define LUMP_TEXTURES 2
#define LUMP_VERTEXES 3
#define LUMP_VISIBILITY 4
#define LUMP_NODES 5
#define LUMP_TEXINFO 6
#define LUMP_FACES 7
#define LUMP_LIGHTING 8
#define LUMP_CLIPNODES 9
#define LUMP_LEAFS 10
#define LUMP_MARKSURFACES 11
#define LUMP_EDGES 12
#define LUMP_SURFEDGES 13
#define LUMP_MODELS 14
#define HEADER_LUMPS 15
typedef struct
{
float mins[3], maxs[3];
float origin[3];
int headnode[MAX_MAP_HULLS];
int visleafs; // not including the solid leaf 0
int firstface, numfaces;
} dmodel_t;
typedef struct
{
int version;
lump_t lumps[HEADER_LUMPS];
} dheader_t;
typedef struct
{
int nummiptex;
int dataofs[4]; // [nummiptex]
} dmiptexlump_t;
#define MIPLEVELS 4
typedef struct miptex_s
{
char name[16];
unsigned width, height;
unsigned offsets[MIPLEVELS]; // four mip maps stored
} miptex_t;
typedef struct
{
float point[3];
} dvertex_t;
// 0-2 are axial planes
#define PLANE_X 0
#define PLANE_Y 1
#define PLANE_Z 2
// 3-5 are non-axial planes snapped to the nearest
#define PLANE_ANYX 3
#define PLANE_ANYY 4
#define PLANE_ANYZ 5
typedef struct
{
float normal[3];
float dist;
int type; // PLANE_X - PLANE_ANYZ ?remove? trivial to regenerate
} dplane_t;
#define CONTENTS_EMPTY -1
#define CONTENTS_SOLID -2
#define CONTENTS_WATER -3
#define CONTENTS_SLIME -4
#define CONTENTS_LAVA -5
#define CONTENTS_SKY -6
#define CONTENTS_ORIGIN -7 // removed at csg time
#define CONTENTS_CLIP -8 // changed to contents_solid
#define CONTENTS_CURRENT_0 -9
#define CONTENTS_CURRENT_90 -10
#define CONTENTS_CURRENT_180 -11
#define CONTENTS_CURRENT_270 -12
#define CONTENTS_CURRENT_UP -13
#define CONTENTS_CURRENT_DOWN -14
#define CONTENTS_TRANSLUCENT -15
// !!! if this is changed, it must be changed in asm_i386.h too !!!
typedef struct
{
int planenum;
short children[2]; // negative numbers are -(leafs+1), not nodes
short mins[3]; // for sphere culling
short maxs[3];
unsigned short firstface;
unsigned short numfaces; // counting both sides
} dnode_t;
typedef struct
{
int planenum;
short children[2]; // negative numbers are contents
} dclipnode_t;
typedef struct texinfo_s
{
float vecs[2][4]; // [s/t][xyz offset]
int miptex;
int flags;
} texinfo_t;
#define TEX_SPECIAL 1 // sky or slime, no lightmap or 256 subdivision
// note that edge 0 is never used, because negative edge nums are used for
// counterclockwise use of the edge in a face
typedef struct
{
unsigned short v[2]; // vertex numbers
} dedge_t;
#define MAXLIGHTMAPS 4
typedef struct
{
short planenum;
short side;
int firstedge; // we must support > 64k edges
short numedges;
short texinfo;
// lighting info
byte styles[MAXLIGHTMAPS];
int lightofs; // start of [numstyles*surfsize] samples
} dface_t;
#define AMBIENT_WATER 0
#define AMBIENT_SKY 1
#define AMBIENT_SLIME 2
#define AMBIENT_LAVA 3
#define NUM_AMBIENTS 4 // automatic ambient sounds
// leaf 0 is the generic CONTENTS_SOLID leaf, used for all solid areas
// all other leafs need visibility info
typedef struct
{
int contents;
int visofs; // -1 = no visibility info
short mins[3]; // for frustum culling
short maxs[3];
unsigned short firstmarksurface;
unsigned short nummarksurfaces;
byte ambient_level[NUM_AMBIENTS];
} dleaf_t;
//============================================================================
#ifndef QUAKE_GAME
#define ANGLE_UP -1
#define ANGLE_DOWN -2
// the utilities get to be lazy and just use large static arrays
extern int nummodels;
extern dmodel_t dmodels[MAX_MAP_MODELS];
extern int dmodels_checksum;
extern int visdatasize;
extern byte dvisdata[MAX_MAP_VISIBILITY];
extern int dvisdata_checksum;
extern int lightdatasize;
extern byte dlightdata[MAX_MAP_LIGHTING];
extern int dlightdata_checksum;
extern int texdatasize;
extern byte dtexdata[MAX_MAP_MIPTEX]; // (dmiptexlump_t)
extern int dtexdata_checksum;
extern int entdatasize;
extern char dentdata[MAX_MAP_ENTSTRING];
extern int dentdata_checksum;
extern int numleafs;
extern dleaf_t dleafs[MAX_MAP_LEAFS];
extern int dleafs_checksum;
extern int numplanes;
extern dplane_t dplanes[MAX_MAP_PLANES];
extern int dplanes_checksum;
extern int numvertexes;
extern dvertex_t dvertexes[MAX_MAP_VERTS];
extern int dvertexes_checksum;
extern int numnodes;
extern dnode_t dnodes[MAX_MAP_NODES];
extern int dnodes_checksum;
extern int numtexinfo;
extern texinfo_t texinfo[MAX_MAP_TEXINFO];
extern int texinfo_checksum;
extern int numfaces;
extern dface_t dfaces[MAX_MAP_FACES];
extern int dfaces_checksum;
extern int numclipnodes;
extern dclipnode_t dclipnodes[MAX_MAP_CLIPNODES];
extern int dclipnodes_checksum;
extern int numedges;
extern dedge_t dedges[MAX_MAP_EDGES];
extern int dedges_checksum;
extern int nummarksurfaces;
extern unsigned short dmarksurfaces[MAX_MAP_MARKSURFACES];
extern int dmarksurfaces_checksum;
extern int numsurfedges;
extern int dsurfedges[MAX_MAP_SURFEDGES];
extern int dsurfedges_checksum;
int FastChecksum(void* buffer, int bytes);
void DecompressVis(byte* in, byte* decompressed);
int CompressVis(byte* vis, byte* dest);
void LoadBSPFile(char* filename);
void WriteBSPFile(char* filename);
void PrintBSPFileSizes(void);
//===============
typedef struct epair_s
{
struct epair_s* next;
char* key;
char* value;
} epair_t;
typedef struct
{
vec3_t origin;
int firstbrush;
int numbrushes;
epair_t* epairs;
} entity_t;
extern int num_entities;
extern entity_t entities[MAX_MAP_ENTITIES];
void ParseEntities(void);
void UnparseEntities(void);
void SetKeyValue(entity_t* ent, char* key, char* value);
char* ValueForKey(entity_t* ent, char* key);
// will return "" if not present
vec_t FloatForKey(entity_t* ent, char* key);
void GetVectorForKey(entity_t* ent, char* key, vec3_t vec);
epair_t* ParseEpair(void);
#endif

2
utils/xwad/xwad.cpp
View file

@ -14,7 +14,7 @@
// #include "csg.h"
#include "lbmlib.h"
#include "mathlib.h"
#include "bsplib.h"
#include "bspfile.h"
#define MAXLUMP (640 * 480 * 85 / 64)