olegpz
/
ericw-tools
mirror of https://github.com/ericwa/ericw-tools.git
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
ericw-tools/qbsp/tjunc.c

505 lines
10 KiB
C
Raw Blame History

/*
Copyright (C) 1996-1997 Id Software, Inc.
Copyright (C) 1997 Greg Lewis
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.
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.
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
See file, 'COPYING', for details.
*/
// tjunc.c
#include "qbsp.h"
static int numwedges, numwverts;
static int tjuncs;
static int tjuncfaces;
static int cWVerts;
static int cWEdges;
static wvert_t *pWVerts;
static wedge_t *pWEdges;
//============================================================================
#define NUM_HASH 1024
static wedge_t *wedge_hash[NUM_HASH];
static vec3_t hash_min, hash_scale;
static void
InitHash(vec3_t mins, vec3_t maxs)
{
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);
newsize[0] = (int)(size[0] / scale);
newsize[1] = (int)(size[1] / scale);
hash_scale[0] = newsize[0] / size[0];
hash_scale[1] = newsize[1] / size[1];
hash_scale[2] = (vec_t)newsize[1];
}
static unsigned
HashVec(vec3_t vec)
{
unsigned h;
h = (unsigned)(hash_scale[0] * (vec[0] - hash_min[0]) * hash_scale[2] +
hash_scale[1] * (vec[1] - hash_min[1]));
if (h >= NUM_HASH)
return NUM_HASH - 1;
return h;
}
//============================================================================
static void
CanonicalVector(vec3_t vec)
{
VectorNormalize(vec);
if (vec[0] > EQUAL_EPSILON)
return;
else if (vec[0] < -EQUAL_EPSILON) {
VectorSubtract(vec3_origin, vec, vec);
return;
} else
vec[0] = 0;
if (vec[1] > EQUAL_EPSILON)
return;
else if (vec[1] < -EQUAL_EPSILON) {
VectorSubtract(vec3_origin, vec, vec);
return;
} else
vec[1] = 0;
if (vec[2] > EQUAL_EPSILON)
return;
else if (vec[2] < -EQUAL_EPSILON) {
VectorSubtract(vec3_origin, vec, vec);
return;
} else
vec[2] = 0;
Message(msgError, errDegenerateEdge, vec[0], vec[1], vec[2]);
}
static 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;
VectorSubtract(p2, p1, dir);
CanonicalVector(dir);
*t1 = DotProduct(p1, dir);
*t2 = DotProduct(p2, dir);
VectorMA(p1, -*t1, dir, origin);
if (*t1 > *t2) {
temp = *t1;
*t1 = *t2;
*t2 = temp;
}
h = HashVec(origin);
for (w = wedge_hash[h]; w; w = w->next) {
temp = w->origin[0] - origin[0];
if (temp < -EQUAL_EPSILON || temp > EQUAL_EPSILON)
continue;
temp = w->origin[1] - origin[1];
if (temp < -EQUAL_EPSILON || temp > EQUAL_EPSILON)
continue;
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;
temp = w->dir[1] - dir[1];
if (temp < -EQUAL_EPSILON || temp > EQUAL_EPSILON)
continue;
temp = w->dir[2] - dir[2];
if (temp < -EQUAL_EPSILON || temp > EQUAL_EPSILON)
continue;
return w;
}
if (numwedges >= cWEdges)
Message(msgError, errLowWedgeCount);
w = pWEdges + 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;
w->head.t = 99999;
return w;
}
/*
===============
AddVert
===============
*/
#define T_EPSILON 0.01
static void
AddVert(wedge_t *w, vec_t t)
{
wvert_t *v, *newv;
v = w->head.next;
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 >= cWVerts)
Message(msgError, errLowWvertCount);
newv = pWVerts + numwverts;
numwverts++;
newv->t = t;
newv->next = v;
newv->prev = v->prev;
v->prev->next = newv;
v->prev = newv;
}
/*
===============
AddEdge
===============
*/
static void
AddEdge(vec3_t p1, vec3_t p2)
{
wedge_t *w;
vec_t t1, t2;
w = FindEdge(p1, p2, &t1, &t2);
AddVert(w, t1);
AddVert(w, t2);
}
/*
===============
AddFaceEdges
===============
*/
static 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]);
}
}
//============================================================================
// a specially allocated face that can hold hundreds of edges if needed
static byte superfacebuf[8192];
static face_t *superface = (face_t *)superfacebuf;
static face_t *newlist;
static void
SplitFaceForTjunc(face_t *f, face_t *original)
{
int i;
face_t *newf, *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
// so copy it back to the original
*original = *f;
original->original = chain;
original->next = newlist;
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);
VectorNormalize(test);
v = DotProduct(test, dir);
if (v < 0.9999 || v > 1.00001) {
break;
}
}
// 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(test);
v = DotProduct(test, dir);
if (v < 0.9999 || v > 1.00001) {
break;
}
}
if (firstcorner + 2 >= MAXPOINTS) {
// rotate the point winding
VectorCopy(f->pts[0], test);
for (i = 1; i < f->numpoints; i++) {
VectorCopy(f->pts[i], f->pts[i - 1]);
}
VectorCopy(test, f->pts[f->numpoints - 1]);
goto restart;
}
// cut off as big a piece as possible, less than MAXPOINTS, and not
// past lastcorner
newf = NewFaceFromFace(f);
if (f->original)
Message(msgError, errOriginalExists);
newf->original = chain;
chain = newf;
newf->next = newlist;
newlist = newf;
if (f->numpoints - firstcorner <= MAXPOINTS)
newf->numpoints = firstcorner + 2;
else if (lastcorner + 2 < MAXPOINTS &&
f->numpoints - lastcorner <= MAXPOINTS)
newf->numpoints = lastcorner + 2;
else
newf->numpoints = MAXPOINTS;
for (i = 0; i < newf->numpoints; i++) {
VectorCopy(f->pts[i], newf->pts[i]);
}
for (i = newf->numpoints - 1; i < f->numpoints; i++) {
VectorCopy(f->pts[i], f->pts[i - (newf->numpoints - 2)]);
}
f->numpoints -= (newf->numpoints - 2);
} while (1);
}
/*
===============
FixFaceEdges
===============
*/
static void
FixFaceEdges(face_t *f)
{
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;
w = FindEdge(superface->pts[i], superface->pts[j], &t1, &t2);
for (v = w->head.next; v->t < t1 + T_EPSILON; v = v->next) {
}
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]);
}
VectorMA(w->origin, v->t, w->dir, superface->pts[j]);
superface->numpoints++;
goto restart;
}
}
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);
}
//============================================================================
static void
tjunc_count_r(node_t *node)
{
face_t *f;
if (node->planenum == PLANENUM_LEAF)
return;
for (f = node->faces; f; f = f->next)
cWVerts += f->numpoints;
tjunc_count_r(node->children[0]);
tjunc_count_r(node->children[1]);
}
static void
tjunc_find_r(node_t *node)
{
face_t *f;
if (node->planenum == PLANENUM_LEAF)
return;
for (f = node->faces; f; f = f->next)
AddFaceEdges(f);
tjunc_find_r(node->children[0]);
tjunc_find_r(node->children[1]);
}
static void
tjunc_fix_r(node_t *node)
{
face_t *f, *next;
if (node->planenum == PLANENUM_LEAF)
return;
newlist = NULL;
for (f = node->faces; f; f = next) {
next = f->next;
FixFaceEdges(f);
}
node->faces = newlist;
tjunc_fix_r(node->children[0]);
tjunc_fix_r(node->children[1]);
}
/*
===========
tjunc
===========
*/
void
tjunc(node_t *headnode)
{
vec3_t maxs, mins;
int i;
Message(msgProgress, "Tjunc");
// Guess edges = 1/2 verts
// Verts are arbitrarily multiplied by 2 because there appears to
// be a need for them to "grow" slightly.
cWVerts = 0;
tjunc_count_r(headnode);
cWEdges = cWVerts;
cWVerts *= 2;
pWVerts = AllocMem(WVERT, cWVerts, true);
pWEdges = AllocMem(WEDGE, cWEdges, true);
// identify all points on common edges
// origin points won't allways be inside the map, so extend the hash area
for (i = 0; i < 3; i++) {
if (fabs(pCurEnt->maxs[i]) > fabs(pCurEnt->mins[i]))
maxs[i] = fabs(pCurEnt->maxs[i]);
else
maxs[i] = fabs(pCurEnt->mins[i]);
}
VectorSubtract(vec3_origin, maxs, mins);
InitHash(mins, maxs);
numwedges = numwverts = 0;
tjunc_find_r(headnode);
Message(msgStat, "%5i world edges", numwedges);
Message(msgStat, "%5i edge points", numwverts);
// add extra vertexes on edges where needed
tjuncs = tjuncfaces = 0;
tjunc_fix_r(headnode);
FreeMem(pWVerts, WVERT, cWVerts);
FreeMem(pWEdges, WEDGE, cWEdges);
Message(msgStat, "%5i edges added by tjunctions", tjuncs);
Message(msgStat, "%5i faces added by tjunctions", tjuncfaces);
}
Reference in New Issue View Git Blame Copy Permalink