quakeforge/tools/qfbsp/source/outside.c

383 lines
8.3 KiB
C
Raw Normal View History

/* Copyright (C) 1996-1997 Id Software, Inc.
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.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "QF/sys.h"
#include "tools/qfbsp/include/brush.h"
#include "tools/qfbsp/include/bsp5.h"
#include "tools/qfbsp/include/draw.h"
#include "tools/qfbsp/include/options.h"
#include "tools/qfbsp/include/portals.h"
#include "tools/qfbsp/include/outside.h"
/** \addtogroup qfbsp_outside
*/
//@{
2002-09-19 17:14:23 +00:00
int outleafs;
2010-08-30 03:04:45 +00:00
/** Find the leaf node in which the point is.
\param node The root of the bsp tree.
\param point The point's location.
\return The leaf node in which the point is.
*/
static __attribute__((pure)) node_t *
2010-09-02 04:01:45 +00:00
PointInLeaf (node_t *node, const vec3_t point)
{
2002-09-19 17:14:23 +00:00
vec_t d;
while (!node->contents) {
d = DotProduct (planes.a[node->planenum].normal, point);
node = node->children[d <= planes.a[node->planenum].dist];
}
return node;
}
2010-08-30 03:04:45 +00:00
/** Set the distance to a node from all reachable nodes.
2010-09-01 01:06:01 +00:00
\param n The current node.
\param dist The distance to the original node.
2010-08-30 03:04:45 +00:00
*/
static void
FloodEntDist_r (node_t *n, int dist)
{
portal_t *p;
int s;
n->o_dist = dist;
for (p = n->portals; p; p = p->next[s]) {
s = (p->nodes[1] == n);
if (p->nodes[!s]->o_dist)
continue;
if ((p->nodes[0]->contents == CONTENTS_SOLID) ||
(p->nodes[1]->contents == CONTENTS_SOLID))
continue;
if ((p->nodes[0]->contents == CONTENTS_SKY) ||
(p->nodes[1]->contents == CONTENTS_SKY))
continue;
FloodEntDist_r (p->nodes[!s], dist + 1);
}
}
2010-08-30 03:04:45 +00:00
/** Try to place an entity in the map.
The entity must be in open space.
\param num The entity number.
\param point The entity's origin.
\param headnode The root of the map's bsp tree.
\return true if the entity could be placed, false otherwise.
*/
static qboolean
2010-09-02 04:01:45 +00:00
PlaceOccupant (int num, const vec3_t point, node_t *headnode)
{
2002-09-19 17:14:23 +00:00
node_t *n;
n = PointInLeaf (headnode, point);
if (n->contents == CONTENTS_SOLID)
return false;
n->occupied = num;
FloodEntDist_r (n, 1);
return true;
}
2010-09-02 04:01:45 +00:00
const portal_t *prevleaknode;
2002-09-19 17:14:23 +00:00
FILE *leakfile;
2002-09-19 18:51:19 +00:00
static void
write_points (const vec3_t p1, const vec3_t p2)
{
vec3_t p, dir;
float len;
VectorSubtract (p2, p1, dir);
len = VectorLength (dir);
_VectorNormalize (dir);
VectorCopy (p1, p);
while (len > 2) {
fprintf (leakfile, "%f %f %f\n", p[0], p[1], p[2]);
VectorMultAdd(p, 2, dir, p);
len -= 2;
}
}
2010-08-30 03:04:45 +00:00
/** Write the coords for points joining two portals to the point file.
\param n2 The second portal.
\note The first portal is set by the preceeding call.
*/
static void
2010-09-02 04:01:45 +00:00
MarkLeakTrail (const portal_t *n2)
{
int i;
2010-09-02 04:01:45 +00:00
const portal_t *n1;
vec3_t p1, p2;
n1 = prevleaknode;
prevleaknode = n2;
2002-09-19 17:14:23 +00:00
if (!n1)
return;
2002-09-19 17:14:23 +00:00
VectorZero (p1);
for (i = 0; i < n1->winding->numpoints; i++)
VectorAdd (p1, n1->winding->points[i], p1);
VectorScale (p1, 1.0 / i, p1);
2002-09-19 17:14:23 +00:00
VectorZero (p2);
for (i = 0; i < n2->winding->numpoints; i++)
VectorAdd (p2, n2->winding->points[i], p2);
VectorScale (p2, 1.0 / i, p2);
2002-09-19 17:14:23 +00:00
if (!leakfile)
leakfile = fopen (options.pointfile, "w");
if (!leakfile)
Sys_Error ("Couldn't open %s\n", options.pointfile);
write_points (p1, p2);
}
2010-09-01 01:06:01 +00:00
/** Mark the trail from outside to the entity.
Try to use the shortest path from the outside node to the entity.
*/
static void
MarkLeakTrail2 (void)
{
int i, first;
int next, side;
2010-09-02 04:01:45 +00:00
const node_t *n, *nextnode;
const portal_t *p, *p2;
vec3_t wc, pwc;
2010-09-02 04:01:45 +00:00
const vec_t *v;
VectorZero (wc);
leakfile = fopen (options.pointfile, "w");
if (!leakfile)
Sys_Error ("Couldn't open %s\n", options.pointfile);
n = &outside_node;
next = -1;
first = 1;
while ((n->o_dist > 1) || (next == -1)) {
nextnode = 0;
p2 = 0;
for (p = n->portals; p; p = p->next[side]) {
side = (p->nodes[1] == n);
if ((next == -1)
|| ((p->nodes[!side]->o_dist < next)
&& p->nodes[!side]->o_dist)) {
nextnode = p->nodes[!side];
next = nextnode->o_dist;
p2 = p;
}
}
if (!nextnode)
break;
n = nextnode;
VectorZero (wc);
for (i = 0; i < p2->winding->numpoints; i++)
VectorAdd (wc, p2->winding->points[i], wc);
VectorScale (wc, 1.0 / i, wc);
if (!first)
write_points(pwc, wc);
first = 0;
VectorCopy(wc, pwc);
}
v = entities[n->occupied].origin;
write_points(wc, v);
fclose (leakfile);
}
2002-09-19 18:51:19 +00:00
int hit_occupied;
2010-08-30 03:04:45 +00:00
/** Recurse through the map setting the outside nodes to solid.
Recursively traverses the portals of the start node.
2010-08-30 03:04:45 +00:00
\param l The start node.
\param fill If false, just check, don't fill
\return \c true if an occupied leaf is reached, otherwise
\c false.
*/
static qboolean
2002-09-19 18:51:19 +00:00
RecursiveFillOutside (node_t *l, qboolean fill)
{
2002-09-19 17:14:23 +00:00
portal_t *p;
int s;
qboolean res = false;
if (l->contents == CONTENTS_SOLID || l->contents == CONTENTS_SKY)
return false;
2002-09-19 17:14:23 +00:00
if (l->valid == valid)
return false;
2002-09-19 17:14:23 +00:00
if (l->occupied) {
2010-09-02 04:01:45 +00:00
const vec_t *v;
hit_occupied = l->occupied;
v = entities[hit_occupied].origin;
qprintf ("reached occupant at: (%4.0f,%4.0f,%4.0f) %s\n", v[0], v[1],
v[2], ValueForKey (&entities[hit_occupied], "classname"));
res = true;
}
2002-09-19 17:14:23 +00:00
l->valid = valid;
2002-09-23 16:27:17 +00:00
// fill it and it's neighbors
if (fill)
l->contents = CONTENTS_SOLID;
outleafs++;
2002-09-19 17:14:23 +00:00
for (p = l->portals; p;) {
s = (p->nodes[0] == l);
2002-09-23 16:27:17 +00:00
if (RecursiveFillOutside (p->nodes[s], fill)) {
// leaked, so stop filling
if (options.smart_leak)
return true;
if (!options.hullnum) {
MarkLeakTrail (p);
DrawLeaf (l, 2);
}
res = true;
}
p = p->next[!s];
}
2002-09-19 17:14:23 +00:00
return res;
}
2010-08-30 03:04:45 +00:00
/** Remove faces from filled in leafs.
Recursively traverses the portals of the start node.
\param node Start node.
*/
static void
2002-09-19 18:51:19 +00:00
ClearOutFaces (node_t *node)
{
2002-09-19 17:14:23 +00:00
face_t **fp;
if (node->planenum != -1) {
ClearOutFaces (node->children[0]);
ClearOutFaces (node->children[1]);
return;
}
if (node->contents != CONTENTS_SOLID)
return;
2002-09-19 17:14:23 +00:00
for (fp = node->markfaces; *fp; fp++) {
// mark all the original faces that are removed
2003-09-08 03:00:53 +00:00
FreeWinding ((*fp)->points);
(*fp)->points = 0;
}
node->faces = NULL;
}
2002-09-19 17:14:23 +00:00
qboolean
2002-09-19 18:51:19 +00:00
FillOutside (node_t *node)
{
2002-09-19 18:51:19 +00:00
int i, s;
2002-09-19 17:14:23 +00:00
qboolean inside;
2002-09-19 18:51:19 +00:00
vec_t *v;
2002-09-19 17:14:23 +00:00
qprintf ("----- FillOutside ----\n");
2002-09-20 21:48:34 +00:00
if (options.nofill) {
printf ("skipped\n");
return false;
}
2002-09-19 17:14:23 +00:00
2010-08-30 03:04:45 +00:00
// Place the map's entities in the map. inside will be true if at least
// one entitie could be placed.
inside = false;
2002-09-19 17:14:23 +00:00
for (i = 1; i < num_entities; i++) {
if (!_VectorCompare (entities[i].origin, vec3_origin)) {
if (PlaceOccupant (i, entities[i].origin, node))
inside = true;
}
}
2002-09-19 17:14:23 +00:00
if (!inside) {
2002-09-19 18:51:19 +00:00
printf ("Hullnum %i: No entities in empty space -- no filling "
2002-09-20 21:48:34 +00:00
"performed\n", options.hullnum);
return false;
}
s = !(outside_node.portals->nodes[1] == &outside_node);
2002-09-23 16:27:17 +00:00
// first check to see if an occupied leaf is hit
outleafs = 0;
valid++;
prevleaknode = NULL;
2002-09-19 17:14:23 +00:00
if (RecursiveFillOutside (outside_node.portals->nodes[s], false)) {
if (leakfile)
fclose (leakfile);
leakfile = 0;
if (!options.hullnum) {
v = entities[hit_occupied].origin;
printf ("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
printf ("reached occupant at: (%4.0f,%4.0f,%4.0f) %s\n",
v[0], v[1], v[2],
ValueForKey (&entities[hit_occupied], "classname"));
printf ("no filling performed\n");
printf ("leak file written to %s\n", options.pointfile);
printf ("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n");
}
if (options.smart_leak)
MarkLeakTrail2 ();
// remove faces from filled in leafs
ClearOutFaces (node);
return false;
}
2002-09-23 16:27:17 +00:00
// now go back and fill things in
valid++;
RecursiveFillOutside (outside_node.portals->nodes[s], true);
2010-08-30 03:04:45 +00:00
// remove faces from filled in leafs
ClearOutFaces (node);
2002-09-19 17:14:23 +00:00
qprintf ("%4i outleafs\n", outleafs);
return true;
}
//@}