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/vis/vis.c

1273 lines
28 KiB
C
Raw Blame History

// vis.c
#include <limits.h>
#include <stddef.h>
#include <vis/leafbits.h>
#include <vis/vis.h>
#include <common/log.h>
#include <common/threads.h>
/*
* If the portal file is "PRT2" format, then the leafs we are dealing with are
* really clusters of leaves. So, after the vis job is done we need to expand
* the clusters to the real leaf numbers before writing back to the bsp file.
*/
int numportals;
int portalleafs; /* leafs (PRT1) or clusters (PRT2) */
int portalleafs_real; /* real no. of leafs after expanding PRT2 clusters */
int *clustermap; /* mapping from real leaf to cluster number */
portal_t *portals;
leaf_t *leafs;
int c_portaltest, c_portalpass, c_portalcheck, c_mightseeupdate;
int c_noclip = 0;
qboolean showgetleaf = true;
static byte *vismap;
static byte *vismap_p;
static byte *vismap_end; // past visfile
int originalvismapsize;
byte *uncompressed; // [leafbytes_real*portalleafs_real]
int leafbytes; // (portalleafs+63)>>3
int leaflongs;
int leafbytes_real; // (portalleafs_real+63)>>3
/* Options - TODO: collect these in a struct */
qboolean fastvis;
static int verbose = 0;
int testlevel = 4;
qboolean ambientsky = true;
qboolean ambientwater = true;
qboolean ambientslime = true;
qboolean ambientlava = true;
#if 0
void
NormalizePlane(plane_t *dp)
{
vec_t ax, ay, az;
if (dp->normal[0] == -1.0) {
dp->normal[0] = 1.0;
dp->dist = -dp->dist;
return;
}
if (dp->normal[1] == -1.0) {
dp->normal[1] = 1.0;
dp->dist = -dp->dist;
return;
}
if (dp->normal[2] == -1.0) {
dp->normal[2] = 1.0;
dp->dist = -dp->dist;
return;
}
ax = fabs(dp->normal[0]);
ay = fabs(dp->normal[1]);
az = fabs(dp->normal[2]);
if (ax >= ay && ax >= az) {
if (dp->normal[0] < 0) {
VectorSubtract(vec3_origin, dp->normal, dp->normal);
dp->dist = -dp->dist;
}
return;
}
if (ay >= ax && ay >= az) {
if (dp->normal[1] < 0) {
VectorSubtract(vec3_origin, dp->normal, dp->normal);
dp->dist = -dp->dist;
}
return;
}
if (dp->normal[2] < 0) {
VectorSubtract(vec3_origin, dp->normal, dp->normal);
dp->dist = -dp->dist;
}
}
#endif
void
PlaneFromWinding(const 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->dist = DotProduct(w->points[0], plane->normal);
}
//============================================================================
/*
==================
NewWinding
==================
*/
winding_t *
NewWinding(int points)
{
winding_t *w;
int size;
if (points > MAX_WINDING)
Error("%s: %i points", __func__, points);
size = offsetof(winding_t, 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++)
logprint("(%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;
logprint("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]);
}
}
/*
==================
CopyWinding
==================
*/
winding_t *
CopyWinding(winding_t * w)
{
int size;
winding_t *c;
size = offsetof(winding_t, points[w->numpoints]);
c = malloc(size);
memcpy(c, w, size);
return c;
}
/*
==================
AllocStackWinding
Return a pointer to a free fixed winding on the stack
==================
*/
winding_t *
AllocStackWinding(pstack_t *stack)
{
int i;
for (i = 0; i < STACK_WINDINGS; i++) {
if (stack->freewindings[i]) {
stack->freewindings[i] = 0;
return &stack->windings[i];
}
}
Error("%s: failed", __func__);
return NULL;
}
/*
==================
FreeStackWinding
As long as the winding passed in is local to the stack, free it. Otherwise,
do nothing (the winding either belongs to a portal or another stack
structure further up the call chain).
==================
*/
void
FreeStackWinding(winding_t *w, pstack_t *stack)
{
unsigned long i = w - stack->windings;
if (i < STACK_WINDINGS) {
if (stack->freewindings[i])
Error("%s: winding already freed", __func__);
stack->freewindings[i] = 1;
}
}
/*
==================
ClipStackWinding
Clips the winding to the plane, returning the new winding on the positive
side. Frees the input winding (if on stack). If the resulting winding would
have too many points, the clip operation is aborted and the original winding
is returned.
==================
*/
winding_t *
ClipStackWinding(winding_t *in, pstack_t *stack, plane_t *split)
{
vec_t dists[MAX_WINDING];
int sides[MAX_WINDING];
int counts[3];
vec_t dot;
int i, j;
vec_t *p1, *p2;
vec3_t mid;
winding_t *neww;
/* Fast test first */
dot = DotProduct(in->origin, split->normal) - split->dist;
if (dot < -in->radius) {
FreeStackWinding(in, stack);
return NULL;
} else if (dot > in->radius) {
return in;
}
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]]++;
}
sides[i] = sides[0];
dists[i] = dists[0];
if (!counts[0]) {
FreeStackWinding(in, stack);
return NULL;
}
if (!counts[1])
return in;
neww = AllocStackWinding(stack);
neww->numpoints = 0;
VectorCopy(in->origin, neww->origin);
neww->radius = in->radius;
for (i = 0; i < in->numpoints; i++) {
p1 = in->points[i];
if (neww->numpoints == MAX_WINDING_FIXED) {
/* Can't clip, fall back to original */
FreeStackWinding(neww, stack);
c_noclip++;
return in;
}
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;
// 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++;
}
FreeStackWinding(in, stack);
return neww;
}
//============================================================================
/*
=============
GetNextPortal
Returns the next portal for a thread to work on
Returns the portals from the least complex, so the later ones can reuse
the earlier information.
=============
*/
portal_t *
GetNextPortal(void)
{
int i;
portal_t *p, *ret;
unsigned min;
ThreadLock();
min = INT_MAX;
ret = NULL;
for (i = 0, p = portals; i < numportals * 2; i++, p++) {
if (p->nummightsee < min && p->status == pstat_none) {
min = p->nummightsee;
ret = p;
}
}
if (ret) {
ret->status = pstat_working;
GetThreadWork_Locked__();
}
ThreadUnlock();
return ret;
}
/*
=============
UpdateMightSee
Called after completing a portal and finding that the source leaf is no
longer visible from the dest leaf. Visibility is symetrical, so the reverse
must also be true. Update mightsee for any portals on the source leaf which
haven't yet started processing.
Called with the lock held.
=============
*/
static void
UpdateMightsee(const leaf_t *source, const leaf_t *dest)
{
int i, leafnum;
portal_t *p;
leafnum = dest - leafs;
for (i = 0; i < source->numportals; i++) {
p = source->portals[i];
if (p->status != pstat_none)
continue;
if (TestLeafBit(p->mightsee, leafnum)) {
ClearLeafBit(p->mightsee, leafnum);
p->nummightsee--;
c_mightseeupdate++;
}
}
}
/*
=============
PortalCompleted
Mark the portal completed and propogate new vis information across
to the complementry portals.
Called with the lock held.
=============
*/
static void
PortalCompleted(portal_t *completed)
{
int i, j, k, bit, numblocks;
int leafnum;
const portal_t *p, *p2;
const leaf_t *myleaf;
const leafblock_t *might, *vis;
leafblock_t changed;
ThreadLock();
completed->status = pstat_done;
/*
* For each portal on the leaf, check the leafs we eliminated from
* mightsee during the full vis so far.
*/
myleaf = &leafs[completed->leaf];
for (i = 0; i < myleaf->numportals; i++) {
p = myleaf->portals[i];
if (p->status != pstat_done)
continue;
might = p->mightsee->bits;
vis = p->visbits->bits;
numblocks = (portalleafs + LEAFMASK) >> LEAFSHIFT;
for (j = 0; j < numblocks; j++) {
changed = might[j] & ~vis[j];
if (!changed)
continue;
/*
* If any of these changed bits are still visible from another
* portal, we can't update yet.
*/
for (k = 0; k < myleaf->numportals; k++) {
if (k == i)
continue;
p2 = myleaf->portals[k];
if (p2->status == pstat_done)
changed &= ~p2->visbits->bits[j];
else
changed &= ~p2->mightsee->bits[j];
if (!changed)
break;
}
/*
* Update mightsee for any of the changed bits that survived
*/
while (changed) {
bit = ffsl(changed) - 1;
changed &= ~(1UL << bit);
leafnum = (j << LEAFSHIFT) + bit;
UpdateMightsee(leafs + leafnum, myleaf);
}
}
}
ThreadUnlock();
}
double starttime, endtime, statetime;
static double stateinterval;
/*
==============
LeafThread
==============
*/
void *
LeafThread(void *unused)
{
double now;
portal_t *p;
do {
ThreadLock();
/* Save state if sufficient time has elapsed */
now = I_FloatTime();
if (now > statetime + stateinterval) {
statetime = now;
SaveVisState();
}
ThreadUnlock();
p = GetNextPortal();
if (!p)
break;
PortalFlow(p);
PortalCompleted(p);
if (verbose > 1) {
logprint("portal:%4i mightsee:%4i cansee:%4i\n",
(int)(p - portals), p->nummightsee, p->numcansee);
}
} while (1);
return NULL;
}
/*
===============
CompressRow
===============
*/
static int
CompressRow(const byte *vis, const int numbytes, byte *out)
{
int i, rep;
byte *dst;
dst = out;
for (i = 0; i < numbytes; i++) {
*dst++ = vis[i];
if (vis[i])
continue;
rep = 1;
for (i++; i < numbytes; i++)
if (vis[i] || rep == 255)
break;
else
rep++;
*dst++ = rep;
i--;
}
return dst - out;
}
/*
===============
LeafFlow
Builds the entire visibility list for a leaf
===============
*/
int totalvis;
void
LeafFlow(int leafnum)
{
leaf_t *leaf;
byte *outbuffer;
byte *compressed;
int i, j, shift, len;
int numvis;
byte *dest;
const portal_t *p;
/*
* flow through all portals, collecting visible bits
*/
outbuffer = uncompressed + leafnum * leafbytes;
leaf = &leafs[leafnum];
for (i = 0; i < leaf->numportals; i++) {
p = leaf->portals[i];
if (p->status != pstat_done)
Error("portal not done");
for (j = 0; j < leafbytes; j++) {
shift = (j << 3) & LEAFMASK;
outbuffer[j] |= (p->visbits->bits[j >> (LEAFSHIFT - 3)] >> shift) & 0xff;
}
}
if (outbuffer[leafnum >> 3] & (1 << (leafnum & 7)))
logprint("WARNING: Leaf portals saw into leaf (%i)\n", leafnum);
outbuffer[leafnum >> 3] |= (1 << (leafnum & 7));
numvis = 0;
for (i = 0; i < portalleafs; i++)
if (outbuffer[i >> 3] & (1 << (i & 3)))
numvis++;
/*
* compress the bit string
*/
if (verbose > 1)
logprint("leaf %4i : %4i visible\n", leafnum, numvis);
totalvis += numvis;
/* Allocate for worst case where RLE might grow the data (unlikely) */
compressed = malloc(portalleafs * 2 / 8);
len = CompressRow(outbuffer, (portalleafs + 7) >> 3, compressed);
dest = vismap_p;
vismap_p += len;
if (vismap_p > vismap_end)
Error("Vismap expansion overflow");
/* leaf 0 is a common solid */
dleafs[leafnum + 1].visofs = dest - vismap;
memcpy(dest, compressed, len);
free(compressed);
}
void
ClusterFlow(int leafnum, leafbits_t *buffer)
{
leaf_t *leaf;
byte *outbuffer;
byte *compressed;
int i, j, len;
int numvis, numblocks;
byte *dest;
const portal_t *p;
/*
* Collect visible bits from all portals into buffer
*/
leaf = &leafs[clustermap[leafnum]];
numblocks = (portalleafs + LEAFMASK) >> LEAFSHIFT;
for (i = 0; i < leaf->numportals; i++) {
p = leaf->portals[i];
if (p->status != pstat_done)
Error("portal not done");
for (j = 0; j < numblocks; j++)
buffer->bits[j] |= p->visbits->bits[j];
}
if (TestLeafBit(buffer, clustermap[leafnum]))
logprint("WARNING: Leaf portals saw into leaf (%i)\n", leafnum);
SetLeafBit(buffer, clustermap[leafnum]);
/*
* Now expand the clusters into the full leaf visibility map
*/
numvis = 0;
outbuffer = uncompressed + leafnum * leafbytes_real;
for (i = 0; i < portalleafs_real; i++) {
if (TestLeafBit(buffer, clustermap[i])) {
outbuffer[i >> 3] |= (1 << (i & 7));
numvis++;
}
}
/*
* compress the bit string
*/
if (verbose > 1)
logprint("leaf %4i : %4i visible\n", leafnum, numvis);
totalvis += numvis;
/* Allocate for worst case where RLE might grow the data (unlikely) */
compressed = malloc(portalleafs_real * 2 / 8);
len = CompressRow(outbuffer, (portalleafs_real + 7) >> 3, compressed);
dest = vismap_p;
vismap_p += len;
if (vismap_p > vismap_end)
Error("Vismap expansion overflow");
/* leaf 0 is a common solid */
dleafs[leafnum + 1].visofs = dest - vismap;
memcpy(dest, compressed, len);
free(compressed);
}
/*
==================
CalcPortalVis
==================
*/
void
CalcPortalVis(void)
{
int i, startcount;
portal_t *p;
// fastvis just uses mightsee for a very loose bound
if (fastvis) {
for (i = 0; i < numportals * 2; i++) {
portals[i].visbits = portals[i].mightsee;
portals[i].status = pstat_done;
}
return;
}
/*
* Count the already completed portals in case we loaded previous state
*/
startcount = 0;
for (i = 0, p = portals; i < numportals * 2; i++, p++) {
if (p->status == pstat_done)
startcount++;
}
RunThreadsOn(startcount, numportals * 2, LeafThread);
if (verbose) {
logprint("portalcheck: %i portaltest: %i portalpass: %i\n",
c_portalcheck, c_portaltest, c_portalpass);
logprint("c_vistest: %i c_mighttest: %i c_mightseeupdate %i\n",
c_vistest, c_mighttest, c_mightseeupdate);
}
}
/*
==================
CalcVis
==================
*/
void
CalcVis(void)
{
int i;
if (LoadVisState()) {
logprint("Loaded previous state. Resuming progress...\n");
} else {
logprint("Calculating Base Vis:\n");
BasePortalVis();
}
logprint("Calculating Full Vis:\n");
CalcPortalVis();
//
// assemble the leaf vis lists by oring and compressing the portal lists
//
if (portalleafs == portalleafs_real) {
for (i = 0; i < portalleafs; i++)
LeafFlow(i);
} else {
leafbits_t *buffer;
logprint("Expanding clusters...\n");
buffer = malloc(LeafbitsSize(portalleafs));
for (i = 0; i < portalleafs_real; i++) {
memset(buffer, 0, LeafbitsSize(portalleafs));
ClusterFlow(i, buffer);
}
free(buffer);
}
logprint("average leafs visible: %i\n", totalvis / portalleafs_real);
}
/*
============================================================================
PASSAGE CALCULATION (not used yet...)
============================================================================
*/
int count_sep;
qboolean
PlaneCompare(plane_t *p1, plane_t *p2)
{
int i;
if (fabs(p1->dist - p2->dist) > 0.01)
return false;
for (i = 0; i < 3; i++)
if (fabs(p1->normal[i] - p2->normal[i]) > 0.001)
return false;
return true;
}
sep_t *
Findpassages(winding_t * source, winding_t * pass)
{
int i, j, k, l;
plane_t plane;
vec3_t v1, v2;
float d;
double length;
int counts[3];
qboolean fliptest;
sep_t *sep, *list;
list = NULL;
// 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] *= (vec_t)length;
plane.normal[1] *= (vec_t)length;
plane.normal[2] *= (vec_t)length;
plane.dist = DotProduct(pass->points[j], plane.normal);
//
// find out which side of the generated seperating plane has the
// source portal
//
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
//
// flip the normal if the source portal is backwards
//
if (fliptest) {
VectorSubtract(vec3_origin, plane.normal, plane.normal);
plane.dist = -plane.dist;
}
//
// 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 pass portal
//
// save this out
//
count_sep++;
sep = malloc(sizeof(*sep));
sep->next = list;
list = sep;
sep->plane = plane;
}
}
return list;
}
/*
============
CalcPassages
============
*/
void
CalcPassages(void)
{
int i, j, k;
int count, count2;
leaf_t *l;
portal_t *p1, *p2;
sep_t *sep;
passage_t *passages;
logprint("building passages...\n");
count = count2 = 0;
for (i = 0; i < portalleafs; i++) {
l = &leafs[i];
for (j = 0; j < l->numportals; j++) {
p1 = l->portals[j];
for (k = 0; k < l->numportals; k++) {
if (k == j)
continue;
count++;
p2 = l->portals[k];
// definately can't see into a coplanar portal
if (PlaneCompare(&p1->plane, &p2->plane))
continue;
count2++;
sep = Findpassages(p1->winding, p2->winding);
if (!sep) {
// Error ("No seperating planes found in portal pair");
count_sep++;
sep = malloc(sizeof(*sep));
sep->next = NULL;
sep->plane = p1->plane;
}
passages = malloc(sizeof(*passages));
passages->planes = sep;
passages->from = p1->leaf;
passages->to = p2->leaf;
passages->next = l->passages;
l->passages = passages;
}
}
}
logprint("numpassages: %i (%i)\n", count2, count);
logprint("total passages: %i\n", count_sep);
}
// ===========================================================================
static void
SetWindingSphere(winding_t *w)
{
int i;
vec3_t origin, dist;
vec_t r, max_r;
VectorCopy(vec3_origin, origin);
for (i = 0; i < w->numpoints; i++)
VectorAdd(origin, w->points[i], origin);
VectorScale(origin, 1.0 / w->numpoints, origin);
max_r = 0;
for (i = 0; i < w->numpoints; i++) {
VectorSubtract(w->points[i], origin, dist);
r = VectorLength(dist);
if (r > max_r)
max_r = r;
}
VectorCopy(origin, w->origin);
w->radius = max_r;
}
/*
============
LoadPortals
============
*/
void
LoadPortals(char *name)
{
int i, j, count;
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) {
logprint("%s: couldn't read %s\n", __func__, name);
logprint("No vising performed.\n");
exit(1);
}
}
/*
* Parse the portal file header
*/
count = fscanf(f, "%79s\n", magic);
if (count != 1)
Error("%s: unknown header: %s\n", __func__, magic);
if (!strcmp(magic, PORTALFILE)) {
count = fscanf(f, "%i\n%i\n", &portalleafs, &numportals);
if (count != 2)
Error("%s: unable to parse %s HEADER\n", __func__, PORTALFILE);
portalleafs_real = portalleafs;
logprint("%6d leafs\n", portalleafs);
logprint("%6d portals\n", numportals);
} else if (!strcmp(magic, PORTALFILE2)) {
count = fscanf(f, "%i\n%i\n%i\n", &portalleafs_real, &portalleafs,
&numportals);
if (count != 3)
Error("%s: unable to parse %s HEADER\n", __func__, PORTALFILE);
logprint("%6d leafs\n", portalleafs_real);
logprint("%6d clusters\n", portalleafs);
logprint("%6d portals\n", numportals);
} else {
Error("%s: unknown header: %s\n", __func__, magic);
}
leafbytes = ((portalleafs + 63) & ~63) >> 3;
leaflongs = leafbytes / sizeof(long);
leafbytes_real = ((portalleafs_real + 63) & ~63) >> 3;
// 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(portalleafs * sizeof(leaf_t));
memset(leafs, 0, portalleafs * sizeof(leaf_t));
originalvismapsize = portalleafs_real * ((portalleafs_real + 7) / 8);
// FIXME - more intelligent allocation?
dvisdata = malloc(MAX_MAP_VISIBILITY);
if (!dvisdata)
Error("%s: dvisdata allocation failed (%i bytes)", __func__,
MAX_MAP_VISIBILITY);
memset(dvisdata, 0, MAX_MAP_VISIBILITY);
vismap = vismap_p = dvisdata;
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("%s: reading portal %i", __func__, i);
if (numpoints > MAX_WINDING)
Error("%s: portal %i has too many points", __func__, i);
if ((unsigned)leafnums[0] > (unsigned)portalleafs
|| (unsigned)leafnums[1] > (unsigned)portalleafs)
Error("%s: reading portal %i", __func__, i);
w = p->winding = NewWinding(numpoints);
w->numpoints = numpoints;
for (j = 0; j < numpoints; j++) {
double v[3];
int k;
// scanf into double, then assign to vec_t
if (fscanf(f, "(%lf %lf %lf ) ", &v[0], &v[1], &v[2]) != 3)
Error("%s: reading portal %i", __func__, i);
for (k = 0; k < 3; k++)
w->points[j][k] = (vec_t)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];
SetWindingSphere(p->winding);
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++;
// Create a reverse winding
p->winding = NewWinding(numpoints);
p->winding->numpoints = numpoints;
for (j = 0; j < numpoints; ++j)
VectorCopy(w->points[numpoints - (j + 1)], p->winding->points[j]);
//p->winding = w;
p->plane = plane;
p->leaf = leafnums[0];
SetWindingSphere(p->winding);
p++;
}
/* Load the cluster expansion map if needed */
if (portalleafs != portalleafs_real) {
clustermap = malloc(portalleafs_real * sizeof(int));
for (i = 0; i < portalleafs; i++) {
while (1) {
int leafnum;
count = fscanf(f, "%i", &leafnum);
if (!count || count == EOF)
break;
if (leafnum < 0)
break;
if (leafnum >= portalleafs_real)
Error("Invalid leaf number in cluster map (%d >= %d",
leafnum, portalleafs_real);
clustermap[leafnum] = i;
}
if (count == EOF)
break;
}
if (i < portalleafs)
Error("Couldn't read cluster map (%d / %d)\n", i, portalleafs);
}
fclose(f);
}
char sourcefile[1024];
char portalfile[1024];
char statefile[1024];
char statetmpfile[1024];
/*
===========
main
===========
*/
int
main(int argc, char **argv)
{
bspdata_t bsp;
int i, bsp_version;
init_log("vis.log");
logprint("---- vis / TyrUtils " stringify(TYRUTILS_VERSION) " ----\n");
numthreads = GetDefaultThreads();
for (i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-threads")) {
numthreads = atoi(argv[i + 1]);
i++;
} else if (!strcmp(argv[i], "-fast")) {
logprint("fastvis = true\n");
fastvis = true;
} else if (!strcmp(argv[i], "-level")) {
testlevel = atoi(argv[i + 1]);
i++;
} else if (!strcmp(argv[i], "-v")) {
logprint("verbose = true\n");
verbose = 1;
} else if (!strcmp(argv[i], "-vv")) {
logprint("verbose = extra\n");
verbose = 2;
} else if (!strcmp(argv[i], "-noambientsky")) {
logprint("ambient sky sounds disabled\n");
ambientsky = false;
} else if (!strcmp(argv[i], "-noambientwater")) {
logprint("ambient water sounds disabled\n");
ambientwater = false;
} else if (!strcmp(argv[i], "-noambientslime")) {
logprint("ambient slime sounds disabled\n");
ambientslime = false;
} else if (!strcmp(argv[i], "-noambientlava")) {
logprint("ambient lava sounds disabled\n");
ambientlava = false;
} else if (!strcmp(argv[i], "-noambient")) {
logprint("ambient sound calculation disabled\n");
ambientsky = false;
ambientwater = false;
ambientslime = false;
ambientlava = false;
} else if (argv[i][0] == '-')
Error("Unknown option \"%s\"", argv[i]);
else
break;
}
if (i != argc - 1) {
printf("usage: vis [-threads #] [-level 0-4] [-fast] [-v|-vv] "
"[-credits] bspfile");
exit(1);
}
logprint("running with %d threads\n", numthreads);
logprint("testlevel = %i\n", testlevel);
stateinterval = 300; /* 5 minutes */
starttime = statetime = I_FloatTime();
strcpy(sourcefile, argv[i]);
StripExtension(sourcefile);
DefaultExtension(sourcefile, ".bsp");
bsp_version = LoadBSPFile(sourcefile, &bsp);
SetBSPGlobals(&bsp); /* FIXME */
strcpy(portalfile, argv[i]);
StripExtension(portalfile);
strcat(portalfile, ".prt");
LoadPortals(portalfile);
strcpy(statefile, sourcefile);
StripExtension(statefile);
DefaultExtension(statefile, ".vis");
strcpy(statetmpfile, sourcefile);
StripExtension(statetmpfile);
DefaultExtension(statetmpfile, ".vi0");
uncompressed = malloc(leafbytes_real * portalleafs_real);
memset(uncompressed, 0, leafbytes_real * portalleafs_real);
// CalcPassages ();
CalcVis();
logprint("c_noclip: %i\n", c_noclip);
logprint("c_chains: %lu\n", c_chains);
visdatasize = vismap_p - dvisdata;
logprint("visdatasize:%i compressed from %i\n",
visdatasize, originalvismapsize);
CalcAmbientSounds();
/* still need to update from globals */
GetBSPGlobals(&bsp);
WriteBSPFile(sourcefile, &bsp, bsp_version);
// unlink (portalfile);
endtime = I_FloatTime();
logprint("%5.1f seconds elapsed\n", endtime - starttime);
close_log();
return 0;
}
Reference in New Issue View Git Blame Copy Permalink