qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2025-01-17 22:50:51 +00:00
Code Issues Projects Releases Packages Wiki Activity

qfbsp now mostly works. only known issue is multiple texture wads don't

Browse source 
load properly and possibly a "reached occupant" issue (dunno if it's the
map or qfbsp)
This commit is contained in:
Bill Currie 2002-09-19 20:39:33 +00:00
parent 54fa6ebae2
commit 0cd34d155f
9 changed files with 256 additions and 130 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

38
include/QF/bspfile.h
View file

@ -71,7 +71,7 @@
#define BSPVERSION 29
#define TOOLVERSION 2
typedef struct {
typedef struct lump_s {
int fileofs;
int filelen;
} lump_t;
@ -94,7 +94,7 @@ typedef struct {
#define HEADER_LUMPS 15
typedef struct {
typedef struct dmodel_s {
float mins[3], maxs[3];
float origin[3];
int headnode[MAX_MAP_HULLS];
@ -102,12 +102,12 @@ typedef struct {
int firstface, numfaces;
} dmodel_t;
typedef struct {
typedef struct dheader_s {
int version;
lump_t lumps[HEADER_LUMPS];
} dheader_t;
typedef struct {
typedef struct dmiptexlump_s {
int nummiptex;
int dataofs[4]; // [nummiptex]
} dmiptexlump_t;
@ -120,7 +120,7 @@ typedef struct miptex_s {
} miptex_t;
typedef struct {
typedef struct dvertex_s {
float point[3];
} dvertex_t;
@ -135,7 +135,7 @@ typedef struct {
#define PLANE_ANYY 4
#define PLANE_ANYZ 5
typedef struct {
typedef struct dplane_s {
float normal[3];
float dist;
int type; // PLANE_X - PLANE_ANYZ ?remove? trivial to regenerate
@ -159,7 +159,7 @@ typedef struct {
// !!! if this is changed, it must be changed in asm_i386.h too !!!
typedef struct {
typedef struct dnode_s {
int planenum;
short children[2]; // negative numbers are -(leafs+1), not nodes
short mins[3]; // for sphere culling
@ -168,7 +168,7 @@ typedef struct {
unsigned short numfaces; // counting both sides
} dnode_t;
typedef struct {
typedef struct dclipnode_s {
int planenum;
short children[2]; // negative numbers are contents
} dclipnode_t;
@ -183,12 +183,12 @@ typedef struct texinfo_s {
// note that edge 0 is never used, because negative edge nums are used for
// counterclockwise use of the edge in a face
typedef struct {
typedef struct dedge_s {
unsigned short v[2]; // vertex numbers
} dedge_t;
#define MAXLIGHTMAPS 4
typedef struct {
typedef struct dface_s {
short planenum;
short side;
@ -212,7 +212,7 @@ typedef struct {
// leaf 0 is the generic CONTENTS_SOLID leaf, used for all solid areas
// all other leafs need visibility info
typedef struct {
typedef struct dleaf_s {
int contents;
int visofs; // -1 = no visibility info
@ -281,6 +281,22 @@ typedef struct bsp_s {
bsp_t *LoadBSPFile (QFile *file, int size);
void WriteBSPFile (bsp_t *bsp, QFile *file);
bsp_t *BSP_New (void);
void BSP_AddPlane (bsp_t *bsp, dplane_t *plane);
void BSP_AddLeaf (bsp_t *bsp, dleaf_t *leaf);
void BSP_AddVertex (bsp_t *bsp, dvertex_t *vertex);
void BSP_AddNode (bsp_t *bsp, dnode_t *node);
void BSP_AddTexinfo (bsp_t *bsp, texinfo_t *texinfo);
void BSP_AddFace (bsp_t *bsp, dface_t *face);
void BSP_AddClipnode (bsp_t *bsp, dclipnode_t *clipnode);
void BSP_AddMarkSurface (bsp_t *bsp, unsigned short marksurface);
void BSP_AddSurfEdge (bsp_t *bsp, int surfedge);
void BSP_AddEdge (bsp_t *bsp, dedge_t *edge);
void BSP_AddModel (bsp_t *bsp, dmodel_t *model);
void BSP_AddLighting (bsp_t *bsp, byte *lightdata, int lightdatasize);
void BSP_AddVisibility (bsp_t *bsp, byte *visdata, int visdatasize);
void BSP_AddEntities (bsp_t *bsp, char *entdata, int entdatasize);
void BSP_AddTextures (bsp_t *bsp, byte *texdata, int texdatasize);
#endif
#endif // __bspfile_h_

113
libs/util/bspfile.c
View file

@ -302,3 +302,116 @@ do { \
Qwrite (file, header, size);
free (header);
}
bsp_t *
BSP_New (void)
{
return calloc (1, sizeof (bsp_t));
}
void BSP_AddPlane (bsp_t *bsp, dplane_t *plane)
{
bsp->planes = realloc (bsp->planes,
(bsp->numplanes + 1) * sizeof (dplane_t));
bsp->planes[bsp->numplanes++] = *plane;
}
void BSP_AddLeaf (bsp_t *bsp, dleaf_t *leaf)
{
bsp->leafs = realloc (bsp->leafs,
(bsp->numleafs + 1) * sizeof (dleaf_t));
bsp->leafs[bsp->numleafs++] = *leaf;
}
void BSP_AddVertex (bsp_t *bsp, dvertex_t *vertex)
{
bsp->vertexes = realloc (bsp->vertexes,
(bsp->numvertexes + 1) * sizeof (dvertex_t));
bsp->vertexes[bsp->numvertexes++] = *vertex;
}
void BSP_AddNode (bsp_t *bsp, dnode_t *node)
{
bsp->nodes = realloc (bsp->nodes,
(bsp->numnodes + 1) * sizeof (dnode_t));
bsp->nodes[bsp->numnodes++] = *node;
}
void
BSP_AddTexinfo (bsp_t *bsp, texinfo_t *texinfo)
{
bsp->texinfo = realloc (bsp->texinfo,
(bsp->numtexinfo + 1) * sizeof (texinfo_t));
bsp->texinfo[bsp->numtexinfo++] = *texinfo;
}
void BSP_AddFace (bsp_t *bsp, dface_t *face)
{
bsp->faces = realloc (bsp->faces,
(bsp->numfaces + 1) * sizeof (dface_t));
bsp->faces[bsp->numfaces++] = *face;
}
void BSP_AddClipnode (bsp_t *bsp, dclipnode_t *clipnode)
{
bsp->clipnodes = realloc (bsp->clipnodes,
(bsp->numclipnodes + 1) * sizeof (dclipnode_t));
bsp->clipnodes[bsp->numclipnodes++] = *clipnode;
}
void BSP_AddMarkSurface (bsp_t *bsp, unsigned short marksurface)
{
bsp->marksurfaces = realloc (bsp->marksurfaces,
(bsp->nummarksurfaces + 1)
* sizeof (unsigned short));
bsp->marksurfaces[bsp->nummarksurfaces++] = marksurface;
}
void BSP_AddSurfEdge (bsp_t *bsp, int surfedge)
{
bsp->surfedges = realloc (bsp->surfedges,
(bsp->numsurfedges + 1) * sizeof (int));
bsp->surfedges[bsp->numsurfedges++] = surfedge;
}
void BSP_AddEdge (bsp_t *bsp, dedge_t *edge)
{
bsp->edges = realloc (bsp->edges,
(bsp->numedges + 1) * sizeof (dedge_t));
bsp->edges[bsp->numedges++] = *edge;
}
void BSP_AddModel (bsp_t *bsp, dmodel_t *model)
{
bsp->models = realloc (bsp->models,
(bsp->nummodels + 1) * sizeof (dmodel_t));
bsp->models[bsp->nummodels++] = *model;
}
void BSP_AddLighting (bsp_t *bsp, byte *lightdata, int lightdatasize)
{
bsp->lightdatasize = lightdatasize;
bsp->lightdata = malloc (lightdatasize);
memcpy (bsp->lightdata, lightdata, lightdatasize);
}
void BSP_AddVisibility (bsp_t *bsp, byte *visdata, int visdatasize)
{
bsp->visdatasize = visdatasize;
bsp->visdata = malloc (visdatasize);
memcpy (bsp->visdata, visdata, visdatasize);
}
void BSP_AddEntities (bsp_t *bsp, char *entdata, int entdatasize)
{
bsp->entdatasize = entdatasize;
bsp->entdata = malloc (entdatasize);
memcpy (bsp->entdata, entdata, entdatasize);
}
void BSP_AddTextures (bsp_t *bsp, byte *texdata, int texdatasize)
{
bsp->texdatasize = texdatasize;
bsp->texdata = malloc (texdatasize);
memcpy (bsp->texdata, texdata, texdatasize);
}

2
tools/qfbsp/include/map.h
View file

@ -18,7 +18,7 @@
See file, 'COPYING', for details.
*/
#define MAX_FACES 16
#define MAX_FACES 128
typedef struct mface_s
{
struct mface_s *next;

4
tools/qfbsp/source/brush.c
View file

@ -429,8 +429,8 @@ vec3_t hull_size[3][2] = {
};
#define MAX_HULL_POINTS 32
#define MAX_HULL_EDGES 64
#define MAX_HULL_POINTS 64
#define MAX_HULL_EDGES 128
int num_hull_points;
vec3_t hull_points[MAX_HULL_POINTS];

33
tools/qfbsp/source/map.c
View file

@ -31,6 +31,7 @@
#endif
#include <stdlib.h>
#include "QF/dstring.h"
#include "QF/quakefs.h"
#include "QF/sys.h"
@ -97,10 +98,7 @@ FindTexinfo (texinfo_t *t)
}
// allocate a new texture
if (bsp->numtexinfo == MAX_MAP_TEXINFO)
Sys_Error ("numtexinfo == MAX_MAP_TEXINFO");
bsp->texinfo[i] = *t;
bsp->numtexinfo++;
BSP_AddTexinfo (bsp, t);
return i;
}
@ -438,8 +436,13 @@ void
LoadMapFile (char *filename)
{
char *buf;
QFile *file;
buf = COM_LoadFile (filename, 0);
file = Qopen (filename, "rt");
buf = malloc (Qfilesize (file) + 1);
buf[Qfilesize (file)] = 0;
Qread (file, buf, Qfilesize (file));
Qclose (file);
StartTokenParsing (buf);
@ -524,33 +527,25 @@ GetVectorForKey (entity_t *ent, char *key, vec3_t vec)
void
WriteEntitiesToString (void)
{
char *buf, *end;
dstring_t *buf;
char line[128];
epair_t *ep;
int i;
buf = bsp->entdata;
end = buf;
*end = 0;
buf = dstring_newstr ();
for (i = 0; i < num_entities; i++) {
ep = entities[i].epairs;
if (!ep)
continue; // ent got removed
strcat (end, "{\n");
end += 2;
dstring_appendstr (buf, "{\n");
for (ep = entities[i].epairs; ep; ep = ep->next) {
sprintf (line, "\"%s\" \"%s\"\n", ep->key, ep->value);
strcat (end, line);
end += strlen (line);
dstring_appendstr (buf, line);
}
strcat (end, "}\n");
end += 2;
if (end > buf + MAX_MAP_ENTSTRING)
Sys_Error ("Entity text too long");
dstring_appendstr (buf, "}\n");
}
bsp->entdatasize = end - buf + 1;
BSP_AddEntities (bsp, buf->str, buf->size);
}

12
tools/qfbsp/source/qfbsp.c
View file

@ -682,7 +682,7 @@ void
ReadClipHull (int hullnum)
{
FILE *f;
dclipnode_t *d;
dclipnode_t d;
dplane_t p;
float f1, f2, f3, f4;
int firstclipnode, junk, c1, c2, i, j, n;
@ -713,8 +713,6 @@ ReadClipHull (int hullnum)
for (i = 0; i < n; i++) {
if (bsp->numclipnodes == MAX_MAP_CLIPNODES)
Sys_Error ("ReadClipHull: MAX_MAP_CLIPNODES");
d = &bsp->clipnodes[bsp->numclipnodes];
bsp->numclipnodes++;
if (fscanf (f, "%i : %f %f %f %f : %i %i\n", &junk, &f1, &f2, &f3, &f4,
&c1, &c2) != 7)
Sys_Error ("Error parsing %s", hullfilename);
@ -729,9 +727,10 @@ ReadClipHull (int hullnum)
norm[2] = f3; // vec_t precision
p.type = PlaneTypeForNormal (norm);
d->children[0] = c1 >= 0 ? c1 + firstclipnode : c1;
d->children[1] = c2 >= 0 ? c2 + firstclipnode : c2;
d->planenum = FindFinalPlane (&p);
d.children[0] = c1 >= 0 ? c1 + firstclipnode : c1;
d.children[1] = c2 >= 0 ? c2 + firstclipnode : c2;
d.planenum = FindFinalPlane (&p);
BSP_AddClipnode (bsp, &d);
}
}
@ -849,6 +848,7 @@ ProcessFile (char *sourcebase, char *bspfilename1)
remove (portfilename);
remove (pointfilename);
}
bsp = BSP_New ();
// load brushes and entities
LoadMapFile (sourcebase);
if (onlyents) {

25
tools/qfbsp/source/region.c
View file

@ -157,8 +157,7 @@ RecursiveGrowRegion (dface_t *r, face_t *f)
// emit a surfedge
if (bsp->numsurfedges == MAX_MAP_SURFEDGES)
Sys_Error ("numsurfedges == MAX_MAP_SURFEDGES");
bsp->surfedges[bsp->numsurfedges] = e;
bsp->numsurfedges++;
BSP_AddSurfEdge (bsp, e);
}
}
@ -390,7 +389,7 @@ CountRealNumbers (void)
void
GrowNodeRegion_r (node_t * node)
{
dface_t *r;
dface_t r;
face_t *f;
int i;
@ -407,14 +406,13 @@ GrowNodeRegion_r (node_t * node)
if (bsp->numfaces == MAX_MAP_FACES)
Sys_Error ("MAX_MAP_FACES");
f->outputnumber = bsp->numfaces;
r = &bsp->faces[bsp->numfaces];
r->planenum = node->outputplanenum;
r->side = f->planeside;
r->texinfo = f->texturenum;
r.planenum = node->outputplanenum;
r.side = f->planeside;
r.texinfo = f->texturenum;
for (i = 0; i < MAXLIGHTMAPS; i++)
r->styles[i] = 255;
r->lightofs = -1;
r.styles[i] = 255;
r.lightofs = -1;
// add the face and mergable neighbors to it
#if 0
@ -422,17 +420,16 @@ GrowNodeRegion_r (node_t * node)
AddFaceToRegionSize (f);
RecursiveGrowRegion (r, f);
#endif
r->firstedge = firstedge = bsp->numsurfedges;
r.firstedge = firstedge = bsp->numsurfedges;
for (i = 0; i < f->numpoints; i++) {
if (bsp->numsurfedges == MAX_MAP_SURFEDGES)
Sys_Error ("numsurfedges == MAX_MAP_SURFEDGES");
bsp->surfedges[bsp->numsurfedges] = f->edges[i];
bsp->numsurfedges++;
BSP_AddSurfEdge (bsp, f->edges[i]);
}
r->numedges = bsp->numsurfedges - r->firstedge;
r.numedges = bsp->numsurfedges - r.firstedge;
bsp->numfaces++;
BSP_AddFace (bsp, &r);
}
node->numfaces = bsp->numfaces - node->firstface;

22
tools/qfbsp/source/surfaces.c
View file

@ -248,6 +248,7 @@ GetVertex (vec3_t in, int planenum)
hashvert_t *hv;
int h, i;
vec3_t vert;
dvertex_t v;
for (i = 0; i < 3; i++) {
if (fabs (in[i] - (int) (in[i] + 0.5)) < 0.001)
@ -293,10 +294,11 @@ GetVertex (vec3_t in, int planenum)
if (bsp->numvertexes == MAX_MAP_VERTS)
Sys_Error ("numvertexes == MAX_MAP_VERTS");
bsp->vertexes[bsp->numvertexes].point[0] = vert[0];
bsp->vertexes[bsp->numvertexes].point[1] = vert[1];
bsp->vertexes[bsp->numvertexes].point[2] = vert[2];
bsp->numvertexes++;
v.point[0] = vert[0];
v.point[1] = vert[1];
v.point[2] = vert[2];
BSP_AddVertex (bsp, &v);
return hv->num;
}
@ -315,7 +317,7 @@ Don't allow four way edges
int
GetEdge (vec3_t p1, vec3_t p2, face_t *f)
{
dedge_t *edge;
dedge_t edge;
int v1, v2, i;
if (!f->contents[0])
@ -325,8 +327,7 @@ GetEdge (vec3_t p1, vec3_t p2, face_t *f)
v1 = GetVertex (p1, f->planenum);
v2 = GetVertex (p2, f->planenum);
for (i = firstmodeledge; i < bsp->numedges; i++) {
edge = &bsp->edges[i];
if (v1 == edge->v[1] && v2 == edge->v[0]
if (v1 == bsp->edges[i].v[1] && v2 == bsp->edges[i].v[0]
&& !edgefaces[i][1]
&& edgefaces[i][0]->contents[0] == f->contents[0]) {
edgefaces[i][1] = f;
@ -337,10 +338,9 @@ GetEdge (vec3_t p1, vec3_t p2, face_t *f)
// emit an edge
if (bsp->numedges == MAX_MAP_EDGES)
Sys_Error ("numedges == MAX_MAP_EDGES");
edge = &bsp->edges[bsp->numedges];
bsp->numedges++;
edge->v[0] = v1;
edge->v[1] = v2;
edge.v[0] = v1;
edge.v[1] = v2;
BSP_AddEdge (bsp, &edge);
edgefaces[i][0] = f;
return i;

137
tools/qfbsp/source/writebsp.c
View file

@ -30,6 +30,7 @@
#include <stdlib.h>
#include <ctype.h>
#include "QF/dstring.h"
#include "QF/qendian.h"
#include "QF/sys.h"
@ -69,9 +70,7 @@ FindFinalPlane (dplane_t *p)
// new plane
if (bsp->numplanes == MAX_MAP_PLANES)
Sys_Error ("numplanes == MAX_MAP_PLANES");
dplane = &bsp->planes[bsp->numplanes];
*dplane = *p;
bsp->numplanes++;
BSP_AddPlane (bsp, p);
return bsp->numplanes - 1;
}
@ -81,7 +80,7 @@ int planemapping[MAX_MAP_PLANES];
void
WriteNodePlanes_r (node_t *node)
{
dplane_t *dplane;
dplane_t dplane;
plane_t *plane;
if (node->planenum == -1)
@ -89,17 +88,14 @@ WriteNodePlanes_r (node_t *node)
if (planemapping[node->planenum] == -1) { // a new plane
planemapping[node->planenum] = bsp->numplanes;
if (bsp->numplanes == MAX_MAP_PLANES)
Sys_Error ("numplanes == MAX_MAP_PLANES");
plane = &planes[node->planenum];
dplane = &bsp->planes[bsp->numplanes];
dplane->normal[0] = plane->normal[0];
dplane->normal[1] = plane->normal[1];
dplane->normal[2] = plane->normal[2];
dplane->dist = plane->dist;
dplane->type = plane->type;
bsp->numplanes++;
dplane.normal[0] = plane->normal[0];
dplane.normal[1] = plane->normal[1];
dplane.normal[2] = plane->normal[2];
dplane.dist = plane->dist;
dplane.type = plane->type;
BSP_AddPlane (bsp, &dplane);
}
node->outputplanenum = planemapping[node->planenum];
@ -120,7 +116,7 @@ WriteNodePlanes (node_t *nodes)
int
WriteClipNodes_r (node_t *node)
{
dclipnode_t *cn;
dclipnode_t cn;
int num, c, i;
// FIXME: free more stuff?
@ -131,11 +127,10 @@ WriteClipNodes_r (node_t *node)
}
// emit a clipnode
c = bsp->numclipnodes;
cn = &bsp->clipnodes[bsp->numclipnodes];
bsp->numclipnodes++;
cn->planenum = node->outputplanenum;
cn.planenum = node->outputplanenum;
for (i = 0; i < 2; i++)
cn->children[i] = WriteClipNodes_r (node->children[i]);
cn.children[i] = WriteClipNodes_r (node->children[i]);
BSP_AddClipnode (bsp, &cn);
free (node);
return c;
@ -161,23 +156,20 @@ WriteClipNodes (node_t *nodes)
void
WriteLeaf (node_t *node)
{
dleaf_t *leaf_p;
dleaf_t leaf_p;
face_t **fp, *f;
// emit a leaf
leaf_p = &bsp->leafs[bsp->numleafs];
bsp->numleafs++;
leaf_p->contents = node->contents;
leaf_p.contents = node->contents;
// write bounding box info
VectorCopy (node->mins, leaf_p->mins);
VectorCopy (node->maxs, leaf_p->maxs);
VectorCopy (node->mins, leaf_p.mins);
VectorCopy (node->maxs, leaf_p.maxs);
leaf_p->visofs = -1; // no vis info yet
leaf_p.visofs = -1; // no vis info yet
// write the marksurfaces
leaf_p->firstmarksurface = bsp->nummarksurfaces;
leaf_p.firstmarksurface = bsp->nummarksurfaces;
for (fp = node->markfaces; *fp; fp++) {
// emit a marksurface
@ -185,26 +177,27 @@ WriteLeaf (node_t *node)
Sys_Error ("nummarksurfaces == MAX_MAP_MARKSURFACES");
f = *fp;
do {
bsp->marksurfaces[bsp->nummarksurfaces] = f->outputnumber;
bsp->nummarksurfaces++;
BSP_AddMarkSurface (bsp, f->outputnumber);
f = f->original; // grab tjunction split faces
} while (f);
}
leaf_p->nummarksurfaces = bsp->nummarksurfaces - leaf_p->firstmarksurface;
leaf_p.nummarksurfaces = bsp->nummarksurfaces - leaf_p.firstmarksurface;
}
void
WriteDrawNodes_r (node_t *node)
{
static dnode_t dummy;
dnode_t *n;
int i;
int nodenum = bsp->numnodes;
// emit a node
if (bsp->numnodes == MAX_MAP_NODES)
Sys_Error ("numnodes == MAX_MAP_NODES");
n = &bsp->nodes[bsp->numnodes];
bsp->numnodes++;
BSP_AddNode (bsp, &dummy);
n = &bsp->nodes[nodenum];
VectorCopy (node->mins, n->mins);
VectorCopy (node->maxs, n->maxs);
@ -215,6 +208,7 @@ WriteDrawNodes_r (node_t *node)
// recursively output the other nodes
for (i = 0; i < 2; i++) {
n = &bsp->nodes[nodenum];
if (node->children[i]->planenum == -1) {
if (node->children[i]->contents == CONTENTS_SOLID)
n->children[i] = -1;
@ -232,7 +226,7 @@ WriteDrawNodes_r (node_t *node)
void
WriteDrawNodes (node_t *headnode)
{
dmodel_t *bm;
dmodel_t bm;
int start, i;
#if 0
@ -243,12 +237,10 @@ WriteDrawNodes (node_t *headnode)
// emit a model
if (bsp->nummodels == MAX_MAP_MODELS)
Sys_Error ("nummodels == MAX_MAP_MODELS");
bm = &bsp->models[bsp->nummodels];
bsp->nummodels++;
bm->headnode[0] = bsp->numnodes;
bm->firstface = firstface;
bm->numfaces = bsp->numfaces - firstface;
bm.headnode[0] = bsp->numnodes;
bm.firstface = firstface;
bm.numfaces = bsp->numfaces - firstface;
firstface = bsp->numfaces;
start = bsp->numleafs;
@ -257,12 +249,13 @@ WriteDrawNodes (node_t *headnode)
WriteLeaf (headnode);
else
WriteDrawNodes_r (headnode);
bm->visleafs = bsp->numleafs - start;
bm.visleafs = bsp->numleafs - start;
for (i = 0; i < 3; i++) {
bm->mins[i] = headnode->mins[i] + SIDESPACE + 1; // remove the padding
bm->maxs[i] = headnode->maxs[i] - SIDESPACE - 1;
bm.mins[i] = headnode->mins[i] + SIDESPACE + 1; // remove the padding
bm.maxs[i] = headnode->maxs[i] - SIDESPACE - 1;
}
BSP_AddModel (bsp, &bm);
// FIXME: are all the children decendant of padded nodes?
}
@ -276,15 +269,11 @@ Used by the clipping hull processes that only need to store headclipnode
void
BumpModel (int hullnum)
{
dmodel_t *bm;
static dmodel_t bm;
// emit a model
if (bsp->nummodels == MAX_MAP_MODELS)
Sys_Error ("nummodels == MAX_MAP_MODELS");
bm = &bsp->models[bsp->nummodels];
bsp->nummodels++;
bm->headnode[hullnum] = headclipnode;
bm.headnode[hullnum] = headclipnode;
BSP_AddModel (bsp, &bm);
}
//=============================================================================
@ -332,6 +321,8 @@ TEX_InitFromWad (char *path)
int i;
texfile = Qopen (path, "rb");
if (!texfile)
Sys_Error ("couldn't open %s", path);
Qread (texfile, &wadinfo, sizeof (wadinfo));
if (strncmp (wadinfo.identification, "WAD2", 4))
Sys_Error ("TEX_InitFromWad: %s isn't a wadfile", path);
@ -349,17 +340,20 @@ TEX_InitFromWad (char *path)
}
int
LoadLump (char *name, byte *dest)
LoadLump (char *name, dstring_t *dest)
{
char cname[16];
int i;
int ofs = dest->size;
CleanupName (name, cname);
for (i = 0; i < wadinfo.numlumps; i++) {
if (!strcmp (cname, lumpinfo[i].name)) {
dest->size += lumpinfo[i].disksize;
dstring_adjust (dest);
Qseek (texfile, lumpinfo[i].filepos, SEEK_SET);
Qread (texfile, dest, lumpinfo[i].disksize);
Qread (texfile, dest->str + ofs, lumpinfo[i].disksize);
return lumpinfo[i].disksize;
}
}
@ -402,8 +396,8 @@ AddAnimatingTextures (void)
void
WriteMiptex (void)
{
byte *data;
char *path;
dstring_t *data;
char *path, *p;
char fullpath[1024];
dmiptexlump_t *l;
int i, len;
@ -417,27 +411,36 @@ WriteMiptex (void)
return;
}
}
path = strdup (path);
p = strtok (path, ";"); // yeah yeah. but it works :)
while (p) {
sprintf (fullpath, "%s/%s", /* FIXME gamedir */ ".", path);
sprintf (fullpath, "%s/%s", /* FIXME gamedir */ ".", path);
TEX_InitFromWad (fullpath);
TEX_InitFromWad (fullpath);
AddAnimatingTextures ();
AddAnimatingTextures ();
p = strtok (0, ";");
}
free (path);
l = (dmiptexlump_t *) bsp->texdata;
data = (byte *) & l->dataofs[nummiptex];
data = dstring_new ();
data->size = sizeof (dmiptexlump_t);
dstring_adjust (data);
l = (dmiptexlump_t *) data->str;
l->nummiptex = nummiptex;
data->size = (char *) &l->dataofs[nummiptex] - data->str;
dstring_adjust (data);
l = (dmiptexlump_t *) data->str;
for (i = 0; i < nummiptex; i++) {
l->dataofs[i] = data - (byte *) l;
l->dataofs[i] = data->size;
len = LoadLump (miptex[i], data);
if (data + len - bsp->texdata >= MAX_MAP_MIPTEX)
Sys_Error ("Textures exceeded MAX_MAP_MIPTEX");
if (!len)
l->dataofs[i] = -1; // didn't find the texture
data += len;
}
bsp->texdatasize = data - bsp->texdata;
BSP_AddTextures (bsp, data->str, data->size);
}
//===========================================================================
@ -445,12 +448,14 @@ WriteMiptex (void)
void
BeginBSPFile (void)
{
static dedge_t edge;
static dleaf_t leaf;
// edge 0 is not used, because 0 can't be negated
bsp->numedges = 1;
BSP_AddEdge (bsp, &edge);
// leaf 0 is common solid with no faces
bsp->numleafs = 1;
bsp->leafs[0].contents = CONTENTS_SOLID;
leaf.contents = CONTENTS_SOLID;
BSP_AddLeaf (bsp, &leaf);
firstface = 0;
}