quakeforge/tools/qfbsp/source/tjunc.c

435 lines
8.8 KiB
C
Raw Normal View History

2002-09-19 18:51:19 +00:00
/*
Copyright (C) 1996-1997 Id Software, Inc.
2002-09-19 18:51:19 +00:00
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
2002-09-19 18:51:19 +00:00
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
2002-09-19 18:51:19 +00:00
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
2002-09-19 18:51:19 +00:00
See file, 'COPYING', for details.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
static __attribute__ ((used)) const char rcsid[] =
"$Id$";
#ifdef HAVE_STRING_H
# include <string.h>
#endif
#include "QF/sys.h"
2003-09-08 03:00:53 +00:00
#include "compat.h"
#include "brush.h"
#include "bsp5.h"
2002-09-20 21:48:34 +00:00
#include "options.h"
#include "tjunc.h"
/** \addtogroup qfbsp_tjunc
*/
//@{
2002-09-19 17:14:23 +00:00
typedef struct wvert_s {
vec_t t;
struct wvert_s *prev, *next;
} wvert_t;
2002-09-19 17:14:23 +00:00
typedef struct wedge_s {
struct wedge_s *next;
2002-09-19 17:14:23 +00:00
vec3_t dir;
vec3_t origin;
wvert_t head;
} wedge_t;
2002-09-19 17:14:23 +00:00
int numwedges, numwverts;
int tjuncs;
int tjuncfaces;
int degenerdges;
#define MAXWVERTS 0x20000
#define MAXWEDGES 0x10000
2002-09-19 17:14:23 +00:00
wvert_t wverts[MAXWVERTS];
wedge_t wedges[MAXWEDGES];
#define NUM_HASH 1024
2002-09-19 17:14:23 +00:00
wedge_t *wedge_hash[NUM_HASH];
2002-09-19 17:14:23 +00:00
static vec3_t hash_min, hash_scale;
2010-08-30 14:19:42 +00:00
/** Initialize the edge hash table.
\param mins The minimum of the bounding box in which the edges reside.
\param maxs The maximum of the bounding box in which the edges reside.
*/
2002-09-19 17:14:23 +00:00
static void
2010-09-02 04:01:45 +00:00
InitHash (const vec3_t mins, const vec3_t maxs)
{
2002-09-19 18:51:19 +00:00
int newsize[2];
2002-09-19 17:14:23 +00:00
vec3_t size;
vec_t volume;
vec_t scale;
VectorCopy (mins, hash_min);
VectorSubtract (maxs, mins, size);
2002-09-19 17:14:23 +00:00
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;
hash_scale[0] = newsize[0] / size[0];
hash_scale[1] = newsize[1] / size[1];
hash_scale[2] = newsize[1];
}
2010-08-30 14:19:42 +00:00
/** Calulate the hash value of a vector.
\param vec The vector for which to calculate the hash value.
\return The hash value of the vector.
*/
2002-09-19 17:14:23 +00:00
static unsigned
2010-09-02 04:01:45 +00:00
HashVec (const vec3_t vec)
{
2002-09-19 17:14:23 +00:00
unsigned h;
2002-09-19 17:14:23 +00:00
h = hash_scale[0] * (vec[0] - hash_min[0]) * hash_scale[2]
+ hash_scale[1] * (vec[1] - hash_min[1]);
2002-09-19 17:14:23 +00:00
if (h >= NUM_HASH)
return NUM_HASH - 1;
return h;
}
2010-08-30 14:19:42 +00:00
/** Make the vector canonical.
A canonical vector is a unit vector with the first non-zero axis
positive.
\param vec The vector to make canonical.
\return false is the vector is (0, 0, 0), otherwise true.
*/
static qboolean
2002-09-19 17:14:23 +00:00
CanonicalVector (vec3_t vec)
{
vec_t len = _VectorNormalize (vec);
if (len < EQUAL_EPSILON)
return false;
2010-08-30 07:58:40 +00:00
if (vec[0] > EQUAL_EPSILON) {
return true;
2010-08-30 07:58:40 +00:00
} else if (vec[0] < -EQUAL_EPSILON) {
VectorNegate (vec, vec);
return true;
2010-08-30 07:58:40 +00:00
} else {
vec[0] = 0;
2010-08-30 07:58:40 +00:00
}
2010-08-30 07:58:40 +00:00
if (vec[1] > EQUAL_EPSILON) {
return true;
2010-08-30 07:58:40 +00:00
} else if (vec[1] < -EQUAL_EPSILON) {
VectorNegate (vec, vec);
return true;
2010-08-30 07:58:40 +00:00
} else {
vec[1] = 0;
2010-08-30 07:58:40 +00:00
}
2002-09-19 17:14:23 +00:00
2010-08-30 07:58:40 +00:00
if (vec[2] > EQUAL_EPSILON) {
return true;
2010-08-30 07:58:40 +00:00
} else if (vec[2] < -EQUAL_EPSILON) {
VectorNegate (vec, vec);
return true;
2010-08-30 07:58:40 +00:00
} else {
vec[2] = 0;
2010-08-30 07:58:40 +00:00
}
return false;
}
2010-08-30 14:19:42 +00:00
/** Find a wedge for the two points.
A wedge is an infinitely long line passing through the two points with
an "origin" at t=0.
\param p1 The first point.
\param p2 The second point.
\param t1 The "time" of one of the points.
\param t2 The "time" of the other point.
\return Pointer to the wedge, or NULL for a degenerate edge
(zero length).
\note t2 will always be greater than t1, so there's no guarantee which
point is represented by t1 and t2.
*/
2010-08-30 07:58:40 +00:00
static wedge_t *
2010-09-02 04:01:45 +00:00
FindEdge (const vec3_t p1, const vec3_t p2, vec_t *t1, vec_t *t2)
{
2002-09-19 17:14:23 +00:00
int h;
2002-09-19 18:51:19 +00:00
vec3_t dir, origin;
vec_t temp;
wedge_t *w;
2002-09-19 17:14:23 +00:00
VectorSubtract (p2, p1, dir);
if (!CanonicalVector (dir)) {
degenerdges++;
return 0;
}
*t1 = DotProduct (p1, dir);
*t2 = DotProduct (p2, dir);
VectorMultSub (p1, *t1, dir, origin);
2002-09-19 17:14:23 +00:00
if (*t1 > *t2) {
2010-08-30 14:19:42 +00:00
// swap t1 and t2
temp = *t1;
*t1 = *t2;
*t2 = temp;
}
2002-09-19 17:14:23 +00:00
h = HashVec (origin);
2002-09-19 17:14:23 +00:00
for (w = wedge_hash[h]; w; w = w->next) {
2010-08-30 11:56:44 +00:00
if (!_VectorCompare (w->origin, origin))
continue;
2010-08-30 11:56:44 +00:00
if (!_VectorCompare (w->dir, dir))
continue;
return w;
}
2002-09-19 17:14:23 +00:00
2010-08-30 14:19:42 +00:00
// create a new wedge
if (numwedges == MAXWEDGES)
Sys_Error ("FindEdge: numwedges == MAXWEDGES");
w = &wedges[numwedges];
numwedges++;
2002-09-19 17:14:23 +00:00
w->next = wedge_hash[h];
wedge_hash[h] = w;
2002-09-19 17:14:23 +00:00
VectorCopy (origin, w->origin);
VectorCopy (dir, w->dir);
w->head.next = w->head.prev = &w->head;
w->head.t = 99999;
return w;
}
#define T_EPSILON 0.01
2010-08-30 14:19:42 +00:00
/** Add a wvert to the wedge.
A wvert is a vertex on the wedge and is specified by the time along the
wedge from the wedge's origin.
If a wvert with the same time already exists, a new one will not be added.
\param w The wedge to which the wvert will be added.
\param t The "time" of the wvert.
*/
static void
2002-09-19 18:51:19 +00:00
AddVert (wedge_t *w, vec_t t)
{
2002-09-19 17:14:23 +00:00
wvert_t *v, *newv;
v = w->head.next;
2002-09-19 17:14:23 +00:00
do {
if (fabs (v->t - t) < T_EPSILON)
return;
if (v->t > t)
break;
v = v->next;
} while (1);
2002-09-19 17:14:23 +00:00
2002-09-23 16:27:17 +00:00
// insert a new wvert before v
if (numwverts == MAXWVERTS)
Sys_Error ("AddVert: numwverts == MAXWVERTS");
newv = &wverts[numwverts];
numwverts++;
2002-09-19 17:14:23 +00:00
newv->t = t;
newv->next = v;
newv->prev = v->prev;
v->prev->next = newv;
v->prev = newv;
}
2010-08-30 14:19:42 +00:00
/** Add a faces edge to the wedge system.
\param p1 The first point of the face's edge.
\param p2 The second point of the face's edge.
*/
static void
2010-09-02 04:01:45 +00:00
AddEdge (const vec3_t p1, const vec3_t p2)
{
2002-09-19 17:14:23 +00:00
wedge_t *w;
vec_t t1, t2;
if ((w = FindEdge (p1, p2, &t1, &t2))) {
AddVert (w, t1);
AddVert (w, t2);
}
}
2010-08-30 14:19:42 +00:00
/** Add the edges from the face.
\param f The face from which to add the faces.
*/
static void
2010-09-02 04:01:45 +00:00
AddFaceEdges (const face_t *f)
{
2002-09-19 17:14:23 +00:00
int i, j;
2003-09-08 03:00:53 +00:00
for (i = 0; i < f->points->numpoints; i++) {
j = (i + 1) % f->points->numpoints;
AddEdge (f->points->points[i], f->points->points[j]);
}
}
2002-09-19 17:14:23 +00:00
face_t *newlist;
2010-08-30 14:19:42 +00:00
/** Check and fix the edges of the face.
If any vertices from other faces lie on an edge of the face between the
edge's end points, add matching vertices along that edge.
\param f The face of which the edges will be checked.
*/
static void
2002-09-19 18:51:19 +00:00
FixFaceEdges (face_t *f)
{
2002-09-19 17:14:23 +00:00
int i, j, k;
2002-09-19 18:51:19 +00:00
vec_t t1, t2;
2002-09-19 17:14:23 +00:00
wedge_t *w;
2003-09-08 03:00:53 +00:00
winding_t *fp = f->points;
2002-09-19 17:14:23 +00:00
wvert_t *v;
2002-09-19 17:14:23 +00:00
restart:
2003-09-08 03:00:53 +00:00
for (i = 0; i < fp->numpoints; i++) {
j = (i + 1) % fp->numpoints;
if (!(w = FindEdge (fp->points[i], fp->points[j], &t1, &t2)))
continue;
2002-09-19 17:14:23 +00:00
for (v = w->head.next; v->t < t1 + T_EPSILON; v = v->next) {
}
2002-09-19 17:14:23 +00:00
if (v->t < t2 - T_EPSILON) {
tjuncs++;
2002-09-19 17:14:23 +00:00
// insert a new vertex here
2003-09-08 03:00:53 +00:00
fp = realloc (fp, field_offset (winding_t,
points[fp->numpoints + 1]));
for (k = fp->numpoints; k > j; k--) {
VectorCopy (fp->points[k - 1], fp->points[k]);
}
2003-09-08 03:00:53 +00:00
VectorMultAdd (w->origin, v->t, w->dir, fp->points[j]);
fp->numpoints++;
2002-09-19 17:14:23 +00:00
goto restart;
}
}
2003-09-08 03:00:53 +00:00
f->points = fp;
2003-09-08 03:00:53 +00:00
f->next = newlist;
newlist = f;
}
static void
2002-09-19 18:51:19 +00:00
tjunc_find_r (node_t *node)
{
2002-09-19 17:14:23 +00:00
face_t *f;
if (node->planenum == PLANENUM_LEAF)
return;
2002-09-19 17:14:23 +00:00
for (f = node->faces; f; f = f->next)
if (f->texturenum >= 0)
AddFaceEdges (f);
2002-09-19 17:14:23 +00:00
tjunc_find_r (node->children[0]);
tjunc_find_r (node->children[1]);
}
2010-08-30 14:19:42 +00:00
/** Check and fix the edges from the faces in the bsp tree.
\param node The current node in the bsp tree.
*/
static void
2002-09-19 18:51:19 +00:00
tjunc_fix_r (node_t *node)
{
2002-09-19 18:51:19 +00:00
face_t *next, *f;
if (node->planenum == PLANENUM_LEAF)
return;
2002-09-19 17:14:23 +00:00
newlist = NULL;
2002-09-19 17:14:23 +00:00
for (f = node->faces; f; f = next) {
next = f->next;
if (f->texturenum < 0)
continue;
FixFaceEdges (f);
}
node->faces = newlist;
tjunc_fix_r (node->children[0]);
tjunc_fix_r (node->children[1]);
}
2002-09-19 17:14:23 +00:00
void
2002-09-19 18:51:19 +00:00
tjunc (node_t *headnode)
{
2002-09-19 17:14:23 +00:00
int i;
2002-09-19 18:51:19 +00:00
vec3_t maxs, mins;
2002-09-19 17:14:23 +00:00
qprintf ("---- tjunc ----\n");
2002-09-19 17:14:23 +00:00
2002-09-20 21:48:34 +00:00
if (options.notjunc)
return;
2010-08-30 14:19:42 +00:00
// origin points won't allways be inside the map, so extend the hash area
2002-09-19 17:14:23 +00:00
for (i = 0; i < 3; i++) {
if (fabs (brushset->maxs[i]) > fabs (brushset->mins[i]))
maxs[i] = fabs (brushset->maxs[i]);
else
2002-09-19 17:14:23 +00:00
maxs[i] = fabs (brushset->mins[i]);
}
VectorNegate (maxs, mins);
2002-09-19 17:14:23 +00:00
InitHash (mins, maxs);
2002-09-19 17:14:23 +00:00
numwedges = numwverts = 0;
2010-08-30 14:19:42 +00:00
// identify all points on common edges
tjunc_find_r (headnode);
2002-09-19 17:14:23 +00:00
qprintf ("%i world edges %i edge points\n", numwedges, numwverts);
2002-09-23 16:27:17 +00:00
// add extra vertexes on edges where needed
tjuncs = tjuncfaces = 0;
degenerdges = 0;
tjunc_fix_r (headnode);
qprintf ("%i degenerate edges\n", degenerdges);
qprintf ("%i edges added by tjunctions\n", tjuncs);
qprintf ("%i faces added by tjunctions\n", tjuncfaces);
}
//@}