mirror of
https://git.code.sf.net/p/quake/quakeforge
synced 2024-11-27 14:42:07 +00:00
d88bd96390
The portal flow stack nodes contain a simd vector, which requires 16-byte alignment. However, on 32-bit Windows, malloc returns 8-byte aligned memory, leading to eventual segfaults. Since pstack_t is 48 bytes on 32-bit systems, it fits nicely into a 64-byte aligned cache line (or two on 64-bit systems due to being 80 bytes).
526 lines
13 KiB
C
526 lines
13 KiB
C
/*
|
|
flow.c
|
|
|
|
PVS PHS generator tool
|
|
|
|
Copyright (C) 1996-1997 Id Software, Inc.
|
|
Copyright (C) 2002 Colin Thompson
|
|
|
|
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:
|
|
|
|
Free Software Foundation, Inc.
|
|
59 Temple Place - Suite 330
|
|
Boston, MA 02111-1307, USA
|
|
|
|
*/
|
|
#ifdef HAVE_CONFIG_H
|
|
# include "config.h"
|
|
#endif
|
|
|
|
#include <getopt.h>
|
|
#include <stdlib.h>
|
|
#ifdef HAVE_UNISTD_H
|
|
# include <unistd.h>
|
|
#endif
|
|
#ifdef HAVE_IO_H
|
|
# include <io.h>
|
|
#endif
|
|
#ifdef HAVE_STRING_H
|
|
# include <string.h>
|
|
#endif
|
|
#ifdef HAVE_STRINGS_H
|
|
# include <strings.h>
|
|
#endif
|
|
#include <getopt.h>
|
|
#include <errno.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "QF/bspfile.h"
|
|
#include "QF/cmem.h"
|
|
#include "QF/cmd.h"
|
|
#include "QF/mathlib.h"
|
|
#include "QF/quakefs.h"
|
|
#include "QF/sys.h"
|
|
|
|
#include "tools/qfvis/include/vis.h"
|
|
#include "tools/qfvis/include/options.h"
|
|
|
|
static int
|
|
CheckStack (cluster_t *cluster, threaddata_t *thread)
|
|
{
|
|
pstack_t *portal;
|
|
|
|
for (portal = thread->pstack_head.next; portal; portal = portal->next) {
|
|
if (portal->cluster == cluster) {
|
|
printf ("CheckStack: cluster recursion\n");
|
|
return 1;
|
|
}
|
|
if (!portal->cluster)
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static pstack_t *
|
|
new_stack (threaddata_t *td)
|
|
{
|
|
pstack_t *stack;
|
|
|
|
stack = cmemalloc (td->memsuper, sizeof (pstack_t));
|
|
stack->next = 0;
|
|
stack->mightsee = set_new_size_r (&td->set_pool, portalclusters);
|
|
td->stats.stack_alloc++;
|
|
return stack;
|
|
}
|
|
|
|
static sep_t *
|
|
new_separator (threaddata_t *thread)
|
|
{
|
|
sep_t *sep;
|
|
|
|
sep = CMEMALLOC (32, sep_t, thread->sep, thread->memsuper);
|
|
thread->stats.sep_alloc++;
|
|
return sep;
|
|
}
|
|
|
|
static void
|
|
delete_separator (threaddata_t *thread, sep_t *sep)
|
|
{
|
|
thread->stats.sep_free++;
|
|
CMEMFREE (thread->sep, sep);
|
|
}
|
|
|
|
static void
|
|
free_separators (threaddata_t *thread, sep_t *sep_list)
|
|
{
|
|
unsigned count = thread->stats.sep_alloc - thread->stats.sep_free;
|
|
if (count > thread->stats.sep_highwater) {
|
|
thread->stats.sep_highwater = count;
|
|
}
|
|
count = 0;
|
|
while (sep_list) {
|
|
sep_t *sep = sep_list;
|
|
sep_list = sep->next;
|
|
delete_separator (thread, sep);
|
|
count++;
|
|
}
|
|
if (count > thread->stats.sep_maxbulk) {
|
|
thread->stats.sep_maxbulk = count;
|
|
}
|
|
}
|
|
|
|
static inline int
|
|
test_zero (float d)
|
|
{
|
|
if (d < -ON_EPSILON)
|
|
return -1;
|
|
else if (d > ON_EPSILON)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
calc_plane (vec4f_t v1, vec4f_t v2, int flip, vec4f_t p, vec4f_t *plane)
|
|
{
|
|
vec4f_t length;
|
|
|
|
if (flip < 0) {
|
|
//CrossProduct (v2, v1, plane.normal);
|
|
(*plane)[0] = v2[1] * v1[2] - v2[2] * v1[1];
|
|
(*plane)[1] = v2[2] * v1[0] - v2[0] * v1[2];
|
|
(*plane)[2] = v2[0] * v1[1] - v2[1] * v1[0];
|
|
} else {
|
|
//CrossProduct (v1, v2, plane.normal);
|
|
(*plane)[0] = v1[1] * v2[2] - v1[2] * v2[1];
|
|
(*plane)[1] = v1[2] * v2[0] - v1[0] * v2[2];
|
|
(*plane)[2] = v1[0] * v2[1] - v1[1] * v2[0];
|
|
}
|
|
(*plane)[3] = 0;
|
|
|
|
length = dotf (*plane, *plane);
|
|
|
|
// if points don't make a valid plane, skip it
|
|
if (length[0] < ON_EPSILON)
|
|
return 0;
|
|
|
|
*plane /= vsqrtf (length);
|
|
(*plane)[3] = -dotf (p, *plane)[0];
|
|
return 1;
|
|
}
|
|
|
|
static inline int
|
|
test_plane (vec4f_t plane, const winding_t *pass, int index)
|
|
{
|
|
int s1, s2;
|
|
int k;
|
|
vec4f_t d;
|
|
|
|
k = (index + 1) % pass->numpoints;
|
|
d = dotf (pass->points[k], plane);
|
|
s1 = test_zero (d[0]);
|
|
k = (index + pass->numpoints - 1) % pass->numpoints;
|
|
d = dotf (pass->points[k], plane);
|
|
s2 = test_zero (d[0]);
|
|
if (s1 == 0 && s2 == 0)
|
|
return 0;
|
|
if (s1 < 0 || s2 < 0)
|
|
return 0;
|
|
return 1;
|
|
}
|
|
|
|
static inline sep_t *
|
|
create_separator (threaddata_t *thread, vec4f_t src_pl, vec4f_t p1, vec4f_t v1,
|
|
const winding_t *pass, int index, int flip)
|
|
{
|
|
int fliptest;
|
|
vec4f_t d;
|
|
vec4f_t v2;
|
|
vec4f_t plane;
|
|
sep_t *sep;
|
|
|
|
d = dotf (pass->points[index], src_pl);
|
|
if ((fliptest = test_zero (d[0])) == 0)
|
|
return 0; // The point lies in the source plane
|
|
|
|
v2 = pass->points[index] - p1;
|
|
if (!calc_plane (v1, v2, fliptest, pass->points[index], &plane))
|
|
return 0; // point does not form a valid plane
|
|
|
|
if (!test_plane (plane, pass, index))
|
|
return 0; // not the right point
|
|
|
|
sep = new_separator (thread);
|
|
// flip the normal if we want the back side
|
|
if (flip) {
|
|
sep->plane = -plane;
|
|
} else {
|
|
sep->plane = plane;
|
|
}
|
|
return sep;
|
|
}
|
|
|
|
/*
|
|
Find the planes separating source from pass. The planes form a double
|
|
pyramid with source as the base (ie, source's edges will all be in one
|
|
plane each) and the vertex of the pyramid is between source and pass.
|
|
Edges from pass may or may not be in a plane, but each vertex will be in
|
|
at least one plane.
|
|
|
|
If flip is false, the planes will be such that the space enclosed by the
|
|
planes and on the pass side of the vertex are on the front sides of the
|
|
planes. If flip is true, then the space on the source side of the vertex
|
|
and enclosed by the planes is on the front side of the planes.
|
|
|
|
// find a vertex of pass that makes a plane that puts all of the
|
|
// vertexes of pass on the front side and all of the vertexes of
|
|
// source on the back side
|
|
*/
|
|
static sep_t *
|
|
FindSeparators (threaddata_t *thread,
|
|
const winding_t *source, vec4f_t src_pl,
|
|
const winding_t *pass, int flip)
|
|
{
|
|
unsigned i, j, l;
|
|
vec4f_t v1;
|
|
|
|
sep_t *separators = 0, *sep;
|
|
|
|
for (i = 0; i < source->numpoints; i++) {
|
|
l = (i + 1) % source->numpoints;
|
|
v1 = source->points[l] - source->points[i];
|
|
|
|
for (j = 0; j < pass->numpoints; j++) {
|
|
sep = create_separator (thread, src_pl, source->points[i], v1,
|
|
pass, j, flip);
|
|
if (sep) {
|
|
sep->next = separators;
|
|
separators = sep;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return separators;
|
|
}
|
|
|
|
static winding_t *
|
|
ClipToSeparators (threaddata_t *thread, const sep_t *separators,
|
|
winding_t *target)
|
|
{
|
|
const sep_t *sep;
|
|
|
|
for (sep = separators; target && sep; sep = sep->next) {
|
|
target = ClipWinding (thread, target, sep->plane, false);
|
|
}
|
|
return target;
|
|
}
|
|
|
|
static inline set_t *
|
|
select_test_set (portal_t *portal, threaddata_t *thread)
|
|
{
|
|
set_t *test;
|
|
|
|
if (portal->status == stat_done) {
|
|
thread->stats.vistest++;
|
|
test = portal->visbits;
|
|
} else {
|
|
thread->stats.mighttest++;
|
|
test = portal->mightsee;
|
|
}
|
|
return test;
|
|
}
|
|
|
|
static inline int
|
|
mightsee_more (set_t *might, const set_t *prev_might, const set_t *test,
|
|
const set_t *vis)
|
|
{
|
|
unsigned i;
|
|
set_bits_t more = 0;
|
|
|
|
// might = intersection (prev_might, test)
|
|
// more = (might is not a subset of vis)
|
|
for (i = 0; i < SET_WORDS (might); i++) {
|
|
might->map[i] = prev_might->map[i] & test->map[i];
|
|
more |= might->map[i] & ~vis->map[i];
|
|
}
|
|
return more != 0;
|
|
}
|
|
|
|
static void
|
|
free_winding_memory (threaddata_t *thread, size_t winding_mark)
|
|
{
|
|
thread->stats.winding_mark = max (thread->stats.winding_mark,
|
|
Hunk_LowMark (thread->hunk));
|
|
Hunk_RawFreeToLowMark (thread->hunk, winding_mark);
|
|
}
|
|
|
|
/*
|
|
RecursiveClusterFlow
|
|
|
|
Flood fill through the clusters
|
|
*/
|
|
static void
|
|
RecursiveClusterFlow (int clusternum, threaddata_t *thread, pstack_t *prevstack)
|
|
{
|
|
int i;
|
|
set_t *might;
|
|
const set_t *test, *vis;
|
|
cluster_t *cluster;
|
|
pstack_t *stack;
|
|
portal_t *target_portal;
|
|
vec4f_t backplane;
|
|
vec4f_t source_plane, pass_plane;
|
|
const winding_t *pass_winding;
|
|
winding_t *source_winding, *target_winding;
|
|
|
|
thread->stats.chains++;
|
|
|
|
if (!prevstack->next)
|
|
prevstack->next = new_stack (thread);
|
|
stack = prevstack->next;
|
|
stack->cluster = 0;
|
|
|
|
cluster = &clusters[clusternum];
|
|
if (CheckStack(cluster, thread))
|
|
return;
|
|
|
|
// mark the cluster as visible
|
|
if (!set_is_member (thread->clustervis, clusternum)) {
|
|
set_add (thread->clustervis, clusternum);
|
|
thread->base->numcansee++;
|
|
}
|
|
|
|
stack->cluster = cluster;
|
|
stack->pass_portal = NULL;
|
|
stack->separators[0] = 0;
|
|
stack->separators[1] = 0;
|
|
might = stack->mightsee;
|
|
vis = thread->clustervis;
|
|
|
|
source_plane = thread->pstack_head.pass_plane;
|
|
pass_winding = prevstack->pass_winding;
|
|
pass_plane = prevstack->pass_plane;
|
|
|
|
size_t winding_mark = Hunk_LowMark (thread->hunk);
|
|
|
|
// check all portals for flowing into other clusters
|
|
for (i = 0; i < cluster->numportals; i++) {
|
|
target_portal = &cluster->portals[i];
|
|
if (!set_is_member (prevstack->mightsee, target_portal->cluster))
|
|
continue; // can't possibly see it
|
|
|
|
// if target_portal can't see anything we haven't already seen, skip it
|
|
test = select_test_set (target_portal, thread);
|
|
if (!mightsee_more (might, prevstack->mightsee, test, vis)) {
|
|
// can't see anything new
|
|
continue;
|
|
}
|
|
|
|
// get plane of target_portal, point normal into the neighbor cluster
|
|
backplane = -target_portal->plane;
|
|
|
|
vec4f_t diff = vabsf (pass_plane - backplane);
|
|
vec4i_t cmp = diff > (vec4f_t) {0.001, 0.001, 0.001, 0.001};
|
|
if (!(cmp[0] || cmp[1] || cmp[2])) { // dist isn't interesting
|
|
continue; // can't go out a coplanar face
|
|
}
|
|
|
|
free_winding_memory (thread, winding_mark);
|
|
|
|
thread->stats.portalcheck++;
|
|
|
|
target_winding = target_portal->winding;
|
|
target_winding = ClipWinding (thread, target_winding, source_plane, false);
|
|
if (!target_winding)
|
|
continue;
|
|
|
|
if (!pass_winding) {
|
|
// the second cluster can be blocked only if coplanar
|
|
|
|
stack->source_winding = prevstack->source_winding;
|
|
|
|
stack->pass_winding = target_winding;
|
|
stack->pass_plane = target_portal->plane;
|
|
stack->pass_portal = target_portal;
|
|
|
|
RecursiveClusterFlow (target_portal->cluster, thread, stack);
|
|
continue;
|
|
}
|
|
|
|
target_winding = ClipWinding (thread, target_winding, pass_plane, false);
|
|
if (!target_winding)
|
|
continue;
|
|
|
|
// copy source_winding because it likely is already a copy and thus
|
|
// if it gets clipped away, earlier stack levels will get corrupted
|
|
source_winding = CopyWinding (thread, prevstack->source_winding);
|
|
|
|
source_winding = ClipWinding (thread, source_winding, backplane, false);
|
|
if (!source_winding) {
|
|
continue;
|
|
}
|
|
|
|
thread->stats.portaltest++;
|
|
thread->stats.targettested++;
|
|
|
|
if (options.level > 0) {
|
|
winding_t *old = target_winding;
|
|
if (!stack->separators[0])
|
|
stack->separators[0] = FindSeparators (thread,
|
|
source_winding,
|
|
source_plane,
|
|
pass_winding, 0);
|
|
target_winding = ClipToSeparators (thread,
|
|
stack->separators[0],
|
|
target_winding);
|
|
if (!target_winding) {
|
|
thread->stats.targetclipped++;
|
|
continue;
|
|
}
|
|
if (target_winding != old)
|
|
thread->stats.targettrimmed++;
|
|
}
|
|
|
|
if (options.level > 1) {
|
|
winding_t *old = target_winding;
|
|
if (!stack->separators[1])
|
|
stack->separators[1] = FindSeparators (thread,
|
|
pass_winding,
|
|
pass_plane,
|
|
source_winding, 1);
|
|
target_winding = ClipToSeparators (thread,
|
|
stack->separators[1],
|
|
target_winding);
|
|
if (!target_winding) {
|
|
thread->stats.targetclipped++;
|
|
continue;
|
|
}
|
|
if (target_winding != old)
|
|
thread->stats.targettrimmed++;
|
|
}
|
|
|
|
thread->stats.sourcetested++;
|
|
if (options.level > 2) {
|
|
winding_t *old = source_winding;
|
|
sep_t *sep;
|
|
sep = FindSeparators (thread,
|
|
target_winding, target_portal->plane,
|
|
pass_winding, 0);
|
|
source_winding = ClipToSeparators (thread, sep, source_winding);
|
|
free_separators (thread, sep);
|
|
if (!source_winding) {
|
|
thread->stats.sourceclipped++;
|
|
continue;
|
|
}
|
|
if (source_winding != old)
|
|
thread->stats.sourcetrimmed++;
|
|
}
|
|
|
|
if (options.level > 3) {
|
|
winding_t *old = source_winding;
|
|
sep_t *sep;
|
|
sep = FindSeparators (thread, pass_winding, pass_plane,
|
|
target_winding, 1);
|
|
source_winding = ClipToSeparators (thread, sep, source_winding);
|
|
free_separators (thread, sep);
|
|
if (!source_winding) {
|
|
thread->stats.sourceclipped++;
|
|
continue;
|
|
}
|
|
if (source_winding != old)
|
|
thread->stats.sourcetrimmed++;
|
|
}
|
|
|
|
stack->source_winding = source_winding;
|
|
stack->pass_winding = target_winding;
|
|
|
|
stack->pass_plane = target_portal->plane;
|
|
stack->pass_portal = target_portal;
|
|
|
|
thread->stats.portalpass++;
|
|
|
|
// flow through it for real
|
|
RecursiveClusterFlow (target_portal->cluster, thread, stack);
|
|
}
|
|
free_winding_memory (thread, winding_mark);
|
|
free_separators (thread, stack->separators[1]);
|
|
free_separators (thread, stack->separators[0]);
|
|
}
|
|
|
|
void
|
|
PortalFlow (threaddata_t *data, portal_t *portal)
|
|
{
|
|
WRLOCK_PORTAL (portal);
|
|
if (portal->status != stat_selected)
|
|
Sys_Error ("PortalFlow: reflowed");
|
|
portal->status = stat_working;
|
|
UNLOCK_PORTAL (portal);
|
|
|
|
portal->visbits = set_new_size_r (&data->set_pool, portalclusters);
|
|
|
|
data->clustervis = portal->visbits;
|
|
data->base = portal;
|
|
|
|
data->pstack_head.cluster = 0;
|
|
data->pstack_head.pass_portal = portal;
|
|
data->pstack_head.source_winding = portal->winding;
|
|
data->pstack_head.pass_winding = 0;
|
|
data->pstack_head.pass_plane = portal->plane;
|
|
data->pstack_head.mightsee = portal->mightsee;
|
|
data->pstack_head.separators[0] = 0;
|
|
data->pstack_head.separators[1] = 0;
|
|
|
|
RecursiveClusterFlow (portal->cluster, data, &data->pstack_head);
|
|
}
|