qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2025-01-30 12:40:42 +00:00
Code Issues Projects Releases Packages Wiki Activity

enough whitespace to crush a shambler

Browse source
This commit is contained in:
Bill Currie 2002-09-19 17:14:23 +00:00
parent afa0b21336
commit 4d520d588d
13 changed files with 2351 additions and 2552 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -39,7 +39,9 @@ int numbrushplanes;
plane_t planes[MAX_MAP_PLANES];
int numbrushfaces;
mface_t faces[128]; // beveled clipping hull can generate many extra
mface_t faces[128]; // beveled clipping hull can generate
// many extra
/*
@ -49,7 +51,8 @@ CheckFace
Note: this will not catch 0 area polygons
=================
*/
void CheckFace (face_t *f)
void
CheckFace (face_t * f)
{
int i, j;
vec_t *p1, *p2;
@ -57,26 +60,26 @@ void CheckFace (face_t *f)
vec3_t dir, edgenormal, facenormal;
if (f->numpoints < 3)
Sys_Error ("CheckFace: %i points",f->numpoints);
Sys_Error ("CheckFace: %i points", f->numpoints);
VectorCopy (planes[f->planenum].normal, facenormal);
if (f->planeside)
{
if (f->planeside) {
VectorSubtract (vec3_origin, facenormal, facenormal);
}
for (i=0 ; i<f->numpoints ; i++)
{
for (i = 0; i < f->numpoints; i++) {
p1 = f->pts[i];
for (j=0 ; j<3 ; j++)
for (j = 0; j < 3; j++)
if (p1[j] > BOGUS_RANGE || p1[j] < -BOGUS_RANGE)
Sys_Error ("CheckFace: BUGUS_RANGE: %f",p1[j]);
Sys_Error ("CheckFace: BUGUS_RANGE: %f", p1[j]);
j = i+1 == f->numpoints ? 0 : i+1;
j = i + 1 == f->numpoints ? 0 : i + 1;
// check the point is on the face plane
d = DotProduct (p1, planes[f->planenum].normal) - planes[f->planenum].dist;
d =
DotProduct (p1,
planes[f->planenum].normal) - planes[f->planenum].dist;
if (d < -ON_EPSILON || d > ON_EPSILON)
Sys_Error ("CheckFace: point off plane");
@ -93,8 +96,7 @@ void CheckFace (face_t *f)
edgedist += ON_EPSILON;
// all other points must be on front side
for (j=0 ; j<f->numpoints ; j++)
{
for (j = 0; j < f->numpoints; j++) {
if (j == i)
continue;
d = DotProduct (f->pts[j], edgenormal);
@ -112,13 +114,13 @@ void CheckFace (face_t *f)
ClearBounds
=================
*/
void ClearBounds (brushset_t *bs)
void
ClearBounds (brushset_t * bs)
{
int i, j;
for (j=0 ; j<NUM_HULLS ; j++)
for (i=0 ; i<3 ; i++)
{
for (j = 0; j < NUM_HULLS; j++)
for (i = 0; i < 3; i++) {
bs->mins[i] = 99999;
bs->maxs[i] = -99999;
}
@ -129,12 +131,12 @@ void ClearBounds (brushset_t *bs)
AddToBounds
=================
*/
void AddToBounds (brushset_t *bs, vec3_t v)
void
AddToBounds (brushset_t * bs, vec3_t v)
{
int i;
for (i=0 ; i<3 ; i++)
{
for (i = 0; i < 3; i++) {
if (v[i] < bs->mins[i])
bs->mins[i] = v[i];
if (v[i] > bs->maxs[i])
@ -144,7 +146,8 @@ void AddToBounds (brushset_t *bs, vec3_t v)
//===========================================================================
int PlaneTypeForNormal (vec3_t normal)
int
PlaneTypeForNormal (vec3_t normal)
{
float ax, ay, az;
@ -155,14 +158,12 @@ int PlaneTypeForNormal (vec3_t normal)
return PLANE_Y;
if (normal[2] == 1.0)
return PLANE_Z;
if (normal[0] == -1.0 ||
normal[1] == -1.0 ||
normal[2] == -1.0)
if (normal[0] == -1.0 || normal[1] == -1.0 || normal[2] == -1.0)
Sys_Error ("PlaneTypeForNormal: not a canonical vector");
ax = fabs(normal[0]);
ay = fabs(normal[1]);
az = fabs(normal[2]);
ax = fabs (normal[0]);
ay = fabs (normal[1]);
az = fabs (normal[2]);
if (ax >= ay && ax >= az)
return PLANE_ANYX;
@ -174,45 +175,40 @@ int PlaneTypeForNormal (vec3_t normal)
#define DISTEPSILON 0.01
#define ANGLEEPSILON 0.00001
void NormalizePlane (plane_t *dp)
void
NormalizePlane (plane_t *dp)
{
vec_t ax, ay, az;
if (dp->normal[0] == -1.0)
{
if (dp->normal[0] == -1.0) {
dp->normal[0] = 1.0;
dp->dist = -dp->dist;
}
if (dp->normal[1] == -1.0)
{
if (dp->normal[1] == -1.0) {
dp->normal[1] = 1.0;
dp->dist = -dp->dist;
}
if (dp->normal[2] == -1.0)
{
if (dp->normal[2] == -1.0) {
dp->normal[2] = 1.0;
dp->dist = -dp->dist;
}
if (dp->normal[0] == 1.0)
{
if (dp->normal[0] == 1.0) {
dp->type = PLANE_X;
return;
}
if (dp->normal[1] == 1.0)
{
if (dp->normal[1] == 1.0) {
dp->type = PLANE_Y;
return;
}
if (dp->normal[2] == 1.0)
{
if (dp->normal[2] == 1.0) {
dp->type = PLANE_Z;
return;
}
ax = fabs(dp->normal[0]);
ay = fabs(dp->normal[1]);
az = fabs(dp->normal[2]);
ax = fabs (dp->normal[0]);
ay = fabs (dp->normal[1]);
az = fabs (dp->normal[2]);
if (ax >= ay && ax >= az)
dp->type = PLANE_ANYX;
@ -220,8 +216,7 @@ void NormalizePlane (plane_t *dp)
dp->type = PLANE_ANYY;
else
dp->type = PLANE_ANYZ;
if (dp->normal[dp->type-PLANE_ANYX] < 0)
{
if (dp->normal[dp->type - PLANE_ANYX] < 0) {
VectorSubtract (vec3_origin, dp->normal, dp->normal);
dp->dist = -dp->dist;
}
@ -235,30 +230,29 @@ FindPlane
Returns a global plane number and the side that will be the front
===============
*/
int FindPlane (plane_t *dplane, int *side)
int
FindPlane (plane_t *dplane, int *side)
{
int i;
plane_t *dp, pl;
vec_t dot;
dot = VectorLength(dplane->normal);
dot = VectorLength (dplane->normal);
if (dot < 1.0 - ANGLEEPSILON || dot > 1.0 + ANGLEEPSILON)
Sys_Error ("FindPlane: normalization error");
pl = *dplane;
NormalizePlane (&pl);
if (DotProduct(pl.normal, dplane->normal) > 0)
if (DotProduct (pl.normal, dplane->normal) > 0)
*side = 0;
else
*side = 1;
dp = planes;
for (i=0 ; i<numbrushplanes;i++, dp++)
{
for (i = 0; i < numbrushplanes; i++, dp++) {
dot = DotProduct (dp->normal, pl.normal);
if (dot > 1.0 - ANGLEEPSILON
&& fabs(dp->dist - pl.dist) < DISTEPSILON )
{ // regular match
if (dot > 1.0 - ANGLEEPSILON && fabs (dp->dist - pl.dist) < DISTEPSILON) { // regular
// match
return i;
}
}
@ -270,7 +264,7 @@ int FindPlane (plane_t *dplane, int *side)
numbrushplanes++;
return numbrushplanes-1;
return numbrushplanes - 1;
}
@ -281,30 +275,29 @@ FindPlane_old
Returns a global plane number and the side that will be the front
===============
*/
int FindPlane_old (plane_t *dplane, int *side)
int
FindPlane_old (plane_t *dplane, int *side)
{
int i;
plane_t *dp;
vec_t dot, ax, ay, az;
dot = VectorLength(dplane->normal);
dot = VectorLength (dplane->normal);
if (dot < 1.0 - ANGLEEPSILON || dot > 1.0 + ANGLEEPSILON)
Sys_Error ("FindPlane: normalization error");
dp = planes;
for (i=0 ; i<numbrushplanes;i++, dp++)
{
for (i = 0; i < numbrushplanes; i++, dp++) {
dot = DotProduct (dplane->normal, dp->normal);
if (dot > 1.0 - ANGLEEPSILON
&& fabs(dplane->dist - dp->dist) < DISTEPSILON )
{ // regular match
if (dot > 1.0 - ANGLEEPSILON && fabs (dplane->dist - dp->dist) < DISTEPSILON) { // regular
// match
*side = 0;
return i;
}
if (dot < -1.0+ANGLEEPSILON
&& fabs(dplane->dist + dp->dist) < DISTEPSILON )
{ // inverse of vector
if (dot < -1.0 + ANGLEEPSILON && fabs (dplane->dist + dp->dist) < DISTEPSILON) { // inverse
// of
// vector
*side = 1;
return i;
}
@ -327,32 +320,25 @@ int FindPlane_old (plane_t *dplane, int *side)
dp->type = PLANE_Y;
else if (dplane->normal[2] == 1.0)
dp->type = PLANE_Z;
else if (dplane->normal[0] == -1.0)
{
else if (dplane->normal[0] == -1.0) {
dp->type = PLANE_X;
dp->normal[0] = 1.0;
dp->dist = -dp->dist;
*side = 1;
}
else if (dplane->normal[1] == -1.0)
{
} else if (dplane->normal[1] == -1.0) {
dp->type = PLANE_Y;
dp->normal[1] = 1.0;
dp->dist = -dp->dist;
*side = 1;
}
else if (dplane->normal[2] == -1.0)
{
} else if (dplane->normal[2] == -1.0) {
dp->type = PLANE_Z;
dp->normal[2] = 1.0;
dp->dist = -dp->dist;
*side = 1;
}
else
{
ax = fabs(dplane->normal[0]);
ay = fabs(dplane->normal[1]);
az = fabs(dplane->normal[2]);
} else {
ax = fabs (dplane->normal[0]);
ay = fabs (dplane->normal[1]);
az = fabs (dplane->normal[2]);
if (ax >= ay && ax >= az)
dp->type = PLANE_ANYX;
@ -360,8 +346,7 @@ int FindPlane_old (plane_t *dplane, int *side)
dp->type = PLANE_ANYY;
else
dp->type = PLANE_ANYZ;
if (dplane->normal[dp->type-PLANE_ANYX] < 0)
{
if (dplane->normal[dp->type - PLANE_ANYX] < 0) {
VectorSubtract (vec3_origin, dp->normal, dp->normal);
dp->dist = -dp->dist;
*side = 1;
@ -390,9 +375,10 @@ CreateBrushFaces
=================
*/
#define ZERO_EPSILON 0.001
void CreateBrushFaces (void)
void
CreateBrushFaces (void)
{
int i,j, k;
int i, j, k;
vec_t r;
face_t *f;
winding_t *w;
@ -404,18 +390,16 @@ void CreateBrushFaces (void)
brush_faces = NULL;
for (i=0 ; i<numbrushfaces ; i++)
{
for (i = 0; i < numbrushfaces; i++) {
mf = &faces[i];
w = BaseWindingForPlane (&mf->plane);
for (j=0 ; j<numbrushfaces && w ; j++)
{
for (j = 0; j < numbrushfaces && w; j++) {
if (j == i)
continue;
// flip the plane, because we want to keep the back side
VectorSubtract (vec3_origin,faces[j].plane.normal, plane.normal);
VectorSubtract (vec3_origin, faces[j].plane.normal, plane.normal);
plane.dist = -faces[j].plane.dist;
w = ClipWinding (w, &plane, false);
@ -430,12 +414,10 @@ void CreateBrushFaces (void)
if (f->numpoints > MAXEDGES)
Sys_Error ("f->numpoints > MAXEDGES");
for (j=0 ; j<w->numpoints ; j++)
{
for (k=0 ; k<3 ; k++)
{
for (j = 0; j < w->numpoints; j++) {
for (k = 0; k < 3; k++) {
r = (int) (w->points[j][k] + 0.5);
if ( fabs(w->points[j][k] - r) < ZERO_EPSILON)
if (fabs (w->points[j][k] - r) < ZERO_EPSILON)
f->pts[j][k] = r;
else
f->pts[j][k] = w->points[j][k];
@ -468,9 +450,9 @@ This is done by brute force, and could easily get a lot faster if anyone cares.
*/
vec3_t hull_size[3][2] = {
{ {0, 0, 0}, {0, 0, 0} },
{ {-16,-16,-32}, {16,16,24} },
{ {-32,-32,-64}, {32,32,24} }
{{0, 0, 0}, {0, 0, 0}},
{{-16, -16, -32}, {16, 16, 24}},
{{-32, -32, -64}, {32, 32, 24}}
};
@ -479,7 +461,7 @@ vec3_t hull_size[3][2] = {
int num_hull_points;
vec3_t hull_points[MAX_HULL_POINTS];
vec3_t hull_corners[MAX_HULL_POINTS*8];
vec3_t hull_corners[MAX_HULL_POINTS * 8];
int num_hull_edges;
int hull_edges[MAX_HULL_EDGES][2];
@ -488,7 +470,8 @@ int hull_edges[MAX_HULL_EDGES][2];
AddBrushPlane
=============
*/
void AddBrushPlane (plane_t *plane)
void
AddBrushPlane (plane_t *plane)
{
int i;
plane_t *pl;
@ -500,11 +483,10 @@ void AddBrushPlane (plane_t *plane)
if (l < 0.999 || l > 1.001)
Sys_Error ("AddBrushPlane: bad normal");
for (i=0 ; i<numbrushfaces ; i++)
{
for (i = 0; i < numbrushfaces; i++) {
pl = &faces[i].plane;
if (VectorCompare (pl->normal, plane->normal)
&& fabs(pl->dist - plane->dist) < ON_EPSILON )
&& fabs (pl->dist - plane->dist) < ON_EPSILON)
return;
}
faces[i].plane = *plane;
@ -521,7 +503,8 @@ Adds the given plane to the brush description if all of the original brush
vertexes can be put on the front side
=============
*/
void TestAddPlane (plane_t *plane)
void
TestAddPlane (plane_t *plane)
{
int i, c;
vec_t d;
@ -532,14 +515,14 @@ void TestAddPlane (plane_t *plane)
plane_t *pl;
// see if the plane has allready been added
for (i=0 ; i<numbrushfaces ; i++)
{
for (i = 0; i < numbrushfaces; i++) {
pl = &faces[i].plane;
if (VectorCompare (plane->normal, pl->normal) && fabs(plane->dist - pl->dist) < ON_EPSILON)
if (VectorCompare (plane->normal, pl->normal)
&& fabs (plane->dist - pl->dist) < ON_EPSILON)
return;
VectorSubtract (vec3_origin, plane->normal, inv);
if (VectorCompare (inv, pl->normal) && fabs(plane->dist + pl->dist) < ON_EPSILON)
return;
if (VectorCompare (inv, pl->normal)
&& fabs (plane->dist + pl->dist) < ON_EPSILON) return;
}
// check all the corner points
@ -547,29 +530,23 @@ void TestAddPlane (plane_t *plane)
c = num_hull_points * 8;
corner = hull_corners[0];
for (i=0 ; i<c ; i++, corner += 3)
{
for (i = 0; i < c; i++, corner += 3) {
d = DotProduct (corner, plane->normal) - plane->dist;
if (d < -ON_EPSILON)
{
if (d < -ON_EPSILON) {
if (counts[0])
return;
counts[1]++;
}
else if (d > ON_EPSILON)
{
} else if (d > ON_EPSILON) {
if (counts[1])
return;
counts[0]++;
}
else
} else
counts[2]++;
}
// the plane is a seperator
if (counts[0])
{
if (counts[0]) {
VectorSubtract (vec3_origin, plane->normal, flip.normal);
flip.dist = -plane->dist;
plane = &flip;
@ -585,24 +562,24 @@ AddHullPoint
Doesn't add if duplicated
=============
*/
int AddHullPoint (vec3_t p, int hullnum)
int
AddHullPoint (vec3_t p, int hullnum)
{
int i;
vec_t *c;
int x,y,z;
int x, y, z;
for (i=0 ; i<num_hull_points ; i++)
for (i = 0; i < num_hull_points; i++)
if (VectorCompare (p, hull_points[i]))
return i;
VectorCopy (p, hull_points[num_hull_points]);
c = hull_corners[i*8];
c = hull_corners[i * 8];
for (x=0 ; x<2 ; x++)
for (y=0 ; y<2 ; y++)
for (z=0; z<2 ; z++)
{
for (x = 0; x < 2; x++)
for (y = 0; y < 2; y++)
for (z = 0; z < 2; z++) {
c[0] = p[0] + hull_size[hullnum][x][0];
c[1] = p[1] + hull_size[hullnum][y][1];
c[2] = p[2] + hull_size[hullnum][z][2];
@ -625,7 +602,8 @@ AddHullEdge
Creates all of the hull planes around the given edge, if not done allready
=============
*/
void AddHullEdge (vec3_t p1, vec3_t p2, int hullnum)
void
AddHullEdge (vec3_t p1, vec3_t p2, int hullnum)
{
int pt1, pt2;
int i;
@ -637,9 +615,9 @@ void AddHullEdge (vec3_t p1, vec3_t p2, int hullnum)
pt1 = AddHullPoint (p1, hullnum);
pt2 = AddHullPoint (p2, hullnum);
for (i=0 ; i<num_hull_edges ; i++)
if ( (hull_edges[i][0] == pt1 && hull_edges[i][1] == pt2)
|| (hull_edges[i][0] == pt2 && hull_edges[i][1] == pt1) )
for (i = 0; i < num_hull_edges; i++)
if ((hull_edges[i][0] == pt1 && hull_edges[i][1] == pt2)
|| (hull_edges[i][0] == pt2 && hull_edges[i][1] == pt1))
return; // allread added
if (num_hull_edges == MAX_HULL_EDGES)
@ -652,13 +630,11 @@ void AddHullEdge (vec3_t p1, vec3_t p2, int hullnum)
VectorSubtract (p1, p2, edgevec);
VectorNormalize (edgevec);
for (a=0 ; a<3 ; a++)
{
b = (a+1)%3;
c = (a+2)%3;
for (d=0 ; d<=1 ; d++)
for (e=0 ; e<=1 ; e++)
{
for (a = 0; a < 3; a++) {
b = (a + 1) % 3;
c = (a + 2) % 3;
for (d = 0; d <= 1; d++)
for (e = 0; e <= 1; e++) {
VectorCopy (p1, planeorg);
planeorg[b] += hull_size[hullnum][d][b];
planeorg[c] += hull_size[hullnum][e][c];
@ -668,7 +644,7 @@ void AddHullEdge (vec3_t p1, vec3_t p2, int hullnum)
CrossProduct (planevec, edgevec, plane.normal);
l = VectorLength (plane.normal);
if (l < 1-ANGLEEPSILON || l > 1+ANGLEEPSILON)
if (l < 1 - ANGLEEPSILON || l > 1 + ANGLEEPSILON)
continue;
plane.dist = DotProduct (planeorg, plane.normal);
TestAddPlane (&plane);
@ -683,7 +659,8 @@ void AddHullEdge (vec3_t p1, vec3_t p2, int hullnum)
ExpandBrush
=============
*/
void ExpandBrush (int hullnum)
void
ExpandBrush (int hullnum)
{
int i, x, s;
vec3_t corner;
@ -694,17 +671,15 @@ void ExpandBrush (int hullnum)
num_hull_edges = 0;
// create all the hull points
for (f=brush_faces ; f ; f=f->next)
for (i=0 ; i<f->numpoints ; i++)
for (f = brush_faces; f; f = f->next)
for (i = 0; i < f->numpoints; i++)
AddHullPoint (f->pts[i], hullnum);
// expand all of the planes
for (i=0 ; i<numbrushfaces ; i++)
{
for (i = 0; i < numbrushfaces; i++) {
p = &faces[i].plane;
VectorCopy (vec3_origin, corner);
for (x=0 ; x<3 ; x++)
{
for (x = 0; x < 3; x++) {
if (p->normal[x] > 0)
corner[x] = hull_size[hullnum][1][x];
else if (p->normal[x] < 0)
@ -714,9 +689,8 @@ void ExpandBrush (int hullnum)
}
// add any axis planes not contained in the brush to bevel off corners
for (x=0 ; x<3 ; x++)
for (s=-1 ; s<=1 ; s+=2)
{
for (x = 0; x < 3; x++)
for (s = -1; s <= 1; s += 2) {
// add the plane
VectorCopy (vec3_origin, plane.normal);
plane.normal[x] = s;
@ -728,9 +702,9 @@ void ExpandBrush (int hullnum)
}
// add all of the edge bevels
for (f=brush_faces ; f ; f=f->next)
for (i=0 ; i<f->numpoints ; i++)
AddHullEdge (f->pts[i], f->pts[(i+1)%f->numpoints], hullnum);
for (f = brush_faces; f; f = f->next)
for (i = 0; i < f->numpoints; i++)
AddHullEdge (f->pts[i], f->pts[(i + 1) % f->numpoints], hullnum);
}
//============================================================================
@ -743,7 +717,8 @@ LoadBrush
Converts a mapbrush to a bsp brush
===============
*/
brush_t *LoadBrush (mbrush_t *mb, int hullnum)
brush_t *
LoadBrush (mbrush_t * mb, int hullnum)
{
brush_t *b;
int contents;
@ -755,25 +730,26 @@ brush_t *LoadBrush (mbrush_t *mb, int hullnum)
//
name = miptex[bsp->texinfo[mb->faces->texinfo].miptex];
if (!strcasecmp(name, "clip") && hullnum == 0)
return NULL; // "clip" brushes don't show up in the draw hull
if (!strcasecmp (name, "clip") && hullnum == 0)
return NULL; // "clip" brushes don't show up in
// the draw hull
if (name[0] == '*' && worldmodel) // entities never use water merging
{
if (!strncasecmp(name+1,"lava",4))
if (!strncasecmp (name + 1, "lava", 4))
contents = CONTENTS_LAVA;
else if (!strncasecmp(name+1,"slime",5))
else if (!strncasecmp (name + 1, "slime", 5))
contents = CONTENTS_SLIME;
else
contents = CONTENTS_WATER;
}
else if (!strncasecmp (name, "sky",3) && worldmodel && hullnum == 0)
} else if (!strncasecmp (name, "sky", 3) && worldmodel && hullnum == 0)
contents = CONTENTS_SKY;
else
contents = CONTENTS_SOLID;
if (hullnum && contents != CONTENTS_SOLID && contents != CONTENTS_SKY)
return NULL; // water brushes don't show up in clipping hulls
return NULL; // water brushes don't show up in
// clipping hulls
// no seperate textures on clip hull
@ -783,8 +759,7 @@ brush_t *LoadBrush (mbrush_t *mb, int hullnum)
brush_faces = NULL;
numbrushfaces = 0;
for (f=mb->faces ; f ; f=f->next)
{
for (f = mb->faces; f; f = f->next) {
faces[numbrushfaces] = *f;
if (hullnum)
faces[numbrushfaces].texinfo = 0;
@ -793,18 +768,15 @@ brush_t *LoadBrush (mbrush_t *mb, int hullnum)
CreateBrushFaces ();
if (!brush_faces)
{
if (!brush_faces) {
printf ("WARNING: couldn't create brush faces\n");
return NULL;
}
if (hullnum)
{
if (hullnum) {
ExpandBrush (hullnum);
CreateBrushFaces ();
}
//
// create the brush
//
@ -827,13 +799,14 @@ Brush_DrawAll
============
*/
void Brush_DrawAll (brushset_t *bs)
void
Brush_DrawAll (brushset_t * bs)
{
brush_t *b;
face_t *f;
for (b=bs->brushes ; b ; b=b->next)
for (f=b->faces ; f ; f=f->next)
for (b = bs->brushes; b; b = b->next)
for (f = b->faces; f; f = f->next)
Draw_DrawFace (f);
}
@ -843,15 +816,16 @@ void Brush_DrawAll (brushset_t *bs)
Brush_LoadEntity
============
*/
brushset_t *Brush_LoadEntity (entity_t *ent, int hullnum)
brushset_t *
Brush_LoadEntity (entity_t *ent, int hullnum)
{
brush_t *b, *next, *water, *other;
mbrush_t *mbr;
int numbrushes;
brushset_t *bset;
bset = malloc (sizeof(brushset_t));
memset (bset, 0, sizeof(brushset_t));
bset = malloc (sizeof (brushset_t));
memset (bset, 0, sizeof (brushset_t));
ClearBounds (bset);
numbrushes = 0;
@ -859,21 +833,17 @@ brushset_t *Brush_LoadEntity (entity_t *ent, int hullnum)
qprintf ("--- Brush_LoadEntity ---\n");
for (mbr = ent->brushes ; mbr ; mbr=mbr->next)
{
for (mbr = ent->brushes; mbr; mbr = mbr->next) {
b = LoadBrush (mbr, hullnum);
if (!b)
continue;
numbrushes++;
if (b->contents != CONTENTS_SOLID)
{
if (b->contents != CONTENTS_SOLID) {
b->next = water;
water = b;
}
else
{
} else {
b->next = other;
other = b;
}
@ -883,8 +853,7 @@ brushset_t *Brush_LoadEntity (entity_t *ent, int hullnum)
}
// add all of the water textures at the start
for (b=water ; b ; b=next)
{
for (b = water; b; b = next) {
next = b->next;
b->next = other;
other = b;
@ -895,9 +864,7 @@ brushset_t *Brush_LoadEntity (entity_t *ent, int hullnum)
brushset = bset;
Brush_DrawAll (bset);
qprintf ("%i brushes read\n",numbrushes);
qprintf ("%i brushes read\n", numbrushes);
return bset;
}

165
tools/qfbsp/source/csg4.c
View file

@ -43,9 +43,10 @@ int brushfaces;
int csgfaces;
int csgmergefaces;
void DrawList (face_t *list)
void
DrawList (face_t * list)
{
for ( ; list ; list=list->next)
for (; list; list = list->next)
Draw_DrawFace (list);
}
@ -58,7 +59,8 @@ Duplicates the non point information of a face, used by SplitFace and
MergeFace.
==================
*/
face_t *NewFaceFromFace (face_t *in)
face_t *
NewFaceFromFace (face_t * in)
{
face_t *newf;
@ -81,10 +83,11 @@ SplitFace
==================
*/
void SplitFace (face_t *in, plane_t *split, face_t **front, face_t **back)
void
SplitFace (face_t * in, plane_t *split, face_t ** front, face_t ** back)
{
vec_t dists[MAXEDGES+1];
int sides[MAXEDGES+1];
vec_t dists[MAXEDGES + 1];
int sides[MAXEDGES + 1];
int counts[3];
vec_t dot;
int i, j;
@ -97,8 +100,7 @@ void SplitFace (face_t *in, plane_t *split, face_t **front, face_t **back)
counts[0] = counts[1] = counts[2] = 0;
// determine sides for each point
for (i=0 ; i<in->numpoints ; i++)
{
for (i = 0; i < in->numpoints; i++) {
dot = DotProduct (in->pts[i], split->normal);
dot -= split->dist;
dists[i] = dot;
@ -113,14 +115,12 @@ void SplitFace (face_t *in, plane_t *split, face_t **front, face_t **back)
sides[i] = sides[0];
dists[i] = dists[0];
if (!counts[0])
{
if (!counts[0]) {
*front = NULL;
*back = in;
return;
}
if (!counts[1])
{
if (!counts[1]) {
*front = in;
*back = NULL;
return;
@ -131,15 +131,13 @@ void SplitFace (face_t *in, plane_t *split, face_t **front, face_t **back)
// distribute the points and generate splits
for (i=0 ; i<in->numpoints ; i++)
{
for (i = 0; i < in->numpoints; i++) {
if (newf->numpoints > MAXEDGES || new2->numpoints > MAXEDGES)
Sys_Error ("SplitFace: numpoints > MAXEDGES");
p1 = in->pts[i];
if (sides[i] == SIDE_ON)
{
if (sides[i] == SIDE_ON) {
VectorCopy (p1, newf->pts[newf->numpoints]);
newf->numpoints++;
VectorCopy (p1, new2->pts[new2->numpoints]);
@ -147,32 +145,29 @@ void SplitFace (face_t *in, plane_t *split, face_t **front, face_t **back)
continue;
}
if (sides[i] == SIDE_FRONT)
{
if (sides[i] == SIDE_FRONT) {
VectorCopy (p1, new2->pts[new2->numpoints]);
new2->numpoints++;
}
else
{
} else {
VectorCopy (p1, newf->pts[newf->numpoints]);
newf->numpoints++;
}
if (sides[i+1] == SIDE_ON || sides[i+1] == sides[i])
if (sides[i + 1] == SIDE_ON || sides[i + 1] == sides[i])
continue;
// generate a split point
p2 = in->pts[(i+1)%in->numpoints];
p2 = in->pts[(i + 1) % in->numpoints];
dot = dists[i] / (dists[i]-dists[i+1]);
for (j=0 ; j<3 ; j++)
{ // avoid round off error when possible
dot = dists[i] / (dists[i] - dists[i + 1]);
for (j = 0; j < 3; j++) { // avoid round off error when
// possible
if (split->normal[j] == 1)
mid[j] = split->dist;
else if (split->normal[j] == -1)
mid[j] = -split->dist;
else
mid[j] = p1[j] + dot*(p2[j]-p1[j]);
mid[j] = p1[j] + dot * (p2[j] - p1[j]);
}
VectorCopy (mid, newf->pts[newf->numpoints]);
@ -185,8 +180,8 @@ void SplitFace (face_t *in, plane_t *split, face_t **front, face_t **back)
Sys_Error ("SplitFace: numpoints > MAXEDGES");
#if 0
CheckFace (newf);
CheckFace (new2);
CheckFace (newf);
CheckFace (new2);
#endif
// free the original face now that is is represented by the fragments
@ -205,7 +200,8 @@ Faces exactly on the plane will stay inside unless overdrawn by later brush
frontside is the side of the plane that holds the outside list
=================
*/
void ClipInside (int splitplane, int frontside, qboolean precedence)
void
ClipInside (int splitplane, int frontside, qboolean precedence)
{
face_t *f, *next;
face_t *frags[2];
@ -215,35 +211,28 @@ void ClipInside (int splitplane, int frontside, qboolean precedence)
split = &planes[splitplane];
insidelist = NULL;
for (f=inside ; f ; f=next)
{
for (f = inside; f; f = next) {
next = f->next;
if (f->planenum == splitplane)
{ // exactly on, handle special
if ( frontside != f->planeside || precedence )
{ // allways clip off opposite faceing
if (f->planenum == splitplane) { // exactly on, handle special
if (frontside != f->planeside || precedence) { // allways clip
// off opposite
// faceing
frags[frontside] = NULL;
frags[!frontside] = f;
}
else
{ // leave it on the outside
} else { // leave it on the outside
frags[frontside] = f;
frags[!frontside] = NULL;
}
}
else
{ // proper split
} else { // proper split
SplitFace (f, split, &frags[0], &frags[1]);
}
if (frags[frontside])
{
if (frags[frontside]) {
frags[frontside]->next = outside;
outside = frags[frontside];
}
if (frags[!frontside])
{
if (frags[!frontside]) {
frags[!frontside]->next = insidelist;
insidelist = frags[!frontside];
}
@ -260,21 +249,20 @@ SaveOutside
Saves all of the faces in the outside list to the bsp plane list
==================
*/
void SaveOutside (qboolean mirror)
void
SaveOutside (qboolean mirror)
{
face_t *f , *next, *newf;
face_t *f, *next, *newf;
int i;
int planenum;
for (f=outside ; f ; f=next)
{
for (f = outside; f; f = next) {
next = f->next;
csgfaces++;
Draw_DrawFace (f);
planenum = f->planenum;
if (mirror)
{
if (mirror) {
newf = NewFaceFromFace (f);
newf->numpoints = f->numpoints;
@ -282,17 +270,16 @@ void SaveOutside (qboolean mirror)
newf->contents[0] = f->contents[1];
newf->contents[1] = f->contents[0];
for (i=0 ; i<f->numpoints ; i++) // add points backwards
for (i = 0; i < f->numpoints; i++) // add points backwards
{
VectorCopy (f->pts[f->numpoints-1-i], newf->pts[i]);
VectorCopy (f->pts[f->numpoints - 1 - i], newf->pts[i]);
}
}
else
} else
newf = NULL;
validfaces[planenum] = MergeFaceToList(f, validfaces[planenum]);
validfaces[planenum] = MergeFaceToList (f, validfaces[planenum]);
if (newf)
validfaces[planenum] = MergeFaceToList(newf, validfaces[planenum]);
validfaces[planenum] = MergeFaceToList (newf, validfaces[planenum]);
validfaces[planenum] = FreeMergeListScraps (validfaces[planenum]);
}
@ -305,21 +292,19 @@ FreeInside
Free all the faces that got clipped out
==================
*/
void FreeInside (int contents)
void
FreeInside (int contents)
{
face_t *f, *next;
for (f=inside ; f ; f=next)
{
for (f = inside; f; f = next) {
next = f->next;
if (contents != CONTENTS_SOLID)
{
if (contents != CONTENTS_SOLID) {
f->contents[0] = contents;
f->next = outside;
outside = f;
}
else
} else
FreeFace (f);
}
}
@ -335,7 +320,8 @@ Returns a chain of all the external surfaces with one or more visible
faces.
==================
*/
surface_t *BuildSurfaces (void)
surface_t *
BuildSurfaces (void)
{
face_t **f;
face_t *count;
@ -346,8 +332,7 @@ surface_t *BuildSurfaces (void)
surfhead = NULL;
f = validfaces;
for (i=0 ; i<numbrushplanes ; i++, f++)
{
for (i = 0; i < numbrushplanes; i++, f++) {
if (!*f)
continue; // nothing left on this plane
@ -357,7 +342,7 @@ surface_t *BuildSurfaces (void)
s->next = surfhead;
surfhead = s;
s->faces = *f;
for (count = s->faces ; count ; count=count->next)
for (count = s->faces; count; count = count->next)
csgmergefaces++;
CalcSurfaceInfo (s); // bounding box and flags
}
@ -372,23 +357,24 @@ surface_t *BuildSurfaces (void)
CopyFacesToOutside
==================
*/
void CopyFacesToOutside (brush_t *b)
void
CopyFacesToOutside (brush_t * b)
{
face_t *f, *newf;
outside = NULL;
for (f=b->faces ; f ; f=f->next)
{
for (f = b->faces; f; f = f->next) {
brushfaces++;
#if 0
{
{
int i;
for (i=0 ; i<f->numpoints ; i++)
printf ("(%f,%f,%f) ",f->pts[i][0], f->pts[i][1], f->pts[i][2]);
for (i = 0; i < f->numpoints; i++)
printf ("(%f,%f,%f) ", f->pts[i][0], f->pts[i][1],
f->pts[i][2]);
printf ("\n");
}
}
#endif
newf = AllocFace ();
*newf = *f;
@ -407,7 +393,8 @@ CSGFaces
Returns a list of surfaces containing aall of the faces
==================
*/
surface_t *CSGFaces (brushset_t *bs)
surface_t *
CSGFaces (brushset_t * bs)
{
brush_t *b1, *b2;
int i;
@ -417,7 +404,7 @@ surface_t *CSGFaces (brushset_t *bs)
qprintf ("---- CSGFaces ----\n");
memset (validfaces, 0, sizeof(validfaces));
memset (validfaces, 0, sizeof (validfaces));
csgfaces = brushfaces = csgmergefaces = 0;
@ -426,28 +413,24 @@ surface_t *CSGFaces (brushset_t *bs)
//
// do the solid faces
//
for (b1=bs->brushes ; b1 ; b1 = b1->next)
{
for (b1 = bs->brushes; b1; b1 = b1->next) {
// set outside to a copy of the brush's faces
CopyFacesToOutside (b1);
overwrite = false;
for (b2=bs->brushes ; b2 ; b2 = b2->next)
{
for (b2 = bs->brushes; b2; b2 = b2->next) {
// see if b2 needs to clip a chunk out of b1
if (b1==b2)
{
if (b1 == b2) {
overwrite = true; // later brushes now overwrite
continue;
}
// check bounding box first
for (i=0 ; i<3 ; i++)
for (i = 0; i < 3; i++)
if (b1->mins[i] > b2->maxs[i] || b1->maxs[i] < b2->mins[i])
break;
if (i<3)
if (i < 3)
continue;
// divide faces by the planes of the new brush
@ -455,12 +438,12 @@ surface_t *CSGFaces (brushset_t *bs)
inside = outside;
outside = NULL;
for (f=b2->faces ; f ; f=f->next)
for (f = b2->faces; f; f = f->next)
ClipInside (f->planenum, f->planeside, overwrite);
// these faces are continued in another brush, so get rid of them
if (b1->contents == CONTENTS_SOLID && b2->contents <= CONTENTS_WATER)
FreeInside (b2->contents);
if (b1->contents == CONTENTS_SOLID
&& b2->contents <= CONTENTS_WATER) FreeInside (b2->contents);
else
FreeInside (CONTENTS_SOLID);
}
@ -485,5 +468,3 @@ surface_t *CSGFaces (brushset_t *bs)
return surfhead;
}

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

@ -52,12 +52,12 @@ FindMiptex
===============
*/
int FindMiptex (char *name)
int
FindMiptex (char *name)
{
int i;
for (i=0 ; i<nummiptex ; i++)
{
for (i = 0; i < nummiptex; i++) {
if (!strcmp (name, miptex[i]))
return i;
}
@ -75,26 +75,25 @@ FindTexinfo
Returns a global texinfo number
===============
*/
int FindTexinfo (texinfo_t *t)
int
FindTexinfo (texinfo_t *t)
{
int i, j;
texinfo_t *tex;
// set the special flag
if (miptex[t->miptex][0] == '*'
|| !strncasecmp (miptex[t->miptex], "sky",3) )
t->flags |= TEX_SPECIAL;
|| !strncasecmp (miptex[t->miptex], "sky", 3)) t->flags |= TEX_SPECIAL;
tex = bsp->texinfo;
for (i=0 ; i<bsp->numtexinfo;i++, tex++)
{
for (i = 0; i < bsp->numtexinfo; i++, tex++) {
if (t->miptex != tex->miptex)
continue;
if (t->flags != tex->flags)
continue;
for (j=0 ; j<8 ; j++)
for (j = 0; j < 8; j++)
if (t->vecs[0][j] != tex->vecs[0][j])
break;
if (j != 8)
@ -122,14 +121,16 @@ qboolean unget;
char *script_p;
int scriptline;
void StartTokenParsing (char *data)
void
StartTokenParsing (char *data)
{
scriptline = 1;
script_p = data;
unget = false;
}
qboolean GetToken (qboolean crossline)
qboolean
GetToken (qboolean crossline)
{
char *token_p;
@ -139,19 +140,16 @@ qboolean GetToken (qboolean crossline)
//
// skip space
//
skipspace:
while (*script_p <= 32)
{
if (!*script_p)
{
skipspace:
while (*script_p <= 32) {
if (!*script_p) {
if (!crossline)
Sys_Error ("Line %i is incomplete",scriptline);
Sys_Error ("Line %i is incomplete", scriptline);
return false;
}
if (*script_p++ == '\n')
{
if (*script_p++ == '\n') {
if (!crossline)
Sys_Error ("Line %i is incomplete",scriptline);
Sys_Error ("Line %i is incomplete", scriptline);
scriptline++;
}
}
@ -159,40 +157,35 @@ skipspace:
if (script_p[0] == '/' && script_p[1] == '/') // comment field
{
if (!crossline)
Sys_Error ("Line %i is incomplete\n",scriptline);
Sys_Error ("Line %i is incomplete\n", scriptline);
while (*script_p++ != '\n')
if (!*script_p)
{
if (!*script_p) {
if (!crossline)
Sys_Error ("Line %i is incomplete",scriptline);
Sys_Error ("Line %i is incomplete", scriptline);
return false;
}
goto skipspace;
}
//
// copy token
//
token_p = token;
if (*script_p == '"')
{
if (*script_p == '"') {
script_p++;
while ( *script_p != '"' )
{
while (*script_p != '"') {
if (!*script_p)
Sys_Error ("EOF inside quoted token");
*token_p++ = *script_p++;
if (token_p > &token[MAXTOKEN-1])
Sys_Error ("Token too large on line %i",scriptline);
if (token_p > &token[MAXTOKEN - 1])
Sys_Error ("Token too large on line %i", scriptline);
}
script_p++;
}
else while ( *script_p > 32 )
{
} else
while (*script_p > 32) {
*token_p++ = *script_p++;
if (token_p > &token[MAXTOKEN-1])
Sys_Error ("Token too large on line %i",scriptline);
if (token_p > &token[MAXTOKEN - 1])
Sys_Error ("Token too large on line %i", scriptline);
}
*token_p = 0;
@ -200,7 +193,8 @@ skipspace:
return true;
}
void UngetToken ()
void
UngetToken ()
{
unget = true;
}
@ -215,20 +209,21 @@ entity_t *mapent;
ParseEpair
=================
*/
void ParseEpair (void)
void
ParseEpair (void)
{
epair_t *e;
e = malloc (sizeof(epair_t));
memset (e, 0, sizeof(epair_t));
e = malloc (sizeof (epair_t));
memset (e, 0, sizeof (epair_t));
e->next = mapent->epairs;
mapent->epairs = e;
if (strlen(token) >= MAX_KEY-1)
if (strlen (token) >= MAX_KEY - 1)
Sys_Error ("ParseEpar: token too long");
e->key = strdup (token);
GetToken (false);
if (strlen(token) >= MAX_VALUE-1)
if (strlen (token) >= MAX_VALUE - 1)
Sys_Error ("ParseEpar: token too long");
e->value = strdup (token);
}
@ -241,37 +236,35 @@ void ParseEpair (void)
textureAxisFromPlane
==================
*/
vec3_t baseaxis[18] =
{
{0,0,1}, {1,0,0}, {0,-1,0}, // floor
{0,0,-1}, {1,0,0}, {0,-1,0}, // ceiling
{1,0,0}, {0,1,0}, {0,0,-1}, // west wall
{-1,0,0}, {0,1,0}, {0,0,-1}, // east wall
{0,1,0}, {1,0,0}, {0,0,-1}, // south wall
{0,-1,0}, {1,0,0}, {0,0,-1} // north wall
vec3_t baseaxis[18] = {
{0, 0, 1}, {1, 0, 0}, {0, -1, 0}, // floor
{0, 0, -1}, {1, 0, 0}, {0, -1, 0}, // ceiling
{1, 0, 0}, {0, 1, 0}, {0, 0, -1}, // west wall
{-1, 0, 0}, {0, 1, 0}, {0, 0, -1}, // east wall
{0, 1, 0}, {1, 0, 0}, {0, 0, -1}, // south wall
{0, -1, 0}, {1, 0, 0}, {0, 0, -1} // north wall
};
void TextureAxisFromPlane(plane_t *pln, vec3_t xv, vec3_t yv)
void
TextureAxisFromPlane (plane_t *pln, vec3_t xv, vec3_t yv)
{
int bestaxis;
float dot,best;
float dot, best;
int i;
best = 0;
bestaxis = 0;
for (i=0 ; i<6 ; i++)
{
dot = DotProduct (pln->normal, baseaxis[i*3]);
if (dot > best)
{
for (i = 0; i < 6; i++) {
dot = DotProduct (pln->normal, baseaxis[i * 3]);
if (dot > best) {
best = dot;
bestaxis = i;
}
}
VectorCopy (baseaxis[bestaxis*3+1], xv);
VectorCopy (baseaxis[bestaxis*3+2], yv);
VectorCopy (baseaxis[bestaxis * 3 + 1], xv);
VectorCopy (baseaxis[bestaxis * 3 + 2], yv);
}
@ -283,13 +276,14 @@ void TextureAxisFromPlane(plane_t *pln, vec3_t xv, vec3_t yv)
ParseBrush
=================
*/
void ParseBrush (void)
void
ParseBrush (void)
{
mbrush_t *b;
mface_t *f, *f2;
vec3_t planepts[3];
vec3_t t1, t2, t3;
int i,j;
int i, j;
texinfo_t tx;
vec_t d;
float shift[2], rotate, scale[2];
@ -299,82 +293,74 @@ void ParseBrush (void)
b->next = mapent->brushes;
mapent->brushes = b;
do
{
do {
if (!GetToken (true))
break;
if (!strcmp (token, "}") )
if (!strcmp (token, "}"))
break;
// read the three point plane definition
for (i=0 ; i<3 ; i++)
{
for (i = 0; i < 3; i++) {
if (i != 0)
GetToken (true);
if (strcmp (token, "(") )
if (strcmp (token, "("))
Sys_Error ("parsing brush");
for (j=0 ; j<3 ; j++)
{
for (j = 0; j < 3; j++) {
GetToken (false);
planepts[i][j] = atoi(token);
planepts[i][j] = atoi (token);
}
GetToken (false);
if (strcmp (token, ")") )
if (strcmp (token, ")"))
Sys_Error ("parsing brush");
}
// read the texturedef
memset (&tx, 0, sizeof(tx));
memset (&tx, 0, sizeof (tx));
GetToken (false);
tx.miptex = FindMiptex (token);
GetToken (false);
shift[0] = atoi(token);
shift[0] = atoi (token);
GetToken (false);
shift[1] = atoi(token);
shift[1] = atoi (token);
GetToken (false);
rotate = atoi(token);
rotate = atoi (token);
GetToken (false);
scale[0] = atof(token);
scale[0] = atof (token);
GetToken (false);
scale[1] = atof(token);
scale[1] = atof (token);
// if the three points are all on a previous plane, it is a
// duplicate plane
for (f2 = b->faces ; f2 ; f2=f2->next)
{
for (i=0 ; i<3 ; i++)
{
d = DotProduct(planepts[i],f2->plane.normal) - f2->plane.dist;
for (f2 = b->faces; f2; f2 = f2->next) {
for (i = 0; i < 3; i++) {
d = DotProduct (planepts[i], f2->plane.normal) - f2->plane.dist;
if (d < -ON_EPSILON || d > ON_EPSILON)
break;
}
if (i==3)
if (i == 3)
break;
}
if (f2)
{
if (f2) {
printf ("WARNING: brush with duplicate plane\n");
continue;
}
f = malloc(sizeof(mface_t));
f = malloc (sizeof (mface_t));
f->next = b->faces;
b->faces = f;
// convert to a vector / dist plane
for (j=0 ; j<3 ; j++)
{
for (j = 0; j < 3; j++) {
t1[j] = planepts[0][j] - planepts[1][j];
t2[j] = planepts[2][j] - planepts[1][j];
t3[j] = planepts[1][j];
}
CrossProduct(t1,t2, f->plane.normal);
if (VectorCompare (f->plane.normal, vec3_origin))
{
CrossProduct (t1, t2, f->plane.normal);
if (VectorCompare (f->plane.normal, vec3_origin)) {
printf ("WARNING: brush plane with no normal\n");
b->faces = f->next;
free (f);
@ -392,7 +378,7 @@ void ParseBrush (void)
float ang, sinv, cosv;
float ns, nt;
TextureAxisFromPlane(&f->plane, vecs[0], vecs[1]);
TextureAxisFromPlane (&f->plane, vecs[0], vecs[1]);
if (!scale[0])
scale[0] = 1;
@ -401,19 +387,22 @@ void ParseBrush (void)
// rotate axis
if (rotate == 0)
{ sinv = 0 ; cosv = 1; }
else if (rotate == 90)
{ sinv = 1 ; cosv = 0; }
else if (rotate == 180)
{ sinv = 0 ; cosv = -1; }
else if (rotate == 270)
{ sinv = -1 ; cosv = 0; }
else
{
if (rotate == 0) {
sinv = 0;
cosv = 1;
} else if (rotate == 90) {
sinv = 1;
cosv = 0;
} else if (rotate == 180) {
sinv = 0;
cosv = -1;
} else if (rotate == 270) {
sinv = -1;
cosv = 0;
} else {
ang = rotate / 180 * M_PI;
sinv = sin(ang);
cosv = cos(ang);
sinv = sin (ang);
cosv = cos (ang);
}
if (vecs[0][0])
@ -430,16 +419,15 @@ void ParseBrush (void)
else
tv = 2;
for (i=0 ; i<2 ; i++)
{
for (i = 0; i < 2; i++) {
ns = cosv * vecs[i][sv] - sinv * vecs[i][tv];
nt = sinv * vecs[i][sv] + cosv * vecs[i][tv];
vecs[i][sv] = ns;
vecs[i][tv] = nt;
}
for (i=0 ; i<2 ; i++)
for (j=0 ; j<3 ; j++)
for (i = 0; i < 2; i++)
for (j = 0; j < 3; j++)
tx.vecs[i][j] = vecs[i][j] / scale[i];
tx.vecs[0][3] = shift[0];
@ -456,12 +444,13 @@ void ParseBrush (void)
ParseEntity
================
*/
qboolean ParseEntity (void)
qboolean
ParseEntity (void)
{
if (!GetToken (true))
return false;
if (strcmp (token, "{") )
if (strcmp (token, "{"))
Sys_Error ("ParseEntity: { not found");
if (num_entities == MAX_MAP_ENTITIES)
@ -470,13 +459,12 @@ qboolean ParseEntity (void)
mapent = &entities[num_entities];
num_entities++;
do
{
do {
if (!GetToken (true))
Sys_Error ("ParseEntity: EOF without closing brace");
if (!strcmp (token, "}") )
if (!strcmp (token, "}"))
break;
if (!strcmp (token, "{") )
if (!strcmp (token, "{"))
ParseBrush ();
else
ParseEpair ();
@ -491,7 +479,8 @@ qboolean ParseEntity (void)
LoadMapFile
================
*/
void LoadMapFile (char *filename)
void
LoadMapFile (char *filename)
{
char *buf;
@ -501,8 +490,7 @@ void LoadMapFile (char *filename)
num_entities = 0;
while (ParseEntity ())
{
while (ParseEntity ()) {
}
free (buf);
@ -515,52 +503,56 @@ void LoadMapFile (char *filename)
qprintf ("%5i texinfo\n", bsp->numtexinfo);
}
void PrintEntity (entity_t *ent)
void
PrintEntity (entity_t *ent)
{
epair_t *ep;
for (ep=ent->epairs ; ep ; ep=ep->next)
for (ep = ent->epairs; ep; ep = ep->next)
printf ("%20s : %s\n", ep->key, ep->value);
}
char *ValueForKey (entity_t *ent, char *key)
char *
ValueForKey (entity_t *ent, char *key)
{
epair_t *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 "";
}
void SetKeyValue (entity_t *ent, char *key, char *value)
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) )
{
for (ep = ent->epairs; ep; ep = ep->next)
if (!strcmp (ep->key, key)) {
free (ep->value);
ep->value = strdup (value);
return;
}
ep = malloc (sizeof(*ep));
ep = malloc (sizeof (*ep));
ep->next = ent->epairs;
ent->epairs = ep;
ep->key = strdup (key);
ep->value = strdup (value);
}
float FloatForKey (entity_t *ent, char *key)
float
FloatForKey (entity_t *ent, char *key)
{
char *k;
k = ValueForKey (ent, key);
return atof(k);
return atof (k);
}
void GetVectorForKey (entity_t *ent, char *key, vec3_t vec)
void
GetVectorForKey (entity_t *ent, char *key, vec3_t vec)
{
char *k;
double v1, v2, v3;
@ -575,7 +567,8 @@ void GetVectorForKey (entity_t *ent, char *key, vec3_t vec)
}
void WriteEntitiesToString (void)
void
WriteEntitiesToString (void)
{
char *buf, *end;
epair_t *ep;
@ -586,22 +579,20 @@ void WriteEntitiesToString (void)
end = buf;
*end = 0;
for (i=0 ; i<num_entities ; i++)
{
for (i = 0; i < num_entities; i++) {
ep = entities[i].epairs;
if (!ep)
continue; // ent got removed
strcat (end,"{\n");
strcat (end, "{\n");
end += 2;
for (ep = entities[i].epairs ; ep ; ep=ep->next)
{
for (ep = entities[i].epairs; ep; ep = ep->next) {
sprintf (line, "\"%s\" \"%s\"\n", ep->key, ep->value);
strcat (end, line);
end += strlen(line);
end += strlen (line);
}
strcat (end,"}\n");
strcat (end, "}\n");
end += 2;
if (end > buf + MAX_MAP_ENTSTRING)
@ -609,4 +600,3 @@ void WriteEntitiesToString (void)
}
bsp->entdatasize = end - buf + 1;
}

96
tools/qfbsp/source/merge.c
View file

@ -36,13 +36,13 @@ CheckColinear
================
*/
void CheckColinear (face_t *f)
void
CheckColinear (face_t * f)
{
int i, j;
vec3_t v1, v2;
for (i=0 ; i<f->numpoints ;i++)
{
for (i = 0; i < f->numpoints; i++) {
// skip the point if the vector from the previous point is the same
// as the vector to the next point
j = (i - 1 < 0) ? f->numpoints - 1 : i - 1;
@ -71,7 +71,8 @@ Returns NULL if the faces couldn't be merged, or the new face.
The originals will NOT be freed.
=============
*/
face_t *TryMerge (face_t *f1, face_t *f2)
face_t *
TryMerge (face_t * f1, face_t * f2)
{
vec_t *p1, *p2, *p3, *p4, *back;
face_t *newf;
@ -98,22 +99,19 @@ face_t *TryMerge (face_t *f1, face_t *f2)
p1 = p2 = NULL; // stop compiler warning
j = 0; //
for (i=0 ; i<f1->numpoints ; i++)
{
for (i = 0; i < f1->numpoints; i++) {
p1 = f1->pts[i];
p2 = f1->pts[(i+1)%f1->numpoints];
for (j=0 ; j<f2->numpoints ; j++)
{
p2 = f1->pts[(i + 1) % f1->numpoints];
for (j = 0; j < f2->numpoints; j++) {
p3 = f2->pts[j];
p4 = f2->pts[(j+1)%f2->numpoints];
for (k=0 ; k<3 ; k++)
{
if (fabs(p1[k] - p4[k]) > EQUAL_EPSILON)
p4 = f2->pts[(j + 1) % f2->numpoints];
for (k = 0; k < 3; k++) {
if (fabs (p1[k] - p4[k]) > EQUAL_EPSILON)
break;
if (fabs(p2[k] - p3[k]) > EQUAL_EPSILON)
if (fabs (p2[k] - p3[k]) > EQUAL_EPSILON)
break;
}
if (k==3)
if (k == 3)
break;
}
if (j < f2->numpoints)
@ -132,24 +130,24 @@ face_t *TryMerge (face_t *f1, face_t *f2)
if (f1->planeside)
VectorSubtract (vec3_origin, planenormal, planenormal);
back = f1->pts[(i+f1->numpoints-1)%f1->numpoints];
back = f1->pts[(i + f1->numpoints - 1) % f1->numpoints];
VectorSubtract (p1, back, delta);
CrossProduct (planenormal, delta, normal);
VectorNormalize (normal);
back = f2->pts[(j+2)%f2->numpoints];
back = f2->pts[(j + 2) % f2->numpoints];
VectorSubtract (back, p1, delta);
dot = DotProduct (delta, normal);
if (dot > CONTINUOUS_EPSILON)
return NULL; // not a convex polygon
keep1 = dot < -CONTINUOUS_EPSILON;
back = f1->pts[(i+2)%f1->numpoints];
back = f1->pts[(i + 2) % f1->numpoints];
VectorSubtract (back, p2, delta);
CrossProduct (planenormal, delta, normal);
VectorNormalize (normal);
back = f2->pts[(j+f2->numpoints-1)%f2->numpoints];
back = f2->pts[(j + f2->numpoints - 1) % f2->numpoints];
VectorSubtract (back, p2, delta);
dot = DotProduct (delta, normal);
if (dot > CONTINUOUS_EPSILON)
@ -159,8 +157,7 @@ face_t *TryMerge (face_t *f1, face_t *f2)
//
// build the new polygon
//
if (f1->numpoints + f2->numpoints > MAXEDGES)
{
if (f1->numpoints + f2->numpoints > MAXEDGES) {
// Sys_Error ("TryMerge: too many edges!");
return NULL;
}
@ -168,9 +165,8 @@ face_t *TryMerge (face_t *f1, face_t *f2)
newf = NewFaceFromFace (f1);
// copy first polygon
for (k=(i+1)%f1->numpoints ; k != i ; k=(k+1)%f1->numpoints)
{
if (k==(i+1)%f1->numpoints && !keep2)
for (k = (i + 1) % f1->numpoints; k != i; k = (k + 1) % f1->numpoints) {
if (k == (i + 1) % f1->numpoints && !keep2)
continue;
VectorCopy (f1->pts[k], newf->pts[newf->numpoints]);
@ -178,9 +174,8 @@ face_t *TryMerge (face_t *f1, face_t *f2)
}
// copy second polygon
for (l= (j+1)%f2->numpoints ; l != j ; l=(l+1)%f2->numpoints)
{
if (l==(j+1)%f2->numpoints && !keep1)
for (l = (j + 1) % f2->numpoints; l != j; l = (l + 1) % f2->numpoints) {
if (l == (j + 1) % f2->numpoints && !keep1)
continue;
VectorCopy (f2->pts[l], newf->pts[newf->numpoints]);
newf->numpoints++;
@ -196,20 +191,19 @@ MergeFaceToList
===============
*/
qboolean mergedebug;
face_t *MergeFaceToList (face_t *face, face_t *list)
face_t *
MergeFaceToList (face_t * face, face_t * list)
{
face_t *newf, *f;
for (f=list ; f ; f=f->next)
{
for (f = list; f; f = f->next) {
//CheckColinear (f);
if (mergedebug)
{
Draw_ClearWindow ();
Draw_DrawFace (face);
Draw_DrawFace (f);
Draw_SetBlack ();
}
if (mergedebug) {
Draw_ClearWindow ();
Draw_DrawFace (face);
Draw_DrawFace (f);
Draw_SetBlack ();
}
newf = TryMerge (face, f);
if (!newf)
continue;
@ -229,18 +223,17 @@ Draw_SetBlack ();
FreeMergeListScraps
===============
*/
face_t *FreeMergeListScraps (face_t *merged)
face_t *
FreeMergeListScraps (face_t * merged)
{
face_t *head, *next;
head = NULL;
for ( ; merged ; merged = next)
{
for (; merged; merged = next) {
next = merged->next;
if (merged->numpoints == -1)
FreeFace (merged);
else
{
else {
merged->next = head;
head = merged;
}
@ -255,15 +248,15 @@ face_t *FreeMergeListScraps (face_t *merged)
MergePlaneFaces
===============
*/
void MergePlaneFaces (surface_t *plane)
void
MergePlaneFaces (surface_t * plane)
{
face_t *f1, *next;
face_t *merged;
merged = NULL;
for (f1 = plane->faces ; f1 ; f1 = next)
{
for (f1 = plane->faces; f1; f1 = next) {
next = f1->next;
merged = MergeFaceToList (f1, merged);
}
@ -278,7 +271,8 @@ void MergePlaneFaces (surface_t *plane)
MergeAll
============
*/
void MergeAll (surface_t *surfhead)
void
MergeAll (surface_t * surfhead)
{
surface_t *surf;
int mergefaces;
@ -287,13 +281,11 @@ void MergeAll (surface_t *surfhead)
printf ("---- MergeAll ----\n");
mergefaces = 0;
for (surf = surfhead ; surf ; surf=surf->next)
{
for (surf = surfhead; surf; surf = surf->next) {
MergePlaneFaces (surf);
Draw_ClearWindow ();
for (f=surf->faces ; f ; f=f->next)
{
Draw_DrawFace (f);
Draw_ClearWindow ();
for (f = surf->faces; f; f = f->next) {
Draw_DrawFace (f);
mergefaces++;
}
}

39
tools/qfbsp/source/nodraw.c
View file

@ -20,54 +20,67 @@
#include "bsp5.h"
void Draw_ClearBounds (void)
void
Draw_ClearBounds (void)
{
}
void Draw_AddToBounds (vec3_t v)
void
Draw_AddToBounds (vec3_t v)
{
}
void Draw_DrawFace (face_t *f)
void
Draw_DrawFace (face_t * f)
{
}
void Draw_ClearWindow (void)
void
Draw_ClearWindow (void)
{
}
void Draw_SetRed (void)
void
Draw_SetRed (void)
{
}
void Draw_SetGrey (void)
void
Draw_SetGrey (void)
{
}
void Draw_SetBlack (void)
void
Draw_SetBlack (void)
{
}
void DrawPoint (vec3_t v)
void
DrawPoint (vec3_t v)
{
}
void DrawLeaf (node_t *l, int color)
void
DrawLeaf (node_t * l, int color)
{
}
void DrawBrush (brush_t *b)
void
DrawBrush (brush_t * b)
{
}
void DrawWinding (winding_t *w)
void
DrawWinding (winding_t * w)
{
}
void DrawTri (vec3_t p1, vec3_t p2, vec3_t p3)
void
DrawTri (vec3_t p1, vec3_t p2, vec3_t p3)
{
}
void DrawPortal (portal_t *portal)
void
DrawPortal (portal_t * portal)
{
}

85
tools/qfbsp/source/outside.c
View file

@ -32,14 +32,17 @@ int outleafs;
PointInLeaf
===========
*/
node_t *PointInLeaf (node_t *node, vec3_t point)
node_t *
PointInLeaf (node_t * node, vec3_t point)
{
vec_t d;
if (node->contents)
return node;
d = DotProduct (planes[node->planenum].normal, point) - planes[node->planenum]. dist;
d =
DotProduct (planes[node->planenum].normal,
point) - planes[node->planenum].dist;
if (d > 0)
return PointInLeaf (node->children[0], point);
@ -52,7 +55,8 @@ node_t *PointInLeaf (node_t *node, vec3_t point)
PlaceOccupant
===========
*/
qboolean PlaceOccupant (int num, vec3_t point, node_t *headnode)
qboolean
PlaceOccupant (int num, vec3_t point, node_t * headnode)
{
node_t *n;
@ -71,7 +75,8 @@ MarkLeakTrail
*/
portal_t *prevleaknode;
FILE *leakfile;
void MarkLeakTrail (portal_t *n2)
void
MarkLeakTrail (portal_t * n2)
{
int i, j;
vec3_t p1, p2, dir;
@ -88,16 +93,14 @@ void MarkLeakTrail (portal_t *n2)
return;
VectorCopy (n2->winding->points[0], p1);
for (i=1 ; i< n2->winding->numpoints ; i++)
{
for (j=0 ; j<3 ; j++)
for (i = 1; i < n2->winding->numpoints; i++) {
for (j = 0; j < 3; j++)
p1[j] = (p1[j] + n2->winding->points[i][j]) / 2;
}
VectorCopy (n1->winding->points[0], p2);
for (i=1 ; i< n1->winding->numpoints ; i++)
{
for (j=0 ; j<3 ; j++)
for (i = 1; i < n1->winding->numpoints; i++) {
for (j = 0; j < 3; j++)
p2[j] = (p2[j] + n1->winding->points[i][j]) / 2;
}
@ -105,11 +108,10 @@ void MarkLeakTrail (portal_t *n2)
len = VectorLength (dir);
VectorNormalize (dir);
while (len > 2)
{
fprintf (leakfile,"%f %f %f\n", p1[0], p1[1], p1[2]);
for (i=0 ; i<3 ; i++)
p1[i] += dir[i]*2;
while (len > 2) {
fprintf (leakfile, "%f %f %f\n", p1[0], p1[1], p1[2]);
for (i = 0; i < 3; i++)
p1[i] += dir[i] * 2;
len -= 2;
}
}
@ -124,7 +126,8 @@ Returns true if an occupied leaf is reached
*/
int hit_occupied;
int backdraw;
qboolean RecursiveFillOutside (node_t *l, qboolean fill)
qboolean
RecursiveFillOutside (node_t * l, qboolean fill)
{
portal_t *p;
int s;
@ -145,14 +148,12 @@ qboolean RecursiveFillOutside (node_t *l, qboolean fill)
l->contents = CONTENTS_SOLID;
outleafs++;
for (p=l->portals ; p ; )
{
for (p = l->portals; p;) {
s = (p->nodes[0] == l);
if (RecursiveFillOutside (p->nodes[s], fill) )
{ // leaked, so stop filling
if (backdraw-- > 0)
{
if (RecursiveFillOutside (p->nodes[s], fill)) { // leaked, so stop
// filling
if (backdraw-- > 0) {
MarkLeakTrail (p);
DrawLeaf (l, 2);
}
@ -170,12 +171,12 @@ ClearOutFaces
==================
*/
void ClearOutFaces (node_t *node)
void
ClearOutFaces (node_t * node)
{
face_t **fp;
if (node->planenum != -1)
{
if (node->planenum != -1) {
ClearOutFaces (node->children[0]);
ClearOutFaces (node->children[1]);
return;
@ -183,8 +184,7 @@ void ClearOutFaces (node_t *node)
if (node->contents != CONTENTS_SOLID)
return;
for (fp=node->markfaces ; *fp ; fp++)
{
for (fp = node->markfaces; *fp; fp++) {
// mark all the original faces that are removed
(*fp)->numpoints = 0;
}
@ -200,7 +200,8 @@ FillOutside
===========
*/
qboolean FillOutside (node_t *node)
qboolean
FillOutside (node_t * node)
{
int s;
vec_t *v;
@ -209,25 +210,23 @@ qboolean FillOutside (node_t *node)
qprintf ("----- FillOutside ----\n");
if (nofill)
{
if (nofill) {
printf ("skipped\n");
return false;
}
inside = false;
for (i=1 ; i<num_entities ; i++)
{
if (!VectorCompare(entities[i].origin, vec3_origin))
{
for (i = 1; i < num_entities; i++) {
if (!VectorCompare (entities[i].origin, vec3_origin)) {
if (PlaceOccupant (i, entities[i].origin, node))
inside = true;
}
}
if (!inside)
{
printf ("Hullnum %i: No entities in empty space -- no filling performed\n", hullnum);
if (!inside) {
printf
("Hullnum %i: No entities in empty space -- no filling performed\n",
hullnum);
return false;
}
@ -239,19 +238,17 @@ qboolean FillOutside (node_t *node)
prevleaknode = NULL;
if (!hullnum)
{
if (!hullnum) {
leakfile = fopen (pointfilename, "w");
if (!leakfile)
Sys_Error ("Couldn't open %s\n", pointfilename);
}
if (RecursiveFillOutside (outside_node.portals->nodes[s], false))
{
if (RecursiveFillOutside (outside_node.portals->nodes[s], false)) {
v = entities[hit_occupied].origin;
qprintf ("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
qprintf ("reached occupant at: (%4.0f,%4.0f,%4.0f)\n"
, v[0], v[1], v[2]);
qprintf ("reached occupant at: (%4.0f,%4.0f,%4.0f)\n", v[0], v[1],
v[2]);
qprintf ("no filling performed\n");
if (!hullnum)
fclose (leakfile);
@ -272,5 +269,3 @@ qboolean FillOutside (node_t *node)
qprintf ("%4i outleafs\n", outleafs);
return true;
}

220
tools/qfbsp/source/portals.c
View file

@ -26,7 +26,9 @@
#include "bsp5.h"
node_t outside_node; // portals outside the world face this
node_t outside_node; // portals outside the world face
// this
//=============================================================================
@ -35,7 +37,8 @@ node_t outside_node; // portals outside the world face this
AddPortalToNodes
=============
*/
void AddPortalToNodes (portal_t *p, node_t *front, node_t *back)
void
AddPortalToNodes (portal_t * p, node_t * front, node_t * back)
{
if (p->nodes[0] || p->nodes[1])
Sys_Error ("AddPortalToNode: allready included");
@ -55,19 +58,19 @@ void AddPortalToNodes (portal_t *p, node_t *front, node_t *back)
RemovePortalFromNode
=============
*/
void RemovePortalFromNode (portal_t *portal, node_t *l)
void
RemovePortalFromNode (portal_t * portal, node_t * l)
{
portal_t **pp, *t;
// remove reference to the current portal
pp = &l->portals;
while (1)
{
while (1) {
t = *pp;
if (!t)
Sys_Error ("RemovePortalFromNode: portal not in leaf");
if ( t == portal )
if (t == portal)
break;
if (t->nodes[0] == l)
@ -78,13 +81,10 @@ void RemovePortalFromNode (portal_t *portal, node_t *l)
Sys_Error ("RemovePortalFromNode: portal not bounding leaf");
}
if (portal->nodes[0] == l)
{
if (portal->nodes[0] == l) {
*pp = portal->next[0];
portal->nodes[0] = NULL;
}
else if (portal->nodes[1] == l)
{
} else if (portal->nodes[1] == l) {
*pp = portal->next[1];
portal->nodes[1] = NULL;
}
@ -92,14 +92,15 @@ void RemovePortalFromNode (portal_t *portal, node_t *l)
//============================================================================
void PrintPortal (portal_t *p)
void
PrintPortal (portal_t * p)
{
int i;
winding_t *w;
w = p->winding;
for (i=0 ; i<w->numpoints ; i++)
printf ("(%5.0f,%5.0f,%5.0f)\n",w->points[i][0]
for (i = 0; i < w->numpoints; i++)
printf ("(%5.0f,%5.0f,%5.0f)\n", w->points[i][0]
, w->points[i][1], w->points[i][2]);
}
@ -110,7 +111,8 @@ MakeHeadnodePortals
The created portals will face the global outside_node
================
*/
void MakeHeadnodePortals (node_t *node)
void
MakeHeadnodePortals (node_t * node)
{
vec3_t bounds[2];
int i, j, n;
@ -121,8 +123,7 @@ void MakeHeadnodePortals (node_t *node)
Draw_ClearWindow ();
// pad with some space so there will never be null volume leafs
for (i=0 ; i<3 ; i++)
{
for (i = 0; i < 3; i++) {
bounds[0][i] = brushset->mins[i] - SIDESPACE;
bounds[1][i] = brushset->maxs[i] + SIDESPACE;
}
@ -130,23 +131,19 @@ void MakeHeadnodePortals (node_t *node)
outside_node.contents = CONTENTS_SOLID;
outside_node.portals = NULL;
for (i=0 ; i<3 ; i++)
for (j=0 ; j<2 ; j++)
{
n = j*3 + i;
for (i = 0; i < 3; i++)
for (j = 0; j < 2; j++) {
n = j * 3 + i;
p = AllocPortal ();
portals[n] = p;
pl = &bplanes[n];
memset (pl, 0, sizeof(*pl));
if (j)
{
memset (pl, 0, sizeof (*pl));
if (j) {
pl->normal[i] = -1;
pl->dist = -bounds[j][i];
}
else
{
} else {
pl->normal[i] = 1;
pl->dist = bounds[j][i];
}
@ -160,56 +157,55 @@ void MakeHeadnodePortals (node_t *node)
}
// clip the basewindings by all the other planes
for (i=0 ; i<6 ; i++)
{
for (j=0 ; j<6 ; j++)
{
for (i = 0; i < 6; i++) {
for (j = 0; j < 6; j++) {
if (j == i)
continue;
portals[i]->winding = ClipWinding (portals[i]->winding, &bplanes[j], true);
portals[i]->winding =
ClipWinding (portals[i]->winding, &bplanes[j], true);
}
}
}
//============================================================================
void CheckWindingInNode (winding_t *w, node_t *node)
void
CheckWindingInNode (winding_t * w, node_t * node)
{
int i, j;
for (i=0 ; i<w->numpoints ; i++)
{
for (j=0 ; j<3 ; j++)
for (i = 0; i < w->numpoints; i++) {
for (j = 0; j < 3; j++)
if (w->points[i][j] < node->mins[j] - 1
|| w->points[i][j] > node->maxs[j] + 1)
{
|| w->points[i][j] > node->maxs[j] + 1) {
printf ("WARNING: CheckWindingInNode: outside\n");
return;
}
}
}
void CheckWindingArea (winding_t *w)
void
CheckWindingArea (winding_t * w)
{
int i;
float total, add;
vec3_t v1, v2, cross;
total = 0;
for (i=1 ; i<w->numpoints ; i++)
{
for (i = 1; i < w->numpoints; i++) {
VectorSubtract (w->points[i], w->points[0], v1);
VectorSubtract (w->points[i+1], w->points[0], v2);
VectorSubtract (w->points[i + 1], w->points[0], v2);
CrossProduct (v1, v2, cross);
add = VectorLength (cross);
total += add*0.5;
total += add * 0.5;
}
if (total < 16)
printf ("WARNING: winding area %f\n", total);
}
void PlaneFromWinding (winding_t *w, plane_t *plane)
void
PlaneFromWinding (winding_t * w, plane_t *plane)
{
vec3_t v1, v2;
@ -221,7 +217,8 @@ void PlaneFromWinding (winding_t *w, plane_t *plane)
plane->dist = DotProduct (w->points[0], plane->normal);
}
void CheckLeafPortalConsistancy (node_t *node)
void
CheckLeafPortalConsistancy (node_t * node)
{
int side, side2;
portal_t *p, *p2;
@ -232,8 +229,7 @@ void CheckLeafPortalConsistancy (node_t *node)
side = side2 = 0; // quiet compiler warning
for (p = node->portals ; p ; p = p->next[side])
{
for (p = node->portals; p; p = p->next[side]) {
if (p->nodes[0] == node)
side = 0;
else if (p->nodes[1] == node)
@ -247,8 +243,7 @@ void CheckLeafPortalConsistancy (node_t *node)
plane = planes[p->planenum];
PlaneFromWinding (p->winding, &plane2);
for (p2 = node->portals ; p2 ; p2 = p2->next[side2])
{
for (p2 = node->portals; p2; p2 = p2->next[side2]) {
if (p2->nodes[0] == node)
side2 = 0;
else if (p2->nodes[1] == node)
@ -256,11 +251,9 @@ void CheckLeafPortalConsistancy (node_t *node)
else
Sys_Error ("CutNodePortals_r: mislinked portal");
w = p2->winding;
for (i=0 ; i<w->numpoints ; i++)
{
for (i = 0; i < w->numpoints; i++) {
dist = DotProduct (w->points[i], plane.normal) - plane.dist;
if ( (side == 0 && dist < -1) || (side == 1 && dist > 1) )
{
if ((side == 0 && dist < -1) || (side == 1 && dist > 1)) {
printf ("WARNING: portal siding direction is wrong\n");
return;
}
@ -277,7 +270,8 @@ CutNodePortals_r
================
*/
void CutNodePortals_r (node_t *node)
void
CutNodePortals_r (node_t * node)
{
plane_t *plane, clipplane;
node_t *f, *b, *other_node;
@ -290,8 +284,7 @@ void CutNodePortals_r (node_t *node)
//
// seperate the portals on node into it's children
//
if (node->contents)
{
if (node->contents) {
return; // at a leaf, no more dividing
}
@ -309,40 +302,33 @@ void CutNodePortals_r (node_t *node)
w = BaseWindingForPlane (&planes[node->planenum]);
side = 0; // shut up compiler warning
for (p = node->portals ; p ; p = p->next[side])
{
for (p = node->portals; p; p = p->next[side]) {
clipplane = planes[p->planenum];
if (p->nodes[0] == node)
side = 0;
else if (p->nodes[1] == node)
{
else if (p->nodes[1] == node) {
clipplane.dist = -clipplane.dist;
VectorSubtract (vec3_origin, clipplane.normal, clipplane.normal);
side = 1;
}
else
} else
Sys_Error ("CutNodePortals_r: mislinked portal");
w = ClipWinding (w, &clipplane, true);
if (!w)
{
if (!w) {
printf ("WARNING: CutNodePortals_r:new portal was clipped away\n");
break;
}
}
if (w)
{
if (w) {
// if the plane was not clipped on all sides, there was an error
new_portal->winding = w;
AddPortalToNodes (new_portal, f, b);
}
//
// partition the portals
//
for (p = node->portals ; p ; p = next_portal)
{
for (p = node->portals; p; p = next_portal) {
if (p->nodes[0] == node)
side = 0;
else if (p->nodes[1] == node)
@ -360,23 +346,20 @@ void CutNodePortals_r (node_t *node)
//
DivideWinding (p->winding, plane, &frontwinding, &backwinding);
if (!frontwinding)
{
if (!frontwinding) {
if (side == 0)
AddPortalToNodes (p, b, other_node);
else
AddPortalToNodes (p, other_node, b);
continue;
}
if (!backwinding)
{
if (!backwinding) {
if (side == 0)
AddPortalToNodes (p, f, other_node);
else
AddPortalToNodes (p, other_node, f);
continue;
}
// the winding is split
new_portal = AllocPortal ();
*new_portal = *p;
@ -384,20 +367,17 @@ void CutNodePortals_r (node_t *node)
FreeWinding (p->winding);
p->winding = frontwinding;
if (side == 0)
{
if (side == 0) {
AddPortalToNodes (p, f, other_node);
AddPortalToNodes (new_portal, b, other_node);
}
else
{
} else {
AddPortalToNodes (p, other_node, f);
AddPortalToNodes (new_portal, other_node, b);
}
}
DrawLeaf (f,1);
DrawLeaf (b,2);
DrawLeaf (f, 1);
DrawLeaf (b, 2);
CutNodePortals_r (f);
CutNodePortals_r (b);
@ -412,7 +392,8 @@ PortalizeWorld
Builds the exact polyhedrons for the nodes and leafs
==================
*/
void PortalizeWorld (node_t *headnode)
void
PortalizeWorld (node_t * headnode)
{
qprintf ("----- portalize ----\n");
@ -427,18 +408,17 @@ FreeAllPortals
==================
*/
void FreeAllPortals (node_t *node)
void
FreeAllPortals (node_t * node)
{
portal_t *p, *nextp;
if (!node->contents)
{
if (!node->contents) {
FreeAllPortals (node->children[0]);
FreeAllPortals (node->children[1]);
}
for (p=node->portals ; p ; p=nextp)
{
for (p = node->portals; p; p = nextp) {
if (p->nodes[0] == node)
nextp = p->next[0];
else
@ -464,23 +444,24 @@ FILE *pf;
int num_visleafs; // leafs the player can be in
int num_visportals;
void WriteFloat (FILE *f, vec_t v)
void
WriteFloat (FILE * f, vec_t v)
{
if ( fabs(v - (int) (v + 0.5)) < 0.001 )
fprintf (f,"%i ",(int)(v + 0.5));
if (fabs (v - (int) (v + 0.5)) < 0.001)
fprintf (f, "%i ", (int) (v + 0.5));
else
fprintf (f,"%f ",v);
fprintf (f, "%f ", v);
}
void WritePortalFile_r (node_t *node)
void
WritePortalFile_r (node_t * node)
{
int i;
portal_t *p;
winding_t *w;
plane_t *pl, plane2;
if (!node->contents)
{
if (!node->contents) {
WritePortalFile_r (node->children[0]);
WritePortalFile_r (node->children[1]);
return;
@ -489,34 +470,32 @@ void WritePortalFile_r (node_t *node)
if (node->contents == CONTENTS_SOLID)
return;
for (p = node->portals ; p ; )
{
for (p = node->portals; p;) {
w = p->winding;
if (w && p->nodes[0] == node
&& p->nodes[0]->contents == p->nodes[1]->contents)
{
&& p->nodes[0]->contents == p->nodes[1]->contents) {
// write out to the file
// sometimes planes get turned around when they are very near
// the changeover point between different axis. interpret the
// plane the same way vis will, and flip the side orders if needed
// plane the same way vis will, and flip the side orders if
// needed
pl = &planes[p->planenum];
PlaneFromWinding (w, &plane2);
if ( DotProduct (pl->normal, plane2.normal) < 0.99 )
{ // backwards...
fprintf (pf,"%i %i %i ",w->numpoints, p->nodes[1]->visleafnum, p->nodes[0]->visleafnum);
}
else
fprintf (pf,"%i %i %i ",w->numpoints, p->nodes[0]->visleafnum, p->nodes[1]->visleafnum);
for (i=0 ; i<w->numpoints ; i++)
{
fprintf (pf,"(");
if (DotProduct (pl->normal, plane2.normal) < 0.99) { // backwards...
fprintf (pf, "%i %i %i ", w->numpoints, p->nodes[1]->visleafnum,
p->nodes[0]->visleafnum);
} else
fprintf (pf, "%i %i %i ", w->numpoints, p->nodes[0]->visleafnum,
p->nodes[1]->visleafnum);
for (i = 0; i < w->numpoints; i++) {
fprintf (pf, "(");
WriteFloat (pf, w->points[i][0]);
WriteFloat (pf, w->points[i][1]);
WriteFloat (pf, w->points[i][2]);
fprintf (pf,") ");
fprintf (pf, ") ");
}
fprintf (pf,"\n");
fprintf (pf, "\n");
}
if (p->nodes[0] == node)
@ -532,12 +511,12 @@ void WritePortalFile_r (node_t *node)
NumberLeafs_r
================
*/
void NumberLeafs_r (node_t *node)
void
NumberLeafs_r (node_t * node)
{
portal_t *p;
if (!node->contents)
{ // decision node
if (!node->contents) { // decision node
node->visleafnum = -99;
NumberLeafs_r (node->children[0]);
NumberLeafs_r (node->children[1]);
@ -547,23 +526,21 @@ void NumberLeafs_r (node_t *node)
Draw_ClearWindow ();
DrawLeaf (node, 1);
if (node->contents == CONTENTS_SOLID)
{ // solid block, viewpoint never inside
if (node->contents == CONTENTS_SOLID) { // solid block, viewpoint never
// inside
node->visleafnum = -1;
return;
}
node->visleafnum = num_visleafs++;
for (p = node->portals ; p ; )
{
for (p = node->portals; p;) {
if (p->nodes[0] == node) // only write out from first leaf
{
if (p->nodes[0]->contents == p->nodes[1]->contents)
num_visportals++;
p = p->next[0];
}
else
} else
p = p->next[1];
}
@ -575,7 +552,8 @@ void NumberLeafs_r (node_t *node)
WritePortalfile
================
*/
void WritePortalfile (node_t *headnode)
void
WritePortalfile (node_t * headnode)
{
// set the visleafnum field in every leaf and count the total number of portals
num_visleafs = 0;
@ -596,5 +574,3 @@ void WritePortalfile (node_t *headnode)
fclose (pf);
}

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

@ -68,7 +68,8 @@ int hullnum;
//===========================================================================
void qprintf (char *fmt, ...)
void
qprintf (char *fmt, ...)
{
va_list argptr;
@ -76,7 +77,7 @@ void qprintf (char *fmt, ...)
return;
va_start (argptr, fmt);
vprintf (fmt,argptr);
vprintf (fmt, argptr);
va_end (argptr);
}
@ -85,7 +86,8 @@ void qprintf (char *fmt, ...)
BaseWindingForPlane
=================
*/
winding_t *BaseWindingForPlane (plane_t *p)
winding_t *
BaseWindingForPlane (plane_t *p)
{
int i, x;
vec_t max, v;
@ -96,21 +98,18 @@ winding_t *BaseWindingForPlane (plane_t *p)
max = -BOGUS_RANGE;
x = -1;
for (i=0 ; i<3; i++)
{
v = fabs(p->normal[i]);
if (v > max)
{
for (i = 0; i < 3; i++) {
v = fabs (p->normal[i]);
if (v > max) {
x = i;
max = v;
}
}
if (x==-1)
if (x == -1)
Sys_Error ("BaseWindingForPlane: no axis found");
VectorCopy (vec3_origin, vup);
switch (x)
{
switch (x) {
case 0:
case 1:
vup[2] = 1;
@ -158,12 +157,13 @@ winding_t *BaseWindingForPlane (plane_t *p)
CopyWinding
==================
*/
winding_t *CopyWinding (winding_t *w)
winding_t *
CopyWinding (winding_t * w)
{
int size;
winding_t *c;
size = (int)((winding_t *)0)->points[w->numpoints];
size = (int) ((winding_t *) 0)->points[w->numpoints];
c = malloc (size);
memcpy (c, w, size);
return c;
@ -178,7 +178,8 @@ CheckWinding
Check for possible errors
==================
*/
void CheckWinding (winding_t *w)
void
CheckWinding (winding_t * w)
{
}
@ -193,7 +194,8 @@ If keepon is true, an exactly on-plane winding will be saved, otherwise
it will be clipped away.
==================
*/
winding_t *ClipWinding (winding_t *in, plane_t *split, qboolean keepon)
winding_t *
ClipWinding (winding_t * in, plane_t *split, qboolean keepon)
{
vec_t dists[MAX_POINTS_ON_WINDING];
int sides[MAX_POINTS_ON_WINDING];
@ -208,8 +210,7 @@ winding_t *ClipWinding (winding_t *in, plane_t *split, qboolean keepon)
counts[0] = counts[1] = counts[2] = 0;
// determine sides for each point
for (i=0 ; i<in->numpoints ; i++)
{
for (i = 0; i < in->numpoints; i++) {
dot = DotProduct (in->points[i], split->normal);
dot -= split->dist;
dists[i] = dot;
@ -217,8 +218,7 @@ winding_t *ClipWinding (winding_t *in, plane_t *split, qboolean keepon)
sides[i] = SIDE_FRONT;
else if (dot < -ON_EPSILON)
sides[i] = SIDE_BACK;
else
{
else {
sides[i] = SIDE_ON;
}
counts[sides[i]]++;
@ -229,50 +229,46 @@ winding_t *ClipWinding (winding_t *in, plane_t *split, qboolean keepon)
if (keepon && !counts[0] && !counts[1])
return in;
if (!counts[0])
{
if (!counts[0]) {
FreeWinding (in);
return NULL;
}
if (!counts[1])
return in;
maxpts = in->numpoints+4; // can't use counts[0]+2 because
maxpts = in->numpoints + 4; // can't use counts[0]+2 because
// of fp grouping errors
neww = NewWinding (maxpts);
for (i=0 ; i<in->numpoints ; i++)
{
for (i = 0; i < in->numpoints; i++) {
p1 = in->points[i];
if (sides[i] == SIDE_ON)
{
if (sides[i] == SIDE_ON) {
VectorCopy (p1, neww->points[neww->numpoints]);
neww->numpoints++;
continue;
}
if (sides[i] == SIDE_FRONT)
{
if (sides[i] == SIDE_FRONT) {
VectorCopy (p1, neww->points[neww->numpoints]);
neww->numpoints++;
}
if (sides[i+1] == SIDE_ON || sides[i+1] == sides[i])
if (sides[i + 1] == SIDE_ON || sides[i + 1] == sides[i])
continue;
// generate a split point
p2 = in->points[(i+1)%in->numpoints];
p2 = in->points[(i + 1) % in->numpoints];
dot = dists[i] / (dists[i]-dists[i+1]);
for (j=0 ; j<3 ; j++)
{ // avoid round off error when possible
dot = dists[i] / (dists[i] - dists[i + 1]);
for (j = 0; j < 3; j++) { // avoid round off error when
// possible
if (split->normal[j] == 1)
mid[j] = split->dist;
else if (split->normal[j] == -1)
mid[j] = -split->dist;
else
mid[j] = p1[j] + dot*(p2[j]-p1[j]);
mid[j] = p1[j] + dot * (p2[j] - p1[j]);
}
VectorCopy (mid, neww->points[neww->numpoints]);
@ -299,7 +295,9 @@ returned winding will be the input winding. If on both sides, two
new windings will be created.
==================
*/
void DivideWinding (winding_t *in, plane_t *split, winding_t **front, winding_t **back)
void
DivideWinding (winding_t * in, plane_t *split, winding_t ** front,
winding_t ** back)
{
vec_t dists[MAX_POINTS_ON_WINDING];
int sides[MAX_POINTS_ON_WINDING];
@ -314,8 +312,7 @@ void DivideWinding (winding_t *in, plane_t *split, winding_t **front, winding_t
counts[0] = counts[1] = counts[2] = 0;
// determine sides for each point
for (i=0 ; i<in->numpoints ; i++)
{
for (i = 0; i < in->numpoints; i++) {
dot = DotProduct (in->points[i], split->normal);
dot -= split->dist;
dists[i] = dot;
@ -323,8 +320,7 @@ void DivideWinding (winding_t *in, plane_t *split, winding_t **front, winding_t
sides[i] = SIDE_FRONT;
else if (dot < -ON_EPSILON)
sides[i] = SIDE_BACK;
else
{
else {
sides[i] = SIDE_ON;
}
counts[sides[i]]++;
@ -334,29 +330,25 @@ void DivideWinding (winding_t *in, plane_t *split, winding_t **front, winding_t
*front = *back = NULL;
if (!counts[0])
{
if (!counts[0]) {
*back = in;
return;
}
if (!counts[1])
{
if (!counts[1]) {
*front = in;
return;
}
maxpts = in->numpoints+4; // can't use counts[0]+2 because
maxpts = in->numpoints + 4; // can't use counts[0]+2 because
// of fp grouping errors
*front = f = NewWinding (maxpts);
*back = b = NewWinding (maxpts);
for (i=0 ; i<in->numpoints ; i++)
{
for (i = 0; i < in->numpoints; i++) {
p1 = in->points[i];
if (sides[i] == SIDE_ON)
{
if (sides[i] == SIDE_ON) {
VectorCopy (p1, f->points[f->numpoints]);
f->numpoints++;
VectorCopy (p1, b->points[b->numpoints]);
@ -364,32 +356,30 @@ void DivideWinding (winding_t *in, plane_t *split, winding_t **front, winding_t
continue;
}
if (sides[i] == SIDE_FRONT)
{
if (sides[i] == SIDE_FRONT) {
VectorCopy (p1, f->points[f->numpoints]);
f->numpoints++;
}
if (sides[i] == SIDE_BACK)
{
if (sides[i] == SIDE_BACK) {
VectorCopy (p1, b->points[b->numpoints]);
b->numpoints++;
}
if (sides[i+1] == SIDE_ON || sides[i+1] == sides[i])
if (sides[i + 1] == SIDE_ON || sides[i + 1] == sides[i])
continue;
// generate a split point
p2 = in->points[(i+1)%in->numpoints];
p2 = in->points[(i + 1) % in->numpoints];
dot = dists[i] / (dists[i]-dists[i+1]);
for (j=0 ; j<3 ; j++)
{ // avoid round off error when possible
dot = dists[i] / (dists[i] - dists[i + 1]);
for (j = 0; j < 3; j++) { // avoid round off error when
// possible
if (split->normal[j] == 1)
mid[j] = split->dist;
else if (split->normal[j] == -1)
mid[j] = -split->dist;
else
mid[j] = p1[j] + dot*(p2[j]-p1[j]);
mid[j] = p1[j] + dot * (p2[j] - p1[j]);
}
VectorCopy (mid, f->points[f->numpoints]);
@ -410,7 +400,8 @@ int c_activesurfaces, c_peaksurfaces;
int c_activewindings, c_peakwindings;
int c_activeportals, c_peakportals;
void PrintMemory (void)
void
PrintMemory (void)
{
printf ("faces : %6i (%6i)\n", c_activefaces, c_peakfaces);
printf ("surfaces: %6i (%6i)\n", c_activesurfaces, c_peaksurfaces);
@ -423,7 +414,8 @@ void PrintMemory (void)
NewWinding
==================
*/
winding_t *NewWinding (int points)
winding_t *
NewWinding (int points)
{
winding_t *w;
int size;
@ -435,7 +427,7 @@ winding_t *NewWinding (int points)
if (c_activewindings > c_peakwindings)
c_peakwindings = c_activewindings;
size = (int)((winding_t *)0)->points[points];
size = (int) ((winding_t *) 0)->points[points];
w = malloc (size);
memset (w, 0, size);
@ -443,7 +435,8 @@ winding_t *NewWinding (int points)
}
void FreeWinding (winding_t *w)
void
FreeWinding (winding_t * w)
{
c_activewindings--;
free (w);
@ -456,7 +449,8 @@ void FreeWinding (winding_t *w)
AllocFace
===========
*/
face_t *AllocFace (void)
face_t *
AllocFace (void)
{
face_t *f;
@ -464,15 +458,16 @@ face_t *AllocFace (void)
if (c_activefaces > c_peakfaces)
c_peakfaces = c_activefaces;
f = malloc (sizeof(face_t));
memset (f, 0, sizeof(face_t));
f = malloc (sizeof (face_t));
memset (f, 0, sizeof (face_t));
f->planenum = -1;
return f;
}
void FreeFace (face_t *f)
void
FreeFace (face_t * f)
{
c_activefaces--;
// memset (f,0xff,sizeof(face_t));
@ -485,12 +480,13 @@ void FreeFace (face_t *f)
AllocSurface
===========
*/
surface_t *AllocSurface (void)
surface_t *
AllocSurface (void)
{
surface_t *s;
s = malloc (sizeof(surface_t));
memset (s, 0, sizeof(surface_t));
s = malloc (sizeof (surface_t));
memset (s, 0, sizeof (surface_t));
c_activesurfaces++;
if (c_activesurfaces > c_peaksurfaces)
@ -499,7 +495,8 @@ surface_t *AllocSurface (void)
return s;
}
void FreeSurface (surface_t *s)
void
FreeSurface (surface_t * s)
{
c_activesurfaces--;
free (s);
@ -510,7 +507,8 @@ void FreeSurface (surface_t *s)
AllocPortal
===========
*/
portal_t *AllocPortal (void)
portal_t *
AllocPortal (void)
{
portal_t *p;
@ -518,13 +516,14 @@ portal_t *AllocPortal (void)
if (c_activeportals > c_peakportals)
c_peakportals = c_activeportals;
p = malloc (sizeof(portal_t));
memset (p, 0, sizeof(portal_t));
p = malloc (sizeof (portal_t));
memset (p, 0, sizeof (portal_t));
return p;
}
void FreePortal (portal_t *p)
void
FreePortal (portal_t * p)
{
c_activeportals--;
free (p);
@ -536,12 +535,13 @@ void FreePortal (portal_t *p)
AllocNode
===========
*/
node_t *AllocNode (void)
node_t *
AllocNode (void)
{
node_t *n;
n = malloc (sizeof(node_t));
memset (n, 0, sizeof(node_t));
n = malloc (sizeof (node_t));
memset (n, 0, sizeof (node_t));
return n;
}
@ -551,12 +551,13 @@ node_t *AllocNode (void)
AllocBrush
===========
*/
brush_t *AllocBrush (void)
brush_t *
AllocBrush (void)
{
brush_t *b;
b = malloc (sizeof(brush_t));
memset (b, 0, sizeof(brush_t));
b = malloc (sizeof (brush_t));
memset (b, 0, sizeof (brush_t));
return b;
}
@ -568,7 +569,8 @@ brush_t *AllocBrush (void)
ProcessEntity
===============
*/
void ProcessEntity (int entnum)
void
ProcessEntity (int entnum)
{
entity_t *ent;
char mod[80];
@ -581,8 +583,7 @@ void ProcessEntity (int entnum)
if (!ent->brushes)
return; // non-bmodel entity
if (entnum > 0)
{
if (entnum > 0) {
worldmodel = false;
if (entnum == 1)
qprintf ("--- Internal Entities ---\n");
@ -593,8 +594,7 @@ void ProcessEntity (int entnum)
if (hullnum == 0)
printf ("MODEL: %s\n", mod);
SetKeyValue (ent, "model", mod);
}
else
} else
worldmodel = true;
@ -604,8 +604,7 @@ void ProcessEntity (int entnum)
//
bs = Brush_LoadEntity (ent, hullnum);
if (!bs->brushes)
{
if (!bs->brushes) {
PrintEntity (ent);
Sys_Error ("Entity with no valid brushes");
}
@ -613,25 +612,23 @@ void ProcessEntity (int entnum)
brushset = bs;
surfs = CSGFaces (bs);
if (hullnum != 0)
{
if (hullnum != 0) {
nodes = SolidBSP (surfs, true);
if (entnum == 0 && !nofill) // assume non-world bmodels are simple
if (entnum == 0 && !nofill) // assume non-world bmodels are
// simple
{
PortalizeWorld (nodes);
if (FillOutside (nodes))
{
if (FillOutside (nodes)) {
surfs = GatherNodeFaces (nodes);
nodes = SolidBSP (surfs, false); // make a really good tree
nodes = SolidBSP (surfs, false); // make a really good
// tree
}
FreeAllPortals (nodes);
}
WriteNodePlanes (nodes);
WriteClipNodes (nodes);
BumpModel (hullnum);
}
else
{
} else {
//
// SolidBSP generates a node tree
//
@ -644,12 +641,12 @@ void ProcessEntity (int entnum)
// build all the portals in the bsp tree
// some portals are solid polygons, and some are paths to other leafs
//
if (entnum == 0 && !nofill) // assume non-world bmodels are simple
if (entnum == 0 && !nofill) // assume non-world bmodels are
// simple
{
PortalizeWorld (nodes);
if (FillOutside (nodes))
{
if (FillOutside (nodes)) {
FreeAllPortals (nodes);
// get the remaining faces together into surfaces again
@ -685,15 +682,15 @@ UpdateEntLump
=================
*/
void UpdateEntLump (void)
void
UpdateEntLump (void)
{
int m, entnum;
char mod[80];
QFile *f;
m = 1;
for (entnum = 1 ; entnum < num_entities ; entnum++)
{
for (entnum = 1; entnum < num_entities; entnum++) {
if (!entities[entnum].brushes)
continue;
sprintf (mod, "*%i", m);
@ -705,7 +702,7 @@ void UpdateEntLump (void)
f = Qopen (bspfilename, "rb");
bsp = LoadBSPFile (f, Qfilesize (f));
Qclose (f);
WriteEntitiesToString();
WriteEntitiesToString ();
f = Qopen (bspfilename, "wb");
WriteBSPFile (bsp, f);
Qclose (f);
@ -718,14 +715,15 @@ WriteClipHull
Write the clipping hull out to a text file so the parent process can get it
=================
*/
void WriteClipHull (void)
void
WriteClipHull (void)
{
FILE *f;
int i;
dplane_t *p;
dclipnode_t *d;
hullfilename[strlen(hullfilename)-1] = '0' + hullnum;
hullfilename[strlen (hullfilename) - 1] = '0' + hullnum;
qprintf ("---- WriteClipHull ----\n");
qprintf ("Writing %s\n", hullfilename);
@ -736,17 +734,18 @@ void WriteClipHull (void)
fprintf (f, "%i\n", bsp->nummodels);
for (i=0 ; i<bsp->nummodels ; i++)
for (i = 0; i < bsp->nummodels; i++)
fprintf (f, "%i\n", bsp->models[i].headnode[hullnum]);
fprintf (f, "\n%i\n", bsp->numclipnodes);
for (i=0 ; i<bsp->numclipnodes ; i++)
{
for (i = 0; i < bsp->numclipnodes; i++) {
d = &bsp->clipnodes[i];
p = &bsp->planes[d->planenum];
// the node number is only written out for human readability
fprintf (f, "%5i : %f %f %f %f : %5i %5i\n", i, p->normal[0], p->normal[1], p->normal[2], p->dist, d->children[0], d->children[1]);
fprintf (f, "%5i : %f %f %f %f : %5i %5i\n", i, p->normal[0],
p->normal[1], p->normal[2], p->dist, d->children[0],
d->children[1]);
}
fclose (f);
@ -759,7 +758,8 @@ ReadClipHull
Read the files written out by the child processes
=================
*/
void ReadClipHull (int hullnum)
void
ReadClipHull (int hullnum)
{
FILE *f;
int i, j, n;
@ -771,35 +771,36 @@ void ReadClipHull (int hullnum)
int junk;
vec3_t norm;
hullfilename[strlen(hullfilename)-1] = '0' + hullnum;
hullfilename[strlen (hullfilename) - 1] = '0' + hullnum;
f = fopen (hullfilename, "r");
if (!f)
Sys_Error ("Couldn't open %s", hullfilename);
if (fscanf (f,"%i\n", &n) != 1)
if (fscanf (f, "%i\n", &n) != 1)
Sys_Error ("Error parsing %s", hullfilename);
if (n != bsp->nummodels)
Sys_Error ("ReadClipHull: hull had %i models, base had %i", n, bsp->nummodels);
Sys_Error ("ReadClipHull: hull had %i models, base had %i", n,
bsp->nummodels);
for (i=0 ; i<n ; i++)
{
for (i = 0; i < n; i++) {
fscanf (f, "%i\n", &j);
bsp->models[i].headnode[hullnum] = bsp->numclipnodes + j;
}
fscanf (f,"\n%i\n", &n);
fscanf (f, "\n%i\n", &n);
firstclipnode = bsp->numclipnodes;
for (i=0 ; i<n ; i++)
{
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)
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);
@ -808,7 +809,9 @@ void ReadClipHull (int hullnum)
p.normal[2] = f3;
p.dist = f4;
norm[0] = f1; norm[1] = f2; norm[2] = f3; // vec_t precision
norm[0] = f1;
norm[1] = f2;
norm[2] = f3; // vec_t precision
p.type = PlaneTypeForNormal (norm);
d->children[0] = c1 >= 0 ? c1 + firstclipnode : c1;
@ -824,13 +827,13 @@ CreateSingleHull
=================
*/
void CreateSingleHull (void)
void
CreateSingleHull (void)
{
int entnum;
// for each entity in the map file that has geometry
for (entnum = 0 ; entnum < num_entities ; entnum++)
{
for (entnum = 0; entnum < num_entities; entnum++) {
ProcessEntity (entnum);
if (!allverbose)
verbose = false; // don't print rest of entities
@ -846,45 +849,37 @@ CreateHulls
=================
*/
void CreateHulls (void)
void
CreateHulls (void)
{
// commanded to create a single hull only
if (hullnum)
{
if (hullnum) {
CreateSingleHull ();
exit (0);
}
// commanded to use the allready existing hulls 1 and 2
if (usehulls)
{
if (usehulls) {
CreateSingleHull ();
return;
}
// commanded to ignore the hulls altogether
if (noclip)
{
if (noclip) {
CreateSingleHull ();
return;
}
// create all the hulls
#ifdef __alpha
printf ("forking hull processes...\n");
// fork a process for each clipping hull
fflush (stdout);
if (!fork ())
{
if (!fork ()) {
hullnum = 1;
verbose = false;
drawflag = false;
sprintf (argv0, "HUL%i", hullnum);
}
else if (!fork ())
{
} else if (!fork ()) {
hullnum = 2;
verbose = false;
drawflag = false;
@ -895,8 +890,10 @@ void CreateHulls (void)
if (hullnum)
exit (0);
wait (NULL); // wait for clip hull process to finish
wait (NULL); // wait for clip hull process to finish
wait (NULL); // wait for clip hull process to
// finish
wait (NULL); // wait for clip hull process to
// finish
#else
// create the hulls sequentially
@ -926,7 +923,8 @@ ProcessFile
=================
*/
void ProcessFile (char *sourcebase, char *bspfilename1)
void
ProcessFile (char *sourcebase, char *bspfilename1)
{
// create filenames
strcpy (bspfilename, bspfilename1);
@ -945,28 +943,23 @@ void ProcessFile (char *sourcebase, char *bspfilename1)
COM_StripExtension (pointfilename, pointfilename);
strcat (pointfilename, ".pts");
if (!onlyents)
{
if (!onlyents) {
remove (bspfilename);
if (!usehulls)
{
hullfilename[strlen(hullfilename)-1] = '1';
if (!usehulls) {
hullfilename[strlen (hullfilename) - 1] = '1';
remove (hullfilename);
hullfilename[strlen(hullfilename)-1] = '2';
hullfilename[strlen (hullfilename) - 1] = '2';
remove (hullfilename);
}
remove (portfilename);
remove (pointfilename);
}
// load brushes and entities
LoadMapFile (sourcebase);
if (onlyents)
{
if (onlyents) {
UpdateEntLump ();
return;
}
// init the tables to be shared by all models
BeginBSPFile ();
@ -976,7 +969,7 @@ void ProcessFile (char *sourcebase, char *bspfilename1)
ReadClipHull (1);
ReadClipHull (2);
WriteEntitiesToString();
WriteEntitiesToString ();
FinishBSPFile ();
}
@ -987,7 +980,8 @@ main
==================
*/
int main (int argc, char **argv)
int
main (int argc, char **argv)
{
int i;
double start, end;
@ -999,42 +993,39 @@ int main (int argc, char **argv)
//
// check command line flags
//
for (i=1 ; i<argc ; i++)
{
for (i = 1; i < argc; i++) {
if (argv[i][0] != '-')
break;
else if (!strcmp (argv[i],"-draw"))
else if (!strcmp (argv[i], "-draw"))
drawflag = true;
else if (!strcmp (argv[i],"-notjunc"))
else if (!strcmp (argv[i], "-notjunc"))
notjunc = true;
else if (!strcmp (argv[i],"-nofill"))
else if (!strcmp (argv[i], "-nofill"))
nofill = true;
else if (!strcmp (argv[i],"-noclip"))
else if (!strcmp (argv[i], "-noclip"))
noclip = true;
else if (!strcmp (argv[i],"-onlyents"))
else if (!strcmp (argv[i], "-onlyents"))
onlyents = true;
else if (!strcmp (argv[i],"-verbose"))
else if (!strcmp (argv[i], "-verbose"))
allverbose = true;
else if (!strcmp (argv[i],"-usehulls"))
usehulls = true; // don't fork -- use the existing files
else if (!strcmp (argv[i],"-hullnum"))
{
hullnum = atoi(argv[i+1]);
else if (!strcmp (argv[i], "-usehulls"))
usehulls = true; // don't fork -- use the existing
// files
else if (!strcmp (argv[i], "-hullnum")) {
hullnum = atoi (argv[i + 1]);
i++;
}
else if (!strcmp (argv[i],"-subdivide"))
{
subdivide_size = atoi(argv[i+1]);
} else if (!strcmp (argv[i], "-subdivide")) {
subdivide_size = atoi (argv[i + 1]);
i++;
}
else
} else
Sys_Error ("qbsp: Unknown option '%s'", argv[i]);
}
if (i != argc - 2 && i != argc - 1)
Sys_Error ("usage: qbsp [options] sourcefile [destfile]\noptions: -nojunc -nofill -threads[124] -draw -onlyents -verbose -proj <projectpath>");
Sys_Error
("usage: qbsp [options] sourcefile [destfile]\noptions: -nojunc -nofill -threads[124] -draw -onlyents -verbose -proj <projectpath>");
//XXX SetQdirFromPath (argv[i]);
// XXX SetQdirFromPath (argv[i]);
//
// let forked processes change name for ps status
@ -1048,15 +1039,13 @@ int main (int argc, char **argv)
strcpy (sourcename, argv[i]);
COM_DefaultExtension (sourcename, ".map");
if (i != argc - 2)
{
if (i != argc - 2) {
strcpy (destname, argv[i]);
COM_StripExtension (destname, destname);
strcat (destname, ".bsp");
printf ("outputfile: %s\n", destname);
}
else
strcpy (destname, argv[i+1]);
} else
strcpy (destname, argv[i + 1]);
//
// do it!
@ -1064,7 +1053,7 @@ int main (int argc, char **argv)
start = Sys_DoubleTime ();
ProcessFile (sourcename, destname);
end = Sys_DoubleTime ();
printf ("%5.1f seconds elapsed\n", end-start);
printf ("%5.1f seconds elapsed\n", end - start);
return 0;
}

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

@ -51,12 +51,12 @@ int firstedge;
vec3_t region_mins, region_maxs;
void AddPointToRegion (vec3_t p)
void
AddPointToRegion (vec3_t p)
{
int i;
for (i=0 ; i<3 ; i++)
{
for (i = 0; i < 3; i++) {
if (p[i] < region_mins[i])
region_mins[i] = p[i];
if (p[i] > region_maxs[i])
@ -64,17 +64,19 @@ void AddPointToRegion (vec3_t p)
}
}
void ClearRegionSize (void)
void
ClearRegionSize (void)
{
region_mins[0] = region_mins[1] = region_mins[2] = 9999;
region_maxs[0] = region_maxs[1] = region_maxs[2] = -9999;
}
void AddFaceToRegionSize (face_t *f)
void
AddFaceToRegionSize (face_t * f)
{
int i;
for (i=0 ; i<f->numpoints ; i++)
for (i = 0; i < f->numpoints; i++)
AddPointToRegion (f->pts[i]);
}
@ -83,41 +85,35 @@ void AddFaceToRegionSize (face_t *f)
CanJoinFaces
==============
*/
qboolean CanJoinFaces (face_t *f, face_t *f2)
qboolean
CanJoinFaces (face_t * f, face_t * f2)
{
vec3_t oldmins, oldmaxs;
int i;
if (f2->planenum != f->planenum
|| f2->planeside != f->planeside
|| f2->texturenum != f->texturenum)
|| f2->planeside != f->planeside || f2->texturenum != f->texturenum)
return false;
if (f2->outputnumber != -1)
return false;
if (f2->contents[0] != f->contents[0])
{ // does this ever happen? theyy shouldn't share.
if (f2->contents[0] != f->contents[0]) { // does this ever happen?
// theyy shouldn't share.
printf ("CanJoinFaces: edge with different contents");
return false;
}
// check size constraints
if ( ! (bsp->texinfo[f->texturenum].flags & TEX_SPECIAL) )
{
if (!(bsp->texinfo[f->texturenum].flags & TEX_SPECIAL)) {
VectorCopy (region_mins, oldmins);
VectorCopy (region_maxs, oldmaxs);
AddFaceToRegionSize (f2);
for (i=0 ; i<3 ; i++)
{
if (region_maxs[i] - region_mins[i] > 240)
{
for (i = 0; i < 3; i++) {
if (region_maxs[i] - region_mins[i] > 240) {
VectorCopy (oldmins, region_mins);
VectorCopy (oldmaxs, region_maxs);
return false;
}
}
}
else
{
} else {
if (bsp->numsurfedges - firstedge + f2->numpoints > MAX_EDGES_IN_REGION)
return false; // a huge water or sky polygon
}
@ -132,7 +128,8 @@ qboolean CanJoinFaces (face_t *f, face_t *f2)
RecursiveGrowRegion
==============
*/
void RecursiveGrowRegion (dface_t *r, face_t *f)
void
RecursiveGrowRegion (dface_t *r, face_t * f)
{
int e;
face_t *f2;
@ -146,29 +143,25 @@ void RecursiveGrowRegion (dface_t *r, face_t *f)
f->outputnumber = bsp->numfaces;
// add edges
for (i=0 ; i<f->numpoints ; i++)
{
for (i = 0; i < f->numpoints; i++) {
e = f->edges[i];
if (!edgefaces[abs(e)][0])
if (!edgefaces[abs (e)][0])
continue; // edge has allready been removed
if (e > 0)
f2 = edgefaces[e][1];
else
f2 = edgefaces[-e][0];
if (f2 && f2->outputnumber == bsp->numfaces)
{
edgefaces[abs(e)][0] = NULL;
edgefaces[abs(e)][1] = NULL;
if (f2 && f2->outputnumber == bsp->numfaces) {
edgefaces[abs (e)][0] = NULL;
edgefaces[abs (e)][1] = NULL;
continue; // allready merged
}
if (f2 && CanJoinFaces (f, f2))
{ // remove the edge and merge the faces
edgefaces[abs(e)][0] = NULL;
edgefaces[abs(e)][1] = NULL;
if (f2 && CanJoinFaces (f, f2)) { // remove the edge and merge the
// faces
edgefaces[abs (e)][0] = NULL;
edgefaces[abs (e)][1] = NULL;
RecursiveGrowRegion (r, f2);
}
else
{
} else {
// emit a surfedge
if (bsp->numsurfedges == MAX_MAP_SURFEDGES)
Sys_Error ("numsurfedges == MAX_MAP_SURFEDGES");
@ -179,17 +172,17 @@ void RecursiveGrowRegion (dface_t *r, face_t *f)
}
void PrintDface (int f)
void
PrintDface (int f)
{ // for debugging
dface_t *df;
dedge_t *e;
int i, n;
df = &bsp->faces[f];
for (i=0 ; i<df->numedges ; i++)
{
n = bsp->surfedges[df->firstedge+i];
e = &bsp->edges[abs(n)];
for (i = 0; i < df->numedges; i++) {
n = bsp->surfedges[df->firstedge + i];
e = &bsp->edges[abs (n)];
if (n < 0)
printf ("%5i = %5i : %5i\n", n, e->v[1], e->v[0]);
else
@ -197,21 +190,19 @@ void PrintDface (int f)
}
}
void FindVertexUse (int v)
void
FindVertexUse (int v)
{ // for debugging
int i, j, n;
dface_t *df;
dedge_t *e;
for (i=firstmodelface ; i<bsp->numfaces ; i++)
{
for (i = firstmodelface; i < bsp->numfaces; i++) {
df = &bsp->faces[i];
for (j=0 ; j<df->numedges ; j++)
{
n = bsp->surfedges[df->firstedge+j];
e = &bsp->edges[abs(n)];
if (e->v[0] == v || e->v[1] == v)
{
for (j = 0; j < df->numedges; j++) {
n = bsp->surfedges[df->firstedge + j];
e = &bsp->edges[abs (n)];
if (e->v[0] == v || e->v[1] == v) {
printf ("on face %i\n", i);
break;
}
@ -219,19 +210,17 @@ void FindVertexUse (int v)
}
}
void FindEdgeUse (int v)
void
FindEdgeUse (int v)
{ // for debugging
int i, j, n;
dface_t *df;
for (i=firstmodelface ; i<bsp->numfaces ; i++)
{
for (i = firstmodelface; i < bsp->numfaces; i++) {
df = &bsp->faces[i];
for (j=0 ; j<df->numedges ; j++)
{
n = bsp->surfedges[df->firstedge+j];
if (n == v || -n == v)
{
for (j = 0; j < df->numedges; j++) {
n = bsp->surfedges[df->firstedge + j];
if (n == v || -n == v) {
printf ("on face %i\n", i);
break;
}
@ -248,7 +237,8 @@ to e2
================
*/
int edgemapping[MAX_MAP_EDGES];
void HealEdges (int e1, int e2)
void
HealEdges (int e1, int e2)
{
int i, j, n, saved;
dface_t *df;
@ -257,14 +247,15 @@ void HealEdges (int e1, int e2)
dface_t *found[2];
int foundj[2];
return;
return;
e1 = edgemapping[e1];
e2 = edgemapping[e2];
// extend e1 to e2
ed = &bsp->edges[e1];
ed2 = &bsp->edges[e2];
VectorSubtract (bsp->vertexes[ed->v[1]].point, bsp->vertexes[ed->v[0]].point, v1);
VectorSubtract (bsp->vertexes[ed->v[1]].point,
bsp->vertexes[ed->v[0]].point, v1);
VectorNormalize (v1);
if (ed->v[0] == ed2->v[0])
@ -278,7 +269,8 @@ return;
else
Sys_Error ("HealEdges: edges don't meet");
VectorSubtract (bsp->vertexes[ed->v[1]].point, bsp->vertexes[ed->v[0]].point, v2);
VectorSubtract (bsp->vertexes[ed->v[1]].point,
bsp->vertexes[ed->v[0]].point, v2);
VectorNormalize (v2);
if (!VectorCompare (v1, v2))
@ -288,14 +280,11 @@ return;
saved = 0;
// remove all uses of e2
for (i=firstmodelface ; i<bsp->numfaces ; i++)
{
for (i = firstmodelface; i < bsp->numfaces; i++) {
df = &bsp->faces[i];
for (j=0 ; j<df->numedges ; j++)
{
n = bsp->surfedges[df->firstedge+j];
if (n == e2 || n == -e2)
{
for (j = 0; j < df->numedges; j++) {
n = bsp->surfedges[df->firstedge + j];
if (n == e2 || n == -e2) {
found[saved] = df;
foundj[saved] = j;
saved++;
@ -306,16 +295,14 @@ return;
if (saved != 2)
printf ("WARNING: didn't find both faces for a saved edge\n");
else
{
for (i=0 ; i<2 ; i++)
{ // remove this edge
else {
for (i = 0; i < 2; i++) { // remove this edge
df = found[i];
j = foundj[i];
for (j++ ; j<df->numedges ; j++)
bsp->surfedges[df->firstedge+j-1] =
bsp->surfedges[df->firstedge+j];
bsp->surfedges[df->firstedge+j-1] = 0;
for (j++; j < df->numedges; j++)
bsp->surfedges[df->firstedge + j - 1] =
bsp->surfedges[df->firstedge + j];
bsp->surfedges[df->firstedge + j - 1] = 0;
df->numedges--;
}
@ -324,8 +311,7 @@ return;
}
}
typedef struct
{
typedef struct {
int numedges;
int edges[2];
} checkpoint_t;
@ -337,28 +323,27 @@ checkpoint_t checkpoints[MAX_MAP_VERTS];
RemoveColinearEdges
==============
*/
void RemoveColinearEdges (void)
void
RemoveColinearEdges (void)
{
int i,j, v;
int i, j, v;
int c0, c1, c2, c3;
checkpoint_t *cp;
// no edges remapped yet
for (i=0 ; i<bsp->numedges ; i++)
for (i = 0; i < bsp->numedges; i++)
edgemapping[i] = i;
// find vertexes that only have two edges
memset (checkpoints, 0, sizeof(checkpoints));
memset (checkpoints, 0, sizeof (checkpoints));
for (i=firstmodeledge ; i<bsp->numedges ; i++)
{
for (i = firstmodeledge; i < bsp->numedges; i++) {
if (!edgefaces[i][0])
continue; // removed
for (j=0 ; j<2 ; j++)
{
for (j = 0; j < 2; j++) {
v = bsp->edges[i].v[j];
cp = &checkpoints[v];
if (cp->numedges<2)
if (cp->numedges < 2)
cp->edges[cp->numedges] = i;
cp->numedges++;
}
@ -367,11 +352,9 @@ void RemoveColinearEdges (void)
// if a vertex only has two edges and they are colinear, it can be removed
c0 = c1 = c2 = c3 = 0;
for (i=0 ; i<bsp->numvertexes ; i++)
{
for (i = 0; i < bsp->numvertexes; i++) {
cp = &checkpoints[i];
switch (cp->numedges)
{
switch (cp->numedges) {
case 0:
c0++;
break;
@ -400,20 +383,21 @@ void RemoveColinearEdges (void)
CountRealNumbers
==============
*/
void CountRealNumbers (void)
void
CountRealNumbers (void)
{
int i;
int c;
qprintf ("%5i regions\n", bsp->numfaces-firstmodelface);
qprintf ("%5i regions\n", bsp->numfaces - firstmodelface);
c = 0;
for (i=firstmodelface ; i<bsp->numfaces ; i++)
for (i = firstmodelface; i < bsp->numfaces; i++)
c += bsp->faces[i].numedges;
qprintf ("%5i real marksurfaces\n", c);
c = 0;
for (i=firstmodeledge ; i<bsp->numedges ; i++)
for (i = firstmodeledge; i < bsp->numedges; i++)
if (edgefaces[i][0])
c++; // not removed
@ -427,7 +411,8 @@ void CountRealNumbers (void)
GrowNodeRegion_r
==============
*/
void GrowNodeRegion_r (node_t *node)
void
GrowNodeRegion_r (node_t * node)
{
dface_t *r;
face_t *f;
@ -438,8 +423,7 @@ void GrowNodeRegion_r (node_t *node)
node->firstface = bsp->numfaces;
for (f=node->faces ; f ; f=f->next)
{
for (f = node->faces; f; f = f->next) {
// if (f->outputnumber != -1)
// continue; // allready grown into an earlier region
@ -453,7 +437,7 @@ void GrowNodeRegion_r (node_t *node)
r->planenum = node->outputplanenum;
r->side = f->planeside;
r->texinfo = f->texturenum;
for (i=0 ; i<MAXLIGHTMAPS ; i++)
for (i = 0; i < MAXLIGHTMAPS; i++)
r->styles[i] = 255;
r->lightofs = -1;
@ -465,8 +449,7 @@ void GrowNodeRegion_r (node_t *node)
RecursiveGrowRegion (r, f);
#endif
r->firstedge = firstedge = bsp->numsurfedges;
for (i=0 ; i<f->numpoints ; i++)
{
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];
@ -490,7 +473,8 @@ void GrowNodeRegion_r (node_t *node)
GrowNodeRegions
==============
*/
void GrowNodeRegions (node_t *headnode)
void
GrowNodeRegions (node_t * headnode)
{
qprintf ("---- GrowRegions ----\n");
@ -521,16 +505,3 @@ for all faces
===============================================================================
*/

259
tools/qfbsp/source/solidbsp.c
View file

@ -45,7 +45,8 @@ FaceSide
For BSP hueristic
==================
*/
int FaceSide (face_t *in, plane_t *split)
int
FaceSide (face_t * in, plane_t *split)
{
int frontcount, backcount;
vec_t dot;
@ -57,35 +58,27 @@ int FaceSide (face_t *in, plane_t *split)
// axial planes are fast
if (split->type < 3)
for (i=0, p = in->pts[0]+split->type ; i<in->numpoints ; i++, p+=3)
{
if (*p > split->dist + ON_EPSILON)
{
for (i = 0, p = in->pts[0] + split->type; i < in->numpoints;
i++, p += 3) {
if (*p > split->dist + ON_EPSILON) {
if (backcount)
return SIDE_ON;
frontcount = 1;
}
else if (*p < split->dist - ON_EPSILON)
{
} else if (*p < split->dist - ON_EPSILON) {
if (frontcount)
return SIDE_ON;
backcount = 1;
}
}
else
} else
// sloping planes take longer
for (i=0, p = in->pts[0] ; i<in->numpoints ; i++, p+=3)
{
for (i = 0, p = in->pts[0]; i < in->numpoints; i++, p += 3) {
dot = DotProduct (p, split->normal);
dot -= split->dist;
if (dot > ON_EPSILON)
{
if (dot > ON_EPSILON) {
if (backcount)
return SIDE_ON;
frontcount = 1;
}
else if (dot < -ON_EPSILON)
{
} else if (dot < -ON_EPSILON) {
if (frontcount)
return SIDE_ON;
backcount = 1;
@ -107,9 +100,10 @@ ChooseMidPlaneFromList
The clipping hull BSP doesn't worry about avoiding splits
==================
*/
surface_t *ChooseMidPlaneFromList (surface_t *surfaces, vec3_t mins, vec3_t maxs)
surface_t *
ChooseMidPlaneFromList (surface_t * surfaces, vec3_t mins, vec3_t maxs)
{
int j,l;
int j, l;
surface_t *p, *bestsurface;
vec_t bestvalue, value, dist;
plane_t *plane;
@ -117,11 +111,10 @@ surface_t *ChooseMidPlaneFromList (surface_t *surfaces, vec3_t mins, vec3_t maxs
//
// pick the plane that splits the least
//
bestvalue = 6*8192*8192;
bestvalue = 6 * 8192 * 8192;
bestsurface = NULL;
for (p=surfaces ; p ; p=p->next)
{
for (p = surfaces; p; p = p->next) {
if (p->onnode)
continue;
@ -138,15 +131,12 @@ surface_t *ChooseMidPlaneFromList (surface_t *surfaces, vec3_t mins, vec3_t maxs
value = 0;
dist = plane->dist * plane->normal[l];
for (j=0 ; j<3 ; j++)
{
if (j == l)
{
value += (maxs[l]-dist)*(maxs[l]-dist);
value += (dist-mins[l])*(dist-mins[l]);
}
else
value += 2*(maxs[j]-mins[j])*(maxs[j]-mins[j]);
for (j = 0; j < 3; j++) {
if (j == l) {
value += (maxs[l] - dist) * (maxs[l] - dist);
value += (dist - mins[l]) * (dist - mins[l]);
} else
value += 2 * (maxs[j] - mins[j]) * (maxs[j] - mins[j]);
}
if (value > bestvalue)
@ -159,9 +149,8 @@ surface_t *ChooseMidPlaneFromList (surface_t *surfaces, vec3_t mins, vec3_t maxs
bestsurface = p;
}
if (!bestsurface)
{
for (p=surfaces ; p ; p=p->next)
if (!bestsurface) {
for (p = surfaces; p; p = p->next)
if (!p->onnode)
return p; // first valid surface
Sys_Error ("ChooseMidPlaneFromList: no valid planes");
@ -179,9 +168,11 @@ ChoosePlaneFromList
The real BSP hueristic
==================
*/
surface_t *ChoosePlaneFromList (surface_t *surfaces, vec3_t mins, vec3_t maxs, qboolean usefloors)
surface_t *
ChoosePlaneFromList (surface_t * surfaces, vec3_t mins, vec3_t maxs,
qboolean usefloors)
{
int j,k,l;
int j, k, l;
surface_t *p, *p2, *bestsurface;
vec_t bestvalue, bestdistribution, value, dist;
plane_t *plane;
@ -194,8 +185,7 @@ surface_t *ChoosePlaneFromList (surface_t *surfaces, vec3_t mins, vec3_t maxs, q
bestsurface = NULL;
bestdistribution = 9e30;
for (p=surfaces ; p ; p=p->next)
{
for (p = surfaces; p; p = p->next) {
if (p->onnode)
continue;
@ -205,17 +195,14 @@ surface_t *ChoosePlaneFromList (surface_t *surfaces, vec3_t mins, vec3_t maxs, q
if (!usefloors && plane->normal[2] == 1)
continue;
for (p2=surfaces ; p2 ; p2=p2->next)
{
for (p2 = surfaces; p2; p2 = p2->next) {
if (p2 == p)
continue;
if (p2->onnode)
continue;
for (f=p2->faces ; f ; f=f->next)
{
if (FaceSide (f, plane) == SIDE_ON)
{
for (f = p2->faces; f; f = f->next) {
if (FaceSide (f, plane) == SIDE_ON) {
k++;
if (k >= bestvalue)
break;
@ -229,30 +216,27 @@ surface_t *ChoosePlaneFromList (surface_t *surfaces, vec3_t mins, vec3_t maxs, q
if (k > bestvalue)
continue;
// if equal numbers, axial planes win, then decide on spatial subdivision
// if equal numbers, axial planes win, then decide on spatial
// subdivision
if (k < bestvalue || (k == bestvalue && plane->type < PLANE_ANYX) )
{
if (k < bestvalue || (k == bestvalue && plane->type < PLANE_ANYX)) {
// check for axis aligned surfaces
l = plane->type;
if (l <= PLANE_Z)
{ // axial aligned
if (l <= PLANE_Z) { // axial aligned
//
//
// calculate the split metric along axis l
//
value = 0;
for (j=0 ; j<3 ; j++)
{
if (j == l)
{
for (j = 0; j < 3; j++) {
if (j == l) {
dist = plane->dist * plane->normal[l];
value += (maxs[l]-dist)*(maxs[l]-dist);
value += (dist-mins[l])*(dist-mins[l]);
}
else
value += 2*(maxs[j]-mins[j])*(maxs[j]-mins[j]);
value += (maxs[l] - dist) * (maxs[l] - dist);
value += (dist - mins[l]) * (dist - mins[l]);
} else
value += 2 * (maxs[j] - mins[j]) * (maxs[j] - mins[j]);
}
if (value > bestdistribution && k == bestvalue)
@ -281,9 +265,10 @@ Selects a surface from a linked list of surfaces to split the group on
returns NULL if the surface list can not be divided any more (a leaf)
==================
*/
surface_t *SelectPartition (surface_t *surfaces)
surface_t *
SelectPartition (surface_t * surfaces)
{
int i,j;
int i, j;
vec3_t mins, maxs;
surface_t *p, *bestsurface;
@ -292,31 +277,28 @@ surface_t *SelectPartition (surface_t *surfaces)
//
i = 0;
bestsurface = NULL;
for (p=surfaces ; p ; p=p->next)
if (!p->onnode)
{
for (p = surfaces; p; p = p->next)
if (!p->onnode) {
i++;
bestsurface = p;
}
if (i==0)
if (i == 0)
return NULL;
if (i==1)
if (i == 1)
return bestsurface; // this is a final split
//
// calculate a bounding box of the entire surfaceset
//
for (i=0 ; i<3 ; i++)
{
for (i = 0; i < 3; i++) {
mins[i] = 99999;
maxs[i] = -99999;
}
for (p=surfaces ; p ; p=p->next)
for (j=0 ; j<3 ; j++)
{
for (p = surfaces; p; p = p->next)
for (j = 0; j < 3; j++) {
if (p->mins[j] < mins[j])
mins[j] = p->mins[j];
if (p->maxs[j] > maxs[j])
@ -344,9 +326,10 @@ CalcSurfaceInfo
Calculates the bounding box
=================
*/
void CalcSurfaceInfo (surface_t *surf)
void
CalcSurfaceInfo (surface_t * surf)
{
int i,j;
int i, j;
face_t *f;
if (!surf->faces)
@ -355,19 +338,16 @@ void CalcSurfaceInfo (surface_t *surf)
//
// calculate a bounding box
//
for (i=0 ; i<3 ; i++)
{
for (i = 0; i < 3; i++) {
surf->mins[i] = 99999;
surf->maxs[i] = -99999;
}
for (f=surf->faces ; f ; f=f->next)
{
if (f->contents[0] >= 0 || f->contents[1] >= 0)
Sys_Error ("Bad contents");
for (i=0 ; i<f->numpoints ; i++)
for (j=0 ; j<3 ; j++)
{
for (f = surf->faces; f; f = f->next) {
if (f->contents[0] >= 0 || f->contents[1] >= 0)
Sys_Error ("Bad contents");
for (i = 0; i < f->numpoints; i++)
for (j = 0; j < 3; j++) {
if (f->pts[i][j] < surf->mins[j])
surf->mins[j] = f->pts[i][j];
if (f->pts[i][j] > surf->maxs[j])
@ -383,7 +363,9 @@ Sys_Error ("Bad contents");
DividePlane
==================
*/
void DividePlane (surface_t *in, plane_t *split, surface_t **front, surface_t **back)
void
DividePlane (surface_t * in, plane_t *split, surface_t ** front,
surface_t ** back)
{
face_t *facet, *next;
face_t *frontlist, *backlist;
@ -394,29 +376,24 @@ void DividePlane (surface_t *in, plane_t *split, surface_t **front, surface_t **
inplane = &planes[in->planenum];
// parallel case is easy
if (VectorCompare (inplane->normal, split->normal))
{
if (VectorCompare (inplane->normal, split->normal)) {
// check for exactly on node
if (inplane->dist == split->dist)
{ // divide the facets to the front and back sides
if (inplane->dist == split->dist) { // divide the facets to the front
// and back sides
news = AllocSurface ();
*news = *in;
facet=in->faces;
facet = in->faces;
in->faces = NULL;
news->faces = NULL;
in->onnode = news->onnode = true;
for ( ; facet ; facet=next)
{
for (; facet; facet = next) {
next = facet->next;
if (facet->planeside == 1)
{
if (facet->planeside == 1) {
facet->next = news->faces;
news->faces = facet;
}
else
{
} else {
facet->next = in->faces;
in->faces = facet;
}
@ -433,35 +410,28 @@ void DividePlane (surface_t *in, plane_t *split, surface_t **front, surface_t **
return;
}
if (inplane->dist > split->dist)
{
if (inplane->dist > split->dist) {
*front = in;
*back = NULL;
}
else
{
} else {
*front = NULL;
*back = in;
}
return;
}
// do a real split. may still end up entirely on one side
// OPTIMIZE: use bounding box for fast test
frontlist = NULL;
backlist = NULL;
for (facet = in->faces ; facet ; facet = next)
{
for (facet = in->faces; facet; facet = next) {
next = facet->next;
SplitFace (facet, split, &frontfrag, &backfrag);
if (frontfrag)
{
if (frontfrag) {
frontfrag->next = frontlist;
frontlist = frontfrag;
}
if (backfrag)
{
if (backfrag) {
backfrag->next = backlist;
backlist = backfrag;
}
@ -469,23 +439,20 @@ void DividePlane (surface_t *in, plane_t *split, surface_t **front, surface_t **
// if nothing actually got split, just move the in plane
if (frontlist == NULL)
{
if (frontlist == NULL) {
*front = NULL;
*back = in;
in->faces = backlist;
return;
}
if (backlist == NULL)
{
if (backlist == NULL) {
*front = in;
*back = NULL;
in->faces = frontlist;
return;
}
// stuff got split, so allocate one new plane and reuse in
news = AllocSurface ();
*news = *in;
@ -505,7 +472,8 @@ void DividePlane (surface_t *in, plane_t *split, surface_t **front, surface_t **
DivideNodeBounds
==================
*/
void DivideNodeBounds (node_t *node, plane_t *split)
void
DivideNodeBounds (node_t * node, plane_t *split)
{
VectorCopy (node->mins, node->children[0]->mins);
VectorCopy (node->mins, node->children[1]->mins);
@ -528,7 +496,8 @@ Determines the contents of the leaf and creates the final list of
original faces that have some fragment inside this leaf
==================
*/
void LinkConvexFaces (surface_t *planelist, node_t *leafnode)
void
LinkConvexFaces (surface_t * planelist, node_t * leafnode)
{
face_t *f, *next;
surface_t *surf, *pnext;
@ -539,10 +508,8 @@ void LinkConvexFaces (surface_t *planelist, node_t *leafnode)
leafnode->planenum = -1;
count = 0;
for ( surf = planelist ; surf ; surf = surf->next)
{
for (f = surf->faces ; f ; f=f->next)
{
for (surf = planelist; surf; surf = surf->next) {
for (f = surf->faces; f; f = f->next) {
count++;
if (!leafnode->contents)
leafnode->contents = f->contents[0];
@ -554,8 +521,7 @@ void LinkConvexFaces (surface_t *planelist, node_t *leafnode)
if (!leafnode->contents)
leafnode->contents = CONTENTS_SOLID;
switch (leafnode->contents)
{
switch (leafnode->contents) {
case CONTENTS_EMPTY:
c_empty++;
break;
@ -576,13 +542,11 @@ void LinkConvexFaces (surface_t *planelist, node_t *leafnode)
// write the list of faces, and free the originals
//
leaffaces += count;
leafnode->markfaces = malloc(sizeof(face_t *)*(count+1));
leafnode->markfaces = malloc (sizeof (face_t *) * (count + 1));
i = 0;
for ( surf = planelist ; surf ; surf = pnext)
{
for (surf = planelist; surf; surf = pnext) {
pnext = surf->next;
for (f = surf->faces ; f ; f=next)
{
for (f = surf->faces; f; f = next) {
next = f->next;
leafnode->markfaces[i] = f->original;
i++;
@ -601,7 +565,8 @@ LinkNodeFaces
Returns a duplicated list of all faces on surface
==================
*/
face_t *LinkNodeFaces (surface_t *surface)
face_t *
LinkNodeFaces (surface_t * surface)
{
face_t *f, *new, **prevptr;
face_t *list;
@ -611,8 +576,7 @@ face_t *LinkNodeFaces (surface_t *surface)
// subdivide
prevptr = &surface->faces;
while (1)
{
while (1) {
f = *prevptr;
if (!f)
break;
@ -622,8 +586,7 @@ face_t *LinkNodeFaces (surface_t *surface)
}
// copy
for (f=surface->faces ; f ; f=f->next)
{
for (f = surface->faces; f; f = f->next) {
nodefaces++;
new = AllocFace ();
*new = *f;
@ -641,7 +604,8 @@ face_t *LinkNodeFaces (surface_t *surface)
PartitionSurfaces
==================
*/
void PartitionSurfaces (surface_t *surfaces, node_t *node)
void
PartitionSurfaces (surface_t * surfaces, node_t * node)
{
surface_t *split, *p, *next;
surface_t *frontlist, *backlist;
@ -649,8 +613,7 @@ void PartitionSurfaces (surface_t *surfaces, node_t *node)
plane_t *splitplane;
split = SelectPartition (surfaces);
if (!split)
{ // this is a leaf node
if (!split) { // this is a leaf node
node->planenum = PLANENUM_LEAF;
LinkConvexFaces (surfaces, node);
return;
@ -673,27 +636,23 @@ void PartitionSurfaces (surface_t *surfaces, node_t *node)
frontlist = NULL;
backlist = NULL;
for (p=surfaces ; p ; p=next)
{
for (p = surfaces; p; p = next) {
next = p->next;
DividePlane (p, splitplane, &frontfrag, &backfrag);
if (frontfrag && backfrag)
{
if (frontfrag && backfrag) {
// the plane was split, which may expose oportunities to merge
// adjacent faces into a single face
// MergePlaneFaces (frontfrag);
// MergePlaneFaces (backfrag);
}
if (frontfrag)
{
if (frontfrag) {
if (!frontfrag->faces)
Sys_Error ("surface with no faces");
frontfrag->next = frontlist;
frontlist = frontfrag;
}
if (backfrag)
{
if (backfrag) {
if (!backfrag->faces)
Sys_Error ("surface with no faces");
backfrag->next = backlist;
@ -710,11 +669,12 @@ void PartitionSurfaces (surface_t *surfaces, node_t *node)
DrawSurface
==================
*/
void DrawSurface (surface_t *surf)
void
DrawSurface (surface_t * surf)
{
face_t *f;
for (f=surf->faces ; f ; f=f->next)
for (f = surf->faces; f; f = f->next)
Draw_DrawFace (f);
}
@ -723,11 +683,11 @@ void DrawSurface (surface_t *surf)
DrawSurfaceList
==================
*/
void DrawSurfaceList (surface_t *surf)
void
DrawSurfaceList (surface_t * surf)
{
Draw_ClearWindow ();
while (surf)
{
while (surf) {
DrawSurface (surf);
surf = surf->next;
}
@ -738,7 +698,8 @@ void DrawSurfaceList (surface_t *surf)
SolidBSP
==================
*/
node_t *SolidBSP (surface_t *surfhead, qboolean midsplit)
node_t *
SolidBSP (surface_t * surfhead, qboolean midsplit)
{
int i;
node_t *headnode;
@ -751,8 +712,7 @@ node_t *SolidBSP (surface_t *surfhead, qboolean midsplit)
//
// calculate a bounding box for the entire model
//
for (i=0 ; i<3 ; i++)
{
for (i = 0; i < 3; i++) {
headnode->mins[i] = brushset->mins[i] - SIDESPACE;
headnode->maxs[i] = brushset->maxs[i] + SIDESPACE;
}
@ -772,9 +732,8 @@ node_t *SolidBSP (surface_t *surfhead, qboolean midsplit)
qprintf ("%5i solid leafs\n", c_solid);
qprintf ("%5i empty leafs\n", c_empty);
qprintf ("%5i water leafs\n", c_water);
qprintf ("%5i leaffaces\n",leaffaces);
qprintf ("%5i leaffaces\n", leaffaces);
qprintf ("%5i nodefaces\n", nodefaces);
return headnode;
}

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

@ -49,7 +49,8 @@ If the face is >256 in either texture direction, carve a valid sized
piece off and insert the remainder in the next link
===============
*/
void SubdivideFace (face_t *f, face_t **prevptr)
void
SubdivideFace (face_t * f, face_t ** prevptr)
{
float mins, maxs;
vec_t v;
@ -61,19 +62,16 @@ void SubdivideFace (face_t *f, face_t **prevptr)
// special (non-surface cached) faces don't need subdivision
tex = &bsp->texinfo[f->texturenum];
if ( tex->flags & TEX_SPECIAL)
if (tex->flags & TEX_SPECIAL)
return;
for (axis = 0 ; axis < 2 ; axis++)
{
while (1)
{
for (axis = 0; axis < 2; axis++) {
while (1) {
mins = 9999;
maxs = -9999;
for (i=0 ; i<f->numpoints ; i++)
{
for (i = 0; i < f->numpoints; i++) {
v = DotProduct (f->pts[i], tex->vecs[axis]);
if (v < mins)
mins = v;
@ -90,7 +88,7 @@ void SubdivideFace (face_t *f, face_t **prevptr)
VectorCopy (tex->vecs[axis], plane.normal);
v = VectorLength (plane.normal);
VectorNormalize (plane.normal);
plane.dist = (mins + subdivide_size - 16)/v;
plane.dist = (mins + subdivide_size - 16) / v;
next = f->next;
SplitFace (f, &plane, &front, &back);
if (!front || !back)
@ -109,20 +107,19 @@ void SubdivideFace (face_t *f, face_t **prevptr)
SubdivideFaces
================
*/
void SubdivideFaces (surface_t *surfhead)
void
SubdivideFaces (surface_t * surfhead)
{
surface_t *surf;
face_t *f , **prevptr;
face_t *f, **prevptr;
qprintf ("--- SubdivideFaces ---\n");
subdivides = 0;
for (surf = surfhead ; surf ; surf=surf->next)
{
for (surf = surfhead; surf; surf = surf->next) {
prevptr = &surf->faces;
while (1)
{
while (1) {
f = *prevptr;
if (!f)
break;
@ -147,24 +144,20 @@ have inside faces.
=============================================================================
*/
void GatherNodeFaces_r (node_t *node)
void
GatherNodeFaces_r (node_t * node)
{
face_t *f, *next;
if (node->planenum != PLANENUM_LEAF)
{
if (node->planenum != PLANENUM_LEAF) {
//
// decision node
//
for (f=node->faces ; f ; f=next)
{
for (f = node->faces; f; f = next) {
next = f->next;
if (!f->numpoints)
{ // face was removed outside
if (!f->numpoints) { // face was removed outside
FreeFace (f);
}
else
{
} else {
f->next = validfaces[f->planenum];
validfaces[f->planenum] = f;
}
@ -174,9 +167,7 @@ void GatherNodeFaces_r (node_t *node)
GatherNodeFaces_r (node->children[1]);
free (node);
}
else
{
} else {
//
// leaf node
//
@ -190,17 +181,17 @@ GatherNodeFaces
================
*/
surface_t *GatherNodeFaces (node_t *headnode)
surface_t *
GatherNodeFaces (node_t * headnode)
{
memset (validfaces, 0, sizeof(validfaces));
memset (validfaces, 0, sizeof (validfaces));
GatherNodeFaces_r (headnode);
return BuildSurfaces ();
}
//===========================================================================
typedef struct hashvert_s
{
typedef struct hashvert_s {
struct hashvert_s *next;
vec3_t point;
int num;
@ -228,7 +219,8 @@ hashvert_t *hashverts[NUM_HASH];
static vec3_t hash_min, hash_scale;
static void InitHash (void)
static void
InitHash (void)
{
vec3_t size;
vec_t volume;
@ -236,17 +228,16 @@ static void InitHash (void)
int newsize[2];
int i;
memset (hashverts, 0, sizeof(hashverts));
memset (hashverts, 0, sizeof (hashverts));
for (i=0 ; i<3 ; i++)
{
for (i = 0; i < 3; i++) {
hash_min[i] = -8000;
size[i] = 16000;
}
volume = size[0]*size[1];
volume = size[0] * size[1];
scale = sqrt(volume / NUM_HASH);
scale = sqrt (volume / NUM_HASH);
newsize[0] = size[0] / scale;
newsize[1] = size[1] / scale;
@ -258,13 +249,14 @@ static void InitHash (void)
hvert_p = hvertex;
}
static unsigned HashVec (vec3_t vec)
static unsigned
HashVec (vec3_t vec)
{
unsigned h;
h = hash_scale[0] * (vec[0] - hash_min[0]) * hash_scale[2]
+ hash_scale[1] * (vec[1] - hash_min[1]);
if ( h >= NUM_HASH)
if (h >= NUM_HASH)
return NUM_HASH - 1;
return h;
}
@ -275,16 +267,16 @@ static unsigned HashVec (vec3_t vec)
GetVertex
=============
*/
int GetVertex (vec3_t in, int planenum)
int
GetVertex (vec3_t in, int planenum)
{
int h;
int i;
hashvert_t *hv;
vec3_t vert;
for (i=0 ; i<3 ; i++)
{
if ( fabs(in[i] - (int) (in[i] + 0.5)) < 0.001)
for (i = 0; i < 3; i++) {
if (fabs (in[i] - (int) (in[i] + 0.5)) < 0.001)
vert[i] = (int) (in[i] + 0.5);
else
vert[i] = in[i];
@ -292,16 +284,14 @@ int GetVertex (vec3_t in, int planenum)
h = HashVec (vert);
for (hv=hashverts[h] ; hv ; hv=hv->next)
{
if ( fabs(hv->point[0]-vert[0])<POINT_EPSILON
&& fabs(hv->point[1]-vert[1])<POINT_EPSILON
&& fabs(hv->point[2]-vert[2])<POINT_EPSILON )
{
for (hv = hashverts[h]; hv; hv = hv->next) {
if (fabs (hv->point[0] - vert[0]) < POINT_EPSILON
&& fabs (hv->point[1] - vert[1]) < POINT_EPSILON
&& fabs (hv->point[2] - vert[2]) < POINT_EPSILON) {
hv->numedges++;
if (hv->numplanes == 3)
return hv->num; // allready known to be a corner
for (i=0 ; i<hv->numplanes ; i++)
for (i = 0; i < hv->numplanes; i++)
if (hv->planenums[i] == planenum)
return hv->num; // allready know this plane
if (hv->numplanes == 2)
@ -321,7 +311,7 @@ int GetVertex (vec3_t in, int planenum)
hashverts[h] = hv;
VectorCopy (vert, hv->point);
hv->num = bsp->numvertexes;
if (hv->num==MAX_MAP_VERTS)
if (hv->num == MAX_MAP_VERTS)
Sys_Error ("GetVertex: MAX_MAP_VERTS");
hvert_p++;
@ -349,7 +339,8 @@ Don't allow four way edges
*/
int c_tryedges;
int GetEdge (vec3_t p1, vec3_t p2, face_t *f)
int
GetEdge (vec3_t p1, vec3_t p2, face_t * f)
{
int v1, v2;
dedge_t *edge;
@ -361,13 +352,11 @@ int GetEdge (vec3_t p1, vec3_t p2, face_t *f)
c_tryedges++;
v1 = GetVertex (p1, f->planenum);
v2 = GetVertex (p2, f->planenum);
for (i=firstmodeledge ; i < bsp->numedges ; i++)
{
for (i = firstmodeledge; i < bsp->numedges; i++) {
edge = &bsp->edges[i];
if (v1 == edge->v[1] && v2 == edge->v[0]
&& !edgefaces[i][1]
&& edgefaces[i][0]->contents[0] == f->contents[0])
{
&& edgefaces[i][0]->contents[0] == f->contents[0]) {
edgefaces[i][1] = f;
return -i;
}
@ -391,7 +380,8 @@ int GetEdge (vec3_t p1, vec3_t p2, face_t *f)
FindFaceEdges
==================
*/
void FindFaceEdges (face_t *face)
void
FindFaceEdges (face_t * face)
{
int i;
@ -399,9 +389,9 @@ void FindFaceEdges (face_t *face)
if (face->numpoints > MAXEDGES)
Sys_Error ("WriteFace: %i points", face->numpoints);
for (i=0; i<face->numpoints ; i++)
for (i = 0; i < face->numpoints; i++)
face->edges[i] = GetEdge
(face->pts[i], face->pts[(i+1)%face->numpoints], face);
(face->pts[i], face->pts[(i + 1) % face->numpoints], face);
}
/*
@ -410,14 +400,14 @@ CheckVertexes
// debugging
=============
*/
void CheckVertexes (void)
void
CheckVertexes (void)
{
int cb, c0, c1, c2, c3;
hashvert_t *hv;
cb = c0 = c1 = c2 = c3 = 0;
for (hv=hvertex ; hv!=hvert_p ; hv++)
{
for (hv = hvertex; hv != hvert_p; hv++) {
if (hv->numedges < 0 || hv->numedges & 1)
cb++;
else if (!hv->numedges)
@ -443,7 +433,8 @@ CheckEdges
// debugging
=============
*/
void CheckEdges (void)
void
CheckEdges (void)
{
dedge_t *edge;
int i;
@ -456,17 +447,16 @@ void CheckEdges (void)
// CheckVertexes ();
for (i=1 ; i < bsp->numedges ; i++)
{
for (i = 1; i < bsp->numedges; i++) {
edge = &bsp->edges[i];
if (!edgefaces[i][1])
{
if (!edgefaces[i][1]) {
d1 = &bsp->vertexes[edge->v[0]];
d2 = &bsp->vertexes[edge->v[1]];
qprintf ("unshared edge at: (%8.2f, %8.2f, %8.2f) (%8.2f, %8.2f, %8.2f)\n",d1->point[0], d1->point[1], d1->point[2], d2->point[0], d2->point[1], d2->point[2]);
}
else
{
qprintf
("unshared edge at: (%8.2f, %8.2f, %8.2f) (%8.2f, %8.2f, %8.2f)\n",
d1->point[0], d1->point[1], d1->point[2], d2->point[0],
d2->point[1], d2->point[2]);
} else {
f1 = edgefaces[i][0];
f2 = edgefaces[i][1];
if (f1->planeside != f2->planeside)
@ -475,13 +465,11 @@ void CheckEdges (void)
continue;
// on the same plane, might be discardable
if (f1->texturenum == f2->texturenum)
{
hvertex[edge->v[0]].numedges-=2;
hvertex[edge->v[1]].numedges-=2;
if (f1->texturenum == f2->texturenum) {
hvertex[edge->v[0]].numedges -= 2;
hvertex[edge->v[1]].numedges -= 2;
c_nonconvex++;
}
else
} else
c_multitexture++;
}
}
@ -499,14 +487,15 @@ void CheckEdges (void)
MakeFaceEdges_r
================
*/
void MakeFaceEdges_r (node_t *node)
void
MakeFaceEdges_r (node_t * node)
{
face_t *f;
if (node->planenum == PLANENUM_LEAF)
return;
for (f=node->faces ; f ; f=f->next)
for (f = node->faces; f; f = f->next)
FindFaceEdges (f);
MakeFaceEdges_r (node->children[0]);
@ -518,7 +507,8 @@ void MakeFaceEdges_r (node_t *node)
MakeFaceEdges
================
*/
void MakeFaceEdges (node_t *headnode)
void
MakeFaceEdges (node_t * headnode)
{
qprintf ("----- MakeFaceEdges -----\n");
@ -535,4 +525,3 @@ void MakeFaceEdges (node_t *headnode)
firstmodeledge = bsp->numedges;
firstmodelface = bsp->numfaces;
}

188
tools/qfbsp/source/tjunc.c
View file

@ -28,14 +28,12 @@
#include "bsp5.h"
typedef struct wvert_s
{
typedef struct wvert_s {
vec_t t;
struct wvert_s *prev, *next;
} wvert_t;
typedef struct wedge_s
{
typedef struct wedge_s {
struct wedge_s *next;
vec3_t dir;
vec3_t origin;
@ -54,12 +52,14 @@ wvert_t wverts[MAXWVERTS];
wedge_t wedges[MAXWEDGES];
void PrintFace (face_t *f)
void
PrintFace (face_t * f)
{
int i;
for (i=0 ; i<f->numpoints ; i++)
printf ("(%5.2f, %5.2f, %5.2f)\n", f->pts[i][0], f->pts[i][1], f->pts[i][2]);
for (i = 0; i < f->numpoints; i++)
printf ("(%5.2f, %5.2f, %5.2f)\n", f->pts[i][0], f->pts[i][1],
f->pts[i][2]);
}
//============================================================================
@ -70,7 +70,8 @@ wedge_t *wedge_hash[NUM_HASH];
static vec3_t hash_min, hash_scale;
static void InitHash (vec3_t mins, vec3_t maxs)
static void
InitHash (vec3_t mins, vec3_t maxs)
{
vec3_t size;
vec_t volume;
@ -79,11 +80,11 @@ static void InitHash (vec3_t mins, vec3_t maxs)
VectorCopy (mins, hash_min);
VectorSubtract (maxs, mins, size);
memset (wedge_hash, 0, sizeof(wedge_hash));
memset (wedge_hash, 0, sizeof (wedge_hash));
volume = size[0]*size[1];
volume = size[0] * size[1];
scale = sqrt(volume / NUM_HASH);
scale = sqrt (volume / NUM_HASH);
newsize[0] = size[0] / scale;
newsize[1] = size[1] / scale;
@ -93,55 +94,52 @@ static void InitHash (vec3_t mins, vec3_t maxs)
hash_scale[2] = newsize[1];
}
static unsigned HashVec (vec3_t vec)
static unsigned
HashVec (vec3_t vec)
{
unsigned h;
h = hash_scale[0] * (vec[0] - hash_min[0]) * hash_scale[2]
+ hash_scale[1] * (vec[1] - hash_min[1]);
if ( h >= NUM_HASH)
if (h >= NUM_HASH)
return NUM_HASH - 1;
return h;
}
//============================================================================
void CanonicalVector (vec3_t vec)
void
CanonicalVector (vec3_t vec)
{
VectorNormalize (vec);
if (vec[0] > EQUAL_EPSILON)
return;
else if (vec[0] < -EQUAL_EPSILON)
{
else if (vec[0] < -EQUAL_EPSILON) {
VectorSubtract (vec3_origin, vec, vec);
return;
}
else
} else
vec[0] = 0;
if (vec[1] > EQUAL_EPSILON)
return;
else if (vec[1] < -EQUAL_EPSILON)
{
else if (vec[1] < -EQUAL_EPSILON) {
VectorSubtract (vec3_origin, vec, vec);
return;
}
else
} else
vec[1] = 0;
if (vec[2] > EQUAL_EPSILON)
return;
else if (vec[2] < -EQUAL_EPSILON)
{
else if (vec[2] < -EQUAL_EPSILON) {
VectorSubtract (vec3_origin, vec, vec);
return;
}
else
} else
vec[2] = 0;
Sys_Error ("CanonicalVector: degenerate");
}
wedge_t *FindEdge (vec3_t p1, vec3_t p2, vec_t *t1, vec_t *t2)
wedge_t *
FindEdge (vec3_t p1, vec3_t p2, vec_t *t1, vec_t *t2)
{
vec3_t origin;
vec3_t dir;
@ -157,8 +155,7 @@ wedge_t *FindEdge (vec3_t p1, vec3_t p2, vec_t *t1, vec_t *t2)
VectorMA (p1, -*t1, dir, origin);
if (*t1 > *t2)
{
if (*t1 > *t2) {
temp = *t1;
*t1 = *t2;
*t2 = temp;
@ -166,8 +163,7 @@ wedge_t *FindEdge (vec3_t p1, vec3_t p2, vec_t *t1, vec_t *t2)
h = HashVec (origin);
for (w = wedge_hash[h] ; w ; w=w->next)
{
for (w = wedge_hash[h]; w; w = w->next) {
temp = w->origin[0] - origin[0];
if (temp < -EQUAL_EPSILON || temp > EQUAL_EPSILON)
continue;
@ -215,14 +211,14 @@ AddVert
*/
#define T_EPSILON 0.01
void AddVert (wedge_t *w, vec_t t)
void
AddVert (wedge_t * w, vec_t t)
{
wvert_t *v, *newv;
v = w->head.next;
do
{
if (fabs(v->t - t) < T_EPSILON)
do {
if (fabs (v->t - t) < T_EPSILON)
return;
if (v->t > t)
break;
@ -250,12 +246,13 @@ AddEdge
===============
*/
void AddEdge (vec3_t p1, vec3_t p2)
void
AddEdge (vec3_t p1, vec3_t p2)
{
wedge_t *w;
vec_t t1, t2;
w = FindEdge(p1, p2, &t1, &t2);
w = FindEdge (p1, p2, &t1, &t2);
AddVert (w, t1);
AddVert (w, t2);
}
@ -266,13 +263,13 @@ AddFaceEdges
===============
*/
void AddFaceEdges (face_t *f)
void
AddFaceEdges (face_t * f)
{
int i, j;
for (i=0 ; i < f->numpoints ; i++)
{
j = (i+1)%f->numpoints;
for (i = 0; i < f->numpoints; i++) {
j = (i + 1) % f->numpoints;
AddEdge (f->pts[i], f->pts[j]);
}
}
@ -282,13 +279,14 @@ void AddFaceEdges (face_t *f)
// a specially allocated face that can hold hundreds of edges if needed
byte superfacebuf[8192];
face_t *superface = (face_t *)superfacebuf;
face_t *superface = (face_t *) superfacebuf;
void FixFaceEdges (face_t *f);
void FixFaceEdges (face_t * f);
face_t *newlist;
void SplitFaceForTjunc (face_t *f, face_t *original)
void
SplitFaceForTjunc (face_t * f, face_t * original)
{
int i;
face_t *new, *chain;
@ -297,10 +295,9 @@ void SplitFaceForTjunc (face_t *f, face_t *original)
int firstcorner, lastcorner;
chain = NULL;
do
{
if (f->numpoints <= MAXPOINTS)
{ // the face is now small enough without more cutting
do {
if (f->numpoints <= MAXPOINTS) { // the face is now small enough
// without more cutting
// so copy it back to the original
*original = *f;
original->original = chain;
@ -311,17 +308,15 @@ void SplitFaceForTjunc (face_t *f, face_t *original)
tjuncfaces++;
restart:
restart:
// find the last corner
VectorSubtract (f->pts[f->numpoints-1], f->pts[0], dir);
VectorSubtract (f->pts[f->numpoints - 1], f->pts[0], dir);
VectorNormalize (dir);
for (lastcorner=f->numpoints-1 ; lastcorner > 0 ; lastcorner--)
{
VectorSubtract (f->pts[lastcorner-1], f->pts[lastcorner], test);
for (lastcorner = f->numpoints - 1; lastcorner > 0; lastcorner--) {
VectorSubtract (f->pts[lastcorner - 1], f->pts[lastcorner], test);
VectorNormalize (test);
v = DotProduct (test, dir);
if (v < 0.9999 || v > 1.00001)
{
if (v < 0.9999 || v > 1.00001) {
break;
}
}
@ -329,30 +324,25 @@ restart:
// find the first corner
VectorSubtract (f->pts[1], f->pts[0], dir);
VectorNormalize (dir);
for (firstcorner=1 ; firstcorner < f->numpoints-1 ; firstcorner++)
{
VectorSubtract (f->pts[firstcorner+1], f->pts[firstcorner], test);
for (firstcorner = 1; firstcorner < f->numpoints - 1; firstcorner++) {
VectorSubtract (f->pts[firstcorner + 1], f->pts[firstcorner], test);
VectorNormalize (test);
v = DotProduct (test, dir);
if (v < 0.9999 || v > 1.00001)
{
if (v < 0.9999 || v > 1.00001) {
break;
}
}
if (firstcorner+2 >= MAXPOINTS)
{
if (firstcorner + 2 >= MAXPOINTS) {
// rotate the point winding
VectorCopy (f->pts[0], test);
for (i=1 ; i<f->numpoints ; i++)
{
VectorCopy (f->pts[i], f->pts[i-1]);
for (i = 1; i < f->numpoints; i++) {
VectorCopy (f->pts[i], f->pts[i - 1]);
}
VectorCopy (test, f->pts[f->numpoints-1]);
VectorCopy (test, f->pts[f->numpoints - 1]);
goto restart;
}
// cut off as big a piece as possible, less than MAXPOINTS, and not
// past lastcorner
@ -365,24 +355,22 @@ restart:
new->next = newlist;
newlist = new;
if (f->numpoints - firstcorner <= MAXPOINTS)
new->numpoints = firstcorner+2;
else if (lastcorner+2 < MAXPOINTS &&
new->numpoints = firstcorner + 2;
else if (lastcorner + 2 < MAXPOINTS &&
f->numpoints - lastcorner <= MAXPOINTS)
new->numpoints = lastcorner+2;
new->numpoints = lastcorner + 2;
else
new->numpoints = MAXPOINTS;
for (i=0 ; i<new->numpoints ; i++)
{
for (i = 0; i < new->numpoints; i++) {
VectorCopy (f->pts[i], new->pts[i]);
}
for (i=new->numpoints-1 ; i<f->numpoints ; i++)
{
VectorCopy (f->pts[i], f->pts[i-(new->numpoints-2)]);
for (i = new->numpoints - 1; i < f->numpoints; i++) {
VectorCopy (f->pts[i], f->pts[i - (new->numpoints - 2)]);
}
f->numpoints -= (new->numpoints-2);
f->numpoints -= (new->numpoints - 2);
} while (1);
}
@ -394,7 +382,8 @@ FixFaceEdges
===============
*/
void FixFaceEdges (face_t *f)
void
FixFaceEdges (face_t * f)
{
int i, j, k;
wedge_t *w;
@ -403,24 +392,20 @@ void FixFaceEdges (face_t *f)
*superface = *f;
restart:
for (i=0 ; i < superface->numpoints ; i++)
{
j = (i+1)%superface->numpoints;
restart:
for (i = 0; i < superface->numpoints; i++) {
j = (i + 1) % superface->numpoints;
w = FindEdge (superface->pts[i], superface->pts[j], &t1, &t2);
for (v=w->head.next ; v->t < t1 + T_EPSILON ; v = v->next)
{
for (v = w->head.next; v->t < t1 + T_EPSILON; v = v->next) {
}
if (v->t < t2-T_EPSILON)
{
if (v->t < t2 - T_EPSILON) {
tjuncs++;
// insert a new vertex here
for (k = superface->numpoints ; k> j ; k--)
{
VectorCopy (superface->pts[k-1], superface->pts[k]);
for (k = superface->numpoints; k > j; k--) {
VectorCopy (superface->pts[k - 1], superface->pts[k]);
}
VectorMA (w->origin, v->t, w->dir, superface->pts[j]);
superface->numpoints++;
@ -429,14 +414,12 @@ restart:
}
if (superface->numpoints <= MAXPOINTS)
{
if (superface->numpoints <= MAXPOINTS) {
*f = *superface;
f->next = newlist;
newlist = f;
return;
}
// the face needs to be split into multiple faces because of too many edges
SplitFaceForTjunc (superface, f);
@ -446,21 +429,23 @@ restart:
//============================================================================
void tjunc_find_r (node_t *node)
void
tjunc_find_r (node_t * node)
{
face_t *f;
if (node->planenum == PLANENUM_LEAF)
return;
for (f=node->faces ; f ; f=f->next)
for (f = node->faces; f; f = f->next)
AddFaceEdges (f);
tjunc_find_r (node->children[0]);
tjunc_find_r (node->children[1]);
}
void tjunc_fix_r (node_t *node)
void
tjunc_fix_r (node_t * node)
{
face_t *f, *next;
@ -469,8 +454,7 @@ void tjunc_fix_r (node_t *node)
newlist = NULL;
for (f=node->faces ; f ; f=next)
{
for (f = node->faces; f; f = next) {
next = f->next;
FixFaceEdges (f);
}
@ -487,7 +471,8 @@ tjunc
===========
*/
void tjunc (node_t *headnode)
void
tjunc (node_t * headnode)
{
vec3_t maxs, mins;
int i;
@ -502,12 +487,11 @@ void tjunc (node_t *headnode)
//
// origin points won't allways be inside the map, so extend the hash area
for (i=0 ; i<3 ; i++)
{
if ( fabs(brushset->maxs[i]) > fabs(brushset->mins[i]) )
maxs[i] = fabs(brushset->maxs[i]);
for (i = 0; i < 3; i++) {
if (fabs (brushset->maxs[i]) > fabs (brushset->mins[i]))
maxs[i] = fabs (brushset->maxs[i]);
else
maxs[i] = fabs(brushset->mins[i]);
maxs[i] = fabs (brushset->mins[i]);
}
VectorSubtract (vec3_origin, maxs, mins);

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

@ -47,13 +47,13 @@ FindFinalPlane
Used to find plane index numbers for clip nodes read from child processes
==================
*/
int FindFinalPlane (dplane_t *p)
int
FindFinalPlane (dplane_t *p)
{
int i;
dplane_t *dplane;
for (i=0, dplane = bsp->planes ; i<bsp->numplanes ; i++, dplane++)
{
for (i = 0, dplane = bsp->planes; i < bsp->numplanes; i++, dplane++) {
if (p->type != dplane->type)
continue;
if (p->dist != dplane->dist)
@ -83,15 +83,15 @@ int FindFinalPlane (dplane_t *p)
int planemapping[MAX_MAP_PLANES];
void WriteNodePlanes_r (node_t *node)
void
WriteNodePlanes_r (node_t * node)
{
plane_t *plane;
dplane_t *dplane;
if (node->planenum == -1)
return;
if (planemapping[node->planenum] == -1)
{ // a new plane
if (planemapping[node->planenum] == -1) { // a new plane
planemapping[node->planenum] = bsp->numplanes;
if (bsp->numplanes == MAX_MAP_PLANES)
@ -119,9 +119,10 @@ WriteNodePlanes
==================
*/
void WriteNodePlanes (node_t *nodes)
void
WriteNodePlanes (node_t * nodes)
{
memset (planemapping,-1, sizeof(planemapping));
memset (planemapping, -1, sizeof (planemapping));
WriteNodePlanes_r (nodes);
}
@ -133,27 +134,26 @@ WriteClipNodes_r
==================
*/
int WriteClipNodes_r (node_t *node)
int
WriteClipNodes_r (node_t * node)
{
int i, c;
dclipnode_t *cn;
int num;
// FIXME: free more stuff?
if (node->planenum == -1)
{
if (node->planenum == -1) {
num = node->contents;
free (node);
return num;
}
// emit a clipnode
c = bsp->numclipnodes;
cn = &bsp->clipnodes[bsp->numclipnodes];
bsp->numclipnodes++;
cn->planenum = node->outputplanenum;
for (i=0 ; i<2 ; i++)
cn->children[i] = WriteClipNodes_r(node->children[i]);
for (i = 0; i < 2; i++)
cn->children[i] = WriteClipNodes_r (node->children[i]);
free (node);
return c;
@ -167,7 +167,8 @@ Called after the clipping hull is completed. Generates a disk format
representation and frees the original memory.
==================
*/
void WriteClipNodes (node_t *nodes)
void
WriteClipNodes (node_t * nodes)
{
headclipnode = bsp->numclipnodes;
WriteClipNodes_r (nodes);
@ -180,7 +181,8 @@ void WriteClipNodes (node_t *nodes)
WriteLeaf
==================
*/
void WriteLeaf (node_t *node)
void
WriteLeaf (node_t * node)
{
face_t **fp, *f;
dleaf_t *leaf_p;
@ -204,17 +206,15 @@ void WriteLeaf (node_t *node)
//
leaf_p->firstmarksurface = bsp->nummarksurfaces;
for (fp=node->markfaces ; *fp ; fp++)
{
for (fp = node->markfaces; *fp; fp++) {
// emit a marksurface
if (bsp->nummarksurfaces == MAX_MAP_MARKSURFACES)
Sys_Error ("nummarksurfaces == MAX_MAP_MARKSURFACES");
f = *fp;
do
{
do {
bsp->marksurfaces[bsp->nummarksurfaces] = f->outputnumber;
bsp->nummarksurfaces++;
f=f->original; // grab tjunction split faces
f = f->original; // grab tjunction split faces
} while (f);
}
@ -227,7 +227,8 @@ void WriteLeaf (node_t *node)
WriteDrawNodes_r
==================
*/
void WriteDrawNodes_r (node_t *node)
void
WriteDrawNodes_r (node_t * node)
{
dnode_t *n;
int i;
@ -249,20 +250,15 @@ void WriteDrawNodes_r (node_t *node)
// recursively output the other nodes
//
for (i=0 ; i<2 ; i++)
{
if (node->children[i]->planenum == -1)
{
for (i = 0; i < 2; i++) {
if (node->children[i]->planenum == -1) {
if (node->children[i]->contents == CONTENTS_SOLID)
n->children[i] = -1;
else
{
else {
n->children[i] = -(bsp->numleafs + 1);
WriteLeaf (node->children[i]);
}
}
else
{
} else {
n->children[i] = bsp->numnodes;
WriteDrawNodes_r (node->children[i]);
}
@ -274,7 +270,8 @@ void WriteDrawNodes_r (node_t *node)
WriteDrawNodes
==================
*/
void WriteDrawNodes (node_t *headnode)
void
WriteDrawNodes (node_t * headnode)
{
int i;
int start;
@ -304,9 +301,9 @@ void WriteDrawNodes (node_t *headnode)
WriteDrawNodes_r (headnode);
bm->visleafs = bsp->numleafs - start;
for (i=0 ; i<3 ; i++)
{
bm->mins[i] = headnode->mins[i] + SIDESPACE + 1; // remove the padding
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;
}
// FIXME: are all the children decendant of padded nodes?
@ -320,7 +317,8 @@ BumpModel
Used by the clipping hull processes that only need to store headclipnode
==================
*/
void BumpModel (int hullnum)
void
BumpModel (int hullnum)
{
dmodel_t *bm;
@ -335,16 +333,14 @@ void BumpModel (int hullnum)
//=============================================================================
typedef struct
{
typedef struct {
char identification[4]; // should be WAD2
int numlumps;
int infotableofs;
} wadinfo_t;
typedef struct
{
typedef struct {
int filepos;
int disksize;
int size; // uncompressed
@ -358,19 +354,19 @@ QFile *texfile;
wadinfo_t wadinfo;
lumpinfo_t *lumpinfo;
void CleanupName (char *in, char *out)
void
CleanupName (char *in, char *out)
{
int i;
for (i=0 ; i< 16 ; i++ )
{
for (i = 0; i < 16; i++) {
if (!in[i])
break;
out[i] = toupper(in[i]);
out[i] = toupper (in[i]);
}
for ( ; i< 16 ; i++ )
for (; i < 16; i++)
out[i] = 0;
}
@ -380,25 +376,25 @@ void CleanupName (char *in, char *out)
TEX_InitFromWad
=================
*/
void TEX_InitFromWad (char *path)
void
TEX_InitFromWad (char *path)
{
int i;
texfile = Qopen (path, "rb");
Qread (texfile, &wadinfo, sizeof(wadinfo));
Qread (texfile, &wadinfo, sizeof (wadinfo));
if (strncmp (wadinfo.identification, "WAD2", 4))
Sys_Error ("TEX_InitFromWad: %s isn't a wadfile",path);
wadinfo.numlumps = LittleLong(wadinfo.numlumps);
wadinfo.infotableofs = LittleLong(wadinfo.infotableofs);
Sys_Error ("TEX_InitFromWad: %s isn't a wadfile", path);
wadinfo.numlumps = LittleLong (wadinfo.numlumps);
wadinfo.infotableofs = LittleLong (wadinfo.infotableofs);
Qseek (texfile, wadinfo.infotableofs, SEEK_SET);
lumpinfo = malloc(wadinfo.numlumps*sizeof(lumpinfo_t));
Qread (texfile, lumpinfo, wadinfo.numlumps*sizeof(lumpinfo_t));
lumpinfo = malloc (wadinfo.numlumps * sizeof (lumpinfo_t));
Qread (texfile, lumpinfo, wadinfo.numlumps * sizeof (lumpinfo_t));
for (i=0 ; i<wadinfo.numlumps ; i++)
{
for (i = 0; i < wadinfo.numlumps; i++) {
CleanupName (lumpinfo[i].name, lumpinfo[i].name);
lumpinfo[i].filepos = LittleLong(lumpinfo[i].filepos);
lumpinfo[i].disksize = LittleLong(lumpinfo[i].disksize);
lumpinfo[i].filepos = LittleLong (lumpinfo[i].filepos);
lumpinfo[i].disksize = LittleLong (lumpinfo[i].disksize);
}
}
@ -407,17 +403,16 @@ void TEX_InitFromWad (char *path)
LoadLump
==================
*/
int LoadLump (char *name, byte *dest)
int
LoadLump (char *name, byte * dest)
{
int i;
char cname[16];
CleanupName (name, cname);
for (i=0 ; i<wadinfo.numlumps ; i++)
{
if (!strcmp(cname, lumpinfo[i].name))
{
for (i = 0; i < wadinfo.numlumps; i++) {
if (!strcmp (cname, lumpinfo[i].name)) {
Qseek (texfile, lumpinfo[i].filepos, SEEK_SET);
Qread (texfile, dest, lumpinfo[i].disksize);
return lumpinfo[i].disksize;
@ -434,7 +429,8 @@ int LoadLump (char *name, byte *dest)
AddAnimatingTextures
==================
*/
void AddAnimatingTextures (void)
void
AddAnimatingTextures (void)
{
int base;
int i, j, k;
@ -442,24 +438,21 @@ void AddAnimatingTextures (void)
base = nummiptex;
for (i=0 ; i<base ; i++)
{
for (i = 0; i < base; i++) {
if (miptex[i][0] != '+')
continue;
strcpy (name, miptex[i]);
for (j=0 ; j<20 ; j++)
{
for (j = 0; j < 20; j++) {
if (j < 10)
name[1] = '0'+j;
name[1] = '0' + j;
else
name[1] = 'A'+j-10; // alternate animation
name[1] = 'A' + j - 10; // alternate animation
// see if this name exists in the wadfile
for (k=0 ; k<wadinfo.numlumps ; k++)
if (!strcmp(name, lumpinfo[k].name))
{
for (k = 0; k < wadinfo.numlumps; k++)
if (!strcmp (name, lumpinfo[k].name)) {
FindMiptex (name); // add to the miptex list
break;
}
@ -474,7 +467,8 @@ void AddAnimatingTextures (void)
WriteMiptex
==================
*/
void WriteMiptex (void)
void
WriteMiptex (void)
{
int i, len;
byte *data;
@ -483,29 +477,26 @@ void WriteMiptex (void)
char fullpath[1024];
path = ValueForKey (&entities[0], "_wad");
if (!path || !path[0])
{
if (!path || !path[0]) {
path = ValueForKey (&entities[0], "wad");
if (!path || !path[0])
{
if (!path || !path[0]) {
printf ("WARNING: no wadfile specified\n");
bsp->texdatasize = 0;
return;
}
}
sprintf (fullpath, "%s/%s", /*FIXME gamedir*/".", path);
sprintf (fullpath, "%s/%s", /* FIXME gamedir */ ".", path);
TEX_InitFromWad (fullpath);
AddAnimatingTextures ();
l = (dmiptexlump_t *)bsp->texdata;
data = (byte *)&l->dataofs[nummiptex];
l = (dmiptexlump_t *) bsp->texdata;
data = (byte *) & l->dataofs[nummiptex];
l->nummiptex = nummiptex;
for (i=0 ; i<nummiptex ; i++)
{
l->dataofs[i] = data - (byte *)l;
for (i = 0; i < nummiptex; i++) {
l->dataofs[i] = data - (byte *) l;
len = LoadLump (miptex[i], data);
if (data + len - bsp->texdata >= MAX_MAP_MIPTEX)
Sys_Error ("Textures exceeded MAX_MAP_MIPTEX");
@ -525,7 +516,8 @@ void WriteMiptex (void)
BeginBSPFile
==================
*/
void BeginBSPFile (void)
void
BeginBSPFile (void)
{
// edge 0 is not used, because 0 can't be negated
bsp->numedges = 1;
@ -543,17 +535,18 @@ void BeginBSPFile (void)
FinishBSPFile
==================
*/
void FinishBSPFile (void)
void
FinishBSPFile (void)
{
QFile *f;
printf ("--- FinishBSPFile ---\n");
printf ("WriteBSPFile: %s\n", bspfilename);
WriteMiptex ();
//XXX PrintBSPFileSizes ();
// XXX PrintBSPFileSizes ();
f = Qopen (bspfilename, "wb");
WriteBSPFile (bsp, f);
Qclose (f);
}