From 4d520d588dbb74c2cdfb22b02912a60aebde9c3f Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 19 Sep 2002 17:14:23 +0000 Subject: [PATCH] enough whitespace to crush a shambler --- tools/qfbsp/source/brush.c | 627 ++++++++++++++-------------- tools/qfbsp/source/csg4.c | 337 ++++++++------- tools/qfbsp/source/map.c | 468 +++++++++++---------- tools/qfbsp/source/merge.c | 194 +++++---- tools/qfbsp/source/nodraw.c | 39 +- tools/qfbsp/source/outside.c | 165 ++++---- tools/qfbsp/source/portals.c | 388 +++++++++--------- tools/qfbsp/source/qfbsp.c | 743 +++++++++++++++++----------------- tools/qfbsp/source/region.c | 383 ++++++++---------- tools/qfbsp/source/solidbsp.c | 511 +++++++++++------------ tools/qfbsp/source/surfaces.c | 339 ++++++++-------- tools/qfbsp/source/tjunc.c | 372 ++++++++--------- tools/qfbsp/source/writebsp.c | 337 ++++++++------- 13 files changed, 2351 insertions(+), 2552 deletions(-) diff --git a/tools/qfbsp/source/brush.c b/tools/qfbsp/source/brush.c index 74719391a..da7347e6b 100644 --- a/tools/qfbsp/source/brush.c +++ b/tools/qfbsp/source/brush.c @@ -35,11 +35,13 @@ #include "bsp5.h" -int numbrushplanes; -plane_t planes[MAX_MAP_PLANES]; +int numbrushplanes; +plane_t planes[MAX_MAP_PLANES]; -int numbrushfaces; -mface_t faces[128]; // beveled clipping hull can generate many extra +int numbrushfaces; +mface_t faces[128]; // beveled clipping hull can generate + + // many extra /* @@ -49,52 +51,52 @@ 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; - vec_t d, edgedist; - vec3_t dir, edgenormal, facenormal; - + int i, j; + vec_t *p1, *p2; + vec_t d, edgedist; + 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 ; inumpoints ; 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; - - // check the point is on the face plane - d = DotProduct (p1, planes[f->planenum].normal) - planes[f->planenum].dist; + 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; if (d < -ON_EPSILON || d > ON_EPSILON) Sys_Error ("CheckFace: point off plane"); - - // check the edge isn't degenerate + + // check the edge isn't degenerate p2 = f->pts[j]; VectorSubtract (p2, p1, dir); - + if (VectorLength (dir) < ON_EPSILON) Sys_Error ("CheckFace: degenerate edge"); - + CrossProduct (facenormal, dir, edgenormal); VectorNormalize (edgenormal); edgedist = DotProduct (p1, edgenormal); edgedist += ON_EPSILON; - - // all other points must be on front side - for (j=0 ; jnumpoints ; j++) - { + + // all other points must be on front side + 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 ; jmins[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++) - { + int 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,26 +146,25 @@ void AddToBounds (brushset_t *bs, vec3_t v) //=========================================================================== -int PlaneTypeForNormal (vec3_t normal) +int +PlaneTypeForNormal (vec3_t normal) { - float ax, ay, az; - -// NOTE: should these have an epsilon around 1.0? + float ax, ay, az; + +// NOTE: should these have an epsilon around 1.0? if (normal[0] == 1.0) return PLANE_X; if (normal[1] == 1.0) 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; if (ay >= ax && ay >= az) @@ -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) - { + vec_t ax, ay, az; + + 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,31 +230,30 @@ 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); + int i; + plane_t *dp, pl; + vec_t dot; + + 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 ; inormal, pl.normal); - if (dot > 1.0 - ANGLEEPSILON - && fabs(dp->dist - pl.dist) < DISTEPSILON ) - { // regular match - return i; + 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,93 +275,84 @@ 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); + int i; + plane_t *dp; + vec_t dot, ax, ay, az; + + dot = VectorLength (dplane->normal); if (dot < 1.0 - ANGLEEPSILON || dot > 1.0 + ANGLEEPSILON) Sys_Error ("FindPlane: normalization error"); - + dp = planes; - - for (i=0 ; inormal, 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; + 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; } } - + // allocate a new plane, flipping normal to a consistant direction // if needed *dp = *dplane; - + if (numbrushplanes == MAX_MAP_PLANES) Sys_Error ("numbrushplanes == MAX_MAP_PLANES"); numbrushplanes++; - + *side = 0; -// NOTE: should these have an epsilon around 1.0? +// NOTE: should these have an epsilon around 1.0? if (dplane->normal[0] == 1.0) dp->type = PLANE_X; else if (dplane->normal[1] == 1.0) 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; else if (ay >= ax && ay >= az) 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; } } - + return i; } @@ -381,8 +366,8 @@ int FindPlane_old (plane_t *dplane, int *side) ============================================================================= */ -vec3_t brush_mins, brush_maxs; -face_t *brush_faces; +vec3_t brush_mins, brush_maxs; +face_t *brush_faces; /* ================= @@ -390,62 +375,59 @@ CreateBrushFaces ================= */ #define ZERO_EPSILON 0.001 -void CreateBrushFaces (void) +void +CreateBrushFaces (void) { - int i,j, k; - vec_t r; - face_t *f; - winding_t *w; - plane_t plane; - mface_t *mf; - + int i, j, k; + vec_t r; + face_t *f; + winding_t *w; + plane_t plane; + mface_t *mf; + brush_mins[0] = brush_mins[1] = brush_mins[2] = 99999; brush_maxs[0] = brush_maxs[1] = brush_maxs[2] = -99999; brush_faces = NULL; - - for (i=0 ; iplane); - for (j=0 ; jnumpoints = w->numpoints; if (f->numpoints > MAXEDGES) Sys_Error ("f->numpoints > MAXEDGES"); - - for (j=0 ; jnumpoints ; 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]; - + if (f->pts[j][k] < brush_mins[k]) brush_mins[k] = f->pts[j][k]; if (f->pts[j][k] > brush_maxs[k]) - brush_maxs[k] = f->pts[j][k]; + brush_maxs[k] = f->pts[j][k]; } - + } FreeWinding (w); f->texturenum = mf->texinfo; @@ -453,7 +435,7 @@ void CreateBrushFaces (void) f->next = brush_faces; brush_faces = f; CheckFace (f); - } + } } @@ -467,44 +449,44 @@ 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} } +vec3_t hull_size[3][2] = { + {{0, 0, 0}, {0, 0, 0}}, + {{-16, -16, -32}, {16, 16, 24}}, + {{-32, -32, -64}, {32, 32, 24}} }; #define MAX_HULL_POINTS 32 #define MAX_HULL_EDGES 64 -int num_hull_points; -vec3_t hull_points[MAX_HULL_POINTS]; -vec3_t hull_corners[MAX_HULL_POINTS*8]; -int num_hull_edges; -int hull_edges[MAX_HULL_EDGES][2]; +int num_hull_points; +vec3_t hull_points[MAX_HULL_POINTS]; +vec3_t hull_corners[MAX_HULL_POINTS * 8]; +int num_hull_edges; +int hull_edges[MAX_HULL_EDGES][2]; /* ============ AddBrushPlane ============= */ -void AddBrushPlane (plane_t *plane) +void +AddBrushPlane (plane_t *plane) { - int i; - plane_t *pl; - float l; - + int i; + plane_t *pl; + float l; + if (numbrushfaces == MAX_FACES) Sys_Error ("AddBrushPlane: numbrushfaces == MAX_FACES"); l = VectorLength (plane->normal); if (l < 0.999 || l > 1.001) Sys_Error ("AddBrushPlane: bad normal"); - - for (i=0 ; inormal, plane->normal) - && fabs(pl->dist - plane->dist) < ON_EPSILON ) + && fabs (pl->dist - plane->dist) < ON_EPSILON) return; } faces[i].plane = *plane; @@ -521,60 +503,55 @@ 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; - vec_t *corner; - plane_t flip; - vec3_t inv; - int counts[3]; - plane_t *pl; - + int i, c; + vec_t d; + vec_t *corner; + plane_t flip; + vec3_t inv; + int counts[3]; + plane_t *pl; + // see if the plane has allready been added - for (i=0 ; inormal, 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 counts[0] = counts[1] = counts[2] = 0; c = num_hull_points * 8; - + corner = hull_corners[0]; - for (i=0 ; inormal) - 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; } - + AddBrushPlane (plane); } @@ -585,35 +562,35 @@ 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; - - for (i=0 ; i 1+ANGLEEPSILON) + if (l < 1 - ANGLEEPSILON || l > 1 + ANGLEEPSILON) continue; - plane.dist = DotProduct (planeorg, plane.normal); + plane.dist = DotProduct (planeorg, plane.normal); TestAddPlane (&plane); } } - -} + +} /* ============ ExpandBrush ============= */ -void ExpandBrush (int hullnum) +void +ExpandBrush (int hullnum) { - int i, x, s; - vec3_t corner; - face_t *f; - plane_t plane, *p; + int i, x, s; + vec3_t corner; + face_t *f; + plane_t plane, *p; num_hull_points = 0; num_hull_edges = 0; // create all the hull points - for (f=brush_faces ; f ; f=f->next) - for (i=0 ; inumpoints ; 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 ; inormal[x] > 0) corner[x] = hull_size[hullnum][1][x]; else if (p->normal[x] < 0) corner[x] = hull_size[hullnum][0][x]; } - p->dist += DotProduct (corner, p->normal); + p->dist += DotProduct (corner, p->normal); } // 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) - { - // add the plane + 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; if (s == -1) @@ -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 ; inumpoints ; 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,37 +717,39 @@ 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; - char *name; - mface_t *f; + brush_t *b; + int contents; + char *name; + mface_t *f; // // check texture name for attributes -// +// 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 (name[0] == '*' && worldmodel) // entities never use water merging + 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 + 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 @@ -781,35 +757,31 @@ brush_t *LoadBrush (mbrush_t *mb, int hullnum) // create the faces // 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; numbrushfaces++; } - + 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 // b = AllocBrush (); - + b->contents = contents; b->faces = brush_faces; VectorCopy (brush_mins, b->mins); @@ -827,14 +799,15 @@ Brush_DrawAll ============ */ -void Brush_DrawAll (brushset_t *bs) +void +Brush_DrawAll (brushset_t * bs) { - brush_t *b; - face_t *f; + brush_t *b; + face_t *f; - for (b=bs->brushes ; b ; b=b->next) - for (f=b->faces ; f ; f=f->next) - Draw_DrawFace (f); + 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)); + 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)); ClearBounds (bset); numbrushes = 0; @@ -859,32 +833,27 @@ 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; } - + AddToBounds (bset, b->mins); AddToBounds (bset, b->maxs); } // 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; @@ -894,10 +863,8 @@ 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; } - - diff --git a/tools/qfbsp/source/csg4.c b/tools/qfbsp/source/csg4.c index 51362bf65..285839cfc 100644 --- a/tools/qfbsp/source/csg4.c +++ b/tools/qfbsp/source/csg4.c @@ -35,17 +35,18 @@ Brushes that touch still need to be split at the cut point to make a tjunction */ -face_t *validfaces[MAX_MAP_PLANES]; +face_t *validfaces[MAX_MAP_PLANES]; -face_t *inside, *outside; -int brushfaces; -int csgfaces; -int csgmergefaces; +face_t *inside, *outside; +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,19 +59,20 @@ 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; - + face_t *newf; + newf = AllocFace (); newf->planenum = in->planenum; - newf->texturenum = in->texturenum; + newf->texturenum = in->texturenum; newf->planeside = in->planeside; newf->original = in->original; newf->contents[0] = in->contents[0]; newf->contents[1] = in->contents[1]; - + return newf; } @@ -81,24 +83,24 @@ 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]; - int counts[3]; - vec_t dot; - int i, j; - face_t *newf, *new2; - vec_t *p1, *p2; - vec3_t mid; - + vec_t dists[MAXEDGES + 1]; + int sides[MAXEDGES + 1]; + int counts[3]; + vec_t dot; + int i, j; + face_t *newf, *new2; + vec_t *p1, *p2; + vec3_t mid; + if (in->numpoints < 0) Sys_Error ("SplitFace: freed face"); counts[0] = counts[1] = counts[2] = 0; // determine sides for each point - for (i=0 ; inumpoints ; i++) - { + for (i = 0; i < in->numpoints; i++) { dot = DotProduct (in->pts[i], split->normal); dot -= split->dist; dists[i] = dot; @@ -112,69 +114,62 @@ 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; } - + *back = newf = NewFaceFromFace (in); *front = new2 = NewFaceFromFace (in); - + // distribute the points and generate splits - for (i=0 ; inumpoints ; 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]); new2->numpoints++; 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]; - - dot = dists[i] / (dists[i]-dists[i+1]); - for (j=0 ; j<3 ; j++) - { // avoid round off error when possible + + // generate a split point + 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 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]); newf->numpoints++; VectorCopy (mid, new2->pts[new2->numpoints]); @@ -184,9 +179,9 @@ void SplitFace (face_t *in, plane_t *split, face_t **front, face_t **back) if (newf->numpoints > MAXEDGES || new2->numpoints > MAXEDGES) Sys_Error ("SplitFace: numpoints > MAXEDGES"); -#if 0 -CheckFace (newf); -CheckFace (new2); +#if 0 + CheckFace (newf); + CheckFace (new2); #endif // free the original face now that is is represented by the fragments @@ -205,50 +200,44 @@ 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]; - face_t *insidelist; - plane_t *split; - + face_t *f, *next; + face_t *frags[2]; + face_t *insidelist; + plane_t *split; + 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]; } } - + inside = insidelist; } @@ -260,39 +249,37 @@ 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; - int i; - int planenum; - - for (f=outside ; f ; f=next) - { + face_t *f, *next, *newf; + int i; + int planenum; + + 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; newf->planeside = f->planeside ^ 1; // reverse side newf->contents[0] = f->contents[1]; newf->contents[1] = f->contents[0]; - - for (i=0 ; inumpoints ; 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) - { + face_t *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,21 +320,21 @@ 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; - int i; - surface_t *s; - surface_t *surfhead; - + face_t **f; + face_t *count; + int i; + surface_t *s; + surface_t *surfhead; + surfhead = NULL; - + f = validfaces; - for (i=0 ; inext = 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 - } - + CalcSurfaceInfo (s); // bounding box and flags + } + return surfhead; } @@ -372,23 +357,24 @@ surface_t *BuildSurfaces (void) CopyFacesToOutside ================== */ -void CopyFacesToOutside (brush_t *b) +void +CopyFacesToOutside (brush_t * b) { - face_t *f, *newf; - + 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 ; inumpoints ; i++) - printf ("(%f,%f,%f) ",f->pts[i][0], f->pts[i][1], f->pts[i][2]); - printf ("\n"); -} + { + 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]); + printf ("\n"); + } #endif newf = AllocFace (); *newf = *f; @@ -407,67 +393,64 @@ 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; - qboolean overwrite; - face_t *f; - surface_t *surfhead; + brush_t *b1, *b2; + int i; + qboolean overwrite; + face_t *f; + surface_t *surfhead; qprintf ("---- CSGFaces ----\n"); - memset (validfaces, 0, sizeof(validfaces)); - + memset (validfaces, 0, sizeof (validfaces)); + csgfaces = brushfaces = csgmergefaces = 0; - + Draw_ClearWindow (); - + // // do the solid faces // - for (b1=bs->brushes ; b1 ; b1 = b1->next) - { - // set outside to a copy of the brush's faces + 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) - { - // see if b2 needs to clip a chunk out of b1 - - if (b1==b2) - { - overwrite = true; // later brushes now overwrite + + for (b2 = bs->brushes; b2; b2 = b2->next) { + // see if b2 needs to clip a chunk out of b1 + + if (b1 == b2) { + overwrite = true; // later brushes now overwrite continue; } - - // check bounding box first - for (i=0 ; i<3 ; i++) + // check bounding box first + 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 - + // divide faces by the planes of the new brush + 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); + // these faces are continued in another brush, so get rid of them + if (b1->contents == CONTENTS_SOLID + && b2->contents <= CONTENTS_WATER) FreeInside (b2->contents); else FreeInside (CONTENTS_SOLID); } - - // all of the faces left in outside are real surface faces + + // all of the faces left in outside are real surface faces if (b1->contents != CONTENTS_SOLID) - SaveOutside (true); // mirror faces for inside view + SaveOutside (true); // mirror faces for inside view else SaveOutside (false); } @@ -478,12 +461,10 @@ surface_t *CSGFaces (brushset_t *bs) #endif surfhead = BuildSurfaces (); - + qprintf ("%5i brushfaces\n", brushfaces); qprintf ("%5i csgfaces\n", csgfaces); qprintf ("%5i mergedfaces\n", csgmergefaces); - + return surfhead; } - - diff --git a/tools/qfbsp/source/map.c b/tools/qfbsp/source/map.c index b8fe40250..74af95f71 100644 --- a/tools/qfbsp/source/map.c +++ b/tools/qfbsp/source/map.c @@ -35,14 +35,14 @@ #include "bsp5.h" -int nummapbrushes; -mbrush_t mapbrushes[MAX_MAP_BRUSHES]; +int nummapbrushes; +mbrush_t mapbrushes[MAX_MAP_BRUSHES]; -int num_entities; -entity_t entities[MAX_MAP_ENTITIES]; +int num_entities; +entity_t entities[MAX_MAP_ENTITIES]; -int nummiptex; -char miptex[MAX_MAP_TEXINFO][16]; +int nummiptex; +char miptex[MAX_MAP_TEXINFO][16]; //============================================================================ @@ -52,12 +52,12 @@ FindMiptex =============== */ -int FindMiptex (char *name) +int +FindMiptex (char *name) { - int i; - - for (i=0 ; imiptex][0] == '*' - || !strncasecmp (miptex[t->miptex], "sky",3) ) - t->flags |= TEX_SPECIAL; + if (miptex[t->miptex][0] == '*' + || !strncasecmp (miptex[t->miptex], "sky", 3)) t->flags |= TEX_SPECIAL; - tex = bsp->texinfo; - for (i=0 ; inumtexinfo;i++, tex++) - { + tex = bsp->texinfo; + 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) continue; - + return i; } - + // allocate a new texture if (bsp->numtexinfo == MAX_MAP_TEXINFO) Sys_Error ("numtexinfo == MAX_MAP_TEXINFO"); @@ -117,41 +116,40 @@ int FindTexinfo (texinfo_t *t) #define MAXTOKEN 128 -char token[MAXTOKEN]; -qboolean unget; -char *script_p; -int scriptline; +char token[MAXTOKEN]; +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; + char *token_p; - if (unget) // is a token allready waiting? + if (unget) // is a token allready waiting? return true; // // 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,48 +157,44 @@ 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 ) - { - *token_p++ = *script_p++; - if (token_p > &token[MAXTOKEN-1]) - Sys_Error ("Token too large on line %i",scriptline); - } + } else + while (*script_p > 32) { + *token_p++ = *script_p++; + if (token_p > &token[MAXTOKEN - 1]) + Sys_Error ("Token too large on line %i", scriptline); + } *token_p = 0; - + return true; } -void UngetToken () +void +UngetToken () { unget = true; } @@ -208,27 +202,28 @@ void UngetToken () //============================================================================ -entity_t *mapent; +entity_t *mapent; /* ================= ParseEpair ================= */ -void ParseEpair (void) +void +ParseEpair (void) { - epair_t *e; - - e = malloc (sizeof(epair_t)); - memset (e, 0, sizeof(epair_t)); + epair_t *e; + + 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; - int i; - + int bestaxis; + 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,98 +276,91 @@ 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; - texinfo_t tx; - vec_t d; - float shift[2], rotate, scale[2]; + mbrush_t *b; + mface_t *f, *f2; + vec3_t planepts[3]; + vec3_t t1, t2, t3; + int i, j; + texinfo_t tx; + vec_t d; + float shift[2], rotate, scale[2]; b = &mapbrushes[nummapbrushes]; nummapbrushes++; 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++) - { + + // read the three point plane definition + 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)); + // read the texturedef + 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++) - { + + // convert to a vector / dist plane + 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); @@ -383,71 +369,73 @@ void ParseBrush (void) VectorNormalize (f->plane.normal); f->plane.dist = DotProduct (t3, f->plane.normal); - // - // fake proper texture vectors from QuakeEd style - // + // + // fake proper texture vectors from QuakeEd style + // { - vec3_t vecs[2]; - int sv, tv; - float ang, sinv, cosv; - float ns, nt; - - TextureAxisFromPlane(&f->plane, vecs[0], vecs[1]); - + vec3_t vecs[2]; + int sv, tv; + float ang, sinv, cosv; + float ns, nt; + + TextureAxisFromPlane (&f->plane, vecs[0], vecs[1]); + if (!scale[0]) scale[0] = 1; if (!scale[1]) scale[1] = 1; - - - // 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 - { + + + // 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 { ang = rotate / 180 * M_PI; - sinv = sin(ang); - cosv = cos(ang); + sinv = sin (ang); + cosv = cos (ang); } - + if (vecs[0][0]) sv = 0; else if (vecs[0][1]) sv = 1; else sv = 2; - + if (vecs[1][0]) tv = 0; else if (vecs[1][1]) tv = 1; 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]; + 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]; tx.vecs[1][3] = shift[1]; } - - // unique the texinfo - f->texinfo = FindTexinfo (&tx); + + // unique the texinfo + f->texinfo = FindTexinfo (&tx); } while (1); } @@ -456,32 +444,32 @@ 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) Sys_Error ("num_entities == MAX_MAP_ENTITIES"); 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 (); } while (1); - + GetVectorForKey (mapent, "origin", mapent->origin); return true; } @@ -491,22 +479,22 @@ qboolean ParseEntity (void) LoadMapFile ================ */ -void LoadMapFile (char *filename) +void +LoadMapFile (char *filename) { - char *buf; - + char *buf; + buf = COM_LoadFile (filename, 0); StartTokenParsing (buf); - + num_entities = 0; - - while (ParseEntity ()) - { + + while (ParseEntity ()) { } - + free (buf); - + qprintf ("--- LoadMapFile ---\n"); qprintf ("%s\n", filename); qprintf ("%5i brushes\n", nummapbrushes); @@ -515,55 +503,59 @@ 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) + epair_t *ep; + + 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) ) + epair_t *ep; + + 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) ) - { + epair_t *ep; + + 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; - + 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; + char *k; + double v1, v2, v3; k = ValueForKey (ent, key); v1 = v2 = v3 = 0; @@ -575,33 +567,32 @@ void GetVectorForKey (entity_t *ent, char *key, vec3_t vec) } -void WriteEntitiesToString (void) +void +WriteEntitiesToString (void) { - char *buf, *end; - epair_t *ep; - char line[128]; - int i; - + char *buf, *end; + epair_t *ep; + char line[128]; + int i; + buf = bsp->entdata; end = buf; *end = 0; - - for (i=0 ; inext) - { + + 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; } - diff --git a/tools/qfbsp/source/merge.c b/tools/qfbsp/source/merge.c index dd88f6da0..912600f3d 100644 --- a/tools/qfbsp/source/merge.c +++ b/tools/qfbsp/source/merge.c @@ -36,27 +36,27 @@ CheckColinear ================ */ -void CheckColinear (face_t *f) +void +CheckColinear (face_t * f) { - int i, j; - vec3_t v1, v2; - - for (i=0 ; inumpoints ;i++) - { + int i, j; + vec3_t v1, v2; + + 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; VectorSubtract (f->pts[i], f->pts[j], v1); VectorNormalize (v1); - + j = (i + 1 == f->numpoints) ? 0 : i + 1; VectorSubtract (f->pts[j], f->pts[i], v2); VectorNormalize (v2); - + if (VectorCompare (v1, v2)) - Sys_Error ("Colinear edge"); + Sys_Error ("Colinear edge"); } - + } @@ -71,16 +71,17 @@ 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; - int i, j, k, l; - vec3_t normal, delta, planenormal; - vec_t dot; - plane_t *plane; - qboolean keep1, keep2; - + vec_t *p1, *p2, *p3, *p4, *back; + face_t *newf; + int i, j, k, l; + vec3_t normal, delta, planenormal; + vec_t dot; + plane_t *plane; + qboolean keep1, keep2; + if (f1->numpoints == -1 || f2->numpoints == -1) return NULL; if (f1->planeside != f2->planeside) @@ -91,37 +92,34 @@ face_t *TryMerge (face_t *f1, face_t *f2) return NULL; if (f1->contents[1] != f2->contents[1]) return NULL; - + // // find a common edge -// - p1 = p2 = NULL; // stop compiler warning - j = 0; // - - for (i=0 ; inumpoints ; i++) - { +// + p1 = p2 = NULL; // stop compiler warning + j = 0; // + + for (i = 0; i < f1->numpoints; i++) { p1 = f1->pts[i]; - p2 = f1->pts[(i+1)%f1->numpoints]; - for (j=0 ; jnumpoints ; 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) break; } - + if (i == f1->numpoints) - return NULL; // no matching edges + return NULL; // no matching edges // // check slope of connected lines @@ -131,56 +129,53 @@ face_t *TryMerge (face_t *f1, face_t *f2) VectorCopy (plane->normal, planenormal); 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 + 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) - return NULL; // not a convex polygon + return NULL; // not a convex polygon keep2 = dot < -CONTINUOUS_EPSILON; // // build the new polygon // - if (f1->numpoints + f2->numpoints > MAXEDGES) - { -// Sys_Error ("TryMerge: too many edges!"); + if (f1->numpoints + f2->numpoints > MAXEDGES) { +// Sys_Error ("TryMerge: too many edges!"); return NULL; } 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]); newf->numpoints++; } - + // 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++; @@ -195,29 +190,28 @@ face_t *TryMerge (face_t *f1, face_t *f2) MergeFaceToList =============== */ -qboolean mergedebug; -face_t *MergeFaceToList (face_t *face, face_t *list) -{ - face_t *newf, *f; - - for (f=list ; f ; f=f->next) - { -//CheckColinear (f); -if (mergedebug) +qboolean mergedebug; +face_t * +MergeFaceToList (face_t * face, face_t * list) { -Draw_ClearWindow (); -Draw_DrawFace (face); -Draw_DrawFace (f); -Draw_SetBlack (); -} + face_t *newf, *f; + + for (f = list; f; f = f->next) { +//CheckColinear (f); + if (mergedebug) { + Draw_ClearWindow (); + Draw_DrawFace (face); + Draw_DrawFace (f); + Draw_SetBlack (); + } newf = TryMerge (face, f); if (!newf) continue; FreeFace (face); - f->numpoints = -1; // merged out + f->numpoints = -1; // merged out return MergeFaceToList (newf, list); } - + // didn't merge, so add at start face->next = list; return face; @@ -229,18 +223,17 @@ Draw_SetBlack (); FreeMergeListScraps =============== */ -face_t *FreeMergeListScraps (face_t *merged) +face_t * +FreeMergeListScraps (face_t * merged) { - face_t *head, *next; - + 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; - + 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,25 +271,24 @@ void MergePlaneFaces (surface_t *plane) MergeAll ============ */ -void MergeAll (surface_t *surfhead) +void +MergeAll (surface_t * surfhead) { - surface_t *surf; - int mergefaces; - face_t *f; - + surface_t *surf; + int mergefaces; + face_t *f; + printf ("---- MergeAll ----\n"); - mergefaces = 0; - for (surf = surfhead ; surf ; surf=surf->next) - { + mergefaces = 0; + 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++; } } - + printf ("%i mergefaces\n", mergefaces); } diff --git a/tools/qfbsp/source/nodraw.c b/tools/qfbsp/source/nodraw.c index e3f2f8c1d..2da14f27a 100644 --- a/tools/qfbsp/source/nodraw.c +++ b/tools/qfbsp/source/nodraw.c @@ -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) { } diff --git a/tools/qfbsp/source/outside.c b/tools/qfbsp/source/outside.c index d256ab8a6..1b47de8fe 100644 --- a/tools/qfbsp/source/outside.c +++ b/tools/qfbsp/source/outside.c @@ -25,25 +25,28 @@ #include "bsp5.h" -int outleafs; +int outleafs; /* =========== PointInLeaf =========== */ -node_t *PointInLeaf (node_t *node, vec3_t point) +node_t * +PointInLeaf (node_t * node, vec3_t point) { - vec_t d; - + 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); - + return PointInLeaf (node->children[1], point); } @@ -52,10 +55,11 @@ 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; - + node_t *n; + n = PointInLeaf (headnode, point); if (n->contents == CONTENTS_SOLID) return false; @@ -69,47 +73,45 @@ qboolean PlaceOccupant (int num, vec3_t point, node_t *headnode) MarkLeakTrail ============== */ -portal_t *prevleaknode; -FILE *leakfile; -void MarkLeakTrail (portal_t *n2) +portal_t *prevleaknode; +FILE *leakfile; +void +MarkLeakTrail (portal_t * n2) { - int i, j; - vec3_t p1, p2, dir; - float len; - portal_t *n1; + int i, j; + vec3_t p1, p2, dir; + float len; + portal_t *n1; if (hullnum) return; n1 = prevleaknode; prevleaknode = n2; - + if (!n1) 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; } - + VectorSubtract (p2, p1, dir); 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; } } @@ -122,22 +124,23 @@ If fill is false, just check, don't fill Returns true if an occupied leaf is reached ================== */ -int hit_occupied; -int backdraw; -qboolean RecursiveFillOutside (node_t *l, qboolean fill) +int hit_occupied; +int backdraw; +qboolean +RecursiveFillOutside (node_t * l, qboolean fill) { - portal_t *p; - int s; + portal_t *p; + int s; if (l->contents == CONTENTS_SOLID || l->contents == CONTENTS_SKY) return false; - + if (l->valid == valid) return false; - + if (l->occupied) return true; - + l->valid = valid; // fill it and it's neighbors @@ -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); } @@ -160,7 +161,7 @@ qboolean RecursiveFillOutside (node_t *l, qboolean fill) } p = p->next[!s]; } - + return false; } @@ -170,12 +171,12 @@ ClearOutFaces ================== */ -void ClearOutFaces (node_t *node) +void +ClearOutFaces (node_t * node) { - face_t **fp; - - if (node->planenum != -1) - { + face_t **fp; + + if (node->planenum != -1) { ClearOutFaces (node->children[0]); ClearOutFaces (node->children[1]); return; @@ -183,9 +184,8 @@ void ClearOutFaces (node_t *node) if (node->contents != CONTENTS_SOLID) return; - for (fp=node->markfaces ; *fp ; fp++) - { - // mark all the original faces that are removed + for (fp = node->markfaces; *fp; fp++) { + // mark all the original faces that are removed (*fp)->numpoints = 0; } node->faces = NULL; @@ -200,34 +200,33 @@ FillOutside =========== */ -qboolean FillOutside (node_t *node) +qboolean +FillOutside (node_t * node) { - int s; - vec_t *v; - int i; - qboolean inside; - + int s; + vec_t *v; + int i; + qboolean inside; + qprintf ("----- FillOutside ----\n"); - if (nofill) - { + if (nofill) { printf ("skipped\n"); return false; } - + inside = false; - for (i=1 ; inodes[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); - qprintf ("leak file written to %s\n", pointfilename); + qprintf ("leak file written to %s\n", pointfilename); qprintf ("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"); return false; } @@ -266,11 +263,9 @@ qboolean FillOutside (node_t *node) valid++; RecursiveFillOutside (outside_node.portals->nodes[s], true); -// remove faces from filled in leafs +// remove faces from filled in leafs ClearOutFaces (node); - + qprintf ("%4i outleafs\n", outleafs); return true; } - - diff --git a/tools/qfbsp/source/portals.c b/tools/qfbsp/source/portals.c index 97f51967e..f72b24055 100644 --- a/tools/qfbsp/source/portals.c +++ b/tools/qfbsp/source/portals.c @@ -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"); @@ -43,7 +46,7 @@ void AddPortalToNodes (portal_t *p, node_t *front, node_t *back) p->nodes[0] = front; p->next[0] = front->portals; front->portals = p; - + p->nodes[1] = back; p->next[1] = back->portals; back->portals = p; @@ -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; - + 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"); + Sys_Error ("RemovePortalFromNode: portal not in leaf"); - if ( t == portal ) + if (t == portal) break; if (t->nodes[0] == l) @@ -77,30 +80,28 @@ void RemovePortalFromNode (portal_t *portal, node_t *l) else 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) - { - *pp = portal->next[1]; + } else if (portal->nodes[1] == l) { + *pp = portal->next[1]; portal->nodes[1] = NULL; } } //============================================================================ -void PrintPortal (portal_t *p) +void +PrintPortal (portal_t * p) { - int i; - winding_t *w; - + int i; + winding_t *w; + w = p->winding; - for (i=0 ; inumpoints ; i++) - printf ("(%5.0f,%5.0f,%5.0f)\n",w->points[i][0] - , w->points[i][1], w->points[i][2]); + 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,108 +111,103 @@ 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; - portal_t *p, *portals[6]; - plane_t bplanes[6], *pl; - int side; - + vec3_t bounds[2]; + int i, j, n; + portal_t *p, *portals[6]; + plane_t bplanes[6], *pl; + int side; + 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; } - + 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]; } p->planenum = FindPlane (pl, &side); - + p->winding = BaseWindingForPlane (pl); if (side) AddPortalToNodes (p, &outside_node, node); else AddPortalToNodes (p, node, &outside_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 ; inumpoints ; i++) - { - for (j=0 ; j<3 ; j++) + int i, 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; - + int i; + float total, add; + vec3_t v1, v2, cross; + total = 0; - for (i=1 ; inumpoints ; 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; + vec3_t v1, v2; // calc plane VectorSubtract (w->points[2], w->points[1], v1); @@ -221,19 +217,19 @@ 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; - plane_t plane, plane2; - int i; - winding_t *w; - float dist; + int side, side2; + portal_t *p, *p2; + plane_t plane, plane2; + int i; + winding_t *w; + float dist; - side = side2 = 0; // quiet compiler warning + 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) @@ -243,12 +239,11 @@ void CheckLeafPortalConsistancy (node_t *node) CheckWindingInNode (p->winding, node); CheckWindingArea (p->winding); - // check that the side orders are correct + // check that the side orders are correct plane = planes[p->planenum]; - PlaneFromWinding (p->winding, &plane2); - - for (p2 = node->portals ; p2 ; p2 = p2->next[side2]) - { + PlaneFromWinding (p->winding, &plane2); + + for (p2 = node->portals; p2; p2 = p2->next[side2]) { if (p2->nodes[0] == node) side2 = 0; else if (p2->nodes[1] == node) @@ -256,16 +251,14 @@ void CheckLeafPortalConsistancy (node_t *node) else Sys_Error ("CutNodePortals_r: mislinked portal"); w = p2->winding; - for (i=0 ; inumpoints ; 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,22 +270,22 @@ CutNodePortals_r ================ */ -void CutNodePortals_r (node_t *node) +void +CutNodePortals_r (node_t * node) { - plane_t *plane, clipplane; - node_t *f, *b, *other_node; - portal_t *p, *new_portal, *next_portal; - winding_t *w, *frontwinding, *backwinding; - int side; + plane_t *plane, clipplane; + node_t *f, *b, *other_node; + portal_t *p, *new_portal, *next_portal; + winding_t *w, *frontwinding, *backwinding; + int side; -// CheckLeafPortalConsistancy (node); +// CheckLeafPortalConsistancy (node); // -// seperate the portals on node into it's children +// seperate the portals on node into it's children // - if (node->contents) - { - return; // at a leaf, no more dividing + if (node->contents) { + return; // at a leaf, no more dividing } plane = &planes[node->planenum]; @@ -306,43 +299,36 @@ void CutNodePortals_r (node_t *node) // new_portal = AllocPortal (); new_portal->planenum = node->planenum; - + w = BaseWindingForPlane (&planes[node->planenum]); - side = 0; // shut up compiler warning - for (p = node->portals ; p ; p = p->next[side]) - { + side = 0; // shut up compiler warning + 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 the plane was not clipped on all sides, there was an error - new_portal->winding = 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) @@ -359,48 +345,42 @@ void CutNodePortals_r (node_t *node) // cut the portal into two portals, one on each side of the cut plane // 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 + // the winding is split new_portal = AllocPortal (); *new_portal = *p; new_portal->winding = backwinding; 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); - CutNodePortals_r (f); - CutNodePortals_r (b); + DrawLeaf (f, 1); + DrawLeaf (b, 2); + + CutNodePortals_r (f); + CutNodePortals_r (b); } @@ -412,12 +392,13 @@ PortalizeWorld Builds the exact polyhedrons for the nodes and leafs ================== */ -void PortalizeWorld (node_t *headnode) +void +PortalizeWorld (node_t * headnode) { qprintf ("----- portalize ----\n"); MakeHeadnodePortals (headnode); - CutNodePortals_r (headnode); + CutNodePortals_r (headnode); } @@ -427,18 +408,17 @@ FreeAllPortals ================== */ -void FreeAllPortals (node_t *node) +void +FreeAllPortals (node_t * node) { - portal_t *p, *nextp; - - if (!node->contents) - { + portal_t *p, *nextp; + + 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 @@ -460,65 +440,64 @@ PORTAL FILE GENERATION #define PORTALFILE "PRT1" -FILE *pf; -int num_visleafs; // leafs the player can be in -int num_visportals; +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; + 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; } - + 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) - { - // 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 + && 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 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 ; inumpoints ; 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) p = p->next[0]; else @@ -526,45 +505,43 @@ void WritePortalFile_r (node_t *node) } } - + /* ================ NumberLeafs_r ================ */ -void NumberLeafs_r (node_t *node) +void +NumberLeafs_r (node_t * node) { - portal_t *p; + 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]); return; } - + 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 - p = p->next[1]; + } else + p = p->next[1]; } } @@ -575,26 +552,25 @@ 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; num_visportals = 0; NumberLeafs_r (headnode); - + // write the file printf ("writing %s\n", portfilename); pf = fopen (portfilename, "w"); if (!pf) Sys_Error ("Error opening %s", portfilename); - + fprintf (pf, "%s\n", PORTALFILE); fprintf (pf, "%i\n", num_visleafs); fprintf (pf, "%i\n", num_visportals); - + WritePortalFile_r (headnode); - + fclose (pf); } - - diff --git a/tools/qfbsp/source/qfbsp.c b/tools/qfbsp/source/qfbsp.c index 9622c26b8..c15243ed3 100644 --- a/tools/qfbsp/source/qfbsp.c +++ b/tools/qfbsp/source/qfbsp.c @@ -35,48 +35,49 @@ #include "bsp5.h" -bsp_t *bsp; +bsp_t *bsp; // // command line flags // -qboolean drawflag; -qboolean nofill; -qboolean notjunc; -qboolean noclip; -qboolean onlyents; -qboolean verbose = true; -qboolean allverbose; -qboolean usehulls; +qboolean drawflag; +qboolean nofill; +qboolean notjunc; +qboolean noclip; +qboolean onlyents; +qboolean verbose = true; +qboolean allverbose; +qboolean usehulls; -int subdivide_size = 240; +int subdivide_size = 240; -brushset_t *brushset; +brushset_t *brushset; -int valid; +int valid; -char bspfilename[1024]; -char pointfilename[1024]; -char portfilename[1024]; -char hullfilename[1024]; +char bspfilename[1024]; +char pointfilename[1024]; +char portfilename[1024]; +char hullfilename[1024]; -char *argv0; // changed after fork(); +char *argv0; // changed after fork(); -qboolean worldmodel; +qboolean worldmodel; -int hullnum; +int hullnum; //=========================================================================== -void qprintf (char *fmt, ...) +void +qprintf (char *fmt, ...) { - va_list argptr; + va_list argptr; if (!verbose) return; va_start (argptr, fmt); - vprintf (fmt,argptr); + vprintf (fmt, argptr); va_end (argptr); } @@ -85,70 +86,68 @@ void qprintf (char *fmt, ...) BaseWindingForPlane ================= */ -winding_t *BaseWindingForPlane (plane_t *p) +winding_t * +BaseWindingForPlane (plane_t *p) { - int i, x; - vec_t max, v; - vec3_t org, vright, vup; - winding_t *w; - + int i, x; + vec_t max, v; + vec3_t org, vright, vup; + winding_t *w; + // find the major axis 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) - { - case 0: - case 1: - vup[2] = 1; - break; - case 2: - vup[0] = 1; - break; + + VectorCopy (vec3_origin, vup); + switch (x) { + case 0: + case 1: + vup[2] = 1; + break; + case 2: + vup[0] = 1; + break; } v = DotProduct (vup, p->normal); VectorMA (vup, -v, p->normal, vup); VectorNormalize (vup); - + VectorScale (p->normal, p->dist, org); - + CrossProduct (vup, p->normal, vright); - + VectorScale (vup, 8192, vup); VectorScale (vright, 8192, vright); -// project a really big axis aligned box onto the plane +// project a really big axis aligned box onto the plane w = NewWinding (4); - + VectorSubtract (org, vright, w->points[0]); VectorAdd (w->points[0], vup, w->points[0]); - + VectorAdd (org, vright, w->points[1]); VectorAdd (w->points[1], vup, w->points[1]); - + VectorAdd (org, vright, w->points[2]); VectorSubtract (w->points[2], vup, w->points[2]); - + VectorSubtract (org, vright, w->points[3]); VectorSubtract (w->points[3], vup, w->points[3]); - + w->numpoints = 4; - - return w; + + return w; } @@ -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]; + int size; + winding_t *c; + + 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,23 +194,23 @@ 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]; - int counts[3]; - vec_t dot; - int i, j; - vec_t *p1, *p2; - vec3_t mid; - winding_t *neww; - int maxpts; - + vec_t dists[MAX_POINTS_ON_WINDING]; + int sides[MAX_POINTS_ON_WINDING]; + int counts[3]; + vec_t dot; + int i, j; + vec_t *p1, *p2; + vec3_t mid; + winding_t *neww; + int maxpts; + counts[0] = counts[1] = counts[2] = 0; // determine sides for each point - for (i=0 ; inumpoints ; i++) - { + for (i = 0; i < in->numpoints; i++) { dot = DotProduct (in->points[i], split->normal); dot -= split->dist; dists[i] = dot; @@ -217,74 +218,69 @@ 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]]++; } sides[i] = sides[0]; dists[i] = dists[0]; - + 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 - // of fp grouping errors + + maxpts = in->numpoints + 4; // can't use counts[0]+2 because + // of fp grouping errors neww = NewWinding (maxpts); - - for (i=0 ; inumpoints ; 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]; - - dot = dists[i] / (dists[i]-dists[i+1]); - for (j=0 ; j<3 ; j++) - { // avoid round off error when possible + + // generate a split point + 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 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]); neww->numpoints++; } - + if (neww->numpoints > maxpts) Sys_Error ("ClipWinding: points exceeded estimate"); - + // free the original winding FreeWinding (in); - + return neww; } @@ -299,23 +295,24 @@ 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]; - int counts[3]; - vec_t dot; - int i, j; - vec_t *p1, *p2; - vec3_t mid; - winding_t *f, *b; - int maxpts; - + vec_t dists[MAX_POINTS_ON_WINDING]; + int sides[MAX_POINTS_ON_WINDING]; + int counts[3]; + vec_t dot; + int i, j; + vec_t *p1, *p2; + vec3_t mid; + winding_t *f, *b; + int maxpts; + counts[0] = counts[1] = counts[2] = 0; // determine sides for each point - for (i=0 ; inumpoints ; i++) - { + for (i = 0; i < in->numpoints; i++) { dot = DotProduct (in->points[i], split->normal); dot -= split->dist; dists[i] = dot; @@ -323,81 +320,74 @@ 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]]++; } sides[i] = sides[0]; dists[i] = dists[0]; - + *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 - // of fp grouping errors + 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 ; inumpoints ; 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]); b->numpoints++; 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]; - - dot = dists[i] / (dists[i]-dists[i+1]); - for (j=0 ; j<3 ; j++) - { // avoid round off error when possible + + // generate a split point + 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 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]); f->numpoints++; VectorCopy (mid, b->points[b->numpoints]); b->numpoints++; } - + if (f->numpoints > maxpts || b->numpoints > maxpts) Sys_Error ("ClipWinding: points exceeded estimate"); } @@ -405,12 +395,13 @@ void DivideWinding (winding_t *in, plane_t *split, winding_t **front, winding_t //=========================================================================== -int c_activefaces, c_peakfaces; -int c_activesurfaces, c_peaksurfaces; -int c_activewindings, c_peakwindings; -int c_activeportals, c_peakportals; +int c_activefaces, c_peakfaces; +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,27 +414,29 @@ void PrintMemory (void) NewWinding ================== */ -winding_t *NewWinding (int points) +winding_t * +NewWinding (int points) { - winding_t *w; - int size; - + winding_t *w; + int size; + if (points > MAX_POINTS_ON_WINDING) Sys_Error ("NewWinding: %i points", points); - + c_activewindings++; 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); - + return w; } -void FreeWinding (winding_t *w) +void +FreeWinding (winding_t * w) { c_activewindings--; free (w); @@ -456,26 +449,28 @@ void FreeWinding (winding_t *w) AllocFace =========== */ -face_t *AllocFace (void) +face_t * +AllocFace (void) { - face_t *f; - + face_t *f; + c_activefaces++; 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)); +// memset (f,0xff,sizeof(face_t)); free (f); } @@ -485,21 +480,23 @@ 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)); - + surface_t *s; + + s = malloc (sizeof (surface_t)); + memset (s, 0, sizeof (surface_t)); + c_activesurfaces++; if (c_activesurfaces > c_peaksurfaces) c_peaksurfaces = c_activesurfaces; - + return s; } -void FreeSurface (surface_t *s) +void +FreeSurface (surface_t * s) { c_activesurfaces--; free (s); @@ -510,21 +507,23 @@ void FreeSurface (surface_t *s) AllocPortal =========== */ -portal_t *AllocPortal (void) +portal_t * +AllocPortal (void) { - portal_t *p; - + portal_t *p; + c_activeportals++; 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,13 +535,14 @@ 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)); - + node_t *n; + + n = malloc (sizeof (node_t)); + memset (n, 0, sizeof (node_t)); + return n; } @@ -551,13 +551,14 @@ 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)); - + brush_t *b; + + b = malloc (sizeof (brush_t)); + memset (b, 0, sizeof (brush_t)); + return b; } @@ -568,21 +569,21 @@ brush_t *AllocBrush (void) ProcessEntity =============== */ -void ProcessEntity (int entnum) +void +ProcessEntity (int entnum) { - entity_t *ent; - char mod[80]; - surface_t *surfs; - node_t *nodes; - brushset_t *bs; - + entity_t *ent; + char mod[80]; + surface_t *surfs; + node_t *nodes; + brushset_t *bs; + ent = &entities[entnum]; if (!ent->brushes) - return; // non-bmodel entity + return; // non-bmodel entity - if (entnum > 0) - { + if (entnum > 0) { worldmodel = false; if (entnum == 1) qprintf ("--- Internal Entities ---\n"); @@ -593,81 +594,77 @@ void ProcessEntity (int entnum) if (hullnum == 0) printf ("MODEL: %s\n", mod); SetKeyValue (ent, "model", mod); - } - else + } else worldmodel = true; - + // // take the brush_ts and clip off all overlapping and contained faces, // leaving a perfect skin of the model with no hidden faces // bs = Brush_LoadEntity (ent, hullnum); - - if (!bs->brushes) - { + + if (!bs->brushes) { PrintEntity (ent); Sys_Error ("Entity with no valid brushes"); } - + 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 - { - // - // SolidBSP generates a node tree - // - // if not the world, make a good tree first - // the world is just going to make a bad tree - // because the outside filling will force a regeneration later - nodes = SolidBSP (surfs, entnum == 0); - - // - // 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 + } else { + // + // SolidBSP generates a node tree + // + // if not the world, make a good tree first + // the world is just going to make a bad tree + // because the outside filling will force a regeneration later + nodes = SolidBSP (surfs, entnum == 0); + + // + // 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 { PortalizeWorld (nodes); - - if (FillOutside (nodes)) - { + + if (FillOutside (nodes)) { FreeAllPortals (nodes); - // get the remaining faces together into surfaces again + // get the remaining faces together into surfaces again surfs = GatherNodeFaces (nodes); - - // merge polygons + + // merge polygons MergeAll (surfs); - - // make a really good tree + + // make a really good tree nodes = SolidBSP (surfs, false); - - // make the real portals for vis tracing + + // make the real portals for vis tracing PortalizeWorld (nodes); - - // save portal file for vis tracing + + // save portal file for vis tracing WritePortalfile (nodes); - - // fix tjunctions + + // fix tjunctions tjunc (nodes); } FreeAllPortals (nodes); @@ -685,15 +682,15 @@ UpdateEntLump ================= */ -void UpdateEntLump (void) +void +UpdateEntLump (void) { - int m, entnum; - char mod[80]; + 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,9 +702,9 @@ void UpdateEntLump (void) f = Qopen (bspfilename, "rb"); bsp = LoadBSPFile (f, Qfilesize (f)); Qclose (f); - WriteEntitiesToString(); + WriteEntitiesToString (); f = Qopen (bspfilename, "wb"); - WriteBSPFile (bsp, f); + 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; + 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,19 +734,20 @@ void WriteClipHull (void) fprintf (f, "%i\n", bsp->nummodels); - for (i=0 ; inummodels ; 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 ; inumclipnodes ; 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,63 +758,67 @@ ReadClipHull Read the files written out by the child processes ================= */ -void ReadClipHull (int hullnum) +void +ReadClipHull (int hullnum) { - FILE *f; - int i, j, n; - int firstclipnode; - dplane_t p; - dclipnode_t *d; - int c1, c2; - float f1, f2, f3, f4; - int junk; - vec3_t norm; + FILE *f; + int i, j, n; + int firstclipnode; + dplane_t p; + dclipnode_t *d; + int c1, c2; + float f1, f2, f3, f4; + 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 ; imodels[i].headnode[hullnum] = bsp->numclipnodes + j; } - - - fscanf (f,"\n%i\n", &n); + + + fscanf (f, "\n%i\n", &n); firstclipnode = bsp->numclipnodes; - - for (i=0 ; inumclipnodes == 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); - + p.normal[0] = f1; p.normal[1] = f2; 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; d->children[1] = c2 >= 0 ? c2 + firstclipnode : c2; d->planenum = FindFinalPlane (&p); } - + } /* @@ -824,16 +827,16 @@ CreateSingleHull ================= */ -void CreateSingleHull (void) +void +CreateSingleHull (void) { - int entnum; + 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 + verbose = false; // don't print rest of entities } if (hullnum) @@ -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; @@ -894,9 +889,11 @@ 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 @@ -904,19 +901,19 @@ void CreateHulls (void) hullnum = 1; CreateSingleHull (); - + bsp->nummodels = 0; bsp->numplanes = 0; bsp->numclipnodes = 0; hullnum = 2; CreateSingleHull (); - + bsp->nummodels = 0; bsp->numplanes = 0; bsp->numclipnodes = 0; hullnum = 0; CreateSingleHull (); -#endif +#endif } @@ -926,7 +923,8 @@ ProcessFile ================= */ -void ProcessFile (char *sourcebase, char *bspfilename1) +void +ProcessFile (char *sourcebase, char *bspfilename1) { // create filenames strcpy (bspfilename, bspfilename1); @@ -940,33 +938,28 @@ void ProcessFile (char *sourcebase, char *bspfilename1) strcpy (portfilename, bspfilename1); COM_StripExtension (portfilename, portfilename); strcat (portfilename, ".prt"); - + strcpy (pointfilename, 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,76 +980,72 @@ main ================== */ -int main (int argc, char **argv) +int +main (int argc, char **argv) { - int i; - double start, end; - char sourcename[1024]; - char destname[1024]; - -// malloc_debug (15); + int i; + double start, end; + char sourcename[1024]; + char destname[1024]; + +// malloc_debug (15); // // check command line flags // - for (i=1 ; i"); - //XXX SetQdirFromPath (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 "); + + // XXX SetQdirFromPath (argv[i]); // // let forked processes change name for ps status // argv0 = argv[0]; - + // // create destination name if not specified // 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; } diff --git a/tools/qfbsp/source/region.c b/tools/qfbsp/source/region.c index 0fb6450c9..e95403f4a 100644 --- a/tools/qfbsp/source/region.c +++ b/tools/qfbsp/source/region.c @@ -47,34 +47,36 @@ face to region mapping numbers #define MAX_EDGES_IN_REGION 32 -int firstedge; +int firstedge; -vec3_t region_mins, region_maxs; +vec3_t region_mins, region_maxs; -void AddPointToRegion (vec3_t p) +void +AddPointToRegion (vec3_t p) { - int i; - - for (i=0 ; i<3 ; i++) - { + int i; + + for (i = 0; i < 3; i++) { if (p[i] < region_mins[i]) region_mins[i] = p[i]; if (p[i] > region_maxs[i]) region_maxs[i] = p[i]; - } + } } -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; + int i; - for (i=0 ; inumpoints ; i++) + for (i = 0; i < f->numpoints; i++) AddPointToRegion (f->pts[i]); } @@ -83,45 +85,39 @@ 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; + 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 + return false; // a huge water or sky polygon } - + // check edge count constraints return true; } @@ -132,44 +128,41 @@ 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; - int i; - + int e; + face_t *f2; + int i; + if (f->outputnumber == bsp->numfaces) return; if (f->outputnumber != -1) Sys_Error ("RecursiveGrowRegion: region collision"); f->outputnumber = bsp->numfaces; - -// add edges - for (i=0 ; inumpoints ; i++) - { + +// add edges + for (i = 0; i < f->numpoints; i++) { e = f->edges[i]; - if (!edgefaces[abs(e)][0]) - continue; // edge has allready been removed + 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; - continue; // allready merged + 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 - { - // emit a surfedge + } else { + // emit a surfedge if (bsp->numsurfedges == MAX_MAP_SURFEDGES) Sys_Error ("numsurfedges == MAX_MAP_SURFEDGES"); bsp->surfedges[bsp->numsurfedges] = e; @@ -179,17 +172,17 @@ void RecursiveGrowRegion (dface_t *r, face_t *f) } -void PrintDface (int f) -{ // for debugging - dface_t *df; - dedge_t *e; - int i, n; - +void +PrintDface (int f) +{ // for debugging + dface_t *df; + dedge_t *e; + int i, n; + df = &bsp->faces[f]; - for (i=0 ; inumedges ; 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) -{ // for debugging - int i, j, n; - dface_t *df; - dedge_t *e; - - for (i=firstmodelface ; inumfaces ; i++) - { +void +FindVertexUse (int v) +{ // for debugging + int i, j, n; + dface_t *df; + dedge_t *e; + + for (i = firstmodelface; i < bsp->numfaces; i++) { df = &bsp->faces[i]; - for (j=0 ; jnumedges ; 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) -{ // for debugging - int i, j, n; - dface_t *df; - - for (i=firstmodelface ; inumfaces ; i++) - { +void +FindEdgeUse (int v) +{ // for debugging + int i, j, n; + dface_t *df; + + for (i = firstmodelface; i < bsp->numfaces; i++) { df = &bsp->faces[i]; - for (j=0 ; jnumedges ; 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; } @@ -247,26 +236,28 @@ Extends e1 so that it goes all the way to e2, and removes all references to e2 ================ */ -int edgemapping[MAX_MAP_EDGES]; -void HealEdges (int e1, int e2) +int edgemapping[MAX_MAP_EDGES]; +void +HealEdges (int e1, int e2) { - int i, j, n, saved; - dface_t *df; - dedge_t *ed, *ed2; - vec3_t v1, v2; - dface_t *found[2]; - int foundj[2]; + int i, j, n, saved; + dface_t *df; + dedge_t *ed, *ed2; + vec3_t v1, v2; + 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]) ed->v[0] = ed2->v[1]; else if (ed->v[0] == ed2->v[1]) @@ -278,24 +269,22 @@ 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)) Sys_Error ("HealEdges: edges not colinear"); edgemapping[e2] = e1; saved = 0; - + // remove all uses of e2 - for (i=firstmodelface ; inumfaces ; i++) - { + for (i = firstmodelface; i < bsp->numfaces; i++) { df = &bsp->faces[i]; - for (j=0 ; jnumedges ; 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++; @@ -303,19 +292,17 @@ 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++ ; jnumedges ; 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,74 +311,70 @@ return; } } -typedef struct -{ - int numedges; - int edges[2]; +typedef struct { + int numedges; + int edges[2]; } checkpoint_t; -checkpoint_t checkpoints[MAX_MAP_VERTS]; +checkpoint_t checkpoints[MAX_MAP_VERTS]; /* ============== RemoveColinearEdges ============== */ -void RemoveColinearEdges (void) +void +RemoveColinearEdges (void) { - int i,j, v; - int c0, c1, c2, c3; - checkpoint_t *cp; - + int i, j, v; + int c0, c1, c2, c3; + checkpoint_t *cp; + // no edges remapped yet - for (i=0 ; inumedges ; i++) + for (i = 0; i < bsp->numedges; i++) edgemapping[i] = i; - + // find vertexes that only have two edges - memset (checkpoints, 0, sizeof(checkpoints)); - - for (i=firstmodeledge ; inumedges ; i++) - { + memset (checkpoints, 0, sizeof (checkpoints)); + + for (i = firstmodeledge; i < bsp->numedges; i++) { if (!edgefaces[i][0]) - continue; // removed - for (j=0 ; j<2 ; j++) - { + continue; // removed + 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++; } } - + // if a vertex only has two edges and they are colinear, it can be removed c0 = c1 = c2 = c3 = 0; - - for (i=0 ; inumvertexes ; i++) - { + + for (i = 0; i < bsp->numvertexes; i++) { cp = &checkpoints[i]; - switch (cp->numedges) - { - case 0: - c0++; - break; - case 1: - c1++; - break; - case 2: - c2++; - HealEdges (cp->edges[0], cp->edges[1]); - break; - default: - c3++; - break; + switch (cp->numedges) { + case 0: + c0++; + break; + case 1: + c1++; + break; + case 2: + c2++; + HealEdges (cp->edges[0], cp->edges[1]); + break; + default: + c3++; + break; } } - -// qprintf ("%5i c0\n", c0); -// qprintf ("%5i c1\n", c1); -// qprintf ("%5i c2\n", c2); -// qprintf ("%5i c3+\n", c3); + +// qprintf ("%5i c0\n", c0); +// qprintf ("%5i c1\n", c1); +// qprintf ("%5i c2\n", c2); +// qprintf ("%5i c3+\n", c3); qprintf ("%5i deges removed by tjunction healing\n", c2); } @@ -400,22 +383,23 @@ void RemoveColinearEdges (void) CountRealNumbers ============== */ -void CountRealNumbers (void) +void +CountRealNumbers (void) { - int i; - int c; - - qprintf ("%5i regions\n", bsp->numfaces-firstmodelface); + int i; + int c; + + qprintf ("%5i regions\n", bsp->numfaces - firstmodelface); c = 0; - for (i=firstmodelface ; inumfaces ; i++) + for (i = firstmodelface; i < bsp->numfaces; i++) c += bsp->faces[i].numedges; qprintf ("%5i real marksurfaces\n", c); - + c = 0; - for (i=firstmodeledge ; inumedges ; i++) + for (i = firstmodeledge; i < bsp->numedges; i++) if (edgefaces[i][0]) - c++; // not removed + c++; // not removed qprintf ("%5i real edges\n", c); } @@ -427,23 +411,23 @@ void CountRealNumbers (void) GrowNodeRegion_r ============== */ -void GrowNodeRegion_r (node_t *node) +void +GrowNodeRegion_r (node_t * node) { - dface_t *r; - face_t *f; - int i; + dface_t *r; + face_t *f; + int i; if (node->planenum == PLANENUM_LEAF) return; node->firstface = bsp->numfaces; - for (f=node->faces ; f ; f=f->next) - { -// if (f->outputnumber != -1) -// continue; // allready grown into an earlier region - - // emit a region + for (f = node->faces; f; f = f->next) { +// if (f->outputnumber != -1) +// continue; // allready grown into an earlier region + + // emit a region if (bsp->numfaces == MAX_MAP_FACES) Sys_Error ("MAX_MAP_FACES"); @@ -453,26 +437,25 @@ void GrowNodeRegion_r (node_t *node) r->planenum = node->outputplanenum; r->side = f->planeside; r->texinfo = f->texturenum; - for (i=0 ; istyles[i] = 255; r->lightofs = -1; - // add the face and mergable neighbors to it - + // add the face and mergable neighbors to it + #if 0 ClearRegionSize (); AddFaceToRegionSize (f); RecursiveGrowRegion (r, f); #endif r->firstedge = firstedge = bsp->numsurfedges; - for (i=0 ; inumpoints ; 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]; bsp->numsurfedges++; } - + r->numedges = bsp->numsurfedges - r->firstedge; bsp->numfaces++; @@ -490,12 +473,13 @@ void GrowNodeRegion_r (node_t *node) GrowNodeRegions ============== */ -void GrowNodeRegions (node_t *headnode) +void +GrowNodeRegions (node_t * headnode) { qprintf ("---- GrowRegions ----\n"); - + GrowNodeRegion_r (headnode); - + //RemoveColinearEdges (); CountRealNumbers (); } @@ -521,16 +505,3 @@ for all faces =============================================================================== */ - - - - - - - - - - - - - diff --git a/tools/qfbsp/source/solidbsp.c b/tools/qfbsp/source/solidbsp.c index 0d96b0c27..45cf0ebfe 100644 --- a/tools/qfbsp/source/solidbsp.c +++ b/tools/qfbsp/source/solidbsp.c @@ -28,13 +28,13 @@ #include "bsp5.h" -int leaffaces; -int nodefaces; -int splitnodes; +int leaffaces; +int nodefaces; +int splitnodes; -int c_solid, c_empty, c_water; +int c_solid, c_empty, c_water; -qboolean usemidsplit; +qboolean usemidsplit; //============================================================================ @@ -45,58 +45,51 @@ 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; - int i; - vec_t *p; - - + int frontcount, backcount; + vec_t dot; + int i; + vec_t *p; + + frontcount = backcount = 0; - + // axial planes are fast if (split->type < 3) - for (i=0, p = in->pts[0]+split->type ; inumpoints ; 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] ; inumpoints ; 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; } } - + if (!frontcount) return SIDE_BACK; if (!backcount) return SIDE_FRONT; - + return SIDE_ON; } @@ -107,66 +100,62 @@ 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; - surface_t *p, *bestsurface; - vec_t bestvalue, value, dist; - plane_t *plane; + int j, l; + surface_t *p, *bestsurface; + vec_t bestvalue, value, dist; + plane_t *plane; // // 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; plane = &planes[p->planenum]; - - // check for axis aligned surfaces + + // check for axis aligned surfaces l = plane->type; if (l > PLANE_Z) continue; - // - // calculate the split metric along axis l, smaller values are better - // + // + // calculate the split metric along axis l, smaller values are better + // 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) continue; - - // - // currently the best! - // + + // + // currently the best! + // bestvalue = value; 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 + return p; // first valid surface Sys_Error ("ChooseMidPlaneFromList: no valid planes"); } - + return bestsurface; } @@ -179,23 +168,24 @@ 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; - surface_t *p, *p2, *bestsurface; - vec_t bestvalue, bestdistribution, value, dist; - plane_t *plane; - face_t *f; - + int j, k, l; + surface_t *p, *p2, *bestsurface; + vec_t bestvalue, bestdistribution, value, dist; + plane_t *plane; + face_t *f; + // // pick the plane that splits the least // bestvalue = 99999; bestsurface = NULL; bestdistribution = 9e30; - - for (p=surfaces ; p ; p=p->next) - { + + for (p = surfaces; p; p = p->next) { if (p->onnode) continue; @@ -205,22 +195,19 @@ 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; } - + } if (k > bestvalue) break; @@ -228,40 +215,37 @@ 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 (k < bestvalue || (k == bestvalue && plane->type < PLANE_ANYX) ) - { - // check for axis aligned surfaces + + // if equal numbers, axial planes win, then decide on spatial + // subdivision + + if (k < bestvalue || (k == bestvalue && plane->type < PLANE_ANYX)) { + // check for axis aligned surfaces l = plane->type; - - if (l <= PLANE_Z) - { // axial aligned - // - // calculate the split metric along axis l - // + + 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) continue; bestdistribution = value; } - // - // currently the best! - // + // + // currently the best! + // bestvalue = k; bestsurface = p; } @@ -281,57 +265,55 @@ 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; - vec3_t mins, maxs; - surface_t *p, *bestsurface; + int i, j; + vec3_t mins, maxs; + surface_t *p, *bestsurface; // // count onnode 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) - return bestsurface; // this is a final split - + + 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]) maxs[j] = p->maxs[j]; } - if (usemidsplit) // do fast way for clipping hull + if (usemidsplit) // do fast way for clipping hull return ChooseMidPlaneFromList (surfaces, mins, maxs); - + // do slow way to save poly splits for drawing hull #if 0 bestsurface = ChoosePlaneFromList (surfaces, mins, maxs, false); - if (bestsurface) + if (bestsurface) return bestsurface; -#endif +#endif return ChoosePlaneFromList (surfaces, mins, maxs, true); } @@ -344,30 +326,28 @@ CalcSurfaceInfo Calculates the bounding box ================= */ -void CalcSurfaceInfo (surface_t *surf) +void +CalcSurfaceInfo (surface_t * surf) { - int i,j; - face_t *f; - + int i, j; + face_t *f; + if (!surf->faces) Sys_Error ("CalcSurfaceInfo: surface without a face"); - + // // 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 ; inumpoints ; 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,45 +363,42 @@ 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; - face_t *frontfrag, *backfrag; - surface_t *news; - plane_t *inplane; - + face_t *facet, *next; + face_t *frontlist, *backlist; + face_t *frontfrag, *backfrag; + surface_t *news; + plane_t *inplane; + 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; } } - + if (in->faces) *front = in; else @@ -432,72 +409,62 @@ void DividePlane (surface_t *in, plane_t *split, surface_t **front, surface_t ** *back = NULL; 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; } } // 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; news->faces = backlist; *back = news; - + in->faces = frontlist; *front = in; - + // recalc bboxes and flags CalcSurfaceInfo (news); - CalcSurfaceInfo (in); + CalcSurfaceInfo (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); @@ -517,7 +485,7 @@ void DivideNodeBounds (node_t *node, plane_t *split) return; node->children[0]->mins[split->type] = - node->children[1]->maxs[split->type] = split->dist; + node->children[1]->maxs[split->type] = split->dist; } /* @@ -528,21 +496,20 @@ 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; - int i, count; - + face_t *f, *next; + surface_t *surf, *pnext; + int i, count; + leafnode->faces = NULL; leafnode->contents = 0; 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]; @@ -553,36 +520,33 @@ void LinkConvexFaces (surface_t *planelist, node_t *leafnode) if (!leafnode->contents) leafnode->contents = CONTENTS_SOLID; - - switch (leafnode->contents) - { - case CONTENTS_EMPTY: - c_empty++; - break; - case CONTENTS_SOLID: - c_solid++; - break; - case CONTENTS_WATER: - case CONTENTS_SLIME: - case CONTENTS_LAVA: - case CONTENTS_SKY: - c_water++; - break; - default: - Sys_Error ("LinkConvexFaces: bad contents number"); + + switch (leafnode->contents) { + case CONTENTS_EMPTY: + c_empty++; + break; + case CONTENTS_SOLID: + c_solid++; + break; + case CONTENTS_WATER: + case CONTENTS_SLIME: + case CONTENTS_LAVA: + case CONTENTS_SKY: + c_water++; + break; + default: + Sys_Error ("LinkConvexFaces: bad contents number"); } // // 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++; @@ -590,7 +554,7 @@ void LinkConvexFaces (surface_t *planelist, node_t *leafnode) } FreeSurface (surf); } - leafnode->markfaces[i] = NULL; // sentinal + leafnode->markfaces[i] = NULL; // sentinal } @@ -601,18 +565,18 @@ 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; - + face_t *f, *new, **prevptr; + face_t *list; + list = NULL; - - + + // 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,21 +604,21 @@ 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; - surface_t *frontfrag, *backfrag; - plane_t *splitplane; - + surface_t *split, *p, *next; + surface_t *frontlist, *backlist; + surface_t *frontfrag, *backfrag; + 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; } - + splitnodes++; node->faces = LinkNodeFaces (split); node->children[0] = AllocNode (); @@ -663,7 +626,7 @@ void PartitionSurfaces (surface_t *surfaces, node_t *node) node->planenum = split->planenum; splitplane = &planes[split->planenum]; - + DivideNodeBounds (node, splitplane); @@ -672,28 +635,24 @@ 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) - { - // the plane was split, which may expose oportunities to merge - // adjacent faces into a single face -// MergePlaneFaces (frontfrag); -// MergePlaneFaces (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) + face_t *f; + + 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,25 +698,25 @@ 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; - + int i; + node_t *headnode; + qprintf ("----- SolidBSP -----\n"); headnode = AllocNode (); usemidsplit = 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; } - + // // recursively partition everything // @@ -771,10 +731,9 @@ node_t *SolidBSP (surface_t *surfhead, qboolean midsplit) qprintf ("%5i split nodes\n", splitnodes); 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 water leafs\n", c_water); + qprintf ("%5i leaffaces\n", leaffaces); qprintf ("%5i nodefaces\n", nodefaces); - + return headnode; } - diff --git a/tools/qfbsp/source/surfaces.c b/tools/qfbsp/source/surfaces.c index fad15e111..6f8be6e09 100644 --- a/tools/qfbsp/source/surfaces.c +++ b/tools/qfbsp/source/surfaces.c @@ -29,7 +29,7 @@ #include "bsp5.h" -surface_t newcopy_t; +surface_t newcopy_t; /* a surface has all of the faces that could be drawn on a given plane @@ -38,7 +38,7 @@ the outside filling stage can remove some of them so a better bsp can be generat */ -int subdivides; +int subdivides; /* @@ -49,48 +49,46 @@ 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; - int axis, i; - plane_t plane; - face_t *front, *back, *next; - texinfo_t *tex; + float mins, maxs; + vec_t v; + int axis, i; + plane_t plane; + face_t *front, *back, *next; + texinfo_t *tex; // 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 ; inumpoints ; i++) - { + + for (i = 0; i < f->numpoints; i++) { v = DotProduct (f->pts[i], tex->vecs[axis]); if (v < mins) mins = v; if (v > maxs) maxs = v; } - + if (maxs - mins <= subdivide_size) break; - - // split it + + // split it subdivides++; - + VectorCopy (tex->vecs[axis], plane.normal); v = VectorLength (plane.normal); - VectorNormalize (plane.normal); - plane.dist = (mins + subdivide_size - 16)/v; + VectorNormalize (plane.normal); + 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; + surface_t *surf; + 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; @@ -133,7 +130,7 @@ void SubdivideFaces (surface_t *surfhead) } qprintf ("%i faces added by subdivision\n", subdivides); - + } @@ -147,36 +144,30 @@ have inside faces. ============================================================================= */ -void GatherNodeFaces_r (node_t *node) +void +GatherNodeFaces_r (node_t * node) { - face_t *f, *next; - - if (node->planenum != PLANENUM_LEAF) - { + face_t *f, *next; + + 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; } } - + GatherNodeFaces_r (node->children[0]); GatherNodeFaces_r (node->children[1]); - + free (node); - } - else - { + } else { // // leaf node // @@ -190,63 +181,63 @@ 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 (); + return BuildSurfaces (); } //=========================================================================== -typedef struct hashvert_s -{ - struct hashvert_s *next; - vec3_t point; - int num; - int numplanes; // for corner determination - int planenums[2]; - int numedges; +typedef struct hashvert_s { + struct hashvert_s *next; + vec3_t point; + int num; + int numplanes; // for corner determination + int planenums[2]; + int numedges; } hashvert_t; #define POINT_EPSILON 0.01 -int c_cornerverts; +int c_cornerverts; -hashvert_t hvertex[MAX_MAP_VERTS]; -hashvert_t *hvert_p; +hashvert_t hvertex[MAX_MAP_VERTS]; +hashvert_t *hvert_p; -face_t *edgefaces[MAX_MAP_EDGES][2]; -int firstmodeledge = 1; -int firstmodelface; +face_t *edgefaces[MAX_MAP_EDGES][2]; +int firstmodeledge = 1; +int firstmodelface; //============================================================================ #define NUM_HASH 4096 -hashvert_t *hashverts[NUM_HASH]; +hashvert_t *hashverts[NUM_HASH]; -static vec3_t hash_min, hash_scale; +static vec3_t hash_min, hash_scale; -static void InitHash (void) +static void +InitHash (void) { - vec3_t size; - vec_t volume; - vec_t scale; - int newsize[2]; - int i; - - memset (hashverts, 0, sizeof(hashverts)); + vec3_t size; + vec_t volume; + vec_t scale; + int newsize[2]; + int i; - for (i=0 ; i<3 ; i++) - { + memset (hashverts, 0, sizeof (hashverts)); + + for (i = 0; i < 3; i++) { hash_min[i] = -8000; size[i] = 16000; } - volume = size[0]*size[1]; - - scale = sqrt(volume / NUM_HASH); + volume = size[0] * size[1]; + + scale = sqrt (volume / NUM_HASH); newsize[0] = size[0] / scale; newsize[1] = size[1] / scale; @@ -254,17 +245,18 @@ static void InitHash (void) hash_scale[0] = newsize[0] / size[0]; hash_scale[1] = newsize[1] / size[1]; hash_scale[2] = newsize[1]; - + 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] + 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,33 +267,31 @@ 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) + 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) vert[i] = (int) (in[i] + 0.5); else vert[i] = in[i]; } - + h = HashVec (vert); - - for (hv=hashverts[h] ; hv ; hv=hv->next) - { - if ( fabs(hv->point[0]-vert[0])point[1]-vert[1])point[2]-vert[2])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 ; inumplanes ; i++) + return hv->num; // allready known to be a corner + for (i = 0; i < hv->numplanes; i++) if (hv->planenums[i] == planenum) return hv->num; // allready know this plane if (hv->numplanes == 2) @@ -312,7 +302,7 @@ int GetVertex (vec3_t in, int planenum) return hv->num; } } - + hv = hvert_p; hv->numedges = 1; hv->numplanes = 1; @@ -321,10 +311,10 @@ 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++; - + // emit a vertex if (bsp->numvertexes == MAX_MAP_VERTS) Sys_Error ("numvertexes == MAX_MAP_VERTS"); @@ -347,32 +337,31 @@ GetEdge Don't allow four way edges ================== */ -int c_tryedges; +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; - int i; + int v1, v2; + dedge_t *edge; + int i; if (!f->contents[0]) Sys_Error ("GetEdge: 0 contents"); - c_tryedges++; + 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][1] + && edgefaces[i][0]->contents[0] == f->contents[0]) { edgefaces[i][1] = f; return -i; } } - + // emit an edge if (bsp->numedges == MAX_MAP_EDGES) Sys_Error ("numedges == MAX_MAP_EDGES"); @@ -381,7 +370,7 @@ int GetEdge (vec3_t p1, vec3_t p2, face_t *f) edge->v[0] = v1; edge->v[1] = v2; edgefaces[i][0] = f; - + return i; } @@ -391,17 +380,18 @@ int GetEdge (vec3_t p1, vec3_t p2, face_t *f) FindFaceEdges ================== */ -void FindFaceEdges (face_t *face) +void +FindFaceEdges (face_t * face) { - int i; + int i; - face->outputnumber = -1; + face->outputnumber = -1; if (face->numpoints > MAXEDGES) Sys_Error ("WriteFace: %i points", face->numpoints); - for (i=0; inumpoints ; i++) - face->edges[i] = GetEdge - (face->pts[i], face->pts[(i+1)%face->numpoints], face); + for (i = 0; i < face->numpoints; i++) + face->edges[i] = GetEdge + (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; - + 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) @@ -429,7 +419,7 @@ void CheckVertexes (void) else c3++; } - + qprintf ("%5i bad edge points\n", cb); qprintf ("%5i 0 edge points\n", c0); qprintf ("%5i 2 edge points\n", c1); @@ -443,54 +433,52 @@ CheckEdges // debugging ============= */ -void CheckEdges (void) +void +CheckEdges (void) { - dedge_t *edge; - int i; - dvertex_t *d1, *d2; - face_t *f1, *f2; - int c_nonconvex; - int c_multitexture; - + dedge_t *edge; + int i; + dvertex_t *d1, *d2; + face_t *f1, *f2; + int c_nonconvex; + int c_multitexture; + c_nonconvex = c_multitexture = 0; - -// CheckVertexes (); - - for (i=1 ; i < bsp->numedges ; i++) - { + +// CheckVertexes (); + + 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) continue; if (f1->planenum != f2->planenum) 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++; } } -// qprintf ("%5i edges\n", i); -// qprintf ("%5i c_nonconvex\n", c_nonconvex); -// qprintf ("%5i c_multitexture\n", c_multitexture); +// qprintf ("%5i edges\n", i); +// qprintf ("%5i c_nonconvex\n", c_nonconvex); +// qprintf ("%5i c_multitexture\n", c_multitexture); -// CheckVertexes (); +// CheckVertexes (); } @@ -499,16 +487,17 @@ void CheckEdges (void) MakeFaceEdges_r ================ */ -void MakeFaceEdges_r (node_t *node) +void +MakeFaceEdges_r (node_t * node) { - face_t *f; - + 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]); MakeFaceEdges_r (node->children[1]); } @@ -518,21 +507,21 @@ void MakeFaceEdges_r (node_t *node) MakeFaceEdges ================ */ -void MakeFaceEdges (node_t *headnode) +void +MakeFaceEdges (node_t * headnode) { qprintf ("----- MakeFaceEdges -----\n"); - + InitHash (); c_tryedges = 0; c_cornerverts = 0; - + MakeFaceEdges_r (headnode); -// CheckEdges (); +// CheckEdges (); GrowNodeRegions (headnode); firstmodeledge = bsp->numedges; firstmodelface = bsp->numfaces; } - diff --git a/tools/qfbsp/source/tjunc.c b/tools/qfbsp/source/tjunc.c index 5f1109ef7..c556804b6 100644 --- a/tools/qfbsp/source/tjunc.c +++ b/tools/qfbsp/source/tjunc.c @@ -28,62 +28,63 @@ #include "bsp5.h" -typedef struct wvert_s -{ - vec_t t; +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; - wvert_t head; + vec3_t dir; + vec3_t origin; + wvert_t head; } wedge_t; -int numwedges, numwverts; -int tjuncs; -int tjuncfaces; +int numwedges, numwverts; +int tjuncs; +int tjuncfaces; #define MAXWVERTS 0x20000 #define MAXWEDGES 0x10000 -wvert_t wverts[MAXWVERTS]; -wedge_t wedges[MAXWEDGES]; +wvert_t wverts[MAXWVERTS]; +wedge_t wedges[MAXWEDGES]; -void PrintFace (face_t *f) +void +PrintFace (face_t * f) { - int i; - - for (i=0 ; inumpoints ; i++) - printf ("(%5.2f, %5.2f, %5.2f)\n", f->pts[i][0], f->pts[i][1], f->pts[i][2]); + 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]); } //============================================================================ #define NUM_HASH 1024 -wedge_t *wedge_hash[NUM_HASH]; +wedge_t *wedge_hash[NUM_HASH]; -static vec3_t hash_min, hash_scale; +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; - vec_t scale; - int newsize[2]; - + vec3_t size; + vec_t volume; + vec_t scale; + int newsize[2]; + VectorCopy (mins, hash_min); VectorSubtract (maxs, mins, size); - memset (wedge_hash, 0, sizeof(wedge_hash)); - - volume = size[0]*size[1]; - - scale = sqrt(volume / NUM_HASH); + memset (wedge_hash, 0, sizeof (wedge_hash)); + + volume = size[0] * size[1]; + + scale = sqrt (volume / NUM_HASH); newsize[0] = size[0] / scale; newsize[1] = size[1] / scale; @@ -93,62 +94,59 @@ 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; + unsigned h; - h = hash_scale[0] * (vec[0] - hash_min[0]) * hash_scale[2] + 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; - wedge_t *w; - vec_t temp; - int h; - + vec3_t origin; + vec3_t dir; + wedge_t *w; + vec_t temp; + int h; + VectorSubtract (p2, p1, dir); CanonicalVector (dir); @@ -157,17 +155,15 @@ 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; } - + 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; @@ -177,7 +173,7 @@ wedge_t *FindEdge (vec3_t p1, vec3_t p2, vec_t *t1, vec_t *t2) temp = w->origin[2] - origin[2]; if (temp < -EQUAL_EPSILON || temp > EQUAL_EPSILON) continue; - + temp = w->dir[0] - dir[0]; if (temp < -EQUAL_EPSILON || temp > EQUAL_EPSILON) continue; @@ -190,15 +186,15 @@ wedge_t *FindEdge (vec3_t p1, vec3_t p2, vec_t *t1, vec_t *t2) return w; } - + if (numwedges == MAXWEDGES) Sys_Error ("FindEdge: numwedges == MAXWEDGES"); w = &wedges[numwedges]; numwedges++; - + w->next = wedge_hash[h]; wedge_hash[h] = w; - + VectorCopy (origin, w->origin); VectorCopy (dir, w->dir); w->head.next = w->head.prev = &w->head; @@ -215,27 +211,27 @@ 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; - + 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; v = v->next; } while (1); - + // insert a new wvert before v if (numwverts == MAXWVERTS) Sys_Error ("AddVert: numwverts == MAXWVERTS"); newv = &wverts[numwverts]; numwverts++; - + newv->t = t; newv->next = v; newv->prev = v->prev; @@ -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); + wedge_t *w; + vec_t t1, t2; + + w = FindEdge (p1, p2, &t1, &t2); AddVert (w, t1); AddVert (w, t2); } @@ -266,14 +263,14 @@ 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; - AddEdge (f->pts[i], f->pts[j]); + int i, j; + + for (i = 0; i < f->numpoints; i++) { + j = (i + 1) % f->numpoints; + AddEdge (f->pts[i], f->pts[j]); } } @@ -281,26 +278,26 @@ 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; +byte superfacebuf[8192]; +face_t *superface = (face_t *) superfacebuf; -void FixFaceEdges (face_t *f); +void FixFaceEdges (face_t * f); -face_t *newlist; +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; - vec3_t dir, test; - vec_t v; - int firstcorner, lastcorner; - + int i; + face_t *new, *chain; + vec3_t dir, test; + vec_t v; + 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; @@ -308,81 +305,72 @@ void SplitFaceForTjunc (face_t *f, face_t *original) newlist = original; return; } - + tjuncfaces++; - -restart: - // find the last corner - 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); + + restart: + // find the last corner + 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); VectorNormalize (test); v = DotProduct (test, dir); - if (v < 0.9999 || v > 1.00001) - { + if (v < 0.9999 || v > 1.00001) { break; } } - - // find the first corner + + // 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); + VectorNormalize (dir); + 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) - { - // rotate the point winding + + if (firstcorner + 2 >= MAXPOINTS) { + // rotate the point winding VectorCopy (f->pts[0], test); - for (i=1 ; inumpoints ; 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 - + + // cut off as big a piece as possible, less than MAXPOINTS, and not + // past lastcorner + new = NewFaceFromFace (f); if (f->original) Sys_Error ("SplitFaceForTjunc: f->original"); - + new->original = chain; chain = new; new->next = newlist; newlist = new; if (f->numpoints - firstcorner <= MAXPOINTS) - new->numpoints = firstcorner+2; - else if (lastcorner+2 < MAXPOINTS && - f->numpoints - lastcorner <= MAXPOINTS) - new->numpoints = lastcorner+2; + new->numpoints = firstcorner + 2; + else if (lastcorner + 2 < MAXPOINTS && + f->numpoints - lastcorner <= MAXPOINTS) + new->numpoints = lastcorner + 2; else new->numpoints = MAXPOINTS; - for (i=0 ; inumpoints ; i++) - { + for (i = 0; i < new->numpoints; i++) { VectorCopy (f->pts[i], new->pts[i]); } - - - for (i=new->numpoints-1 ; inumpoints ; 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,49 +382,44 @@ FixFaceEdges =============== */ -void FixFaceEdges (face_t *f) +void +FixFaceEdges (face_t * f) { - int i, j, k; - wedge_t *w; - wvert_t *v; - vec_t t1, t2; + int i, j, k; + wedge_t *w; + wvert_t *v; + vec_t t1, t2; *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]); + // insert a new vertex here + 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++; - goto restart; + goto 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,31 +429,32 @@ restart: //============================================================================ -void tjunc_find_r (node_t *node) +void +tjunc_find_r (node_t * node) { - face_t *f; + 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; + face_t *f, *next; if (node->planenum == PLANENUM_LEAF) return; - + newlist = NULL; - - for (f=node->faces ; f ; f=next) - { + + for (f = node->faces; f; f = next) { next = f->next; FixFaceEdges (f); } @@ -487,13 +471,14 @@ tjunc =========== */ -void tjunc (node_t *headnode) +void +tjunc (node_t * headnode) { - vec3_t maxs, mins; - int i; - + vec3_t maxs, mins; + int i; + qprintf ("---- tjunc ----\n"); - + if (notjunc) return; @@ -502,21 +487,20 @@ 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); - + InitHash (mins, maxs); - + numwedges = numwverts = 0; tjunc_find_r (headnode); - + qprintf ("%i world edges %i edge points\n", numwedges, numwverts); // diff --git a/tools/qfbsp/source/writebsp.c b/tools/qfbsp/source/writebsp.c index c21239aea..b5bfd4e3f 100644 --- a/tools/qfbsp/source/writebsp.c +++ b/tools/qfbsp/source/writebsp.c @@ -35,8 +35,8 @@ #include "bsp5.h" -int headclipnode; -int firstface; +int headclipnode; +int firstface; //=========================================================================== @@ -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 ; inumplanes ; i++, dplane++) - { + int i; + dplane_t *dplane; + + for (i = 0, dplane = bsp->planes; i < bsp->numplanes; i++, dplane++) { if (p->type != dplane->type) continue; if (p->dist != dplane->dist) @@ -66,7 +66,7 @@ int FindFinalPlane (dplane_t *p) continue; return i; } - + // // new plane // @@ -75,25 +75,25 @@ int FindFinalPlane (dplane_t *p) dplane = &bsp->planes[bsp->numplanes]; *dplane = *p; bsp->numplanes++; - + return bsp->numplanes - 1; } -int planemapping[MAX_MAP_PLANES]; +int planemapping[MAX_MAP_PLANES]; -void WriteNodePlanes_r (node_t *node) +void +WriteNodePlanes_r (node_t * node) { - plane_t *plane; - dplane_t *dplane; + 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) Sys_Error ("numplanes == MAX_MAP_PLANES"); plane = &planes[node->planenum]; @@ -108,7 +108,7 @@ void WriteNodePlanes_r (node_t *node) } node->outputplanenum = planemapping[node->planenum]; - + WriteNodePlanes_r (node->children[0]); WriteNodePlanes_r (node->children[1]); } @@ -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,28 +134,27 @@ 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) - { + int i, c; + dclipnode_t *cn; + int num; + +// FIXME: free more stuff? + 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,11 +181,12 @@ void WriteClipNodes (node_t *nodes) WriteLeaf ================== */ -void WriteLeaf (node_t *node) +void +WriteLeaf (node_t * node) { - face_t **fp, *f; - dleaf_t *leaf_p; - + face_t **fp, *f; + dleaf_t *leaf_p; + // emit a leaf leaf_p = &bsp->leafs[bsp->numleafs]; bsp->numleafs++; @@ -193,31 +195,29 @@ void WriteLeaf (node_t *node) // // write bounding box info -// +// VectorCopy (node->mins, leaf_p->mins); VectorCopy (node->maxs, leaf_p->maxs); - - leaf_p->visofs = -1; // no vis info yet - + + leaf_p->visofs = -1; // no vis info yet + // // write the marksurfaces // leaf_p->firstmarksurface = bsp->nummarksurfaces; - - for (fp=node->markfaces ; *fp ; fp++) - { - // emit a marksurface + + for (fp = node->markfaces; *fp; fp++) { + // emit a marksurface if (bsp->nummarksurfaces == MAX_MAP_MARKSURFACES) Sys_Error ("nummarksurfaces == MAX_MAP_MARKSURFACES"); f = *fp; - do - { - bsp->marksurfaces[bsp->nummarksurfaces] = f->outputnumber; + 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); } - + leaf_p->nummarksurfaces = bsp->nummarksurfaces - leaf_p->firstmarksurface; } @@ -227,12 +227,13 @@ void WriteLeaf (node_t *node) WriteDrawNodes_r ================== */ -void WriteDrawNodes_r (node_t *node) +void +WriteDrawNodes_r (node_t * node) { - dnode_t *n; - int i; + dnode_t *n; + int i; -// emit a node +// emit a node if (bsp->numnodes == MAX_MAP_NODES) Sys_Error ("numnodes == MAX_MAP_NODES"); n = &bsp->nodes[bsp->numnodes]; @@ -247,23 +248,18 @@ 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 - { - n->children[i] = bsp->numnodes; + } else { + n->children[i] = bsp->numnodes; WriteDrawNodes_r (node->children[i]); } } @@ -274,11 +270,12 @@ void WriteDrawNodes_r (node_t *node) WriteDrawNodes ================== */ -void WriteDrawNodes (node_t *headnode) +void +WriteDrawNodes (node_t * headnode) { - int i; - int start; - dmodel_t *bm; + int i; + int start; + dmodel_t *bm; #if 0 if (headnode->contents < 0) @@ -290,23 +287,23 @@ void WriteDrawNodes (node_t *headnode) Sys_Error ("nummodels == MAX_MAP_MODELS"); bm = &bsp->models[bsp->nummodels]; bsp->nummodels++; - + bm->headnode[0] = bsp->numnodes; bm->firstface = firstface; - bm->numfaces = bsp->numfaces - firstface; + bm->numfaces = bsp->numfaces - firstface; firstface = bsp->numfaces; - + start = bsp->numleafs; - if (headnode->contents < 0) + if (headnode->contents < 0) WriteLeaf (headnode); else 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,57 +317,56 @@ BumpModel Used by the clipping hull processes that only need to store headclipnode ================== */ -void BumpModel (int hullnum) +void +BumpModel (int hullnum) { - dmodel_t *bm; + dmodel_t *bm; // emit a model if (bsp->nummodels == MAX_MAP_MODELS) Sys_Error ("nummodels == MAX_MAP_MODELS"); bm = &bsp->models[bsp->nummodels]; bsp->nummodels++; - + bm->headnode[hullnum] = headclipnode; } //============================================================================= -typedef struct -{ - char identification[4]; // should be WAD2 - int numlumps; - int infotableofs; +typedef struct { + char identification[4]; // should be WAD2 + int numlumps; + int infotableofs; } wadinfo_t; -typedef struct -{ - int filepos; - int disksize; - int size; // uncompressed - char type; - char compression; - char pad1, pad2; - char name[16]; // must be null terminated +typedef struct { + int filepos; + int disksize; + int size; // uncompressed + char type; + char compression; + char pad1, pad2; + char name[16]; // must be null terminated } lumpinfo_t; -QFile *texfile; -wadinfo_t wadinfo; -lumpinfo_t *lumpinfo; +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++ ) - { + int 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; - + 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)); - - for (i=0 ; itexdatasize = 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 ; idataofs[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"); if (!len) - l->dataofs[i] = -1; // didn't find the texture + l->dataofs[i] = -1; // didn't find the texture data += len; } @@ -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; @@ -534,7 +526,7 @@ void BeginBSPFile (void) bsp->numleafs = 1; bsp->leafs[0].contents = CONTENTS_SOLID; - firstface = 0; + firstface = 0; } @@ -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); } -