olegpz
/
ericw-tools
mirror of https://github.com/ericwa/ericw-tools.git
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

qbsp: refactor edges writing

This commit is contained in:
Eric Wasylishen 2021-08-23 19:36:41 -06:00
parent 671bacf30c
commit f4700f978d
4 changed files with 24 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
include/qbsp/map.hh
View File

@ -160,6 +160,7 @@ typedef struct mapdata_s {
std::vector<bsp29_dnode_t> exported_nodes_bsp29; // FIXME: change to generic node
std::vector<uint16_t> exported_marksurfaces; // FIXME: change type to generic
std::vector<bsp29_dclipnode_t> exported_clipnodes;
std::vector<bsp29_dedge_t> exported_edges;
// helpers
std::string texinfoTextureName(int texinfo) const {

4
qbsp/bspfile.cc
View File

@ -302,7 +302,7 @@ WriteBSPFile(void)
AddLumpFromBuffer(f, LUMP_CLIPNODES, map.exported_clipnodes.data(), map.exported_clipnodes.size() * sizeof(map.exported_clipnodes[0]));
AddLumpFromBuffer(f, LUMP_MARKSURFACES, map.exported_marksurfaces.data(), map.exported_marksurfaces.size() * sizeof(map.exported_marksurfaces[0]));
AddLump(f, LUMP_SURFEDGES);
AddLump(f, LUMP_EDGES);
AddLumpFromBuffer(f, LUMP_EDGES, map.exported_edges.data(), map.exported_edges.size() * sizeof(map.exported_edges[0]));
AddLump(f, LUMP_MODELS);
AddLump(f, LUMP_LIGHTING);
@ -390,7 +390,7 @@ PrintBSPFileSizes(void)
Message(msgStat, "%8d leafs %10d", static_cast<int>(map.exported_leafs_bsp29.size()), static_cast<int>(map.exported_leafs_bsp29.size()) * MemSize[BSP_LEAF]);
Message(msgStat, "%8d marksurfaces %10d", static_cast<int>(map.exported_marksurfaces.size()), static_cast<int>(map.exported_marksurfaces.size()) * MemSize[BSP_MARKSURF]);
Message(msgStat, "%8d surfedges %10d", map.cTotal[LUMP_SURFEDGES], map.cTotal[LUMP_SURFEDGES] * MemSize[BSP_SURFEDGE]);
Message(msgStat, "%8d edges %10d", map.cTotal[LUMP_EDGES], map.cTotal[LUMP_EDGES] * MemSize[BSP_EDGE]);
Message(msgStat, "%8d edges %10d", static_cast<int>(map.exported_edges.size()), static_cast<int>(map.exported_edges.size()) * MemSize[BSP_EDGE]);
lump = &pWorldEnt()->lumps[LUMP_TEXTURES];
if (lump->data)

56
qbsp/surfaces.cc
View File

@ -173,9 +173,8 @@ GatherNodeFaces(node_t *headnode)
//===========================================================================
// This is a kludge. Should be pEdgeFaces[2].
static const face_t **pEdgeFaces0;
static const face_t **pEdgeFaces1;
static int cStartEdge;
static std::map<int, const face_t *> pEdgeFaces0;
static std::map<int, const face_t *> pEdgeFaces1;
//============================================================================
@ -187,6 +186,8 @@ static std::map<std::tuple<int,int,int>, std::list<hashvert_t>> hashverts;
static void
InitHash(void)
{
pEdgeFaces0.clear();
pEdgeFaces1.clear();
hashverts.clear();
hashedges.clear();
}
@ -293,7 +294,6 @@ static int
GetEdge(mapentity_t *entity, const vec3_t p1, const vec3_t p2,
const face_t *face)
{
struct lumpdata *edges = &entity->lumps[LUMP_EDGES];
int v1, v2;
int i;
@ -306,32 +306,30 @@ GetEdge(mapentity_t *entity, const vec3_t p1, const vec3_t p2,
// search for an existing edge from v2->v1
const std::pair<int,int> edge_hash_key = std::make_pair(v2, v1);
if (options.BSPVersion == BSPVERSION || options.BSPVersion == BSPHLVERSION) {
{
bsp29_dedge_t *edge;
auto it = hashedges.find(edge_hash_key);
if (it != hashedges.end()) {
for (const int i : it->second) {
edge = (bsp29_dedge_t *)edges->data + i;
if (!(v1 == edge->v[1] && v2 == edge->v[0])) {
Error("Too many edges for standard BSP format. Try compiling with -bsp2");
}
edge = &map.exported_edges.at(i);
if (pEdgeFaces1[i] == NULL
&& pEdgeFaces0[i]->contents[0] == face->contents[0]) {
pEdgeFaces1[i] = face;
return -(i + cStartEdge);
return -i;
}
}
}
/* emit an edge */
i = edges->index;
edge = (bsp29_dedge_t *)edges->data + i;
if (edges->index >= edges->count)
Error("Internal error: didn't allocate enough edges?");
i = static_cast<int>(map.exported_edges.size());
map.exported_edges.push_back({});
edge = &map.exported_edges.at(i);
edge->v[0] = v1;
edge->v[1] = v2;
} else {
}
#if 0
else {
bsp2_dedge_t *edge;
auto it = hashedges.find(edge_hash_key);
@ -355,13 +353,12 @@ GetEdge(mapentity_t *entity, const vec3_t p1, const vec3_t p2,
edge->v[0] = v1;
edge->v[1] = v2;
}
#endif
AddHashEdge(v1, v2, edges->index);
AddHashEdge(v1, v2, i);
edges->index++;
map.cTotal[LUMP_EDGES]++;
pEdgeFaces0[i] = face;
return i + cStartEdge;
return i;
}
@ -539,7 +536,6 @@ MakeFaceEdges(mapentity_t *entity, node_t *headnode)
{
int i, firstface;
struct lumpdata *surfedges = &entity->lumps[LUMP_SURFEDGES];
struct lumpdata *edges = &entity->lumps[LUMP_EDGES];
struct lumpdata *vertices = &entity->lumps[LUMP_VERTEXES];
struct lumpdata *faces = &entity->lumps[LUMP_FACES];
struct lumpdata *lmshifts = &entity->lumps[BSPX_LMSHIFT];
@ -547,10 +543,6 @@ MakeFaceEdges(mapentity_t *entity, node_t *headnode)
Message(msgProgress, "MakeFaceEdges");
needlmshifts = false;
cStartEdge = 0;
const int entnum = entity - &map.entities.at(0);
for (i = 0; i < entnum; i++)
cStartEdge += map.entities.at(i).lumps[LUMP_EDGES].count;
CountData_r(entity, headnode);
@ -561,22 +553,17 @@ MakeFaceEdges(mapentity_t *entity, node_t *headnode)
* the time without wasting too much memory...
*/
surfedges->count = vertices->count;
edges->count += surfedges->count;
vertices->data = AllocMem(BSP_VERTEX, vertices->count, true);
edges->data = AllocMem(BSP_EDGE, edges->count, true);
// Accessory data
pEdgeFaces0 = (const face_t **)AllocMem(OTHER, sizeof(face_t *) * edges->count, true);
pEdgeFaces1 = (const face_t **)AllocMem(OTHER, sizeof(face_t *) * edges->count, true);
InitHash();
firstface = map.cTotal[LUMP_FACES];
MakeFaceEdges_r(entity, headnode, 0);
FreeMem(pEdgeFaces0, OTHER, sizeof(face_t *) * edges->count);
FreeMem(pEdgeFaces1, OTHER, sizeof(face_t *) * edges->count);
pEdgeFaces0.clear();
pEdgeFaces1.clear();
/* Free any excess allocated memory */
if (vertices->index < vertices->count) {
@ -586,13 +573,6 @@ MakeFaceEdges(mapentity_t *entity, node_t *headnode)
vertices->data = temp;
vertices->count = vertices->index;
}
if (edges->index < edges->count) {
void *temp = AllocMem(BSP_EDGE, edges->index, true);
memcpy(temp, edges->data, MemSize[BSP_EDGE] * edges->index);
FreeMem(edges->data, BSP_EDGE, edges->count);
edges->data = temp;
edges->count = edges->index;
}
if (map.cTotal[LUMP_VERTEXES] > 65535 && (options.BSPVersion == BSPVERSION || options.BSPVersion == BSPHLVERSION))
Error("Too many vertices (%d > 65535). Recompile with the \"-bsp2\" flag to lift this restriction.", map.cTotal[LUMP_VERTEXES]);

5
qbsp/writebsp.cc
View File

@ -374,9 +374,8 @@ void
BeginBSPFile(void)
{
// First edge must remain unused because 0 can't be negated
pWorldEnt()->lumps[LUMP_EDGES].count++;
pWorldEnt()->lumps[LUMP_EDGES].index++;
map.cTotal[LUMP_EDGES]++;
map.exported_edges.push_back({});
Q_assert(map.exported_edges.size() == 1);
// Leave room for leaf 0 (must be solid)
map.exported_leafs_bsp29.push_back({});