mirror of
https://github.com/id-Software/Quake-2-Tools.git
synced 2026-03-19 16:39:44 +01:00
The Quake 2 tools as originally released under the GPL license.
This commit is contained in:
Travis Bradshaw
788
bsp/qvis3/flow.c
Normal file
788
bsp/qvis3/flow.c
Normal file
@@ -0,0 +1,788 @@
|
||||
/*
|
||||
===========================================================================
|
||||
Copyright (C) 1997-2006 Id Software, Inc.
|
||||
|
||||
This file is part of Quake 2 Tools source code.
|
||||
|
||||
Quake 2 Tools source code 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.
|
||||
|
||||
Quake 2 Tools source code 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 Quake 2 Tools source code; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
===========================================================================
|
||||
*/
|
||||
#include "vis.h"
|
||||
|
||||
/*
|
||||
|
||||
each portal will have a list of all possible to see from first portal
|
||||
|
||||
if (!thread->portalmightsee[portalnum])
|
||||
|
||||
portal mightsee
|
||||
|
||||
for p2 = all other portals in leaf
|
||||
get sperating planes
|
||||
for all portals that might be seen by p2
|
||||
mark as unseen if not present in seperating plane
|
||||
flood fill a new mightsee
|
||||
save as passagemightsee
|
||||
|
||||
|
||||
void CalcMightSee (leaf_t *leaf,
|
||||
*/
|
||||
|
||||
int CountBits (byte *bits, int numbits)
|
||||
{
|
||||
int i;
|
||||
int c;
|
||||
|
||||
c = 0;
|
||||
for (i=0 ; i<numbits ; i++)
|
||||
if (bits[i>>3] & (1<<(i&7)) )
|
||||
c++;
|
||||
|
||||
return c;
|
||||
}
|
||||
|
||||
int c_fullskip;
|
||||
int c_portalskip, c_leafskip;
|
||||
int c_vistest, c_mighttest;
|
||||
|
||||
int c_chop, c_nochop;
|
||||
|
||||
int active;
|
||||
|
||||
void CheckStack (leaf_t *leaf, threaddata_t *thread)
|
||||
{
|
||||
pstack_t *p, *p2;
|
||||
|
||||
for (p=thread->pstack_head.next ; p ; p=p->next)
|
||||
{
|
||||
// printf ("=");
|
||||
if (p->leaf == leaf)
|
||||
Error ("CheckStack: leaf recursion");
|
||||
for (p2=thread->pstack_head.next ; p2 != p ; p2=p2->next)
|
||||
if (p2->leaf == p->leaf)
|
||||
Error ("CheckStack: late leaf recursion");
|
||||
}
|
||||
// printf ("\n");
|
||||
}
|
||||
|
||||
|
||||
winding_t *AllocStackWinding (pstack_t *stack)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i=0 ; i<3 ; i++)
|
||||
{
|
||||
if (stack->freewindings[i])
|
||||
{
|
||||
stack->freewindings[i] = 0;
|
||||
return &stack->windings[i];
|
||||
}
|
||||
}
|
||||
|
||||
Error ("AllocStackWinding: failed");
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void FreeStackWinding (winding_t *w, pstack_t *stack)
|
||||
{
|
||||
int i;
|
||||
|
||||
i = w - stack->windings;
|
||||
|
||||
if (i<0 || i>2)
|
||||
return; // not from local
|
||||
|
||||
if (stack->freewindings[i])
|
||||
Error ("FreeStackWinding: allready free");
|
||||
stack->freewindings[i] = 1;
|
||||
}
|
||||
|
||||
/*
|
||||
==============
|
||||
ChopWinding
|
||||
|
||||
==============
|
||||
*/
|
||||
winding_t *ChopWinding (winding_t *in, pstack_t *stack, plane_t *split)
|
||||
{
|
||||
vec_t dists[128];
|
||||
int sides[128];
|
||||
int counts[3];
|
||||
vec_t dot;
|
||||
int i, j;
|
||||
vec_t *p1, *p2;
|
||||
vec3_t mid;
|
||||
winding_t *neww;
|
||||
|
||||
counts[0] = counts[1] = counts[2] = 0;
|
||||
|
||||
// determine sides for each point
|
||||
for (i=0 ; i<in->numpoints ; i++)
|
||||
{
|
||||
dot = DotProduct (in->points[i], split->normal);
|
||||
dot -= split->dist;
|
||||
dists[i] = dot;
|
||||
if (dot > ON_EPSILON)
|
||||
sides[i] = SIDE_FRONT;
|
||||
else if (dot < -ON_EPSILON)
|
||||
sides[i] = SIDE_BACK;
|
||||
else
|
||||
{
|
||||
sides[i] = SIDE_ON;
|
||||
}
|
||||
counts[sides[i]]++;
|
||||
}
|
||||
|
||||
if (!counts[1])
|
||||
return in; // completely on front side
|
||||
|
||||
if (!counts[0])
|
||||
{
|
||||
FreeStackWinding (in, stack);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
sides[i] = sides[0];
|
||||
dists[i] = dists[0];
|
||||
|
||||
neww = AllocStackWinding (stack);
|
||||
|
||||
neww->numpoints = 0;
|
||||
|
||||
for (i=0 ; i<in->numpoints ; i++)
|
||||
{
|
||||
p1 = in->points[i];
|
||||
|
||||
if (neww->numpoints == MAX_POINTS_ON_FIXED_WINDING)
|
||||
{
|
||||
FreeStackWinding (neww, stack);
|
||||
return in; // can't chop -- fall back to original
|
||||
}
|
||||
|
||||
if (sides[i] == SIDE_ON)
|
||||
{
|
||||
VectorCopy (p1, neww->points[neww->numpoints]);
|
||||
neww->numpoints++;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (sides[i] == SIDE_FRONT)
|
||||
{
|
||||
VectorCopy (p1, neww->points[neww->numpoints]);
|
||||
neww->numpoints++;
|
||||
}
|
||||
|
||||
if (sides[i+1] == SIDE_ON || sides[i+1] == sides[i])
|
||||
continue;
|
||||
|
||||
if (neww->numpoints == MAX_POINTS_ON_FIXED_WINDING)
|
||||
{
|
||||
FreeStackWinding (neww, stack);
|
||||
return in; // can't chop -- fall back to original
|
||||
}
|
||||
|
||||
// generate a split point
|
||||
p2 = in->points[(i+1)%in->numpoints];
|
||||
|
||||
dot = dists[i] / (dists[i]-dists[i+1]);
|
||||
for (j=0 ; j<3 ; j++)
|
||||
{ // avoid round off error when possible
|
||||
if (split->normal[j] == 1)
|
||||
mid[j] = split->dist;
|
||||
else if (split->normal[j] == -1)
|
||||
mid[j] = -split->dist;
|
||||
else
|
||||
mid[j] = p1[j] + dot*(p2[j]-p1[j]);
|
||||
}
|
||||
|
||||
VectorCopy (mid, neww->points[neww->numpoints]);
|
||||
neww->numpoints++;
|
||||
}
|
||||
|
||||
// free the original winding
|
||||
FreeStackWinding (in, stack);
|
||||
|
||||
return neww;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
==============
|
||||
ClipToSeperators
|
||||
|
||||
Source, pass, and target are an ordering of portals.
|
||||
|
||||
Generates seperating planes canidates by taking two points from source and one
|
||||
point from pass, and clips target by them.
|
||||
|
||||
If target is totally clipped away, that portal can not be seen through.
|
||||
|
||||
Normal clip keeps target on the same side as pass, which is correct if the
|
||||
order goes source, pass, target. If the order goes pass, source, target then
|
||||
flipclip should be set.
|
||||
==============
|
||||
*/
|
||||
winding_t *ClipToSeperators (winding_t *source, winding_t *pass, winding_t *target, qboolean flipclip, pstack_t *stack)
|
||||
{
|
||||
int i, j, k, l;
|
||||
plane_t plane;
|
||||
vec3_t v1, v2;
|
||||
float d;
|
||||
vec_t length;
|
||||
int counts[3];
|
||||
qboolean fliptest;
|
||||
|
||||
// check all combinations
|
||||
for (i=0 ; i<source->numpoints ; i++)
|
||||
{
|
||||
l = (i+1)%source->numpoints;
|
||||
VectorSubtract (source->points[l] , source->points[i], v1);
|
||||
|
||||
// fing 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
|
||||
for (j=0 ; j<pass->numpoints ; j++)
|
||||
{
|
||||
VectorSubtract (pass->points[j], source->points[i], v2);
|
||||
|
||||
plane.normal[0] = v1[1]*v2[2] - v1[2]*v2[1];
|
||||
plane.normal[1] = v1[2]*v2[0] - v1[0]*v2[2];
|
||||
plane.normal[2] = v1[0]*v2[1] - v1[1]*v2[0];
|
||||
|
||||
// if points don't make a valid plane, skip it
|
||||
|
||||
length = plane.normal[0] * plane.normal[0]
|
||||
+ plane.normal[1] * plane.normal[1]
|
||||
+ plane.normal[2] * plane.normal[2];
|
||||
|
||||
if (length < ON_EPSILON)
|
||||
continue;
|
||||
|
||||
length = 1/sqrt(length);
|
||||
|
||||
plane.normal[0] *= length;
|
||||
plane.normal[1] *= length;
|
||||
plane.normal[2] *= length;
|
||||
|
||||
plane.dist = DotProduct (pass->points[j], plane.normal);
|
||||
|
||||
//
|
||||
// find out which side of the generated seperating plane has the
|
||||
// source portal
|
||||
//
|
||||
#if 1
|
||||
fliptest = false;
|
||||
for (k=0 ; k<source->numpoints ; k++)
|
||||
{
|
||||
if (k == i || k == l)
|
||||
continue;
|
||||
d = DotProduct (source->points[k], plane.normal) - plane.dist;
|
||||
if (d < -ON_EPSILON)
|
||||
{ // source is on the negative side, so we want all
|
||||
// pass and target on the positive side
|
||||
fliptest = false;
|
||||
break;
|
||||
}
|
||||
else if (d > ON_EPSILON)
|
||||
{ // source is on the positive side, so we want all
|
||||
// pass and target on the negative side
|
||||
fliptest = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (k == source->numpoints)
|
||||
continue; // planar with source portal
|
||||
#else
|
||||
fliptest = flipclip;
|
||||
#endif
|
||||
//
|
||||
// flip the normal if the source portal is backwards
|
||||
//
|
||||
if (fliptest)
|
||||
{
|
||||
VectorSubtract (vec3_origin, plane.normal, plane.normal);
|
||||
plane.dist = -plane.dist;
|
||||
}
|
||||
#if 1
|
||||
//
|
||||
// if all of the pass portal points are now on the positive side,
|
||||
// this is the seperating plane
|
||||
//
|
||||
counts[0] = counts[1] = counts[2] = 0;
|
||||
for (k=0 ; k<pass->numpoints ; k++)
|
||||
{
|
||||
if (k==j)
|
||||
continue;
|
||||
d = DotProduct (pass->points[k], plane.normal) - plane.dist;
|
||||
if (d < -ON_EPSILON)
|
||||
break;
|
||||
else if (d > ON_EPSILON)
|
||||
counts[0]++;
|
||||
else
|
||||
counts[2]++;
|
||||
}
|
||||
if (k != pass->numpoints)
|
||||
continue; // points on negative side, not a seperating plane
|
||||
|
||||
if (!counts[0])
|
||||
continue; // planar with seperating plane
|
||||
#else
|
||||
k = (j+1)%pass->numpoints;
|
||||
d = DotProduct (pass->points[k], plane.normal) - plane.dist;
|
||||
if (d < -ON_EPSILON)
|
||||
continue;
|
||||
k = (j+pass->numpoints-1)%pass->numpoints;
|
||||
d = DotProduct (pass->points[k], plane.normal) - plane.dist;
|
||||
if (d < -ON_EPSILON)
|
||||
continue;
|
||||
#endif
|
||||
//
|
||||
// flip the normal if we want the back side
|
||||
//
|
||||
if (flipclip)
|
||||
{
|
||||
VectorSubtract (vec3_origin, plane.normal, plane.normal);
|
||||
plane.dist = -plane.dist;
|
||||
}
|
||||
|
||||
//
|
||||
// clip target by the seperating plane
|
||||
//
|
||||
target = ChopWinding (target, stack, &plane);
|
||||
if (!target)
|
||||
return NULL; // target is not visible
|
||||
}
|
||||
}
|
||||
|
||||
return target;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*
|
||||
==================
|
||||
RecursiveLeafFlow
|
||||
|
||||
Flood fill through the leafs
|
||||
If src_portal is NULL, this is the originating leaf
|
||||
==================
|
||||
*/
|
||||
void RecursiveLeafFlow (int leafnum, threaddata_t *thread, pstack_t *prevstack)
|
||||
{
|
||||
pstack_t stack;
|
||||
portal_t *p;
|
||||
plane_t backplane;
|
||||
leaf_t *leaf;
|
||||
int i, j;
|
||||
long *test, *might, *vis, more;
|
||||
int pnum;
|
||||
|
||||
thread->c_chains++;
|
||||
|
||||
leaf = &leafs[leafnum];
|
||||
// CheckStack (leaf, thread);
|
||||
|
||||
prevstack->next = &stack;
|
||||
|
||||
stack.next = NULL;
|
||||
stack.leaf = leaf;
|
||||
stack.portal = NULL;
|
||||
|
||||
might = (long *)stack.mightsee;
|
||||
vis = (long *)thread->base->portalvis;
|
||||
|
||||
// check all portals for flowing into other leafs
|
||||
for (i=0 ; i<leaf->numportals ; i++)
|
||||
{
|
||||
p = leaf->portals[i];
|
||||
pnum = p - portals;
|
||||
|
||||
if ( ! (prevstack->mightsee[pnum >> 3] & (1<<(pnum&7)) ) )
|
||||
{
|
||||
continue; // can't possibly see it
|
||||
}
|
||||
|
||||
// if the portal can't see anything we haven't allready seen, skip it
|
||||
if (p->status == stat_done)
|
||||
{
|
||||
test = (long *)p->portalvis;
|
||||
}
|
||||
else
|
||||
{
|
||||
test = (long *)p->portalflood;
|
||||
}
|
||||
|
||||
more = 0;
|
||||
for (j=0 ; j<portallongs ; j++)
|
||||
{
|
||||
might[j] = ((long *)prevstack->mightsee)[j] & test[j];
|
||||
more |= (might[j] & ~vis[j]);
|
||||
}
|
||||
|
||||
if (!more &&
|
||||
(thread->base->portalvis[pnum>>3] & (1<<(pnum&7))) )
|
||||
{ // can't see anything new
|
||||
continue;
|
||||
}
|
||||
|
||||
// get plane of portal, point normal into the neighbor leaf
|
||||
stack.portalplane = p->plane;
|
||||
VectorSubtract (vec3_origin, p->plane.normal, backplane.normal);
|
||||
backplane.dist = -p->plane.dist;
|
||||
|
||||
// c_portalcheck++;
|
||||
|
||||
stack.portal = p;
|
||||
stack.next = NULL;
|
||||
stack.freewindings[0] = 1;
|
||||
stack.freewindings[1] = 1;
|
||||
stack.freewindings[2] = 1;
|
||||
|
||||
#if 1
|
||||
{
|
||||
float d;
|
||||
|
||||
d = DotProduct (p->origin, thread->pstack_head.portalplane.normal);
|
||||
d -= thread->pstack_head.portalplane.dist;
|
||||
if (d < -p->radius)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
else if (d > p->radius)
|
||||
{
|
||||
stack.pass = p->winding;
|
||||
}
|
||||
else
|
||||
{
|
||||
stack.pass = ChopWinding (p->winding, &stack, &thread->pstack_head.portalplane);
|
||||
if (!stack.pass)
|
||||
continue;
|
||||
}
|
||||
}
|
||||
#else
|
||||
stack.pass = ChopWinding (p->winding, &stack, &thread->pstack_head.portalplane);
|
||||
if (!stack.pass)
|
||||
continue;
|
||||
#endif
|
||||
|
||||
|
||||
#if 1
|
||||
{
|
||||
float d;
|
||||
|
||||
d = DotProduct (thread->base->origin, p->plane.normal);
|
||||
d -= p->plane.dist;
|
||||
if (d > p->radius)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
else if (d < -p->radius)
|
||||
{
|
||||
stack.source = prevstack->source;
|
||||
}
|
||||
else
|
||||
{
|
||||
stack.source = ChopWinding (prevstack->source, &stack, &backplane);
|
||||
if (!stack.source)
|
||||
continue;
|
||||
}
|
||||
}
|
||||
#else
|
||||
stack.source = ChopWinding (prevstack->source, &stack, &backplane);
|
||||
if (!stack.source)
|
||||
continue;
|
||||
#endif
|
||||
|
||||
if (!prevstack->pass)
|
||||
{ // the second leaf can only be blocked if coplanar
|
||||
|
||||
// mark the portal as visible
|
||||
thread->base->portalvis[pnum>>3] |= (1<<(pnum&7));
|
||||
|
||||
RecursiveLeafFlow (p->leaf, thread, &stack);
|
||||
continue;
|
||||
}
|
||||
|
||||
stack.pass = ClipToSeperators (stack.source, prevstack->pass, stack.pass, false, &stack);
|
||||
if (!stack.pass)
|
||||
continue;
|
||||
|
||||
stack.pass = ClipToSeperators (prevstack->pass, stack.source, stack.pass, true, &stack);
|
||||
if (!stack.pass)
|
||||
continue;
|
||||
|
||||
// mark the portal as visible
|
||||
thread->base->portalvis[pnum>>3] |= (1<<(pnum&7));
|
||||
|
||||
// flow through it for real
|
||||
RecursiveLeafFlow (p->leaf, thread, &stack);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===============
|
||||
PortalFlow
|
||||
|
||||
generates the portalvis bit vector
|
||||
===============
|
||||
*/
|
||||
void PortalFlow (int portalnum)
|
||||
{
|
||||
threaddata_t data;
|
||||
int i;
|
||||
portal_t *p;
|
||||
int c_might, c_can;
|
||||
|
||||
p = sorted_portals[portalnum];
|
||||
p->status = stat_working;
|
||||
|
||||
c_might = CountBits (p->portalflood, numportals*2);
|
||||
|
||||
memset (&data, 0, sizeof(data));
|
||||
data.base = p;
|
||||
|
||||
data.pstack_head.portal = p;
|
||||
data.pstack_head.source = p->winding;
|
||||
data.pstack_head.portalplane = p->plane;
|
||||
for (i=0 ; i<portallongs ; i++)
|
||||
((long *)data.pstack_head.mightsee)[i] = ((long *)p->portalflood)[i];
|
||||
RecursiveLeafFlow (p->leaf, &data, &data.pstack_head);
|
||||
|
||||
p->status = stat_done;
|
||||
|
||||
c_can = CountBits (p->portalvis, numportals*2);
|
||||
|
||||
qprintf ("portal:%4i mightsee:%4i cansee:%4i (%i chains)\n",
|
||||
(int)(p - portals), c_might, c_can, data.c_chains);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===============================================================================
|
||||
|
||||
This is a rough first-order aproximation that is used to trivially reject some
|
||||
of the final calculations.
|
||||
|
||||
|
||||
Calculates portalfront and portalflood bit vectors
|
||||
|
||||
thinking about:
|
||||
|
||||
typedef struct passage_s
|
||||
{
|
||||
struct passage_s *next;
|
||||
struct portal_s *to;
|
||||
stryct sep_s *seperators;
|
||||
byte *mightsee;
|
||||
} passage_t;
|
||||
|
||||
typedef struct portal_s
|
||||
{
|
||||
struct passage_s *passages;
|
||||
int leaf; // leaf portal faces into
|
||||
} portal_s;
|
||||
|
||||
leaf = portal->leaf
|
||||
clear
|
||||
for all portals
|
||||
|
||||
|
||||
calc portal visibility
|
||||
clear bit vector
|
||||
for all passages
|
||||
passage visibility
|
||||
|
||||
|
||||
for a portal to be visible to a passage, it must be on the front of
|
||||
all seperating planes, and both portals must be behind the mew portal
|
||||
|
||||
===============================================================================
|
||||
*/
|
||||
|
||||
int c_flood, c_vis;
|
||||
|
||||
|
||||
/*
|
||||
==================
|
||||
SimpleFlood
|
||||
|
||||
==================
|
||||
*/
|
||||
void SimpleFlood (portal_t *srcportal, int leafnum)
|
||||
{
|
||||
int i;
|
||||
leaf_t *leaf;
|
||||
portal_t *p;
|
||||
int pnum;
|
||||
|
||||
leaf = &leafs[leafnum];
|
||||
|
||||
for (i=0 ; i<leaf->numportals ; i++)
|
||||
{
|
||||
p = leaf->portals[i];
|
||||
pnum = p - portals;
|
||||
if ( ! (srcportal->portalfront[pnum>>3] & (1<<(pnum&7)) ) )
|
||||
continue;
|
||||
|
||||
if (srcportal->portalflood[pnum>>3] & (1<<(pnum&7)) )
|
||||
continue;
|
||||
|
||||
srcportal->portalflood[pnum>>3] |= (1<<(pnum&7));
|
||||
|
||||
SimpleFlood (srcportal, p->leaf);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
==============
|
||||
BasePortalVis
|
||||
==============
|
||||
*/
|
||||
void BasePortalVis (int portalnum)
|
||||
{
|
||||
int j, k;
|
||||
portal_t *tp, *p;
|
||||
float d;
|
||||
winding_t *w;
|
||||
|
||||
p = portals+portalnum;
|
||||
|
||||
p->portalfront = malloc (portalbytes);
|
||||
memset (p->portalfront, 0, portalbytes);
|
||||
|
||||
p->portalflood = malloc (portalbytes);
|
||||
memset (p->portalflood, 0, portalbytes);
|
||||
|
||||
p->portalvis = malloc (portalbytes);
|
||||
memset (p->portalvis, 0, portalbytes);
|
||||
|
||||
for (j=0, tp = portals ; j<numportals*2 ; j++, tp++)
|
||||
{
|
||||
if (j == portalnum)
|
||||
continue;
|
||||
w = tp->winding;
|
||||
for (k=0 ; k<w->numpoints ; k++)
|
||||
{
|
||||
d = DotProduct (w->points[k], p->plane.normal)
|
||||
- p->plane.dist;
|
||||
if (d > ON_EPSILON)
|
||||
break;
|
||||
}
|
||||
if (k == w->numpoints)
|
||||
continue; // no points on front
|
||||
|
||||
w = p->winding;
|
||||
for (k=0 ; k<w->numpoints ; k++)
|
||||
{
|
||||
d = DotProduct (w->points[k], tp->plane.normal)
|
||||
- tp->plane.dist;
|
||||
if (d < -ON_EPSILON)
|
||||
break;
|
||||
}
|
||||
if (k == w->numpoints)
|
||||
continue; // no points on front
|
||||
|
||||
p->portalfront[j>>3] |= (1<<(j&7));
|
||||
}
|
||||
|
||||
SimpleFlood (p, p->leaf);
|
||||
|
||||
p->nummightsee = CountBits (p->portalflood, numportals*2);
|
||||
// printf ("portal %i: %i mightsee\n", portalnum, p->nummightsee);
|
||||
c_flood += p->nummightsee;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*
|
||||
===============================================================================
|
||||
|
||||
This is a second order aproximation
|
||||
|
||||
Calculates portalvis bit vector
|
||||
|
||||
WAAAAAAY too slow.
|
||||
|
||||
===============================================================================
|
||||
*/
|
||||
|
||||
/*
|
||||
==================
|
||||
RecursiveLeafBitFlow
|
||||
|
||||
==================
|
||||
*/
|
||||
void RecursiveLeafBitFlow (int leafnum, byte *mightsee, byte *cansee)
|
||||
{
|
||||
portal_t *p;
|
||||
leaf_t *leaf;
|
||||
int i, j;
|
||||
long more;
|
||||
int pnum;
|
||||
byte newmight[MAX_PORTALS/8];
|
||||
|
||||
leaf = &leafs[leafnum];
|
||||
|
||||
// check all portals for flowing into other leafs
|
||||
for (i=0 ; i<leaf->numportals ; i++)
|
||||
{
|
||||
p = leaf->portals[i];
|
||||
pnum = p - portals;
|
||||
|
||||
// if some previous portal can't see it, skip
|
||||
if (! (mightsee[pnum>>3] & (1<<(pnum&7)) ) )
|
||||
continue;
|
||||
|
||||
// if this portal can see some portals we mightsee, recurse
|
||||
more = 0;
|
||||
for (j=0 ; j<portallongs ; j++)
|
||||
{
|
||||
((long *)newmight)[j] = ((long *)mightsee)[j]
|
||||
& ((long *)p->portalflood)[j];
|
||||
more |= ((long *)newmight)[j] & ~((long *)cansee)[j];
|
||||
}
|
||||
|
||||
if (!more)
|
||||
continue; // can't see anything new
|
||||
|
||||
cansee[pnum>>3] |= (1<<(pnum&7));
|
||||
|
||||
RecursiveLeafBitFlow (p->leaf, newmight, cansee);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
==============
|
||||
BetterPortalVis
|
||||
==============
|
||||
*/
|
||||
void BetterPortalVis (int portalnum)
|
||||
{
|
||||
portal_t *p;
|
||||
|
||||
p = portals+portalnum;
|
||||
|
||||
RecursiveLeafBitFlow (p->leaf, p->portalflood, p->portalvis);
|
||||
|
||||
// build leaf vis information
|
||||
p->nummightsee = CountBits (p->portalvis, numportals*2);
|
||||
c_vis += p->nummightsee;
|
||||
}
|
||||
|
||||
|
||||
62
bsp/qvis3/makefile
Normal file
62
bsp/qvis3/makefile
Normal file
@@ -0,0 +1,62 @@
|
||||
|
||||
CFLAGS = -c
|
||||
LDFLAGS =
|
||||
ODIR = baddir
|
||||
|
||||
EXEBASE = qvis3
|
||||
EXE = $(ODIR)/qvis3
|
||||
all: $(EXE)
|
||||
|
||||
_next:
|
||||
make "CFLAGS = -c -g -I../../common" "ODIR = next"
|
||||
|
||||
_irix:
|
||||
make "CFLAGS = -c -Ofast=ip32_10k -I../../common -Xcpluscomm" "LDFLAGS = -Ofast=ip32_10k" "ODIR = irix"
|
||||
|
||||
_irixinst:
|
||||
make "CFLAGS = -c -Ofast=ip32_10k -I../../common -Xcpluscomm" "LDFLAGS = -Ofast=ip32_10k" "ODIR = irix"
|
||||
cp irix/$(EXEBASE) /limbo/quake2/bin_irix
|
||||
|
||||
_irixclean:
|
||||
rm -f irix/*.o irix/$(EXEBASE)
|
||||
|
||||
_osf:
|
||||
make "CFLAGS = -c -O4 -I../../common -threads" "LDFLAGS = -threads -lm" "ODIR = osf"
|
||||
|
||||
clean:
|
||||
rm -f irix/*.o irix/$(EXEBASE)
|
||||
|
||||
install:
|
||||
cp irix/$(EXEBASE) /limbo/quake2/bin_irix
|
||||
|
||||
|
||||
FILES = $(ODIR)/bspfile.o $(ODIR)/cmdlib.o $(ODIR)/mathlib.o $(ODIR)/scriplib.o $(ODIR)/threads.o $(ODIR)/qvis3.o $(ODIR)/flow.o
|
||||
|
||||
$(EXE) : $(FILES)
|
||||
cc -o $(EXE) $(LDFLAGS) $(FILES)
|
||||
|
||||
$(ODIR)/qvis3.o : qvis3.c
|
||||
cc $(CFLAGS) -E $? | tr -d '\015' > /tmp/temp.i
|
||||
cc $(CFLAGS) -o $@ /tmp/temp.i
|
||||
$(ODIR)/flow.o : flow.c
|
||||
cc $(CFLAGS) -E $? | tr -d '\015' > /tmp/temp.i
|
||||
cc $(CFLAGS) -o $@ /tmp/temp.i
|
||||
|
||||
$(ODIR)/cmdlib.o : ../../common/cmdlib.c
|
||||
cc $(CFLAGS) -E $? | tr -d '\015' > /tmp/temp.i
|
||||
cc $(CFLAGS) -o $@ /tmp/temp.i
|
||||
$(ODIR)/mathlib.o : ../../common/mathlib.c
|
||||
cc $(CFLAGS) -E $? | tr -d '\015' > /tmp/temp.i
|
||||
cc $(CFLAGS) -o $@ /tmp/temp.i
|
||||
$(ODIR)/polylib.o : ../../common/polylib.c
|
||||
cc $(CFLAGS) -E $? | tr -d '\015' > /tmp/temp.i
|
||||
cc $(CFLAGS) -o $@ /tmp/temp.i
|
||||
$(ODIR)/scriplib.o : ../../common/scriplib.c
|
||||
cc $(CFLAGS) -E $? | tr -d '\015' > /tmp/temp.i
|
||||
cc $(CFLAGS) -o $@ /tmp/temp.i
|
||||
$(ODIR)/threads.o : ../../common/threads.c
|
||||
cc $(CFLAGS) -E $? | tr -d '\015' > /tmp/temp.i
|
||||
cc $(CFLAGS) -o $@ /tmp/temp.i
|
||||
$(ODIR)/bspfile.o : ../../common/bspfile.c
|
||||
cc $(CFLAGS) -E $? | tr -d '\015' > /tmp/temp.i
|
||||
cc $(CFLAGS) -o $@ /tmp/temp.i
|
||||
615
bsp/qvis3/qvis3.c
Normal file
615
bsp/qvis3/qvis3.c
Normal file
@@ -0,0 +1,615 @@
|
||||
/*
|
||||
===========================================================================
|
||||
Copyright (C) 1997-2006 Id Software, Inc.
|
||||
|
||||
This file is part of Quake 2 Tools source code.
|
||||
|
||||
Quake 2 Tools source code 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.
|
||||
|
||||
Quake 2 Tools source code 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 Quake 2 Tools source code; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
===========================================================================
|
||||
*/
|
||||
|
||||
#include "vis.h"
|
||||
#include "threads.h"
|
||||
#include "stdlib.h"
|
||||
|
||||
int numportals;
|
||||
int portalclusters;
|
||||
|
||||
char inbase[32];
|
||||
char outbase[32];
|
||||
|
||||
portal_t *portals;
|
||||
leaf_t *leafs;
|
||||
|
||||
int c_portaltest, c_portalpass, c_portalcheck;
|
||||
|
||||
byte *uncompressedvis;
|
||||
|
||||
byte *vismap, *vismap_p, *vismap_end; // past visfile
|
||||
int originalvismapsize;
|
||||
|
||||
int leafbytes; // (portalclusters+63)>>3
|
||||
int leaflongs;
|
||||
|
||||
int portalbytes, portallongs;
|
||||
|
||||
qboolean fastvis;
|
||||
qboolean nosort;
|
||||
|
||||
int testlevel = 2;
|
||||
|
||||
int totalvis;
|
||||
|
||||
portal_t *sorted_portals[MAX_MAP_PORTALS*2];
|
||||
|
||||
|
||||
//=============================================================================
|
||||
|
||||
void PlaneFromWinding (winding_t *w, plane_t *plane)
|
||||
{
|
||||
vec3_t v1, v2;
|
||||
|
||||
// calc plane
|
||||
VectorSubtract (w->points[2], w->points[1], v1);
|
||||
VectorSubtract (w->points[0], w->points[1], v2);
|
||||
CrossProduct (v2, v1, plane->normal);
|
||||
VectorNormalize (plane->normal, plane->normal);
|
||||
plane->dist = DotProduct (w->points[0], plane->normal);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
==================
|
||||
NewWinding
|
||||
==================
|
||||
*/
|
||||
winding_t *NewWinding (int points)
|
||||
{
|
||||
winding_t *w;
|
||||
int size;
|
||||
|
||||
if (points > MAX_POINTS_ON_WINDING)
|
||||
Error ("NewWinding: %i points", points);
|
||||
|
||||
size = (int)((winding_t *)0)->points[points];
|
||||
w = malloc (size);
|
||||
memset (w, 0, size);
|
||||
|
||||
return w;
|
||||
}
|
||||
|
||||
|
||||
|
||||
void pw(winding_t *w)
|
||||
{
|
||||
int i;
|
||||
for (i=0 ; i<w->numpoints ; i++)
|
||||
printf ("(%5.1f, %5.1f, %5.1f)\n",w->points[i][0], w->points[i][1],w->points[i][2]);
|
||||
}
|
||||
|
||||
void prl(leaf_t *l)
|
||||
{
|
||||
int i;
|
||||
portal_t *p;
|
||||
plane_t pl;
|
||||
|
||||
for (i=0 ; i<l->numportals ; i++)
|
||||
{
|
||||
p = l->portals[i];
|
||||
pl = p->plane;
|
||||
printf ("portal %4i to leaf %4i : %7.1f : (%4.1f, %4.1f, %4.1f)\n",(int)(p-portals),p->leaf,pl.dist, pl.normal[0], pl.normal[1], pl.normal[2]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//=============================================================================
|
||||
|
||||
/*
|
||||
=============
|
||||
SortPortals
|
||||
|
||||
Sorts the portals from the least complex, so the later ones can reuse
|
||||
the earlier information.
|
||||
=============
|
||||
*/
|
||||
int PComp (const void *a, const void *b)
|
||||
{
|
||||
if ( (*(portal_t **)a)->nummightsee == (*(portal_t **)b)->nummightsee)
|
||||
return 0;
|
||||
if ( (*(portal_t **)a)->nummightsee < (*(portal_t **)b)->nummightsee)
|
||||
return -1;
|
||||
return 1;
|
||||
}
|
||||
void SortPortals (void)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i=0 ; i<numportals*2 ; i++)
|
||||
sorted_portals[i] = &portals[i];
|
||||
|
||||
if (nosort)
|
||||
return;
|
||||
qsort (sorted_portals, numportals*2, sizeof(sorted_portals[0]), PComp);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
==============
|
||||
LeafVectorFromPortalVector
|
||||
==============
|
||||
*/
|
||||
int LeafVectorFromPortalVector (byte *portalbits, byte *leafbits)
|
||||
{
|
||||
int i;
|
||||
portal_t *p;
|
||||
int c_leafs;
|
||||
|
||||
|
||||
memset (leafbits, 0, leafbytes);
|
||||
|
||||
for (i=0 ; i<numportals*2 ; i++)
|
||||
{
|
||||
if (portalbits[i>>3] & (1<<(i&7)) )
|
||||
{
|
||||
p = portals+i;
|
||||
leafbits[p->leaf>>3] |= (1<<(p->leaf&7));
|
||||
}
|
||||
}
|
||||
|
||||
c_leafs = CountBits (leafbits, portalclusters);
|
||||
|
||||
return c_leafs;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===============
|
||||
ClusterMerge
|
||||
|
||||
Merges the portal visibility for a leaf
|
||||
===============
|
||||
*/
|
||||
void ClusterMerge (int leafnum)
|
||||
{
|
||||
leaf_t *leaf;
|
||||
byte portalvector[MAX_PORTALS/8];
|
||||
byte uncompressed[MAX_MAP_LEAFS/8];
|
||||
byte compressed[MAX_MAP_LEAFS/8];
|
||||
int i, j;
|
||||
int numvis;
|
||||
byte *dest;
|
||||
portal_t *p;
|
||||
int pnum;
|
||||
|
||||
// OR together all the portalvis bits
|
||||
|
||||
memset (portalvector, 0, portalbytes);
|
||||
leaf = &leafs[leafnum];
|
||||
for (i=0 ; i<leaf->numportals ; i++)
|
||||
{
|
||||
p = leaf->portals[i];
|
||||
if (p->status != stat_done)
|
||||
Error ("portal not done");
|
||||
for (j=0 ; j<portallongs ; j++)
|
||||
((long *)portalvector)[j] |= ((long *)p->portalvis)[j];
|
||||
pnum = p - portals;
|
||||
portalvector[pnum>>3] |= 1<<(pnum&7);
|
||||
}
|
||||
|
||||
// convert portal bits to leaf bits
|
||||
numvis = LeafVectorFromPortalVector (portalvector, uncompressed);
|
||||
|
||||
if (uncompressed[leafnum>>3] & (1<<(leafnum&7)))
|
||||
printf ("WARNING: Leaf portals saw into leaf\n");
|
||||
|
||||
uncompressed[leafnum>>3] |= (1<<(leafnum&7));
|
||||
numvis++; // count the leaf itself
|
||||
|
||||
// save uncompressed for PHS calculation
|
||||
memcpy (uncompressedvis + leafnum*leafbytes, uncompressed, leafbytes);
|
||||
|
||||
//
|
||||
// compress the bit string
|
||||
//
|
||||
qprintf ("cluster %4i : %4i visible\n", leafnum, numvis);
|
||||
totalvis += numvis;
|
||||
|
||||
i = CompressVis (uncompressed, compressed);
|
||||
|
||||
dest = vismap_p;
|
||||
vismap_p += i;
|
||||
|
||||
if (vismap_p > vismap_end)
|
||||
Error ("Vismap expansion overflow");
|
||||
|
||||
dvis->bitofs[leafnum][DVIS_PVS] = dest-vismap;
|
||||
|
||||
memcpy (dest, compressed, i);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
==================
|
||||
CalcPortalVis
|
||||
==================
|
||||
*/
|
||||
void CalcPortalVis (void)
|
||||
{
|
||||
int i;
|
||||
|
||||
// fastvis just uses mightsee for a very loose bound
|
||||
if (fastvis)
|
||||
{
|
||||
for (i=0 ; i<numportals*2 ; i++)
|
||||
{
|
||||
portals[i].portalvis = portals[i].portalflood;
|
||||
portals[i].status = stat_done;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
RunThreadsOnIndividual (numportals*2, true, PortalFlow);
|
||||
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
==================
|
||||
CalcVis
|
||||
==================
|
||||
*/
|
||||
void CalcVis (void)
|
||||
{
|
||||
int i;
|
||||
|
||||
RunThreadsOnIndividual (numportals*2, true, BasePortalVis);
|
||||
|
||||
// RunThreadsOnIndividual (numportals*2, true, BetterPortalVis);
|
||||
|
||||
SortPortals ();
|
||||
|
||||
CalcPortalVis ();
|
||||
|
||||
//
|
||||
// assemble the leaf vis lists by oring and compressing the portal lists
|
||||
//
|
||||
for (i=0 ; i<portalclusters ; i++)
|
||||
ClusterMerge (i);
|
||||
|
||||
printf ("Average clusters visible: %i\n", totalvis / portalclusters);
|
||||
}
|
||||
|
||||
|
||||
void SetPortalSphere (portal_t *p)
|
||||
{
|
||||
int i;
|
||||
vec3_t total, dist;
|
||||
winding_t *w;
|
||||
float r, bestr;
|
||||
|
||||
w = p->winding;
|
||||
VectorCopy (vec3_origin, total);
|
||||
for (i=0 ; i<w->numpoints ; i++)
|
||||
{
|
||||
VectorAdd (total, w->points[i], total);
|
||||
}
|
||||
|
||||
for (i=0 ; i<3 ; i++)
|
||||
total[i] /= w->numpoints;
|
||||
|
||||
bestr = 0;
|
||||
for (i=0 ; i<w->numpoints ; i++)
|
||||
{
|
||||
VectorSubtract (w->points[i], total, dist);
|
||||
r = VectorLength (dist);
|
||||
if (r > bestr)
|
||||
bestr = r;
|
||||
}
|
||||
VectorCopy (total, p->origin);
|
||||
p->radius = bestr;
|
||||
}
|
||||
|
||||
/*
|
||||
============
|
||||
LoadPortals
|
||||
============
|
||||
*/
|
||||
void LoadPortals (char *name)
|
||||
{
|
||||
int i, j;
|
||||
portal_t *p;
|
||||
leaf_t *l;
|
||||
char magic[80];
|
||||
FILE *f;
|
||||
int numpoints;
|
||||
winding_t *w;
|
||||
int leafnums[2];
|
||||
plane_t plane;
|
||||
|
||||
if (!strcmp(name,"-"))
|
||||
f = stdin;
|
||||
else
|
||||
{
|
||||
f = fopen(name, "r");
|
||||
if (!f)
|
||||
Error ("LoadPortals: couldn't read %s\n",name);
|
||||
}
|
||||
|
||||
if (fscanf (f,"%79s\n%i\n%i\n",magic, &portalclusters, &numportals) != 3)
|
||||
Error ("LoadPortals: failed to read header");
|
||||
if (strcmp(magic,PORTALFILE))
|
||||
Error ("LoadPortals: not a portal file");
|
||||
|
||||
printf ("%4i portalclusters\n", portalclusters);
|
||||
printf ("%4i numportals\n", numportals);
|
||||
|
||||
// these counts should take advantage of 64 bit systems automatically
|
||||
leafbytes = ((portalclusters+63)&~63)>>3;
|
||||
leaflongs = leafbytes/sizeof(long);
|
||||
|
||||
portalbytes = ((numportals*2+63)&~63)>>3;
|
||||
portallongs = portalbytes/sizeof(long);
|
||||
|
||||
// each file portal is split into two memory portals
|
||||
portals = malloc(2*numportals*sizeof(portal_t));
|
||||
memset (portals, 0, 2*numportals*sizeof(portal_t));
|
||||
|
||||
leafs = malloc(portalclusters*sizeof(leaf_t));
|
||||
memset (leafs, 0, portalclusters*sizeof(leaf_t));
|
||||
|
||||
originalvismapsize = portalclusters*leafbytes;
|
||||
uncompressedvis = malloc(originalvismapsize);
|
||||
|
||||
vismap = vismap_p = dvisdata;
|
||||
dvis->numclusters = portalclusters;
|
||||
vismap_p = (byte *)&dvis->bitofs[portalclusters];
|
||||
|
||||
vismap_end = vismap + MAX_MAP_VISIBILITY;
|
||||
|
||||
for (i=0, p=portals ; i<numportals ; i++)
|
||||
{
|
||||
if (fscanf (f, "%i %i %i ", &numpoints, &leafnums[0], &leafnums[1])
|
||||
!= 3)
|
||||
Error ("LoadPortals: reading portal %i", i);
|
||||
if (numpoints > MAX_POINTS_ON_WINDING)
|
||||
Error ("LoadPortals: portal %i has too many points", i);
|
||||
if ( (unsigned)leafnums[0] > portalclusters
|
||||
|| (unsigned)leafnums[1] > portalclusters)
|
||||
Error ("LoadPortals: reading portal %i", i);
|
||||
|
||||
w = p->winding = NewWinding (numpoints);
|
||||
w->original = true;
|
||||
w->numpoints = numpoints;
|
||||
|
||||
for (j=0 ; j<numpoints ; j++)
|
||||
{
|
||||
double v[3];
|
||||
int k;
|
||||
|
||||
// scanf into double, then assign to vec_t
|
||||
// so we don't care what size vec_t is
|
||||
if (fscanf (f, "(%lf %lf %lf ) "
|
||||
, &v[0], &v[1], &v[2]) != 3)
|
||||
Error ("LoadPortals: reading portal %i", i);
|
||||
for (k=0 ; k<3 ; k++)
|
||||
w->points[j][k] = v[k];
|
||||
}
|
||||
fscanf (f, "\n");
|
||||
|
||||
// calc plane
|
||||
PlaneFromWinding (w, &plane);
|
||||
|
||||
// create forward portal
|
||||
l = &leafs[leafnums[0]];
|
||||
if (l->numportals == MAX_PORTALS_ON_LEAF)
|
||||
Error ("Leaf with too many portals");
|
||||
l->portals[l->numportals] = p;
|
||||
l->numportals++;
|
||||
|
||||
p->winding = w;
|
||||
VectorSubtract (vec3_origin, plane.normal, p->plane.normal);
|
||||
p->plane.dist = -plane.dist;
|
||||
p->leaf = leafnums[1];
|
||||
SetPortalSphere (p);
|
||||
p++;
|
||||
|
||||
// create backwards portal
|
||||
l = &leafs[leafnums[1]];
|
||||
if (l->numportals == MAX_PORTALS_ON_LEAF)
|
||||
Error ("Leaf with too many portals");
|
||||
l->portals[l->numportals] = p;
|
||||
l->numportals++;
|
||||
|
||||
p->winding = NewWinding(w->numpoints);
|
||||
p->winding->numpoints = w->numpoints;
|
||||
for (j=0 ; j<w->numpoints ; j++)
|
||||
{
|
||||
VectorCopy (w->points[w->numpoints-1-j], p->winding->points[j]);
|
||||
}
|
||||
|
||||
p->plane = plane;
|
||||
p->leaf = leafnums[0];
|
||||
SetPortalSphere (p);
|
||||
p++;
|
||||
|
||||
}
|
||||
|
||||
fclose (f);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
================
|
||||
CalcPHS
|
||||
|
||||
Calculate the PHS (Potentially Hearable Set)
|
||||
by ORing together all the PVS visible from a leaf
|
||||
================
|
||||
*/
|
||||
void CalcPHS (void)
|
||||
{
|
||||
int i, j, k, l, index;
|
||||
int bitbyte;
|
||||
long *dest, *src;
|
||||
byte *scan;
|
||||
int count;
|
||||
byte uncompressed[MAX_MAP_LEAFS/8];
|
||||
byte compressed[MAX_MAP_LEAFS/8];
|
||||
|
||||
printf ("Building PHS...\n");
|
||||
|
||||
count = 0;
|
||||
for (i=0 ; i<portalclusters ; i++)
|
||||
{
|
||||
scan = uncompressedvis + i*leafbytes;
|
||||
memcpy (uncompressed, scan, leafbytes);
|
||||
for (j=0 ; j<leafbytes ; j++)
|
||||
{
|
||||
bitbyte = scan[j];
|
||||
if (!bitbyte)
|
||||
continue;
|
||||
for (k=0 ; k<8 ; k++)
|
||||
{
|
||||
if (! (bitbyte & (1<<k)) )
|
||||
continue;
|
||||
// OR this pvs row into the phs
|
||||
index = ((j<<3)+k);
|
||||
if (index >= portalclusters)
|
||||
Error ("Bad bit in PVS"); // pad bits should be 0
|
||||
src = (long *)(uncompressedvis + index*leafbytes);
|
||||
dest = (long *)uncompressed;
|
||||
for (l=0 ; l<leaflongs ; l++)
|
||||
((long *)uncompressed)[l] |= src[l];
|
||||
}
|
||||
}
|
||||
for (j=0 ; j<portalclusters ; j++)
|
||||
if (uncompressed[j>>3] & (1<<(j&7)) )
|
||||
count++;
|
||||
|
||||
//
|
||||
// compress the bit string
|
||||
//
|
||||
j = CompressVis (uncompressed, compressed);
|
||||
|
||||
dest = (long *)vismap_p;
|
||||
vismap_p += j;
|
||||
|
||||
if (vismap_p > vismap_end)
|
||||
Error ("Vismap expansion overflow");
|
||||
|
||||
dvis->bitofs[i][DVIS_PHS] = (byte *)dest-vismap;
|
||||
|
||||
memcpy (dest, compressed, j);
|
||||
}
|
||||
|
||||
printf ("Average clusters hearable: %i\n", count/portalclusters);
|
||||
}
|
||||
|
||||
/*
|
||||
===========
|
||||
main
|
||||
===========
|
||||
*/
|
||||
int main (int argc, char **argv)
|
||||
{
|
||||
char portalfile[1024];
|
||||
char source[1024];
|
||||
char name[1024];
|
||||
int i;
|
||||
double start, end;
|
||||
|
||||
printf ("---- vis ----\n");
|
||||
|
||||
verbose = false;
|
||||
for (i=1 ; i<argc ; i++)
|
||||
{
|
||||
if (!strcmp(argv[i],"-threads"))
|
||||
{
|
||||
numthreads = atoi (argv[i+1]);
|
||||
i++;
|
||||
}
|
||||
else if (!strcmp(argv[i], "-fast"))
|
||||
{
|
||||
printf ("fastvis = true\n");
|
||||
fastvis = true;
|
||||
}
|
||||
else if (!strcmp(argv[i], "-level"))
|
||||
{
|
||||
testlevel = atoi(argv[i+1]);
|
||||
printf ("testlevel = %i\n", testlevel);
|
||||
i++;
|
||||
}
|
||||
else if (!strcmp(argv[i], "-v"))
|
||||
{
|
||||
printf ("verbose = true\n");
|
||||
verbose = true;
|
||||
}
|
||||
else if (!strcmp (argv[i],"-nosort"))
|
||||
{
|
||||
printf ("nosort = true\n");
|
||||
nosort = true;
|
||||
}
|
||||
else if (!strcmp (argv[i],"-tmpin"))
|
||||
strcpy (inbase, "/tmp");
|
||||
else if (!strcmp (argv[i],"-tmpout"))
|
||||
strcpy (outbase, "/tmp");
|
||||
else if (argv[i][0] == '-')
|
||||
Error ("Unknown option \"%s\"", argv[i]);
|
||||
else
|
||||
break;
|
||||
}
|
||||
|
||||
if (i != argc - 1)
|
||||
Error ("usage: vis [-threads #] [-level 0-4] [-fast] [-v] bspfile");
|
||||
|
||||
start = I_FloatTime ();
|
||||
|
||||
ThreadSetDefault ();
|
||||
|
||||
SetQdirFromPath (argv[i]);
|
||||
strcpy (source, ExpandArg(argv[i]));
|
||||
StripExtension (source);
|
||||
DefaultExtension (source, ".bsp");
|
||||
|
||||
sprintf (name, "%s%s", inbase, source);
|
||||
printf ("reading %s\n", name);
|
||||
LoadBSPFile (name);
|
||||
if (numnodes == 0 || numfaces == 0)
|
||||
Error ("Empty map");
|
||||
|
||||
sprintf (portalfile, "%s%s", inbase, ExpandArg(argv[i]));
|
||||
StripExtension (portalfile);
|
||||
strcat (portalfile, ".prt");
|
||||
|
||||
printf ("reading %s\n", portalfile);
|
||||
LoadPortals (portalfile);
|
||||
|
||||
CalcVis ();
|
||||
|
||||
CalcPHS ();
|
||||
|
||||
visdatasize = vismap_p - dvisdata;
|
||||
printf ("visdatasize:%i compressed from %i\n", visdatasize, originalvismapsize*2);
|
||||
|
||||
sprintf (name, "%s%s", outbase, source);
|
||||
printf ("writing %s\n", name);
|
||||
WriteBSPFile (name);
|
||||
|
||||
end = I_FloatTime ();
|
||||
printf ("%5.1f seconds elapsed\n", end-start);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
149
bsp/qvis3/vis.h
Normal file
149
bsp/qvis3/vis.h
Normal file
@@ -0,0 +1,149 @@
|
||||
/*
|
||||
===========================================================================
|
||||
Copyright (C) 1997-2006 Id Software, Inc.
|
||||
|
||||
This file is part of Quake 2 Tools source code.
|
||||
|
||||
Quake 2 Tools source code 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.
|
||||
|
||||
Quake 2 Tools source code 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 Quake 2 Tools source code; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
===========================================================================
|
||||
*/
|
||||
|
||||
#include "cmdlib.h"
|
||||
#include "mathlib.h"
|
||||
#include "bspfile.h"
|
||||
|
||||
#define MAX_PORTALS 32768
|
||||
|
||||
#define PORTALFILE "PRT1"
|
||||
|
||||
#define ON_EPSILON 0.1
|
||||
|
||||
typedef struct
|
||||
{
|
||||
vec3_t normal;
|
||||
float dist;
|
||||
} plane_t;
|
||||
|
||||
#define MAX_POINTS_ON_WINDING 64
|
||||
#define MAX_POINTS_ON_FIXED_WINDING 12
|
||||
|
||||
typedef struct
|
||||
{
|
||||
qboolean original; // don't free, it's part of the portal
|
||||
int numpoints;
|
||||
vec3_t points[MAX_POINTS_ON_FIXED_WINDING]; // variable sized
|
||||
} winding_t;
|
||||
|
||||
winding_t *NewWinding (int points);
|
||||
void FreeWinding (winding_t *w);
|
||||
winding_t *CopyWinding (winding_t *w);
|
||||
|
||||
|
||||
typedef enum {stat_none, stat_working, stat_done} vstatus_t;
|
||||
typedef struct
|
||||
{
|
||||
plane_t plane; // normal pointing into neighbor
|
||||
int leaf; // neighbor
|
||||
|
||||
vec3_t origin; // for fast clip testing
|
||||
float radius;
|
||||
|
||||
winding_t *winding;
|
||||
vstatus_t status;
|
||||
byte *portalfront; // [portals], preliminary
|
||||
byte *portalflood; // [portals], intermediate
|
||||
byte *portalvis; // [portals], final
|
||||
|
||||
int nummightsee; // bit count on portalflood for sort
|
||||
} portal_t;
|
||||
|
||||
typedef struct seperating_plane_s
|
||||
{
|
||||
struct seperating_plane_s *next;
|
||||
plane_t plane; // from portal is on positive side
|
||||
} sep_t;
|
||||
|
||||
|
||||
typedef struct passage_s
|
||||
{
|
||||
struct passage_s *next;
|
||||
int from, to; // leaf numbers
|
||||
sep_t *planes;
|
||||
} passage_t;
|
||||
|
||||
#define MAX_PORTALS_ON_LEAF 128
|
||||
typedef struct leaf_s
|
||||
{
|
||||
int numportals;
|
||||
passage_t *passages;
|
||||
portal_t *portals[MAX_PORTALS_ON_LEAF];
|
||||
} leaf_t;
|
||||
|
||||
|
||||
typedef struct pstack_s
|
||||
{
|
||||
byte mightsee[MAX_PORTALS/8]; // bit string
|
||||
struct pstack_s *next;
|
||||
leaf_t *leaf;
|
||||
portal_t *portal; // portal exiting
|
||||
winding_t *source;
|
||||
winding_t *pass;
|
||||
|
||||
winding_t windings[3]; // source, pass, temp in any order
|
||||
int freewindings[3];
|
||||
|
||||
plane_t portalplane;
|
||||
} pstack_t;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
portal_t *base;
|
||||
int c_chains;
|
||||
pstack_t pstack_head;
|
||||
} threaddata_t;
|
||||
|
||||
|
||||
|
||||
extern int numportals;
|
||||
extern int portalclusters;
|
||||
|
||||
extern portal_t *portals;
|
||||
extern leaf_t *leafs;
|
||||
|
||||
extern int c_portaltest, c_portalpass, c_portalcheck;
|
||||
extern int c_portalskip, c_leafskip;
|
||||
extern int c_vistest, c_mighttest;
|
||||
extern int c_chains;
|
||||
|
||||
extern byte *vismap, *vismap_p, *vismap_end; // past visfile
|
||||
|
||||
extern int testlevel;
|
||||
|
||||
extern byte *uncompressed;
|
||||
|
||||
extern int leafbytes, leaflongs;
|
||||
extern int portalbytes, portallongs;
|
||||
|
||||
|
||||
void LeafFlow (int leafnum);
|
||||
|
||||
|
||||
void BasePortalVis (int portalnum);
|
||||
void BetterPortalVis (int portalnum);
|
||||
void PortalFlow (int portalnum);
|
||||
|
||||
extern portal_t *sorted_portals[MAX_MAP_PORTALS*2];
|
||||
|
||||
int CountBits (byte *bits, int numbits);
|
||||
Reference in New Issue
Block a user