mirror of
https://git.code.sf.net/p/quake/quakeforge
synced 2025-01-18 06:51:47 +00:00
whitespace cleanup and add rcsid tags
This commit is contained in:
Bill Currie
parent
6721cd05e3
commit
4bf8ac58f1
15 changed files with 308 additions and 454 deletions
|
|
@ -16,6 +16,8 @@
|
|||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
See file, 'COPYING', for details.
|
||||
|
||||
$Id$
|
||||
*/
|
||||
|
||||
// bsp5.h
|
||||
|
|
|
|||
|
|
@ -16,6 +16,8 @@
|
|||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
See file, 'COPYING', for details.
|
||||
|
||||
$Id$
|
||||
*/
|
||||
|
||||
#define MAX_FACES 128
|
||||
|
|
|
|||
|
|
@ -17,8 +17,8 @@
|
|||
|
||||
See file, 'COPYING', for details.
|
||||
*/
|
||||
|
||||
// brush.c
|
||||
static const char rcsid[] =
|
||||
"$Id$";
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
|
|
@ -43,11 +43,9 @@ mface_t faces[128]; // beveled clipping hull can generate many extra
|
|||
|
||||
|
||||
/*
|
||||
=================
|
||||
CheckFace
|
||||
|
||||
Note: this will not catch 0 area polygons
|
||||
=================
|
||||
*/
|
||||
void
|
||||
CheckFace (face_t *f)
|
||||
|
|
@ -103,8 +101,6 @@ CheckFace (face_t *f)
|
|||
}
|
||||
}
|
||||
|
||||
//===========================================================================
|
||||
|
||||
void
|
||||
ClearBounds (brushset_t *bs)
|
||||
{
|
||||
|
|
@ -130,8 +126,6 @@ AddToBounds (brushset_t *bs, vec3_t v)
|
|||
}
|
||||
}
|
||||
|
||||
//===========================================================================
|
||||
|
||||
int
|
||||
PlaneTypeForNormal (vec3_t normal)
|
||||
{
|
||||
|
|
@ -209,11 +203,9 @@ NormalizePlane (plane_t *dp)
|
|||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
FindPlane
|
||||
|
||||
Returns a global plane number and the side that will be the front
|
||||
===============
|
||||
*/
|
||||
int
|
||||
FindPlane (plane_t *dplane, int *side)
|
||||
|
|
@ -253,11 +245,9 @@ FindPlane (plane_t *dplane, int *side)
|
|||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
FindPlane_old
|
||||
|
||||
Returns a global plane number and the side that will be the front
|
||||
===============
|
||||
*/
|
||||
int
|
||||
FindPlane_old (plane_t *dplane, int *side)
|
||||
|
|
@ -286,7 +276,8 @@ FindPlane_old (plane_t *dplane, int *side)
|
|||
}
|
||||
}
|
||||
|
||||
// allocate a new plane, flipping normal to a consistant direction if needed
|
||||
// allocate a new plane, flipping normal to a consistant direction if
|
||||
// needed
|
||||
*dp = *dplane;
|
||||
|
||||
if (numbrushplanes == MAX_MAP_PLANES)
|
||||
|
|
@ -339,11 +330,7 @@ FindPlane_old (plane_t *dplane, int *side)
|
|||
}
|
||||
|
||||
/*
|
||||
=============================================================================
|
||||
|
||||
TURN BRUSHES INTO GROUPS OF FACES
|
||||
|
||||
=============================================================================
|
||||
Turn brushes into groups of faces.
|
||||
*/
|
||||
|
||||
vec3_t brush_mins, brush_maxs;
|
||||
|
|
@ -414,12 +401,10 @@ CreateBrushFaces (void)
|
|||
}
|
||||
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
BEVELED CLIPPING HULL GENERATION
|
||||
|
||||
This is done by brute force, and could easily get a lot faster if anyone cares.
|
||||
==============================================================================
|
||||
This is done by brute force, and could easily get a lot faster if anyone
|
||||
cares.
|
||||
*/
|
||||
|
||||
vec3_t hull_size[3][2] = {
|
||||
|
|
@ -463,12 +448,10 @@ AddBrushPlane (plane_t *plane)
|
|||
}
|
||||
|
||||
/*
|
||||
============
|
||||
TestAddPlane
|
||||
|
||||
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)
|
||||
|
|
@ -512,7 +495,6 @@ TestAddPlane (plane_t *plane)
|
|||
}
|
||||
|
||||
// the plane is a seperator
|
||||
|
||||
if (counts[0]) {
|
||||
VectorSubtract (vec3_origin, plane->normal, flip.normal);
|
||||
flip.dist = -plane->dist;
|
||||
|
|
@ -523,11 +505,9 @@ TestAddPlane (plane_t *plane)
|
|||
}
|
||||
|
||||
/*
|
||||
============
|
||||
AddHullPoint
|
||||
|
||||
Doesn't add if duplicated
|
||||
=============
|
||||
*/
|
||||
int
|
||||
AddHullPoint (vec3_t p, int hullnum)
|
||||
|
|
@ -561,11 +541,9 @@ AddHullPoint (vec3_t p, int hullnum)
|
|||
}
|
||||
|
||||
/*
|
||||
============
|
||||
AddHullEdge
|
||||
|
||||
Creates all of the hull planes around the given edge, if not done already
|
||||
=============
|
||||
*/
|
||||
void
|
||||
AddHullEdge (vec3_t p1, vec3_t p2, int hullnum)
|
||||
|
|
@ -663,14 +641,10 @@ ExpandBrush (int hullnum)
|
|||
AddHullEdge (f->pts[i], f->pts[(i + 1) % f->numpoints], hullnum);
|
||||
}
|
||||
|
||||
//============================================================================
|
||||
|
||||
/*
|
||||
===============
|
||||
LoadBrush
|
||||
|
||||
Converts a mapbrush to a bsp brush
|
||||
===============
|
||||
*/
|
||||
brush_t *
|
||||
LoadBrush (mbrush_t *mb, int hullnum)
|
||||
|
|
@ -684,8 +658,7 @@ LoadBrush (mbrush_t *mb, int hullnum)
|
|||
name = miptex[bsp->texinfo[mb->faces->texinfo].miptex];
|
||||
|
||||
if (!strcasecmp (name, "clip") && hullnum == 0)
|
||||
return NULL; // "clip" brushes don't show up in
|
||||
// the draw hull
|
||||
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))
|
||||
|
|
@ -700,8 +673,7 @@ LoadBrush (mbrush_t *mb, int hullnum)
|
|||
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
|
||||
|
||||
|
|
@ -739,8 +711,6 @@ LoadBrush (mbrush_t *mb, int hullnum)
|
|||
return b;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
void
|
||||
Brush_DrawAll (brushset_t *bs)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -17,8 +17,8 @@
|
|||
|
||||
See file, 'COPYING', for details.
|
||||
*/
|
||||
|
||||
// csg4.c
|
||||
static const char rcsid[] =
|
||||
"$Id$";
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include "config.h"
|
||||
|
|
@ -34,7 +34,8 @@
|
|||
/*
|
||||
NOTES
|
||||
|
||||
Brushes that touch still need to be split at the cut point to make a tjunction
|
||||
Brushes that touch still need to be split at the cut point to make a
|
||||
tjunction
|
||||
*/
|
||||
|
||||
face_t *validfaces[MAX_MAP_PLANES];
|
||||
|
|
@ -52,12 +53,10 @@ DrawList (face_t *list)
|
|||
}
|
||||
|
||||
/*
|
||||
==================
|
||||
NewFaceFromFace
|
||||
|
||||
Duplicates the non point information of a face, used by SplitFace and
|
||||
MergeFace.
|
||||
==================
|
||||
*/
|
||||
face_t *
|
||||
NewFaceFromFace (face_t *in)
|
||||
|
|
@ -170,17 +169,11 @@ 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);
|
||||
#endif
|
||||
|
||||
// free the original face now that is is represented by the fragments
|
||||
FreeFace (in);
|
||||
}
|
||||
|
||||
/*
|
||||
=================
|
||||
ClipInside
|
||||
|
||||
Clips all of the faces in the inside list, possibly moving them to the
|
||||
|
|
@ -189,7 +182,6 @@ outside list or spliting it into a piece in each list.
|
|||
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)
|
||||
|
|
@ -231,11 +223,9 @@ ClipInside (int splitplane, int frontside, qboolean precedence)
|
|||
}
|
||||
|
||||
/*
|
||||
==================
|
||||
SaveOutside
|
||||
|
||||
Saves all of the faces in the outside list to the bsp plane list
|
||||
==================
|
||||
*/
|
||||
void
|
||||
SaveOutside (qboolean mirror)
|
||||
|
|
@ -274,11 +264,9 @@ SaveOutside (qboolean mirror)
|
|||
}
|
||||
|
||||
/*
|
||||
==================
|
||||
FreeInside
|
||||
|
||||
Free all the faces that got clipped out
|
||||
==================
|
||||
*/
|
||||
void
|
||||
FreeInside (int contents)
|
||||
|
|
@ -297,15 +285,11 @@ FreeInside (int contents)
|
|||
}
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
|
||||
/*
|
||||
==================
|
||||
BuildSurfaces
|
||||
|
||||
Returns a chain of all the external surfaces with one or more visible
|
||||
faces.
|
||||
==================
|
||||
*/
|
||||
surface_t *
|
||||
BuildSurfaces (void)
|
||||
|
|
@ -336,8 +320,6 @@ BuildSurfaces (void)
|
|||
return surfhead;
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
|
||||
void
|
||||
CopyFacesToOutside (brush_t *b)
|
||||
{
|
||||
|
|
@ -347,16 +329,6 @@ CopyFacesToOutside (brush_t *b)
|
|||
|
||||
for (f = b->faces; f; f = f->next) {
|
||||
brushfaces++;
|
||||
#if 0
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < f->numpoints; i++)
|
||||
printf ("(%f,%f,%f) ", f->pts[i][0], f->pts[i][1],
|
||||
f->pts[i][2]);
|
||||
printf ("\n");
|
||||
}
|
||||
#endif
|
||||
newf = AllocFace ();
|
||||
*newf = *f;
|
||||
newf->next = outside;
|
||||
|
|
@ -367,11 +339,9 @@ CopyFacesToOutside (brush_t *b)
|
|||
}
|
||||
|
||||
/*
|
||||
==================
|
||||
CSGFaces
|
||||
|
||||
Returns a list of surfaces containing aall of the faces
|
||||
==================
|
||||
*/
|
||||
surface_t *
|
||||
CSGFaces (brushset_t *bs)
|
||||
|
|
|
|||
|
|
@ -17,8 +17,8 @@
|
|||
|
||||
See file, 'COPYING', for details.
|
||||
*/
|
||||
|
||||
// map.c
|
||||
static const char rcsid[] =
|
||||
"$Id$";
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include "config.h"
|
||||
|
|
@ -64,11 +64,9 @@ FindMiptex (char *name)
|
|||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
FindTexinfo
|
||||
|
||||
Returns a global texinfo number
|
||||
===============
|
||||
*/
|
||||
int
|
||||
FindTexinfo (texinfo_t *t)
|
||||
|
|
@ -103,8 +101,6 @@ FindTexinfo (texinfo_t *t)
|
|||
return i;
|
||||
}
|
||||
|
||||
//============================================================================
|
||||
|
||||
#define MAXTOKEN 128
|
||||
|
||||
char token[MAXTOKEN];
|
||||
|
|
@ -186,8 +182,6 @@ UngetToken ()
|
|||
unget = true;
|
||||
}
|
||||
|
||||
//============================================================================
|
||||
|
||||
entity_t *mapent;
|
||||
|
||||
void
|
||||
|
|
@ -209,8 +203,6 @@ ParseEpair (void)
|
|||
e->value = strdup (token);
|
||||
}
|
||||
|
||||
//============================================================================
|
||||
|
||||
vec3_t baseaxis[18] = {
|
||||
{0, 0, 1}, {1, 0, 0}, {0, -1, 0}, // floor
|
||||
{0, 0, -1}, {1, 0, 0}, {0, -1, 0}, // ceiling
|
||||
|
|
@ -241,8 +233,6 @@ TextureAxisFromPlane (plane_t *pln, vec3_t xv, vec3_t yv)
|
|||
VectorCopy (baseaxis[bestaxis * 3 + 2], yv);
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
void
|
||||
ParseBrush (void)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -17,8 +17,8 @@
|
|||
|
||||
See file, 'COPYING', for details.
|
||||
*/
|
||||
|
||||
// merge.c
|
||||
static const char rcsid[] =
|
||||
"$Id$";
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include "config.h"
|
||||
|
|
@ -38,8 +38,8 @@ CheckColinear (face_t *f)
|
|||
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
|
||||
// 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);
|
||||
|
|
@ -55,7 +55,6 @@ CheckColinear (face_t *f)
|
|||
}
|
||||
|
||||
/*
|
||||
=============
|
||||
TryMerge
|
||||
|
||||
If two polygons share a common edge and the edges that meet at the common
|
||||
|
|
@ -63,7 +62,6 @@ points are both inside the other polygons, merge them
|
|||
|
||||
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)
|
||||
|
|
|
|||
|
|
@ -17,6 +17,8 @@
|
|||
|
||||
See file, 'COPYING', for details.
|
||||
*/
|
||||
static const char rcsid[] =
|
||||
"$Id$";
|
||||
|
||||
#include "bsp5.h"
|
||||
|
||||
|
|
|
|||
|
|
@ -16,6 +16,8 @@
|
|||
|
||||
See file, 'COPYING', for details.
|
||||
*/
|
||||
static const char rcsid[] =
|
||||
"$Id$";
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include "config.h"
|
||||
|
|
@ -105,12 +107,10 @@ int hit_occupied;
|
|||
int backdraw;
|
||||
|
||||
/*
|
||||
==================
|
||||
RecursiveFillOutside
|
||||
|
||||
If fill is false, just check, don't fill
|
||||
Returns true if an occupied leaf is reached
|
||||
==================
|
||||
*/
|
||||
qboolean
|
||||
RecursiveFillOutside (node_t *l, qboolean fill)
|
||||
|
|
@ -144,8 +144,8 @@ RecursiveFillOutside (node_t *l, qboolean fill)
|
|||
for (p = l->portals; p;) {
|
||||
s = (p->nodes[0] == l);
|
||||
|
||||
if (RecursiveFillOutside (p->nodes[s], fill)) { // leaked, so stop
|
||||
// filling
|
||||
if (RecursiveFillOutside (p->nodes[s], fill)) {
|
||||
// leaked, so stop filling
|
||||
if (backdraw-- > 0) {
|
||||
MarkLeakTrail (p);
|
||||
DrawLeaf (l, 2);
|
||||
|
|
@ -178,8 +178,6 @@ ClearOutFaces (node_t *node)
|
|||
node->faces = NULL;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
qboolean
|
||||
FillOutside (node_t *node)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -17,6 +17,8 @@
|
|||
|
||||
See file, 'COPYING', for details.
|
||||
*/
|
||||
static const char rcsid[] =
|
||||
"$Id$";
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include "config.h"
|
||||
|
|
@ -80,8 +82,6 @@ RemovePortalFromNode (portal_t *portal, node_t *l)
|
|||
}
|
||||
}
|
||||
|
||||
//============================================================================
|
||||
|
||||
void
|
||||
PrintPortal (portal_t *p)
|
||||
{
|
||||
|
|
@ -95,11 +95,9 @@ PrintPortal (portal_t *p)
|
|||
}
|
||||
|
||||
/*
|
||||
================
|
||||
MakeHeadnodePortals
|
||||
|
||||
The created portals will face the global outside_node
|
||||
================
|
||||
*/
|
||||
void
|
||||
MakeHeadnodePortals (node_t *node)
|
||||
|
|
@ -270,13 +268,13 @@ CutNodePortals_r (node_t *node)
|
|||
f = node->children[0];
|
||||
b = node->children[1];
|
||||
|
||||
// create the new portal by taking the full plane winding for the cutting plane
|
||||
// and clipping it by all of the planes from the other portals
|
||||
// create the new portal by taking the full plane winding for the cutting
|
||||
// plane and clipping it by all of the planes from the other portals
|
||||
new_portal = AllocPortal ();
|
||||
new_portal->planenum = node->planenum;
|
||||
|
||||
w = BaseWindingForPlane (&planes[node->planenum]);
|
||||
side = 0; // shut up compiler warning
|
||||
side = 0;
|
||||
for (p = node->portals; p; p = p->next[side]) {
|
||||
clipplane = planes[p->planenum];
|
||||
if (p->nodes[0] == node)
|
||||
|
|
@ -356,11 +354,9 @@ CutNodePortals_r (node_t *node)
|
|||
}
|
||||
|
||||
/*
|
||||
==================
|
||||
PortalizeWorld
|
||||
|
||||
Builds the exact polyhedrons for the nodes and leafs
|
||||
==================
|
||||
*/
|
||||
void
|
||||
PortalizeWorld (node_t *headnode)
|
||||
|
|
@ -393,7 +389,7 @@ FreeAllPortals (node_t *node)
|
|||
}
|
||||
}
|
||||
|
||||
// PORTAL FILE GENERATION =====================================================
|
||||
// PORTAL FILE GENERATION
|
||||
|
||||
#define PORTALFILE "PRT1"
|
||||
|
||||
|
|
@ -467,7 +463,8 @@ NumberLeafs_r (node_t *node)
|
|||
{
|
||||
portal_t *p;
|
||||
|
||||
if (!node->contents) { // decision node
|
||||
if (!node->contents) {
|
||||
// decision node
|
||||
node->visleafnum = -99;
|
||||
NumberLeafs_r (node->children[0]);
|
||||
NumberLeafs_r (node->children[1]);
|
||||
|
|
@ -477,8 +474,8 @@ NumberLeafs_r (node_t *node)
|
|||
Draw_ClearWindow ();
|
||||
DrawLeaf (node, 1);
|
||||
|
||||
if (node->contents == CONTENTS_SOLID) { // solid block, viewpoint never
|
||||
// inside
|
||||
if (node->contents == CONTENTS_SOLID) {
|
||||
// solid block, viewpoint never inside
|
||||
node->visleafnum = -1;
|
||||
return;
|
||||
}
|
||||
|
|
@ -486,8 +483,8 @@ NumberLeafs_r (node_t *node)
|
|||
node->visleafnum = num_visleafs++;
|
||||
|
||||
for (p = node->portals; p;) {
|
||||
if (p->nodes[0] == node) // only write out from first leaf
|
||||
{
|
||||
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];
|
||||
|
|
@ -499,7 +496,8 @@ NumberLeafs_r (node_t *node)
|
|||
void
|
||||
WritePortalfile (node_t *headnode)
|
||||
{
|
||||
// set the visleafnum field in every leaf and count the total number of portals
|
||||
// set the visleafnum field in every leaf and count the total number of
|
||||
// portals
|
||||
num_visleafs = 0;
|
||||
num_visportals = 0;
|
||||
NumberLeafs_r (headnode);
|
||||
|
|
|
|||
|
|
@ -17,8 +17,8 @@
|
|||
|
||||
See file, 'COPYING', for details.
|
||||
*/
|
||||
|
||||
// bsp5.c
|
||||
static const char rcsid[] =
|
||||
"$Id$";
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include "config.h"
|
||||
|
|
@ -43,6 +43,10 @@ bsp_t *bsp;
|
|||
|
||||
brushset_t *brushset;
|
||||
|
||||
int c_activefaces, c_peakfaces;
|
||||
int c_activesurfaces, c_peaksurfaces;
|
||||
int c_activewindings, c_peakwindings;
|
||||
int c_activeportals, c_peakportals;
|
||||
int valid;
|
||||
|
||||
char *argv0; // changed after fork();
|
||||
|
|
@ -141,27 +145,21 @@ CopyWinding (winding_t *w)
|
|||
return c;
|
||||
}
|
||||
|
||||
/*
|
||||
==================
|
||||
CheckWinding
|
||||
|
||||
Check for possible errors
|
||||
==================
|
||||
*/
|
||||
void
|
||||
CheckWinding (winding_t * w)
|
||||
{
|
||||
}
|
||||
|
||||
/*
|
||||
==================
|
||||
ClipWinding
|
||||
|
||||
Clips the winding to the plane, returning the new winding on the positive side
|
||||
Clips the winding to the plane, returning the new winding on the positive
|
||||
side.
|
||||
|
||||
Frees the input winding.
|
||||
|
||||
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)
|
||||
|
|
@ -252,14 +250,12 @@ ClipWinding (winding_t *in, plane_t *split, qboolean keepon)
|
|||
}
|
||||
|
||||
/*
|
||||
==================
|
||||
DivideWinding
|
||||
|
||||
Divides a winding by a plane, producing one or two windings. The
|
||||
original winding is not damaged or freed. If only on one side, the
|
||||
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,
|
||||
|
|
@ -357,14 +353,6 @@ DivideWinding (winding_t *in, plane_t *split, winding_t **front,
|
|||
Sys_Error ("ClipWinding: points exceeded estimate");
|
||||
}
|
||||
|
||||
|
||||
//===========================================================================
|
||||
|
||||
int c_activefaces, c_peakfaces;
|
||||
int c_activesurfaces, c_peaksurfaces;
|
||||
int c_activewindings, c_peakwindings;
|
||||
int c_activeportals, c_peakportals;
|
||||
|
||||
void
|
||||
PrintMemory (void)
|
||||
{
|
||||
|
|
@ -421,7 +409,6 @@ void
|
|||
FreeFace (face_t *f)
|
||||
{
|
||||
c_activefaces--;
|
||||
// memset (f, 0xff, sizeof (face_t));
|
||||
free (f);
|
||||
}
|
||||
|
||||
|
|
@ -491,8 +478,6 @@ AllocBrush (void)
|
|||
return b;
|
||||
}
|
||||
|
||||
//===========================================================================
|
||||
|
||||
void
|
||||
ProcessEntity (int entnum)
|
||||
{
|
||||
|
|
@ -617,11 +602,9 @@ UpdateEntLump (void)
|
|||
}
|
||||
|
||||
/*
|
||||
=================
|
||||
WriteClipHull
|
||||
|
||||
Write the clipping hull out to a text file so the parent process can get it
|
||||
=================
|
||||
*/
|
||||
void
|
||||
WriteClipHull (void)
|
||||
|
|
@ -660,11 +643,9 @@ WriteClipHull (void)
|
|||
}
|
||||
|
||||
/*
|
||||
=================
|
||||
ReadClipHull
|
||||
|
||||
Read the files written out by the child processes
|
||||
=================
|
||||
*/
|
||||
void
|
||||
ReadClipHull (int hullnum)
|
||||
|
|
@ -809,7 +790,6 @@ void
|
|||
ProcessFile ()
|
||||
{
|
||||
// create filenames
|
||||
|
||||
COM_StripExtension (options.bspfile, options.hullfile);
|
||||
strcat (options.hullfile, ".h0");
|
||||
|
||||
|
|
@ -857,8 +837,6 @@ main (int argc, char **argv)
|
|||
char destname[1024];
|
||||
double start, end;
|
||||
|
||||
// malloc_debug (15);
|
||||
|
||||
// check command line flags
|
||||
DecodeArgs (argc, argv);
|
||||
|
||||
|
|
|
|||
|
|
@ -17,8 +17,8 @@
|
|||
|
||||
See file, 'COPYING', for details.
|
||||
*/
|
||||
|
||||
// region.h
|
||||
static const char rcsid[] =
|
||||
"$Id$";
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include "config.h"
|
||||
|
|
@ -222,12 +222,10 @@ FindEdgeUse (int v)
|
|||
int edgemapping[MAX_MAP_EDGES];
|
||||
|
||||
/*
|
||||
================
|
||||
HealEdges
|
||||
|
||||
Extends e1 so that it goes all the way to e2, and removes all references
|
||||
to e2
|
||||
================
|
||||
*/
|
||||
void
|
||||
HealEdges (int e1, int e2)
|
||||
|
|
@ -384,8 +382,6 @@ CountRealNumbers (void)
|
|||
qprintf ("%5i real edges\n", c);
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
void
|
||||
GrowNodeRegion_r (node_t * node)
|
||||
{
|
||||
|
|
@ -450,7 +446,6 @@ GrowNodeRegions (node_t *headnode)
|
|||
}
|
||||
|
||||
/*
|
||||
===============================================================================
|
||||
Turn the faces on a plane into optimal non-convex regions
|
||||
The edges may still be split later as a result of tjunctions
|
||||
|
||||
|
|
|
|||
|
|
@ -17,8 +17,8 @@
|
|||
|
||||
See file, 'COPYING', for details.
|
||||
*/
|
||||
|
||||
// solidbsp.c
|
||||
static const char rcsid[] =
|
||||
"$Id$";
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include "config.h"
|
||||
|
|
@ -39,11 +39,9 @@ qboolean usemidsplit;
|
|||
|
||||
|
||||
/*
|
||||
==================
|
||||
FaceSide
|
||||
|
||||
For BSP hueristic
|
||||
==================
|
||||
*/
|
||||
int
|
||||
FaceSide (face_t *in, plane_t *split)
|
||||
|
|
@ -92,11 +90,9 @@ FaceSide (face_t *in, plane_t *split)
|
|||
}
|
||||
|
||||
/*
|
||||
==================
|
||||
ChooseMidPlaneFromList
|
||||
|
||||
The clipping hull BSP doesn't worry about avoiding splits
|
||||
==================
|
||||
*/
|
||||
surface_t *
|
||||
ChooseMidPlaneFromList (surface_t *surfaces, vec3_t mins, vec3_t maxs)
|
||||
|
|
@ -152,11 +148,9 @@ ChooseMidPlaneFromList (surface_t *surfaces, vec3_t mins, vec3_t maxs)
|
|||
}
|
||||
|
||||
/*
|
||||
==================
|
||||
ChoosePlaneFromList
|
||||
|
||||
The real BSP hueristic
|
||||
==================
|
||||
*/
|
||||
surface_t *
|
||||
ChoosePlaneFromList (surface_t *surfaces, vec3_t mins, vec3_t maxs,
|
||||
|
|
@ -238,12 +232,10 @@ ChoosePlaneFromList (surface_t *surfaces, vec3_t mins, vec3_t maxs,
|
|||
}
|
||||
|
||||
/*
|
||||
==================
|
||||
SelectPartition
|
||||
|
||||
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)
|
||||
|
|
@ -296,11 +288,9 @@ SelectPartition (surface_t *surfaces)
|
|||
//============================================================================
|
||||
|
||||
/*
|
||||
=================
|
||||
CalcSurfaceInfo
|
||||
|
||||
Calculates the bounding box
|
||||
=================
|
||||
*/
|
||||
void
|
||||
CalcSurfaceInfo (surface_t * surf)
|
||||
|
|
@ -345,8 +335,8 @@ DividePlane (surface_t *in, plane_t *split, surface_t **front,
|
|||
// parallel case is easy
|
||||
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;
|
||||
|
||||
|
|
@ -449,12 +439,10 @@ DivideNodeBounds (node_t *node, plane_t *split)
|
|||
}
|
||||
|
||||
/*
|
||||
==================
|
||||
LinkConvexFaces
|
||||
|
||||
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)
|
||||
|
|
@ -516,11 +504,9 @@ LinkConvexFaces (surface_t *planelist, node_t *leafnode)
|
|||
}
|
||||
|
||||
/*
|
||||
==================
|
||||
LinkNodeFaces
|
||||
|
||||
Returns a duplicated list of all faces on surface
|
||||
==================
|
||||
*/
|
||||
face_t *
|
||||
LinkNodeFaces (surface_t *surface)
|
||||
|
|
@ -578,7 +564,8 @@ PartitionSurfaces (surface_t *surfaces, node_t *node)
|
|||
|
||||
DivideNodeBounds (node, splitplane);
|
||||
|
||||
// multiple surfaces, so split all the polysurfaces into front and back lists
|
||||
// multiple surfaces, so split all the polysurfaces into front and back
|
||||
// lists
|
||||
frontlist = NULL;
|
||||
backlist = NULL;
|
||||
|
||||
|
|
|
|||
|
|
@ -17,8 +17,8 @@
|
|||
|
||||
See file, 'COPYING', for details.
|
||||
*/
|
||||
|
||||
// divide.h
|
||||
static const char rcsid[] =
|
||||
"$Id$";
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include "config.h"
|
||||
|
|
@ -44,12 +44,10 @@ int subdivides;
|
|||
|
||||
|
||||
/*
|
||||
===============
|
||||
SubdivideFace
|
||||
|
||||
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)
|
||||
|
|
@ -130,12 +128,10 @@ SubdivideFaces (surface_t *surfhead)
|
|||
}
|
||||
|
||||
/*
|
||||
=============================================================================
|
||||
GatherNodeFaces
|
||||
|
||||
Frees the current node tree and returns a new chain of the surfaces that
|
||||
have inside faces.
|
||||
=============================================================================
|
||||
*/
|
||||
void
|
||||
GatherNodeFaces_r (node_t *node)
|
||||
|
|
@ -309,11 +305,9 @@ GetVertex (vec3_t in, int planenum)
|
|||
int c_tryedges;
|
||||
|
||||
/*
|
||||
==================
|
||||
GetEdge
|
||||
|
||||
Don't allow four way edges
|
||||
==================
|
||||
*/
|
||||
int
|
||||
GetEdge (vec3_t p1, vec3_t p2, face_t *f)
|
||||
|
|
@ -361,12 +355,6 @@ FindFaceEdges (face_t *face)
|
|||
(face->pts[i], face->pts[(i + 1) % face->numpoints], face);
|
||||
}
|
||||
|
||||
/*
|
||||
=============
|
||||
CheckVertexes
|
||||
// debugging
|
||||
=============
|
||||
*/
|
||||
void
|
||||
CheckVertexes (void)
|
||||
{
|
||||
|
|
@ -394,12 +382,6 @@ CheckVertexes (void)
|
|||
qprintf ("%5i 6+ edge points\n", c3);
|
||||
}
|
||||
|
||||
/*
|
||||
=============
|
||||
CheckEdges
|
||||
// debugging
|
||||
=============
|
||||
*/
|
||||
void
|
||||
CheckEdges (void)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -17,8 +17,8 @@
|
|||
|
||||
See file, 'COPYING', for details.
|
||||
*/
|
||||
|
||||
// tjunc.c
|
||||
static const char rcsid[] =
|
||||
"$Id$";
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include "config.h"
|
||||
|
|
@ -65,8 +65,6 @@ PrintFace (face_t *f)
|
|||
f->pts[i][2]);
|
||||
}
|
||||
|
||||
//============================================================================
|
||||
|
||||
#define NUM_HASH 1024
|
||||
|
||||
wedge_t *wedge_hash[NUM_HASH];
|
||||
|
|
@ -109,8 +107,6 @@ HashVec (vec3_t vec)
|
|||
return h;
|
||||
}
|
||||
|
||||
//============================================================================
|
||||
|
||||
void
|
||||
CanonicalVector (vec3_t vec)
|
||||
{
|
||||
|
|
@ -256,8 +252,6 @@ 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;
|
||||
|
|
@ -276,9 +270,9 @@ SplitFaceForTjunc (face_t *f, face_t *original)
|
|||
|
||||
chain = NULL;
|
||||
do {
|
||||
if (f->numpoints <= MAXPOINTS) { // the face is now small enough
|
||||
// without more cutting
|
||||
// so copy it back to the original
|
||||
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;
|
||||
original->next = newlist;
|
||||
|
|
|
|||
|
|
@ -17,6 +17,8 @@
|
|||
|
||||
See file, 'COPYING', for details.
|
||||
*/
|
||||
static const char rcsid[] =
|
||||
"$Id$";
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
# include "config.h"
|
||||
|
|
@ -43,11 +45,9 @@ int firstface;
|
|||
|
||||
|
||||
/*
|
||||
==================
|
||||
FindFinalPlane
|
||||
|
||||
Used to find plane index numbers for clip nodes read from child processes
|
||||
==================
|
||||
*/
|
||||
int
|
||||
FindFinalPlane (dplane_t *p)
|
||||
|
|
@ -113,8 +113,6 @@ WriteNodePlanes (node_t *nodes)
|
|||
WriteNodePlanes_r (nodes);
|
||||
}
|
||||
|
||||
//===========================================================================
|
||||
|
||||
int
|
||||
WriteClipNodes_r (node_t *node)
|
||||
{
|
||||
|
|
@ -139,12 +137,10 @@ WriteClipNodes_r (node_t *node)
|
|||
}
|
||||
|
||||
/*
|
||||
==================
|
||||
WriteClipNodes
|
||||
|
||||
Called after the clipping hull is completed. Generates a disk format
|
||||
representation and frees the original memory.
|
||||
==================
|
||||
*/
|
||||
void
|
||||
WriteClipNodes (node_t *nodes)
|
||||
|
|
@ -153,8 +149,6 @@ WriteClipNodes (node_t *nodes)
|
|||
WriteClipNodes_r (nodes);
|
||||
}
|
||||
|
||||
//===========================================================================
|
||||
|
||||
void
|
||||
WriteLeaf (node_t *node)
|
||||
{
|
||||
|
|
@ -263,11 +257,9 @@ WriteDrawNodes (node_t *headnode)
|
|||
}
|
||||
|
||||
/*
|
||||
==================
|
||||
BumpModel
|
||||
|
||||
Used by the clipping hull processes that only need to store headclipnode
|
||||
==================
|
||||
*/
|
||||
void
|
||||
BumpModel (int hullnum)
|
||||
|
|
@ -279,8 +271,6 @@ BumpModel (int hullnum)
|
|||
BSP_AddModel (bsp, &bm);
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
|
||||
typedef struct {
|
||||
char identification[4]; // should be WAD2
|
||||
int numlumps;
|
||||
|
|
@ -496,8 +486,6 @@ WriteMiptex (void)
|
|||
BSP_AddTextures (bsp, data->str, data->size);
|
||||
}
|
||||
|
||||
//===========================================================================
|
||||
|
||||
void
|
||||
BeginBSPFile (void)
|
||||
{
|
||||
|
|
|
|||
Loading…
Reference in a new issue