mirror of
https://github.com/UberGames/lilium-voyager.git
synced 2024-12-15 14:40:53 +00:00
1142 lines
35 KiB
C
1142 lines
35 KiB
C
/*
|
|
===========================================================================
|
|
Copyright (C) 1999-2005 Id Software, Inc.
|
|
|
|
This file is part of Quake III Arena source code.
|
|
|
|
Quake III Arena 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 III Arena 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 Foobar; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
===========================================================================
|
|
*/
|
|
|
|
#include "qbsp.h"
|
|
#include "../botlib/aasfile.h"
|
|
#include "aas_create.h"
|
|
#include "aas_store.h"
|
|
#include "aas_gsubdiv.h"
|
|
#include "aas_facemerging.h"
|
|
#include "aas_areamerging.h"
|
|
#include "aas_edgemelting.h"
|
|
#include "aas_prunenodes.h"
|
|
#include "aas_cfg.h"
|
|
#include "../game/surfaceflags.h"
|
|
|
|
//#define AW_DEBUG
|
|
//#define L_DEBUG
|
|
|
|
#define AREAONFACESIDE(face, area) (face->frontarea != area)
|
|
|
|
tmp_aas_t tmpaasworld;
|
|
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
void AAS_InitTmpAAS(void)
|
|
{
|
|
//tmp faces
|
|
tmpaasworld.numfaces = 0;
|
|
tmpaasworld.facenum = 0;
|
|
tmpaasworld.faces = NULL;
|
|
//tmp convex areas
|
|
tmpaasworld.numareas = 0;
|
|
tmpaasworld.areanum = 0;
|
|
tmpaasworld.areas = NULL;
|
|
//tmp nodes
|
|
tmpaasworld.numnodes = 0;
|
|
tmpaasworld.nodes = NULL;
|
|
//
|
|
tmpaasworld.nodebuffer = NULL;
|
|
} //end of the function AAS_InitTmpAAS
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
void AAS_FreeTmpAAS(void)
|
|
{
|
|
tmp_face_t *f, *nextf;
|
|
tmp_area_t *a, *nexta;
|
|
tmp_nodebuf_t *nb, *nextnb;
|
|
|
|
//free all the faces
|
|
for (f = tmpaasworld.faces; f; f = nextf)
|
|
{
|
|
nextf = f->l_next;
|
|
if (f->winding) FreeWinding(f->winding);
|
|
FreeMemory(f);
|
|
} //end if
|
|
//free all tmp areas
|
|
for (a = tmpaasworld.areas; a; a = nexta)
|
|
{
|
|
nexta = a->l_next;
|
|
if (a->settings) FreeMemory(a->settings);
|
|
FreeMemory(a);
|
|
} //end for
|
|
//free all the tmp nodes
|
|
for (nb = tmpaasworld.nodebuffer; nb; nb = nextnb)
|
|
{
|
|
nextnb = nb->next;
|
|
FreeMemory(nb);
|
|
} //end for
|
|
} //end of the function AAS_FreeTmpAAS
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
tmp_face_t *AAS_AllocTmpFace(void)
|
|
{
|
|
tmp_face_t *tmpface;
|
|
|
|
tmpface = (tmp_face_t *) GetClearedMemory(sizeof(tmp_face_t));
|
|
tmpface->num = tmpaasworld.facenum++;
|
|
tmpface->l_prev = NULL;
|
|
tmpface->l_next = tmpaasworld.faces;
|
|
if (tmpaasworld.faces) tmpaasworld.faces->l_prev = tmpface;
|
|
tmpaasworld.faces = tmpface;
|
|
tmpaasworld.numfaces++;
|
|
return tmpface;
|
|
} //end of the function AAS_AllocTmpFace
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
void AAS_FreeTmpFace(tmp_face_t *tmpface)
|
|
{
|
|
if (tmpface->l_next) tmpface->l_next->l_prev = tmpface->l_prev;
|
|
if (tmpface->l_prev) tmpface->l_prev->l_next = tmpface->l_next;
|
|
else tmpaasworld.faces = tmpface->l_next;
|
|
//free the winding
|
|
if (tmpface->winding) FreeWinding(tmpface->winding);
|
|
//free the face
|
|
FreeMemory(tmpface);
|
|
tmpaasworld.numfaces--;
|
|
} //end of the function AAS_FreeTmpFace
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
tmp_area_t *AAS_AllocTmpArea(void)
|
|
{
|
|
tmp_area_t *tmparea;
|
|
|
|
tmparea = (tmp_area_t *) GetClearedMemory(sizeof(tmp_area_t));
|
|
tmparea->areanum = tmpaasworld.areanum++;
|
|
tmparea->l_prev = NULL;
|
|
tmparea->l_next = tmpaasworld.areas;
|
|
if (tmpaasworld.areas) tmpaasworld.areas->l_prev = tmparea;
|
|
tmpaasworld.areas = tmparea;
|
|
tmpaasworld.numareas++;
|
|
return tmparea;
|
|
} //end of the function AAS_AllocTmpArea
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
void AAS_FreeTmpArea(tmp_area_t *tmparea)
|
|
{
|
|
if (tmparea->l_next) tmparea->l_next->l_prev = tmparea->l_prev;
|
|
if (tmparea->l_prev) tmparea->l_prev->l_next = tmparea->l_next;
|
|
else tmpaasworld.areas = tmparea->l_next;
|
|
if (tmparea->settings) FreeMemory(tmparea->settings);
|
|
FreeMemory(tmparea);
|
|
tmpaasworld.numareas--;
|
|
} //end of the function AAS_FreeTmpArea
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
tmp_node_t *AAS_AllocTmpNode(void)
|
|
{
|
|
tmp_nodebuf_t *nodebuf;
|
|
|
|
if (!tmpaasworld.nodebuffer ||
|
|
tmpaasworld.nodebuffer->numnodes >= NODEBUF_SIZE)
|
|
{
|
|
nodebuf = (tmp_nodebuf_t *) GetClearedMemory(sizeof(tmp_nodebuf_t));
|
|
nodebuf->next = tmpaasworld.nodebuffer;
|
|
nodebuf->numnodes = 0;
|
|
tmpaasworld.nodebuffer = nodebuf;
|
|
} //end if
|
|
tmpaasworld.numnodes++;
|
|
return &tmpaasworld.nodebuffer->nodes[tmpaasworld.nodebuffer->numnodes++];
|
|
} //end of the function AAS_AllocTmpNode
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
void AAS_FreeTmpNode(tmp_node_t *tmpnode)
|
|
{
|
|
tmpaasworld.numnodes--;
|
|
} //end of the function AAS_FreeTmpNode
|
|
//===========================================================================
|
|
// returns true if the face is a gap from the given side
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
int AAS_GapFace(tmp_face_t *tmpface, int side)
|
|
{
|
|
vec3_t invgravity;
|
|
|
|
//if the face is a solid or ground face it can't be a gap
|
|
if (tmpface->faceflags & (FACE_GROUND | FACE_SOLID)) return 0;
|
|
|
|
VectorCopy(cfg.phys_gravitydirection, invgravity);
|
|
VectorInverse(invgravity);
|
|
|
|
return (DotProduct(invgravity, mapplanes[tmpface->planenum ^ side].normal) > cfg.phys_maxsteepness);
|
|
} //end of the function AAS_GapFace
|
|
//===========================================================================
|
|
// returns true if the face is a ground face
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
int AAS_GroundFace(tmp_face_t *tmpface)
|
|
{
|
|
vec3_t invgravity;
|
|
|
|
//must be a solid face
|
|
if (!(tmpface->faceflags & FACE_SOLID)) return 0;
|
|
|
|
VectorCopy(cfg.phys_gravitydirection, invgravity);
|
|
VectorInverse(invgravity);
|
|
|
|
return (DotProduct(invgravity, mapplanes[tmpface->planenum].normal) > cfg.phys_maxsteepness);
|
|
} //end of the function AAS_GroundFace
|
|
//===========================================================================
|
|
// adds the side of a face to an area
|
|
//
|
|
// side : 0 = front side
|
|
// 1 = back side
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
void AAS_AddFaceSideToArea(tmp_face_t *tmpface, int side, tmp_area_t *tmparea)
|
|
{
|
|
int tmpfaceside;
|
|
|
|
if (side)
|
|
{
|
|
if (tmpface->backarea) Error("AAS_AddFaceSideToArea: already a back area\n");
|
|
} //end if
|
|
else
|
|
{
|
|
if (tmpface->frontarea) Error("AAS_AddFaceSideToArea: already a front area\n");
|
|
} //end else
|
|
|
|
if (side) tmpface->backarea = tmparea;
|
|
else tmpface->frontarea = tmparea;
|
|
|
|
if (tmparea->tmpfaces)
|
|
{
|
|
tmpfaceside = tmparea->tmpfaces->frontarea != tmparea;
|
|
tmparea->tmpfaces->prev[tmpfaceside] = tmpface;
|
|
} //end if
|
|
tmpface->next[side] = tmparea->tmpfaces;
|
|
tmpface->prev[side] = NULL;
|
|
tmparea->tmpfaces = tmpface;
|
|
} //end of the function AAS_AddFaceSideToArea
|
|
//===========================================================================
|
|
// remove (a side of) a face from an area
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
void AAS_RemoveFaceFromArea(tmp_face_t *tmpface, tmp_area_t *tmparea)
|
|
{
|
|
int side, prevside, nextside;
|
|
|
|
if (tmpface->frontarea != tmparea &&
|
|
tmpface->backarea != tmparea)
|
|
{
|
|
Error("AAS_RemoveFaceFromArea: face not part of the area");
|
|
} //end if
|
|
side = tmpface->frontarea != tmparea;
|
|
if (tmpface->prev[side])
|
|
{
|
|
prevside = tmpface->prev[side]->frontarea != tmparea;
|
|
tmpface->prev[side]->next[prevside] = tmpface->next[side];
|
|
} //end if
|
|
else
|
|
{
|
|
tmparea->tmpfaces = tmpface->next[side];
|
|
} //end else
|
|
if (tmpface->next[side])
|
|
{
|
|
nextside = tmpface->next[side]->frontarea != tmparea;
|
|
tmpface->next[side]->prev[nextside] = tmpface->prev[side];
|
|
} //end if
|
|
//remove the area number from the face depending on the side
|
|
if (side) tmpface->backarea = NULL;
|
|
else tmpface->frontarea = NULL;
|
|
tmpface->prev[side] = NULL;
|
|
tmpface->next[side] = NULL;
|
|
} //end of the function AAS_RemoveFaceFromArea
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
void AAS_CheckArea(tmp_area_t *tmparea)
|
|
{
|
|
int side;
|
|
tmp_face_t *face;
|
|
plane_t *plane;
|
|
vec3_t wcenter, acenter = {0, 0, 0};
|
|
vec3_t normal;
|
|
float n, dist;
|
|
|
|
if (tmparea->invalid) Log_Print("AAS_CheckArea: invalid area\n");
|
|
for (n = 0, face = tmparea->tmpfaces; face; face = face->next[side])
|
|
{
|
|
//side of the face the area is on
|
|
side = face->frontarea != tmparea;
|
|
WindingCenter(face->winding, wcenter);
|
|
VectorAdd(acenter, wcenter, acenter);
|
|
n++;
|
|
} //end for
|
|
n = 1 / n;
|
|
VectorScale(acenter, n, acenter);
|
|
for (face = tmparea->tmpfaces; face; face = face->next[side])
|
|
{
|
|
//side of the face the area is on
|
|
side = face->frontarea != tmparea;
|
|
|
|
#ifdef L_DEBUG
|
|
if (WindingError(face->winding))
|
|
{
|
|
Log_Write("AAS_CheckArea: area %d face %d: %s\r\n", tmparea->areanum,
|
|
face->num, WindingErrorString());
|
|
} //end if
|
|
#endif L_DEBUG
|
|
|
|
plane = &mapplanes[face->planenum ^ side];
|
|
|
|
if (DotProduct(plane->normal, acenter) - plane->dist < 0)
|
|
{
|
|
Log_Print("AAS_CheckArea: area %d face %d is flipped\n", tmparea->areanum, face->num);
|
|
Log_Print("AAS_CheckArea: area %d center is %f %f %f\n", tmparea->areanum, acenter[0], acenter[1], acenter[2]);
|
|
} //end if
|
|
//check if the winding plane is the same as the face plane
|
|
WindingPlane(face->winding, normal, &dist);
|
|
plane = &mapplanes[face->planenum];
|
|
#ifdef L_DEBUG
|
|
if (fabs(dist - plane->dist) > 0.4 ||
|
|
fabs(normal[0] - plane->normal[0]) > 0.0001 ||
|
|
fabs(normal[1] - plane->normal[1]) > 0.0001 ||
|
|
fabs(normal[2] - plane->normal[2]) > 0.0001)
|
|
{
|
|
Log_Write("AAS_CheckArea: area %d face %d winding plane unequal to face plane\r\n",
|
|
tmparea->areanum, face->num);
|
|
} //end if
|
|
#endif L_DEBUG
|
|
} //end for
|
|
} //end of the function AAS_CheckArea
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
void AAS_CheckFaceWindingPlane(tmp_face_t *face)
|
|
{
|
|
float dist, sign1, sign2;
|
|
vec3_t normal;
|
|
plane_t *plane;
|
|
winding_t *w;
|
|
|
|
//check if the winding plane is the same as the face plane
|
|
WindingPlane(face->winding, normal, &dist);
|
|
plane = &mapplanes[face->planenum];
|
|
//
|
|
sign1 = DotProduct(plane->normal, normal);
|
|
//
|
|
if (fabs(dist - plane->dist) > 0.4 ||
|
|
fabs(normal[0] - plane->normal[0]) > 0.0001 ||
|
|
fabs(normal[1] - plane->normal[1]) > 0.0001 ||
|
|
fabs(normal[2] - plane->normal[2]) > 0.0001)
|
|
{
|
|
VectorInverse(normal);
|
|
dist = -dist;
|
|
if (fabs(dist - plane->dist) > 0.4 ||
|
|
fabs(normal[0] - plane->normal[0]) > 0.0001 ||
|
|
fabs(normal[1] - plane->normal[1]) > 0.0001 ||
|
|
fabs(normal[2] - plane->normal[2]) > 0.0001)
|
|
{
|
|
Log_Write("AAS_CheckFaceWindingPlane: face %d winding plane unequal to face plane\r\n",
|
|
face->num);
|
|
//
|
|
sign2 = DotProduct(plane->normal, normal);
|
|
if ((sign1 < 0 && sign2 > 0) ||
|
|
(sign1 > 0 && sign2 < 0))
|
|
{
|
|
Log_Write("AAS_CheckFaceWindingPlane: face %d winding reversed\r\n",
|
|
face->num);
|
|
w = face->winding;
|
|
face->winding = ReverseWinding(w);
|
|
FreeWinding(w);
|
|
} //end if
|
|
} //end if
|
|
else
|
|
{
|
|
Log_Write("AAS_CheckFaceWindingPlane: face %d winding reversed\r\n",
|
|
face->num);
|
|
w = face->winding;
|
|
face->winding = ReverseWinding(w);
|
|
FreeWinding(w);
|
|
} //end else
|
|
} //end if
|
|
} //end of the function AAS_CheckFaceWindingPlane
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
void AAS_CheckAreaWindingPlanes(void)
|
|
{
|
|
int side;
|
|
tmp_area_t *tmparea;
|
|
tmp_face_t *face;
|
|
|
|
Log_Write("AAS_CheckAreaWindingPlanes:\r\n");
|
|
for (tmparea = tmpaasworld.areas; tmparea; tmparea = tmparea->l_next)
|
|
{
|
|
if (tmparea->invalid) continue;
|
|
for (face = tmparea->tmpfaces; face; face = face->next[side])
|
|
{
|
|
side = face->frontarea != tmparea;
|
|
AAS_CheckFaceWindingPlane(face);
|
|
} //end for
|
|
} //end for
|
|
} //end of the function AAS_CheckAreaWindingPlanes
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
void AAS_FlipAreaFaces(tmp_area_t *tmparea)
|
|
{
|
|
int side;
|
|
tmp_face_t *face;
|
|
plane_t *plane;
|
|
vec3_t wcenter, acenter = {0, 0, 0};
|
|
//winding_t *w;
|
|
float n;
|
|
|
|
for (n = 0, face = tmparea->tmpfaces; face; face = face->next[side])
|
|
{
|
|
if (!face->frontarea) Error("face %d has no front area\n", face->num);
|
|
//side of the face the area is on
|
|
side = face->frontarea != tmparea;
|
|
WindingCenter(face->winding, wcenter);
|
|
VectorAdd(acenter, wcenter, acenter);
|
|
n++;
|
|
} //end for
|
|
n = 1 / n;
|
|
VectorScale(acenter, n, acenter);
|
|
for (face = tmparea->tmpfaces; face; face = face->next[side])
|
|
{
|
|
//side of the face the area is on
|
|
side = face->frontarea != tmparea;
|
|
|
|
plane = &mapplanes[face->planenum ^ side];
|
|
|
|
if (DotProduct(plane->normal, acenter) - plane->dist < 0)
|
|
{
|
|
Log_Print("area %d face %d flipped: front area %d, back area %d\n", tmparea->areanum, face->num,
|
|
face->frontarea ? face->frontarea->areanum : 0,
|
|
face->backarea ? face->backarea->areanum : 0);
|
|
/*
|
|
face->planenum = face->planenum ^ 1;
|
|
w = face->winding;
|
|
face->winding = ReverseWinding(w);
|
|
FreeWinding(w);
|
|
*/
|
|
} //end if
|
|
#ifdef L_DEBUG
|
|
{
|
|
float dist;
|
|
vec3_t normal;
|
|
|
|
//check if the winding plane is the same as the face plane
|
|
WindingPlane(face->winding, normal, &dist);
|
|
plane = &mapplanes[face->planenum];
|
|
if (fabs(dist - plane->dist) > 0.4 ||
|
|
fabs(normal[0] - plane->normal[0]) > 0.0001 ||
|
|
fabs(normal[1] - plane->normal[1]) > 0.0001 ||
|
|
fabs(normal[2] - plane->normal[2]) > 0.0001)
|
|
{
|
|
Log_Write("area %d face %d winding plane unequal to face plane\r\n",
|
|
tmparea->areanum, face->num);
|
|
} //end if
|
|
}
|
|
#endif
|
|
} //end for
|
|
} //end of the function AAS_FlipAreaFaces
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
void AAS_RemoveAreaFaceColinearPoints(void)
|
|
{
|
|
int side;
|
|
tmp_face_t *face;
|
|
tmp_area_t *tmparea;
|
|
|
|
//FIXME: loop over the faces instead of area->faces
|
|
for (tmparea = tmpaasworld.areas; tmparea; tmparea = tmparea->l_next)
|
|
{
|
|
for (face = tmparea->tmpfaces; face; face = face->next[side])
|
|
{
|
|
side = face->frontarea != tmparea;
|
|
RemoveColinearPoints(face->winding);
|
|
// RemoveEqualPoints(face->winding, 0.1);
|
|
} //end for
|
|
} //end for
|
|
} //end of the function AAS_RemoveAreaFaceColinearPoints
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
void AAS_RemoveTinyFaces(void)
|
|
{
|
|
int side, num;
|
|
tmp_face_t *face, *nextface;
|
|
tmp_area_t *tmparea;
|
|
|
|
//FIXME: loop over the faces instead of area->faces
|
|
Log_Write("AAS_RemoveTinyFaces\r\n");
|
|
num = 0;
|
|
for (tmparea = tmpaasworld.areas; tmparea; tmparea = tmparea->l_next)
|
|
{
|
|
for (face = tmparea->tmpfaces; face; face = nextface)
|
|
{
|
|
side = face->frontarea != tmparea;
|
|
nextface = face->next[side];
|
|
//
|
|
if (WindingArea(face->winding) < 1)
|
|
{
|
|
if (face->frontarea) AAS_RemoveFaceFromArea(face, face->frontarea);
|
|
if (face->backarea) AAS_RemoveFaceFromArea(face, face->backarea);
|
|
AAS_FreeTmpFace(face);
|
|
//Log_Write("area %d face %d is tiny\r\n", tmparea->areanum, face->num);
|
|
num++;
|
|
} //end if
|
|
} //end for
|
|
} //end for
|
|
Log_Write("%d tiny faces removed\r\n", num);
|
|
} //end of the function AAS_RemoveTinyFaces
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
void AAS_CreateAreaSettings(void)
|
|
{
|
|
int i, flags, side, numgrounded, numladderareas, numliquidareas;
|
|
tmp_face_t *face;
|
|
tmp_area_t *tmparea;
|
|
|
|
numgrounded = 0;
|
|
numladderareas = 0;
|
|
numliquidareas = 0;
|
|
Log_Write("AAS_CreateAreaSettings\r\n");
|
|
i = 0;
|
|
qprintf("%6d areas provided with settings", i);
|
|
for (tmparea = tmpaasworld.areas; tmparea; tmparea = tmparea->l_next)
|
|
{
|
|
//if the area is invalid there no need to create settings for it
|
|
if (tmparea->invalid) continue;
|
|
|
|
tmparea->settings = (tmp_areasettings_t *) GetClearedMemory(sizeof(tmp_areasettings_t));
|
|
tmparea->settings->contents = tmparea->contents;
|
|
tmparea->settings->modelnum = tmparea->modelnum;
|
|
flags = 0;
|
|
for (face = tmparea->tmpfaces; face; face = face->next[side])
|
|
{
|
|
side = face->frontarea != tmparea;
|
|
flags |= face->faceflags;
|
|
} //end for
|
|
tmparea->settings->areaflags = 0;
|
|
if (flags & FACE_GROUND)
|
|
{
|
|
tmparea->settings->areaflags |= AREA_GROUNDED;
|
|
numgrounded++;
|
|
} //end if
|
|
if (flags & FACE_LADDER)
|
|
{
|
|
tmparea->settings->areaflags |= AREA_LADDER;
|
|
numladderareas++;
|
|
} //end if
|
|
if (tmparea->contents & (AREACONTENTS_WATER |
|
|
AREACONTENTS_SLIME |
|
|
AREACONTENTS_LAVA))
|
|
{
|
|
tmparea->settings->areaflags |= AREA_LIQUID;
|
|
numliquidareas++;
|
|
} //end if
|
|
//presence type of the area
|
|
tmparea->settings->presencetype = tmparea->presencetype;
|
|
//
|
|
qprintf("\r%6d", ++i);
|
|
} //end for
|
|
qprintf("\n");
|
|
#ifdef AASINFO
|
|
Log_Print("%6d grounded areas\n", numgrounded);
|
|
Log_Print("%6d ladder areas\n", numladderareas);
|
|
Log_Print("%6d liquid areas\n", numliquidareas);
|
|
#endif //AASINFO
|
|
} //end of the function AAS_CreateAreaSettings
|
|
//===========================================================================
|
|
// create a tmp AAS area from a leaf node
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
tmp_node_t *AAS_CreateArea(node_t *node)
|
|
{
|
|
int pside;
|
|
int areafaceflags;
|
|
portal_t *p;
|
|
tmp_face_t *tmpface;
|
|
tmp_area_t *tmparea;
|
|
tmp_node_t *tmpnode;
|
|
vec3_t up = {0, 0, 1};
|
|
|
|
//create an area from this leaf
|
|
tmparea = AAS_AllocTmpArea();
|
|
tmparea->tmpfaces = NULL;
|
|
//clear the area face flags
|
|
areafaceflags = 0;
|
|
//make aas faces from the portals
|
|
for (p = node->portals; p; p = p->next[pside])
|
|
{
|
|
pside = (p->nodes[1] == node);
|
|
//don't create faces from very small portals
|
|
// if (WindingArea(p->winding) < 1) continue;
|
|
//if there's already a face created for this portal
|
|
if (p->tmpface)
|
|
{
|
|
//add the back side of the face to the area
|
|
AAS_AddFaceSideToArea(p->tmpface, 1, tmparea);
|
|
} //end if
|
|
else
|
|
{
|
|
tmpface = AAS_AllocTmpFace();
|
|
//set the face pointer at the portal so we can see from
|
|
//the portal there's a face created for it
|
|
p->tmpface = tmpface;
|
|
//FIXME: test this change
|
|
//tmpface->planenum = (p->planenum & ~1) | pside;
|
|
tmpface->planenum = p->planenum ^ pside;
|
|
if (pside) tmpface->winding = ReverseWinding(p->winding);
|
|
else tmpface->winding = CopyWinding(p->winding);
|
|
#ifdef L_DEBUG
|
|
//
|
|
AAS_CheckFaceWindingPlane(tmpface);
|
|
#endif //L_DEBUG
|
|
//if there's solid at the other side of the portal
|
|
if (p->nodes[!pside]->contents & (CONTENTS_SOLID | CONTENTS_PLAYERCLIP))
|
|
{
|
|
tmpface->faceflags |= FACE_SOLID;
|
|
} //end if
|
|
//else there is no solid at the other side and if there
|
|
//is a liquid at this side
|
|
else if (node->contents & (CONTENTS_WATER|CONTENTS_SLIME|CONTENTS_LAVA))
|
|
{
|
|
tmpface->faceflags |= FACE_LIQUID;
|
|
//if there's no liquid at the other side
|
|
if (!(p->nodes[!pside]->contents & (CONTENTS_WATER|CONTENTS_SLIME|CONTENTS_LAVA)))
|
|
{
|
|
tmpface->faceflags |= FACE_LIQUIDSURFACE;
|
|
} //end if
|
|
} //end else
|
|
//if there's ladder contents at other side of the portal
|
|
if ((p->nodes[pside]->contents & CONTENTS_LADDER) ||
|
|
(p->nodes[!pside]->contents & CONTENTS_LADDER))
|
|
{
|
|
|
|
//NOTE: doesn't have to be solid at the other side because
|
|
// when standing one can use a crouch area (which is not solid)
|
|
// as a ladder
|
|
// imagine a ladder one can walk underthrough,
|
|
// under the ladder against the ladder is a crouch area
|
|
// the (vertical) sides of this crouch area area also used as
|
|
// ladder sides when standing (not crouched)
|
|
tmpface->faceflags |= FACE_LADDER;
|
|
} //end if
|
|
//if it is possible to stand on the face
|
|
if (AAS_GroundFace(tmpface))
|
|
{
|
|
tmpface->faceflags |= FACE_GROUND;
|
|
} //end if
|
|
//
|
|
areafaceflags |= tmpface->faceflags;
|
|
//no aas face number yet (zero is a dummy in the aasworld faces)
|
|
tmpface->aasfacenum = 0;
|
|
//add the front side of the face to the area
|
|
AAS_AddFaceSideToArea(tmpface, 0, tmparea);
|
|
} //end else
|
|
} //end for
|
|
qprintf("\r%6d", tmparea->areanum);
|
|
//presence type in the area
|
|
tmparea->presencetype = ~node->expansionbboxes & cfg.allpresencetypes;
|
|
//
|
|
tmparea->contents = 0;
|
|
if (node->contents & CONTENTS_CLUSTERPORTAL) tmparea->contents |= AREACONTENTS_CLUSTERPORTAL;
|
|
if (node->contents & CONTENTS_MOVER) tmparea->contents |= AREACONTENTS_MOVER;
|
|
if (node->contents & CONTENTS_TELEPORTER) tmparea->contents |= AREACONTENTS_TELEPORTER;
|
|
if (node->contents & CONTENTS_JUMPPAD) tmparea->contents |= AREACONTENTS_JUMPPAD;
|
|
if (node->contents & CONTENTS_DONOTENTER) tmparea->contents |= AREACONTENTS_DONOTENTER;
|
|
if (node->contents & CONTENTS_WATER) tmparea->contents |= AREACONTENTS_WATER;
|
|
if (node->contents & CONTENTS_LAVA) tmparea->contents |= AREACONTENTS_LAVA;
|
|
if (node->contents & CONTENTS_SLIME) tmparea->contents |= AREACONTENTS_SLIME;
|
|
if (node->contents & CONTENTS_NOTTEAM1) tmparea->contents |= AREACONTENTS_NOTTEAM1;
|
|
if (node->contents & CONTENTS_NOTTEAM2) tmparea->contents |= AREACONTENTS_NOTTEAM2;
|
|
|
|
//store the bsp model that's inside this node
|
|
tmparea->modelnum = node->modelnum;
|
|
//sorta check for flipped area faces (remove??)
|
|
AAS_FlipAreaFaces(tmparea);
|
|
//check if the area is ok (remove??)
|
|
AAS_CheckArea(tmparea);
|
|
//
|
|
tmpnode = AAS_AllocTmpNode();
|
|
tmpnode->planenum = 0;
|
|
tmpnode->children[0] = 0;
|
|
tmpnode->children[1] = 0;
|
|
tmpnode->tmparea = tmparea;
|
|
//
|
|
return tmpnode;
|
|
} //end of the function AAS_CreateArea
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
tmp_node_t *AAS_CreateAreas_r(node_t *node)
|
|
{
|
|
tmp_node_t *tmpnode;
|
|
|
|
//recurse down to leafs
|
|
if (node->planenum != PLANENUM_LEAF)
|
|
{
|
|
//the first tmp node is a dummy
|
|
tmpnode = AAS_AllocTmpNode();
|
|
tmpnode->planenum = node->planenum;
|
|
tmpnode->children[0] = AAS_CreateAreas_r(node->children[0]);
|
|
tmpnode->children[1] = AAS_CreateAreas_r(node->children[1]);
|
|
return tmpnode;
|
|
} //end if
|
|
//areas won't be created for solid leafs
|
|
if (node->contents & CONTENTS_SOLID)
|
|
{
|
|
//just return zero for a solid leaf (in tmp AAS NULL is a solid leaf)
|
|
return NULL;
|
|
} //end if
|
|
|
|
return AAS_CreateArea(node);
|
|
} //end of the function AAS_CreateAreas_r
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
void AAS_CreateAreas(node_t *node)
|
|
{
|
|
Log_Write("AAS_CreateAreas\r\n");
|
|
qprintf("%6d areas created", 0);
|
|
tmpaasworld.nodes = AAS_CreateAreas_r(node);
|
|
qprintf("\n");
|
|
Log_Write("%6d areas created\r\n", tmpaasworld.numareas);
|
|
} //end of the function AAS_CreateAreas
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
void AAS_PrintNumGroundFaces(void)
|
|
{
|
|
tmp_face_t *tmpface;
|
|
int numgroundfaces = 0;
|
|
|
|
for (tmpface = tmpaasworld.faces; tmpface; tmpface = tmpface->l_next)
|
|
{
|
|
if (tmpface->faceflags & FACE_GROUND)
|
|
{
|
|
numgroundfaces++;
|
|
} //end if
|
|
} //end for
|
|
qprintf("%6d ground faces\n", numgroundfaces);
|
|
} //end of the function AAS_PrintNumGroundFaces
|
|
//===========================================================================
|
|
// checks the number of shared faces between the given two areas
|
|
// since areas are convex they should only have ONE shared face
|
|
// however due to crappy face merging there are sometimes several
|
|
// shared faces
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
void AAS_CheckAreaSharedFaces(tmp_area_t *tmparea1, tmp_area_t *tmparea2)
|
|
{
|
|
int numsharedfaces, side;
|
|
tmp_face_t *face1, *sharedface;
|
|
|
|
if (tmparea1->invalid || tmparea2->invalid) return;
|
|
|
|
sharedface = NULL;
|
|
numsharedfaces = 0;
|
|
for (face1 = tmparea1->tmpfaces; face1; face1 = face1->next[side])
|
|
{
|
|
side = face1->frontarea != tmparea1;
|
|
if (face1->backarea == tmparea2 || face1->frontarea == tmparea2)
|
|
{
|
|
sharedface = face1;
|
|
numsharedfaces++;
|
|
} //end if
|
|
} //end if
|
|
if (!sharedface) return;
|
|
//the areas should only have one shared face
|
|
if (numsharedfaces > 1)
|
|
{
|
|
Log_Write("---- tmp area %d and %d have %d shared faces\r\n",
|
|
tmparea1->areanum, tmparea2->areanum, numsharedfaces);
|
|
for (face1 = tmparea1->tmpfaces; face1; face1 = face1->next[side])
|
|
{
|
|
side = face1->frontarea != tmparea1;
|
|
if (face1->backarea == tmparea2 || face1->frontarea == tmparea2)
|
|
{
|
|
Log_Write("face %d, planenum = %d, face->frontarea = %d face->backarea = %d\r\n",
|
|
face1->num, face1->planenum, face1->frontarea->areanum, face1->backarea->areanum);
|
|
} //end if
|
|
} //end if
|
|
} //end if
|
|
} //end of the function AAS_CheckAreaSharedFaces
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
void AAS_CheckSharedFaces(void)
|
|
{
|
|
tmp_area_t *tmparea1, *tmparea2;
|
|
|
|
for (tmparea1 = tmpaasworld.areas; tmparea1; tmparea1 = tmparea1->l_next)
|
|
{
|
|
for (tmparea2 = tmpaasworld.areas; tmparea2; tmparea2 = tmparea2->l_next)
|
|
{
|
|
if (tmparea1 == tmparea2) continue;
|
|
AAS_CheckAreaSharedFaces(tmparea1, tmparea2);
|
|
} //end for
|
|
} //end for
|
|
} //end of the function AAS_CheckSharedFaces
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
void AAS_FlipFace(tmp_face_t *face)
|
|
{
|
|
tmp_area_t *frontarea, *backarea;
|
|
winding_t *w;
|
|
|
|
frontarea = face->frontarea;
|
|
backarea = face->backarea;
|
|
//must have an area at both sides before flipping is allowed
|
|
if (!frontarea || !backarea) return;
|
|
//flip the face winding
|
|
w = face->winding;
|
|
face->winding = ReverseWinding(w);
|
|
FreeWinding(w);
|
|
//flip the face plane
|
|
face->planenum ^= 1;
|
|
//flip the face areas
|
|
AAS_RemoveFaceFromArea(face, frontarea);
|
|
AAS_RemoveFaceFromArea(face, backarea);
|
|
AAS_AddFaceSideToArea(face, 1, frontarea);
|
|
AAS_AddFaceSideToArea(face, 0, backarea);
|
|
} //end of the function AAS_FlipFace
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
/*
|
|
void AAS_FlipAreaSharedFaces(tmp_area_t *tmparea1, tmp_area_t *tmparea2)
|
|
{
|
|
int numsharedfaces, side, area1facing, area2facing;
|
|
tmp_face_t *face1, *sharedface;
|
|
|
|
if (tmparea1->invalid || tmparea2->invalid) return;
|
|
|
|
sharedface = NULL;
|
|
numsharedfaces = 0;
|
|
area1facing = 0; //number of shared faces facing towards area 1
|
|
area2facing = 0; //number of shared faces facing towards area 2
|
|
for (face1 = tmparea1->tmpfaces; face1; face1 = face1->next[side])
|
|
{
|
|
side = face1->frontarea != tmparea1;
|
|
if (face1->backarea == tmparea2 || face1->frontarea == tmparea2)
|
|
{
|
|
sharedface = face1;
|
|
numsharedfaces++;
|
|
if (face1->frontarea == tmparea1) area1facing++;
|
|
else area2facing++;
|
|
} //end if
|
|
} //end if
|
|
if (!sharedface) return;
|
|
//if there's only one shared face
|
|
if (numsharedfaces <= 1) return;
|
|
//if all the shared faces are facing to the same area
|
|
if (numsharedfaces == area1facing || numsharedfaces == area2facing) return;
|
|
//
|
|
do
|
|
{
|
|
for (face1 = tmparea1->tmpfaces; face1; face1 = face1->next[side])
|
|
{
|
|
side = face1->frontarea != tmparea1;
|
|
if (face1->backarea == tmparea2 || face1->frontarea == tmparea2)
|
|
{
|
|
if (face1->frontarea != tmparea1)
|
|
{
|
|
AAS_FlipFace(face1);
|
|
break;
|
|
} //end if
|
|
} //end if
|
|
} //end for
|
|
} while(face1);
|
|
} //end of the function AAS_FlipAreaSharedFaces
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
void AAS_FlipSharedFaces(void)
|
|
{
|
|
int i;
|
|
tmp_area_t *tmparea1, *tmparea2;
|
|
|
|
i = 0;
|
|
qprintf("%6d areas checked for shared face flipping", i);
|
|
for (tmparea1 = tmpaasworld.areas; tmparea1; tmparea1 = tmparea1->l_next)
|
|
{
|
|
if (tmparea1->invalid) continue;
|
|
for (tmparea2 = tmpaasworld.areas; tmparea2; tmparea2 = tmparea2->l_next)
|
|
{
|
|
if (tmparea2->invalid) continue;
|
|
if (tmparea1 == tmparea2) continue;
|
|
AAS_FlipAreaSharedFaces(tmparea1, tmparea2);
|
|
} //end for
|
|
qprintf("\r%6d", ++i);
|
|
} //end for
|
|
Log_Print("\r%6d areas checked for shared face flipping\n", i);
|
|
} //end of the function AAS_FlipSharedFaces
|
|
*/
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
void AAS_FlipSharedFaces(void)
|
|
{
|
|
int i, side1, side2;
|
|
tmp_area_t *tmparea1;
|
|
tmp_face_t *face1, *face2;
|
|
|
|
i = 0;
|
|
qprintf("%6d areas checked for shared face flipping", i);
|
|
for (tmparea1 = tmpaasworld.areas; tmparea1; tmparea1 = tmparea1->l_next)
|
|
{
|
|
if (tmparea1->invalid) continue;
|
|
for (face1 = tmparea1->tmpfaces; face1; face1 = face1->next[side1])
|
|
{
|
|
side1 = face1->frontarea != tmparea1;
|
|
if (!face1->frontarea || !face1->backarea) continue;
|
|
//
|
|
for (face2 = face1->next[side1]; face2; face2 = face2->next[side2])
|
|
{
|
|
side2 = face2->frontarea != tmparea1;
|
|
if (!face2->frontarea || !face2->backarea) continue;
|
|
//
|
|
if (face1->frontarea == face2->backarea &&
|
|
face1->backarea == face2->frontarea)
|
|
{
|
|
AAS_FlipFace(face2);
|
|
} //end if
|
|
//recheck side
|
|
side2 = face2->frontarea != tmparea1;
|
|
} //end for
|
|
} //end for
|
|
qprintf("\r%6d", ++i);
|
|
} //end for
|
|
qprintf("\n");
|
|
Log_Write("%6d areas checked for shared face flipping\r\n", i);
|
|
} //end of the function AAS_FlipSharedFaces
|
|
//===========================================================================
|
|
// creates an .AAS file with the given name
|
|
// a MAP should be loaded before calling this
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
void AAS_Create(char *aasfile)
|
|
{
|
|
entity_t *e;
|
|
tree_t *tree;
|
|
double start_time;
|
|
|
|
//for a possible leak file
|
|
strcpy(source, aasfile);
|
|
StripExtension(source);
|
|
//the time started
|
|
start_time = I_FloatTime();
|
|
//set the default number of threads (depends on number of processors)
|
|
ThreadSetDefault();
|
|
//set the global entity number to the world model
|
|
entity_num = 0;
|
|
//the world entity
|
|
e = &entities[entity_num];
|
|
//process the whole world
|
|
tree = ProcessWorldBrushes(e->firstbrush, e->firstbrush + e->numbrushes);
|
|
//if the conversion is cancelled
|
|
if (cancelconversion)
|
|
{
|
|
Tree_Free(tree);
|
|
return;
|
|
} //end if
|
|
//display BSP tree creation time
|
|
Log_Print("BSP tree created in %5.0f seconds\n", I_FloatTime() - start_time);
|
|
//prune the bsp tree
|
|
Tree_PruneNodes(tree->headnode);
|
|
//if the conversion is cancelled
|
|
if (cancelconversion)
|
|
{
|
|
Tree_Free(tree);
|
|
return;
|
|
} //end if
|
|
//create the tree portals
|
|
MakeTreePortals(tree);
|
|
//if the conversion is cancelled
|
|
if (cancelconversion)
|
|
{
|
|
Tree_Free(tree);
|
|
return;
|
|
} //end if
|
|
//Marks all nodes that can be reached by entites
|
|
if (FloodEntities(tree))
|
|
{
|
|
//fill out nodes that can't be reached
|
|
FillOutside(tree->headnode);
|
|
} //end if
|
|
else
|
|
{
|
|
LeakFile(tree);
|
|
Error("**** leaked ****\n");
|
|
return;
|
|
} //end else
|
|
//create AAS from the BSP tree
|
|
//==========================================
|
|
//initialize tmp aas
|
|
AAS_InitTmpAAS();
|
|
//create the convex areas from the leaves
|
|
AAS_CreateAreas(tree->headnode);
|
|
//free the BSP tree because it isn't used anymore
|
|
if (freetree) Tree_Free(tree);
|
|
//try to merge area faces
|
|
AAS_MergeAreaFaces();
|
|
//do gravitational subdivision
|
|
AAS_GravitationalSubdivision();
|
|
//merge faces if possible
|
|
AAS_MergeAreaFaces();
|
|
AAS_RemoveAreaFaceColinearPoints();
|
|
//merge areas if possible
|
|
AAS_MergeAreas();
|
|
//NOTE: prune nodes directly after area merging
|
|
AAS_PruneNodes();
|
|
//flip shared faces so they are all facing to the same area
|
|
AAS_FlipSharedFaces();
|
|
AAS_RemoveAreaFaceColinearPoints();
|
|
//merge faces if possible
|
|
AAS_MergeAreaFaces();
|
|
//merge area faces in the same plane
|
|
AAS_MergeAreaPlaneFaces();
|
|
//do ladder subdivision
|
|
AAS_LadderSubdivision();
|
|
//FIXME: melting is buggy
|
|
AAS_MeltAreaFaceWindings();
|
|
//remove tiny faces
|
|
AAS_RemoveTinyFaces();
|
|
//create area settings
|
|
AAS_CreateAreaSettings();
|
|
//check if the winding plane is equal to the face plane
|
|
//AAS_CheckAreaWindingPlanes();
|
|
//
|
|
//AAS_CheckSharedFaces();
|
|
//==========================================
|
|
//if the conversion is cancelled
|
|
if (cancelconversion)
|
|
{
|
|
Tree_Free(tree);
|
|
AAS_FreeTmpAAS();
|
|
return;
|
|
} //end if
|
|
//store the created AAS stuff in the AAS file format and write the file
|
|
AAS_StoreFile(aasfile);
|
|
//free the temporary AAS memory
|
|
AAS_FreeTmpAAS();
|
|
//display creation time
|
|
Log_Print("\nAAS created in %5.0f seconds\n", I_FloatTime() - start_time);
|
|
} //end of the function AAS_Create
|