From 3b447421efc76ba76fbdae62f893fc6916af5433 Mon Sep 17 00:00:00 2001
From: Tim Angus <tim@ngus.net>
Date: Sat, 10 Dec 2005 03:08:56 +0000
Subject: * Well I fucked that up then...
---
ioq3-r437/src/botlib/be_aas_sample.c | 1394 ----------------------------------
1 file changed, 1394 deletions(-)
delete mode 100644 ioq3-r437/src/botlib/be_aas_sample.c
(limited to 'ioq3-r437/src/botlib/be_aas_sample.c')
diff --git a/ioq3-r437/src/botlib/be_aas_sample.c b/ioq3-r437/src/botlib/be_aas_sample.c
deleted file mode 100644
index 92b75174..00000000
--- a/ioq3-r437/src/botlib/be_aas_sample.c
+++ /dev/null
@@ -1,1394 +0,0 @@
-/*
-===========================================================================
-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 Quake III Arena source code; if not, write to the Free Software
-Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-===========================================================================
-*/
-
-/*****************************************************************************
- * name: be_aas_sample.c
- *
- * desc: AAS environment sampling
- *
- * $Archive: /MissionPack/code/botlib/be_aas_sample.c $
- *
- *****************************************************************************/
-
-#include "../qcommon/q_shared.h"
-#include "l_memory.h"
-#include "l_script.h"
-#include "l_precomp.h"
-#include "l_struct.h"
-#ifndef BSPC
-#include "l_libvar.h"
-#endif
-#include "aasfile.h"
-#include "botlib.h"
-#include "be_aas.h"
-#include "be_interface.h"
-#include "be_aas_funcs.h"
-#include "be_aas_def.h"
-
-extern botlib_import_t botimport;
-
-//#define AAS_SAMPLE_DEBUG
-
-#define BBOX_NORMAL_EPSILON 0.001
-
-#define ON_EPSILON 0 //0.0005
-
-#define TRACEPLANE_EPSILON 0.125
-
-typedef struct aas_tracestack_s
-{
- vec3_t start; //start point of the piece of line to trace
- vec3_t end; //end point of the piece of line to trace
- int planenum; //last plane used as splitter
- int nodenum; //node found after splitting with planenum
-} aas_tracestack_t;
-
-int numaaslinks;
-
-//===========================================================================
-//
-// Parameter: -
-// Returns: -
-// Changes Globals: -
-//===========================================================================
-void AAS_PresenceTypeBoundingBox(int presencetype, vec3_t mins, vec3_t maxs)
-{
- int index;
- //bounding box size for each presence type
- vec3_t boxmins[3] = {{0, 0, 0}, {-15, -15, -24}, {-15, -15, -24}};
- vec3_t boxmaxs[3] = {{0, 0, 0}, { 15, 15, 32}, { 15, 15, 8}};
-
- if (presencetype == PRESENCE_NORMAL) index = 1;
- else if (presencetype == PRESENCE_CROUCH) index = 2;
- else
- {
- botimport.Print(PRT_FATAL, "AAS_PresenceTypeBoundingBox: unknown presence type\n");
- index = 2;
- } //end if
- VectorCopy(boxmins[index], mins);
- VectorCopy(boxmaxs[index], maxs);
-} //end of the function AAS_PresenceTypeBoundingBox
-//===========================================================================
-//
-// Parameter: -
-// Returns: -
-// Changes Globals: -
-//===========================================================================
-void AAS_InitAASLinkHeap(void)
-{
- int i, max_aaslinks;
-
- max_aaslinks = aasworld.linkheapsize;
- //if there's no link heap present
- if (!aasworld.linkheap)
- {
-#ifdef BSPC
- max_aaslinks = 6144;
-#else
- max_aaslinks = (int) LibVarValue("max_aaslinks", "6144");
-#endif
- if (max_aaslinks < 0) max_aaslinks = 0;
- aasworld.linkheapsize = max_aaslinks;
- aasworld.linkheap = (aas_link_t *) GetHunkMemory(max_aaslinks * sizeof(aas_link_t));
- } //end if
- //link the links on the heap
- aasworld.linkheap[0].prev_ent = NULL;
- aasworld.linkheap[0].next_ent = &aasworld.linkheap[1];
- for (i = 1; i < max_aaslinks-1; i++)
- {
- aasworld.linkheap[i].prev_ent = &aasworld.linkheap[i - 1];
- aasworld.linkheap[i].next_ent = &aasworld.linkheap[i + 1];
- } //end for
- aasworld.linkheap[max_aaslinks-1].prev_ent = &aasworld.linkheap[max_aaslinks-2];
- aasworld.linkheap[max_aaslinks-1].next_ent = NULL;
- //pointer to the first free link
- aasworld.freelinks = &aasworld.linkheap[0];
- //
- numaaslinks = max_aaslinks;
-} //end of the function AAS_InitAASLinkHeap
-//===========================================================================
-//
-// Parameter: -
-// Returns: -
-// Changes Globals: -
-//===========================================================================
-void AAS_FreeAASLinkHeap(void)
-{
- if (aasworld.linkheap) FreeMemory(aasworld.linkheap);
- aasworld.linkheap = NULL;
- aasworld.linkheapsize = 0;
-} //end of the function AAS_FreeAASLinkHeap
-//===========================================================================
-//
-// Parameter: -
-// Returns: -
-// Changes Globals: -
-//===========================================================================
-aas_link_t *AAS_AllocAASLink(void)
-{
- aas_link_t *link;
-
- link = aasworld.freelinks;
- if (!link)
- {
-#ifndef BSPC
- if (bot_developer)
-#endif
- {
- botimport.Print(PRT_FATAL, "empty aas link heap\n");
- } //end if
- return NULL;
- } //end if
- if (aasworld.freelinks) aasworld.freelinks = aasworld.freelinks->next_ent;
- if (aasworld.freelinks) aasworld.freelinks->prev_ent = NULL;
- numaaslinks--;
- return link;
-} //end of the function AAS_AllocAASLink
-//===========================================================================
-//
-// Parameter: -
-// Returns: -
-// Changes Globals: -
-//===========================================================================
-void AAS_DeAllocAASLink(aas_link_t *link)
-{
- if (aasworld.freelinks) aasworld.freelinks->prev_ent = link;
- link->prev_ent = NULL;
- link->next_ent = aasworld.freelinks;
- link->prev_area = NULL;
- link->next_area = NULL;
- aasworld.freelinks = link;
- numaaslinks++;
-} //end of the function AAS_DeAllocAASLink
-//===========================================================================
-//
-// Parameter: -
-// Returns: -
-// Changes Globals: -
-//===========================================================================
-void AAS_InitAASLinkedEntities(void)
-{
- if (!aasworld.loaded) return;
- if (aasworld.arealinkedentities) FreeMemory(aasworld.arealinkedentities);
- aasworld.arealinkedentities = (aas_link_t **) GetClearedHunkMemory(
- aasworld.numareas * sizeof(aas_link_t *));
-} //end of the function AAS_InitAASLinkedEntities
-//===========================================================================
-//
-// Parameter: -
-// Returns: -
-// Changes Globals: -
-//===========================================================================
-void AAS_FreeAASLinkedEntities(void)
-{
- if (aasworld.arealinkedentities) FreeMemory(aasworld.arealinkedentities);
- aasworld.arealinkedentities = NULL;
-} //end of the function AAS_InitAASLinkedEntities
-//===========================================================================
-// returns the AAS area the point is in
-//
-// Parameter: -
-// Returns: -
-// Changes Globals: -
-//===========================================================================
-int AAS_PointAreaNum(vec3_t point)
-{
- int nodenum;
- vec_t dist;
- aas_node_t *node;
- aas_plane_t *plane;
-
- if (!aasworld.loaded)
- {
- botimport.Print(PRT_ERROR, "AAS_PointAreaNum: aas not loaded\n");
- return 0;
- } //end if
-
- //start with node 1 because node zero is a dummy used for solid leafs
- nodenum = 1;
- while (nodenum > 0)
- {
-// botimport.Print(PRT_MESSAGE, "[%d]", nodenum);
-#ifdef AAS_SAMPLE_DEBUG
- if (nodenum >= aasworld.numnodes)
- {
- botimport.Print(PRT_ERROR, "nodenum = %d >= aasworld.numnodes = %d\n", nodenum, aasworld.numnodes);
- return 0;
- } //end if
-#endif //AAS_SAMPLE_DEBUG
- node = &aasworld.nodes[nodenum];
-#ifdef AAS_SAMPLE_DEBUG
- if (node->planenum < 0 || node->planenum >= aasworld.numplanes)
- {
- botimport.Print(PRT_ERROR, "node->planenum = %d >= aasworld.numplanes = %d\n", node->planenum, aasworld.numplanes);
- return 0;
- } //end if
-#endif //AAS_SAMPLE_DEBUG
- plane = &aasworld.planes[node->planenum];
- dist = DotProduct(point, plane->normal) - plane->dist;
- if (dist > 0) nodenum = node->children[0];
- else nodenum = node->children[1];
- } //end while
- if (!nodenum)
- {
-#ifdef AAS_SAMPLE_DEBUG
- botimport.Print(PRT_MESSAGE, "in solid\n");
-#endif //AAS_SAMPLE_DEBUG
- return 0;
- } //end if
- return -nodenum;
-} //end of the function AAS_PointAreaNum
-//===========================================================================
-//
-// Parameter: -
-// Returns: -
-// Changes Globals: -
-//===========================================================================
-int AAS_PointReachabilityAreaIndex( vec3_t origin )
-{
- int areanum, cluster, i, index;
-
- if (!aasworld.initialized)
- return 0;
-
- if ( !origin )
- {
- index = 0;
- for (i = 0; i < aasworld.numclusters; i++)
- {
- index += aasworld.clusters[i].numreachabilityareas;
- } //end for
- return index;
- } //end if
-
- areanum = AAS_PointAreaNum( origin );
- if ( !areanum || !AAS_AreaReachability(areanum) )
- return 0;
- cluster = aasworld.areasettings[areanum].cluster;
- areanum = aasworld.areasettings[areanum].clusterareanum;
- if (cluster < 0)
- {
- cluster = aasworld.portals[-cluster].frontcluster;
- areanum = aasworld.portals[-cluster].clusterareanum[0];
- } //end if
-
- index = 0;
- for (i = 0; i < cluster; i++)
- {
- index += aasworld.clusters[i].numreachabilityareas;
- } //end for
- index += areanum;
- return index;
-} //end of the function AAS_PointReachabilityAreaIndex
-//===========================================================================
-//
-// Parameter: -
-// Returns: -
-// Changes Globals: -
-//===========================================================================
-int AAS_AreaCluster(int areanum)
-{
- if (areanum <= 0 || areanum >= aasworld.numareas)
- {
- botimport.Print(PRT_ERROR, "AAS_AreaCluster: invalid area number\n");
- return 0;
- } //end if
- return aasworld.areasettings[areanum].cluster;
-} //end of the function AAS_AreaCluster
-//===========================================================================
-// returns the presence types of the given area
-//
-// Parameter: -
-// Returns: -
-// Changes Globals: -
-//===========================================================================
-int AAS_AreaPresenceType(int areanum)
-{
- if (!aasworld.loaded) return 0;
- if (areanum <= 0 || areanum >= aasworld.numareas)
- {
- botimport.Print(PRT_ERROR, "AAS_AreaPresenceType: invalid area number\n");
- return 0;
- } //end if
- return aasworld.areasettings[areanum].presencetype;
-} //end of the function AAS_AreaPresenceType
-//===========================================================================
-// returns the presence type at the given point
-//
-// Parameter: -
-// Returns: -
-// Changes Globals: -
-//===========================================================================
-int AAS_PointPresenceType(vec3_t point)
-{
- int areanum;
-
- if (!aasworld.loaded) return 0;
-
- areanum = AAS_PointAreaNum(point);
- if (!areanum) return PRESENCE_NONE;
- return aasworld.areasettings[areanum].presencetype;
-} //end of the function AAS_PointPresenceType
-//===========================================================================
-// calculates the minimum distance between the origin of the box and the
-// given plane when both will collide on the given side of the plane
-//
-// normal = normal vector of plane to calculate distance from
-// mins = minimums of box relative to origin
-// maxs = maximums of box relative to origin
-// side = side of the plane we want to calculate the distance from
-// 0 normal vector side
-// 1 not normal vector side
-//
-// Parameter: -
-// Returns: -
-// Changes Globals: -
-//===========================================================================
-vec_t AAS_BoxOriginDistanceFromPlane(vec3_t normal, vec3_t mins, vec3_t maxs, int side)
-{
- vec3_t v1, v2;
- int i;
-
- //swap maxs and mins when on the other side of the plane
- if (side)
- {
- //get a point of the box that would be one of the first
- //to collide with the plane
- for (i = 0; i < 3; i++)
- {
- if (normal[i] > BBOX_NORMAL_EPSILON) v1[i] = maxs[i];
- else if (normal[i] < -BBOX_NORMAL_EPSILON) v1[i] = mins[i];
- else v1[i] = 0;
- } //end for
- } //end if
- else
- {
- //get a point of the box that would be one of the first
- //to collide with the plane
- for (i = 0; i < 3; i++)
- {
- if (normal[i] > BBOX_NORMAL_EPSILON) v1[i] = mins[i];
- else if (normal[i] < -BBOX_NORMAL_EPSILON) v1[i] = maxs[i];
- else v1[i] = 0;
- } //end for
- } //end else
- //
- VectorCopy(normal, v2);
- VectorInverse(v2);
-// VectorNegate(normal, v2);
- return DotProduct(v1, v2);
-} //end of the function AAS_BoxOriginDistanceFromPlane
-//===========================================================================
-//
-// Parameter: -
-// Returns: -
-// Changes Globals: -
-//===========================================================================
-qboolean AAS_AreaEntityCollision(int areanum, vec3_t start, vec3_t end,
- int presencetype, int passent, aas_trace_t *trace)
-{
- int collision;
- vec3_t boxmins, boxmaxs;
- aas_link_t *link;
- bsp_trace_t bsptrace;
-
- AAS_PresenceTypeBoundingBox(presencetype, boxmins, boxmaxs);
-
- Com_Memset(&bsptrace, 0, sizeof(bsp_trace_t)); //make compiler happy
- //assume no collision
- bsptrace.fraction = 1;
- collision = qfalse;
- for (link = aasworld.arealinkedentities[areanum]; link; link = link->next_ent)
- {
- //ignore the pass entity
- if (link->entnum == passent) continue;
- //
- if (AAS_EntityCollision(link->entnum, start, boxmins, boxmaxs, end,
- CONTENTS_SOLID|CONTENTS_PLAYERCLIP, &bsptrace))
- {
- collision = qtrue;
- } //end if
- } //end for
- if (collision)
- {
- trace->startsolid = bsptrace.startsolid;
- trace->ent = bsptrace.ent;
- VectorCopy(bsptrace.endpos, trace->endpos);
- trace->area = 0;
- trace->planenum = 0;
- return qtrue;
- } //end if
- return qfalse;
-} //end of the function AAS_AreaEntityCollision
-//===========================================================================
-// recursive subdivision of the line by the BSP tree.
-//
-// Parameter: -
-// Returns: -
-// Changes Globals: -
-//===========================================================================
-aas_trace_t AAS_TraceClientBBox(vec3_t start, vec3_t end, int presencetype,
- int passent)
-{
- int side, nodenum, tmpplanenum;
- float front, back, frac;
- vec3_t cur_start, cur_end, cur_mid, v1, v2;
- aas_tracestack_t tracestack[127];
- aas_tracestack_t *tstack_p;
- aas_node_t *aasnode;
- aas_plane_t *plane;
- aas_trace_t trace;
-
- //clear the trace structure
- Com_Memset(&trace, 0, sizeof(aas_trace_t));
-
- if (!aasworld.loaded) return trace;
-
- tstack_p = tracestack;
- //we start with the whole line on the stack
- VectorCopy(start, tstack_p->start);
- VectorCopy(end, tstack_p->end);
- tstack_p->planenum = 0;
- //start with node 1 because node zero is a dummy for a solid leaf
- tstack_p->nodenum = 1; //starting at the root of the tree
- tstack_p++;
-
- while (1)
- {
- //pop up the stack
- tstack_p--;
- //if the trace stack is empty (ended up with a piece of the
- //line to be traced in an area)
- if (tstack_p < tracestack)
- {
- tstack_p++;
- //nothing was hit
- trace.startsolid = qfalse;
- trace.fraction = 1.0;
- //endpos is the end of the line
- VectorCopy(end, trace.endpos);
- //nothing hit
- trace.ent = 0;
- trace.area = 0;
- trace.planenum = 0;
- return trace;
- } //end if
- //number of the current node to test the line against
- nodenum = tstack_p->nodenum;
- //if it is an area
- if (nodenum < 0)
- {
-#ifdef AAS_SAMPLE_DEBUG
- if (-nodenum > aasworld.numareasettings)
- {
- botimport.Print(PRT_ERROR, "AAS_TraceBoundingBox: -nodenum out of range\n");
- return trace;
- } //end if
-#endif //AAS_SAMPLE_DEBUG
- //botimport.Print(PRT_MESSAGE, "areanum = %d, must be %d\n", -nodenum, AAS_PointAreaNum(start));
- //if can't enter the area because it hasn't got the right presence type
- if (!(aasworld.areasettings[-nodenum].presencetype & presencetype))
- {
- //if the start point is still the initial start point
- //NOTE: no need for epsilons because the points will be
- //exactly the same when they're both the start point
- if (tstack_p->start[0] == start[0] &&
- tstack_p->start[1] == start[1] &&
- tstack_p->start[2] == start[2])
- {
- trace.startsolid = qtrue;
- trace.fraction = 0.0;
- VectorClear(v1);
- } //end if
- else
- {
- trace.startsolid = qfalse;
- VectorSubtract(end, start, v1);
- VectorSubtract(tstack_p->start, start, v2);
- trace.fraction = VectorLength(v2) / VectorNormalize(v1);
- VectorMA(tstack_p->start, -0.125, v1, tstack_p->start);
- } //end else
- VectorCopy(tstack_p->start, trace.endpos);
- trace.ent = 0;
- trace.area = -nodenum;
-// VectorSubtract(end, start, v1);
- trace.planenum = tstack_p->planenum;
- //always take the plane with normal facing towards the trace start
- plane = &aasworld.planes[trace.planenum];
- if (DotProduct(v1, plane->normal) > 0) trace.planenum ^= 1;
- return trace;
- } //end if
- else
- {
- if (passent >= 0)
- {
- if (AAS_AreaEntityCollision(-nodenum, tstack_p->start,
- tstack_p->end, presencetype, passent,
- &trace))
- {
- if (!trace.startsolid)
- {
- VectorSubtract(end, start, v1);
- VectorSubtract(trace.endpos, start, v2);
- trace.fraction = VectorLength(v2) / VectorLength(v1);
- } //end if
- return trace;
- } //end if
- } //end if
- } //end else
- trace.lastarea = -nodenum;
- continue;
- } //end if
- //if it is a solid leaf
- if (!nodenum)
- {
- //if the start point is still the initial start point
- //NOTE: no need for epsilons because the points will be
- //exactly the same when they're both the start point
- if (tstack_p->start[0] == start[0] &&
- tstack_p->start[1] == start[1] &&
- tstack_p->start[2] == start[2])
- {
- trace.startsolid = qtrue;
- trace.fraction = 0.0;
- VectorClear(v1);
- } //end if
- else
- {
- trace.startsolid = qfalse;
- VectorSubtract(end, start, v1);
- VectorSubtract(tstack_p->start, start, v2);
- trace.fraction = VectorLength(v2) / VectorNormalize(v1);
- VectorMA(tstack_p->start, -0.125, v1, tstack_p->start);
- } //end else
- VectorCopy(tstack_p->start, trace.endpos);
- trace.ent = 0;
- trace.area = 0; //hit solid leaf
-// VectorSubtract(end, start, v1);
- trace.planenum = tstack_p->planenum;
- //always take the plane with normal facing towards the trace start
- plane = &aasworld.planes[trace.planenum];
- if (DotProduct(v1, plane->normal) > 0) trace.planenum ^= 1;
- return trace;
- } //end if
-#ifdef AAS_SAMPLE_DEBUG
- if (nodenum > aasworld.numnodes)
- {
- botimport.Print(PRT_ERROR, "AAS_TraceBoundingBox: nodenum out of range\n");
- return trace;
- } //end if
-#endif //AAS_SAMPLE_DEBUG
- //the node to test against
- aasnode = &aasworld.nodes[nodenum];
- //start point of current line to test against node
- VectorCopy(tstack_p->start, cur_start);
- //end point of the current line to test against node
- VectorCopy(tstack_p->end, cur_end);
- //the current node plane
- plane = &aasworld.planes[aasnode->planenum];
-
- switch(plane->type)
- {/*FIXME: wtf doesn't this work? obviously the axial node planes aren't always facing positive!!!
- //check for axial planes
- case PLANE_X:
- {
- front = cur_start[0] - plane->dist;
- back = cur_end[0] - plane->dist;
- break;
- } //end case
- case PLANE_Y:
- {
- front = cur_start[1] - plane->dist;
- back = cur_end[1] - plane->dist;
- break;
- } //end case
- case PLANE_Z:
- {
- front = cur_start[2] - plane->dist;
- back = cur_end[2] - plane->dist;
- break;
- } //end case*/
- default: //gee it's not an axial plane
- {
- front = DotProduct(cur_start, plane->normal) - plane->dist;
- back = DotProduct(cur_end, plane->normal) - plane->dist;
- break;
- } //end default
- } //end switch
- // bk010221 - old location of FPE hack and divide by zero expression
- //if the whole to be traced line is totally at the front of this node
- //only go down the tree with the front child
- if ((front >= -ON_EPSILON && back >= -ON_EPSILON))
- {
- //keep the current start and end point on the stack
- //and go down the tree with the front child
- tstack_p->nodenum = aasnode->children[0];
- tstack_p++;
- if (tstack_p >= &tracestack[127])
- {
- botimport.Print(PRT_ERROR, "AAS_TraceBoundingBox: stack overflow\n");
- return trace;
- } //end if
- } //end if
- //if the whole to be traced line is totally at the back of this node
- //only go down the tree with the back child
- else if ((front < ON_EPSILON && back < ON_EPSILON))
- {
- //keep the current start and end point on the stack
- //and go down the tree with the back child
- tstack_p->nodenum = aasnode->children[1];
- tstack_p++;
- if (tstack_p >= &tracestack[127])
- {
- botimport.Print(PRT_ERROR, "AAS_TraceBoundingBox: stack overflow\n");
- return trace;
- } //end if
- } //end if
- //go down the tree both at the front and back of the node
- else
- {
- tmpplanenum = tstack_p->planenum;
- // bk010221 - new location of divide by zero (see above)
- if ( front == back ) front -= 0.001f; // bk0101022 - hack/FPE
- //calculate the hitpoint with the node (split point of the line)
- //put the crosspoint TRACEPLANE_EPSILON pixels on the near side
- if (front < 0) frac = (front + TRACEPLANE_EPSILON)/(front-back);
- else frac = (front - TRACEPLANE_EPSILON)/(front-back); // bk010221
- //
- if (frac < 0)
- frac = 0.001f; //0
- else if (frac > 1)
- frac = 0.999f; //1
- //frac = front / (front-back);
- //
- cur_mid[0] = cur_start[0] + (cur_end[0] - cur_start[0]) * frac;
- cur_mid[1] = cur_start[1] + (cur_end[1] - cur_start[1]) * frac;
- cur_mid[2] = cur_start[2] + (cur_end[2] - cur_start[2]) * frac;
-
-// AAS_DrawPlaneCross(cur_mid, plane->normal, plane->dist, plane->type, LINECOLOR_RED);
- //side the front part of the line is on
- side = front < 0;
- //first put the end part of the line on the stack (back side)
- VectorCopy(cur_mid, tstack_p->start);
- //not necesary to store because still on stack
- //VectorCopy(cur_end, tstack_p->end);
- tstack_p->planenum = aasnode->planenum;
- tstack_p->nodenum = aasnode->children[!side];
- tstack_p++;
- if (tstack_p >= &tracestack[127])
- {
- botimport.Print(PRT_ERROR, "AAS_TraceBoundingBox: stack overflow\n");
- return trace;
- } //end if
- //now put the part near the start of the line on the stack so we will
- //continue with thats part first. This way we'll find the first
- //hit of the bbox
- VectorCopy(cur_start, tstack_p->start);
- VectorCopy(cur_mid, tstack_p->end);
- tstack_p->planenum = tmpplanenum;
- tstack_p->nodenum = aasnode->children[side];
- tstack_p++;
- if (tstack_p >= &tracestack[127])
- {
- botimport.Print(PRT_ERROR, "AAS_TraceBoundingBox: stack overflow\n");
- return trace;
- } //end if
- } //end else
- } //end while
-// return trace;
-} //end of the function AAS_TraceClientBBox
-//===========================================================================
-// recursive subdivision of the line by the BSP tree.
-//
-// Parameter: -
-// Returns: -
-// Changes Globals: -
-//===========================================================================
-int AAS_TraceAreas(vec3_t start, vec3_t end, int *areas, vec3_t *points, int maxareas)
-{
- int side, nodenum, tmpplanenum;
- int numareas;
- float front, back, frac;
- vec3_t cur_start, cur_end, cur_mid;
- aas_tracestack_t tracestack[127];
- aas_tracestack_t *tstack_p;
- aas_node_t *aasnode;
- aas_plane_t *plane;
-
- numareas = 0;
- areas[0] = 0;
- if (!aasworld.loaded) return numareas;
-
- tstack_p = tracestack;
- //we start with the whole line on the stack
- VectorCopy(start, tstack_p->start);
- VectorCopy(end, tstack_p->end);
- tstack_p->planenum = 0;
- //start with node 1 because node zero is a dummy for a solid leaf
- tstack_p->nodenum = 1; //starting at the root of the tree
- tstack_p++;
-
- while (1)
- {
- //pop up the stack
- tstack_p--;
- //if the trace stack is empty (ended up with a piece of the
- //line to be traced in an area)
- if (tstack_p < tracestack)
- {
- return numareas;
- } //end if
- //number of the current node to test the line against
- nodenum = tstack_p->nodenum;
- //if it is an area
- if (nodenum < 0)
- {
-#ifdef AAS_SAMPLE_DEBUG
- if (-nodenum > aasworld.numareasettings)
- {
- botimport.Print(PRT_ERROR, "AAS_TraceAreas: -nodenum = %d out of range\n", -nodenum);
- return numareas;
- } //end if
-#endif //AAS_SAMPLE_DEBUG
- //botimport.Print(PRT_MESSAGE, "areanum = %d, must be %d\n", -nodenum, AAS_PointAreaNum(start));
- areas[numareas] = -nodenum;
- if (points) VectorCopy(tstack_p->start, points[numareas]);
- numareas++;
- if (numareas >= maxareas) return numareas;
- continue;
- } //end if
- //if it is a solid leaf
- if (!nodenum)
- {
- continue;
- } //end if
-#ifdef AAS_SAMPLE_DEBUG
- if (nodenum > aasworld.numnodes)
- {
- botimport.Print(PRT_ERROR, "AAS_TraceAreas: nodenum out of range\n");
- return numareas;
- } //end if
-#endif //AAS_SAMPLE_DEBUG
- //the node to test against
- aasnode = &aasworld.nodes[nodenum];
- //start point of current line to test against node
- VectorCopy(tstack_p->start, cur_start);
- //end point of the current line to test against node
- VectorCopy(tstack_p->end, cur_end);
- //the current node plane
- plane = &aasworld.planes[aasnode->planenum];
-
- switch(plane->type)
- {/*FIXME: wtf doesn't this work? obviously the node planes aren't always facing positive!!!
- //check for axial planes
- case PLANE_X:
- {
- front = cur_start[0] - plane->dist;
- back = cur_end[0] - plane->dist;
- break;
- } //end case
- case PLANE_Y:
- {
- front = cur_start[1] - plane->dist;
- back = cur_end[1] - plane->dist;
- break;
- } //end case
- case PLANE_Z:
- {
- front = cur_start[2] - plane->dist;
- back = cur_end[2] - plane->dist;
- break;
- } //end case*/
- default: //gee it's not an axial plane
- {
- front = DotProduct(cur_start, plane->normal) - plane->dist;
- back = DotProduct(cur_end, plane->normal) - plane->dist;
- break;
- } //end default
- } //end switch
-
- //if the whole to be traced line is totally at the front of this node
- //only go down the tree with the front child
- if (front > 0 && back > 0)
- {
- //keep the current start and end point on the stack
- //and go down the tree with the front child
- tstack_p->nodenum = aasnode->children[0];
- tstack_p++;
- if (tstack_p >= &tracestack[127])
- {
- botimport.Print(PRT_ERROR, "AAS_TraceAreas: stack overflow\n");
- return numareas;
- } //end if
- } //end if
- //if the whole to be traced line is totally at the back of this node
- //only go down the tree with the back child
- else if (front <= 0 && back <= 0)
- {
- //keep the current start and end point on the stack
- //and go down the tree with the back child
- tstack_p->nodenum = aasnode->children[1];
- tstack_p++;
- if (tstack_p >= &tracestack[127])
- {
- botimport.Print(PRT_ERROR, "AAS_TraceAreas: stack overflow\n");
- return numareas;
- } //end if
- } //end if
- //go down the tree both at the front and back of the node
- else
- {
- tmpplanenum = tstack_p->planenum;
- //calculate the hitpoint with the node (split point of the line)
- //put the crosspoint TRACEPLANE_EPSILON pixels on the near side
- if (front < 0) frac = (front)/(front-back);
- else frac = (front)/(front-back);
- if (frac < 0) frac = 0;
- else if (frac > 1) frac = 1;
- //frac = front / (front-back);
- //
- cur_mid[0] = cur_start[0] + (cur_end[0] - cur_start[0]) * frac;
- cur_mid[1] = cur_start[1] + (cur_end[1] - cur_start[1]) * frac;
- cur_mid[2] = cur_start[2] + (cur_end[2] - cur_start[2]) * frac;
-
-// AAS_DrawPlaneCross(cur_mid, plane->normal, plane->dist, plane->type, LINECOLOR_RED);
- //side the front part of the line is on
- side = front < 0;
- //first put the end part of the line on the stack (back side)
- VectorCopy(cur_mid, tstack_p->start);
- //not necesary to store because still on stack
- //VectorCopy(cur_end, tstack_p->end);
- tstack_p->planenum = aasnode->planenum;
- tstack_p->nodenum = aasnode->children[!side];
- tstack_p++;
- if (tstack_p >= &tracestack[127])
- {
- botimport.Print(PRT_ERROR, "AAS_TraceAreas: stack overflow\n");
- return numareas;
- } //end if
- //now put the part near the start of the line on the stack so we will
- //continue with thats part first. This way we'll find the first
- //hit of the bbox
- VectorCopy(cur_start, tstack_p->start);
- VectorCopy(cur_mid, tstack_p->end);
- tstack_p->planenum = tmpplanenum;
- tstack_p->nodenum = aasnode->children[side];
- tstack_p++;
- if (tstack_p >= &tracestack[127])
- {
- botimport.Print(PRT_ERROR, "AAS_TraceAreas: stack overflow\n");
- return numareas;
- } //end if
- } //end else
- } //end while
-// return numareas;
-} //end of the function AAS_TraceAreas
-//===========================================================================
-// a simple cross product
-//
-// Parameter: -
-// Returns: -
-// Changes Globals: -
-//===========================================================================
-// void AAS_OrthogonalToVectors(vec3_t v1, vec3_t v2, vec3_t res)
-#define AAS_OrthogonalToVectors(v1, v2, res) \
- (res)[0] = ((v1)[1] * (v2)[2]) - ((v1)[2] * (v2)[1]);\
- (res)[1] = ((v1)[2] * (v2)[0]) - ((v1)[0] * (v2)[2]);\
- (res)[2] = ((v1)[0] * (v2)[1]) - ((v1)[1] * (v2)[0]);
-//===========================================================================
-// tests if the given point is within the face boundaries
-//
-// Parameter: face : face to test if the point is in it
-// pnormal : normal of the plane to use for the face
-// point : point to test if inside face boundaries
-// Returns: qtrue if the point is within the face boundaries
-// Changes Globals: -
-//===========================================================================
-qboolean AAS_InsideFace(aas_face_t *face, vec3_t pnormal, vec3_t point, float epsilon)
-{
- int i, firstvertex, edgenum;
- vec3_t v0;
- vec3_t edgevec, pointvec, sepnormal;
- aas_edge_t *edge;
-#ifdef AAS_SAMPLE_DEBUG
- int lastvertex = 0;
-#endif //AAS_SAMPLE_DEBUG
-
- if (!aasworld.loaded) return qfalse;
-
- for (i = 0; i < face->numedges; i++)
- {
- edgenum = aasworld.edgeindex[face->firstedge + i];
- edge = &aasworld.edges[abs(edgenum)];
- //get the first vertex of the edge
- firstvertex = edgenum < 0;
- VectorCopy(aasworld.vertexes[edge->v[firstvertex]], v0);
- //edge vector
- VectorSubtract(aasworld.vertexes[edge->v[!firstvertex]], v0, edgevec);
- //
-#ifdef AAS_SAMPLE_DEBUG
- if (lastvertex && lastvertex != edge->v[firstvertex])
- {
- botimport.Print(PRT_MESSAGE, "winding not counter clockwise\n");
- } //end if
- lastvertex = edge->v[!firstvertex];
-#endif //AAS_SAMPLE_DEBUG
- //vector from first edge point to point possible in face
- VectorSubtract(point, v0, pointvec);
- //get a vector pointing inside the face orthogonal to both the
- //edge vector and the normal vector of the plane the face is in
- //this vector defines a plane through the origin (first vertex of
- //edge) and through both the edge vector and the normal vector
- //of the plane
- AAS_OrthogonalToVectors(edgevec, pnormal, sepnormal);
- //check on wich side of the above plane the point is
- //this is done by checking the sign of the dot product of the
- //vector orthogonal vector from above and the vector from the
- //origin (first vertex of edge) to the point
- //if the dotproduct is smaller than zero the point is outside the face
- if (DotProduct(pointvec, sepnormal) < -epsilon) return qfalse;
- } //end for
- return qtrue;
-} //end of the function AAS_InsideFace
-//===========================================================================
-//
-// Parameter: -
-// Returns: -
-// Changes Globals: -
-//===========================================================================
-qboolean AAS_PointInsideFace(int facenum, vec3_t point, float epsilon)
-{
- int i, firstvertex, edgenum;
- vec_t *v1, *v2;
- vec3_t edgevec, pointvec, sepnormal;
- aas_edge_t *edge;
- aas_plane_t *plane;
- aas_face_t *face;
-
- if (!aasworld.loaded) return qfalse;
-
- face = &aasworld.faces[facenum];
- plane = &aasworld.planes[face->planenum];
- //
- for (i = 0; i < face->numedges; i++)
- {
- edgenum = aasworld.edgeindex[face->firstedge + i];
- edge = &aasworld.edges[abs(edgenum)];
- //get the first vertex of the edge
- firstvertex = edgenum < 0;
- v1 = aasworld.vertexes[edge->v[firstvertex]];
- v2 = aasworld.vertexes[edge->v[!firstvertex]];
- //edge vector
- VectorSubtract(v2, v1, edgevec);
- //vector from first edge point to point possible in face
- VectorSubtract(point, v1, pointvec);
- //
- CrossProduct(edgevec, plane->normal, sepnormal);
- //
- if (DotProduct(pointvec, sepnormal) < -epsilon) return qfalse;
- } //end for
- return qtrue;
-} //end of the function AAS_PointInsideFace
-//===========================================================================
-// returns the ground face the given point is above in the given area
-//
-// Parameter: -
-// Returns: -
-// Changes Globals: -
-//===========================================================================
-aas_face_t *AAS_AreaGroundFace(int areanum, vec3_t point)
-{
- int i, facenum;
- vec3_t up = {0, 0, 1};
- vec3_t normal;
- aas_area_t *area;
- aas_face_t *face;
-
- if (!aasworld.loaded) return NULL;
-
- area = &aasworld.areas[areanum];
- for (i = 0; i < area->numfaces; i++)
- {
- facenum = aasworld.faceindex[area->firstface + i];
- face = &aasworld.faces[abs(facenum)];
- //if this is a ground face
- if (face->faceflags & FACE_GROUND)
- {
- //get the up or down normal
- if (aasworld.planes[face->planenum].normal[2] < 0) VectorNegate(up, normal);
- else VectorCopy(up, normal);
- //check if the point is in the face
- if (AAS_InsideFace(face, normal, point, 0.01f)) return face;
- } //end if
- } //end for
- return NULL;
-} //end of the function AAS_AreaGroundFace
-//===========================================================================
-// returns the face the trace end position is situated in
-//
-// Parameter: -
-// Returns: -
-// Changes Globals: -
-//===========================================================================
-void AAS_FacePlane(int facenum, vec3_t normal, float *dist)
-{
- aas_plane_t *plane;
-
- plane = &aasworld.planes[aasworld.faces[facenum].planenum];
- VectorCopy(plane->normal, normal);
- *dist = plane->dist;
-} //end of the function AAS_FacePlane
-//===========================================================================
-// returns the face the trace end position is situated in
-//
-// Parameter: -
-// Returns: -
-// Changes Globals: -
-//===========================================================================
-aas_face_t *AAS_TraceEndFace(aas_trace_t *trace)
-{
- int i, facenum;
- aas_area_t *area;
- aas_face_t *face, *firstface = NULL;
-
- if (!aasworld.loaded) return NULL;
-
- //if started in solid no face was hit
- if (trace->startsolid) return NULL;
- //trace->lastarea is the last area the trace was in
- area = &aasworld.areas[trace->lastarea];
- //check which face the trace.endpos was in
- for (i = 0; i < area->numfaces; i++)
- {
- facenum = aasworld.faceindex[area->firstface + i];
- face = &aasworld.faces[abs(facenum)];
- //if the face is in the same plane as the trace end point
- if ((face->planenum & ~1) == (trace->planenum & ~1))
- {
- //firstface is used for optimization, if theres only one
- //face in the plane then it has to be the good one
- //if there are more faces in the same plane then always
- //check the one with the fewest edges first
-/* if (firstface)
- {
- if (firstface->numedges < face->numedges)
- {
- if (AAS_InsideFace(firstface,
- aasworld.planes[face->planenum].normal, trace->endpos))
- {
- return firstface;
- } //end if
- firstface = face;
- } //end if
- else
- {
- if (AAS_InsideFace(face,
- aasworld.planes[face->planenum].normal, trace->endpos))
- {
- return face;
- } //end if
- } //end else
- } //end if
- else
- {
- firstface = face;
- } //end else*/
- if (AAS_InsideFace(face,
- aasworld.planes[face->planenum].normal, trace->endpos, 0.01f)) return face;
- } //end if
- } //end for
- return firstface;
-} //end of the function AAS_TraceEndFace
-//===========================================================================
-//
-// Parameter: -
-// Returns: -
-// Changes Globals: -
-//===========================================================================
-int AAS_BoxOnPlaneSide2(vec3_t absmins, vec3_t absmaxs, aas_plane_t *p)
-{
- int i, sides;
- float dist1, dist2;
- vec3_t corners[2];
-
- for (i = 0; i < 3; i++)
- {
- if (p->normal[i] < 0)
- {
- corners[0][i] = absmins[i];
- corners[1][i] = absmaxs[i];
- } //end if
- else
- {
- corners[1][i] = absmins[i];
- corners[0][i] = absmaxs[i];
- } //end else
- } //end for
- dist1 = DotProduct(p->normal, corners[0]) - p->dist;
- dist2 = DotProduct(p->normal, corners[1]) - p->dist;
- sides = 0;
- if (dist1 >= 0) sides = 1;
- if (dist2 < 0) sides |= 2;
-
- return sides;
-} //end of the function AAS_BoxOnPlaneSide2
-//===========================================================================
-//
-// Parameter: -
-// Returns: -
-// Changes Globals: -
-//===========================================================================
-//int AAS_BoxOnPlaneSide(vec3_t absmins, vec3_t absmaxs, aas_plane_t *p)
-#define AAS_BoxOnPlaneSide(absmins, absmaxs, p) (\
- ( (p)->type < 3) ?\
- (\
- ( (p)->dist <= (absmins)[(p)->type]) ?\
- (\
- 1\
- )\
- :\
- (\
- ( (p)->dist >= (absmaxs)[(p)->type]) ?\
- (\
- 2\
- )\
- :\
- (\
- 3\
- )\
- )\
- )\
- :\
- (\
- AAS_BoxOnPlaneSide2((absmins), (absmaxs), (p))\
- )\
-) //end of the function AAS_BoxOnPlaneSide
-//===========================================================================
-// remove the links to this entity from all areas
-//
-// Parameter: -
-// Returns: -
-// Changes Globals: -
-//===========================================================================
-void AAS_UnlinkFromAreas(aas_link_t *areas)
-{
- aas_link_t *link, *nextlink;
-
- for (link = areas; link; link = nextlink)
- {
- //next area the entity is linked in
- nextlink = link->next_area;
- //remove the entity from the linked list of this area
- if (link->prev_ent) link->prev_ent->next_ent = link->next_ent;
- else aasworld.arealinkedentities[link->areanum] = link->next_ent;
- if (link->next_ent) link->next_ent->prev_ent = link->prev_ent;
- //deallocate the link structure
- AAS_DeAllocAASLink(link);
- } //end for
-} //end of the function AAS_UnlinkFromAreas
-//===========================================================================
-// link the entity to the areas the bounding box is totally or partly
-// situated in. This is done with recursion down the tree using the
-// bounding box to test for plane sides
-//
-// Parameter: -
-// Returns: -
-// Changes Globals: -
-//===========================================================================
-
-typedef struct
-{
- int nodenum; //node found after splitting
-} aas_linkstack_t;
-
-aas_link_t *AAS_AASLinkEntity(vec3_t absmins, vec3_t absmaxs, int entnum)
-{
- int side, nodenum;
- aas_linkstack_t linkstack[128];
- aas_linkstack_t *lstack_p;
- aas_node_t *aasnode;
- aas_plane_t *plane;
- aas_link_t *link, *areas;
-
- if (!aasworld.loaded)
- {
- botimport.Print(PRT_ERROR, "AAS_LinkEntity: aas not loaded\n");
- return NULL;
- } //end if
-
- areas = NULL;
- //
- lstack_p = linkstack;
- //we start with the whole line on the stack
- //start with node 1 because node zero is a dummy used for solid leafs
- lstack_p->nodenum = 1; //starting at the root of the tree
- lstack_p++;
-
- while (1)
- {
- //pop up the stack
- lstack_p--;
- //if the trace stack is empty (ended up with a piece of the
- //line to be traced in an area)
- if (lstack_p < linkstack) break;
- //number of the current node to test the line against
- nodenum = lstack_p->nodenum;
- //if it is an area
- if (nodenum < 0)
- {
- //NOTE: the entity might have already been linked into this area
- // because several node children can point to the same area
- for (link = aasworld.arealinkedentities[-nodenum]; link; link = link->next_ent)
- {
- if (link->entnum == entnum) break;
- } //end for
- if (link) continue;
- //
- link = AAS_AllocAASLink();
- if (!link) return areas;
- link->entnum = entnum;
- link->areanum = -nodenum;
- //put the link into the double linked area list of the entity
- link->prev_area = NULL;
- link->next_area = areas;
- if (areas) areas->prev_area = link;
- areas = link;
- //put the link into the double linked entity list of the area
- link->prev_ent = NULL;
- link->next_ent = aasworld.arealinkedentities[-nodenum];
- if (aasworld.arealinkedentities[-nodenum])
- aasworld.arealinkedentities[-nodenum]->prev_ent = link;
- aasworld.arealinkedentities[-nodenum] = link;
- //
- continue;
- } //end if
- //if solid leaf
- if (!nodenum) continue;
- //the node to test against
- aasnode = &aasworld.nodes[nodenum];
- //the current node plane
- plane = &aasworld.planes[aasnode->planenum];
- //get the side(s) the box is situated relative to the plane
- side = AAS_BoxOnPlaneSide2(absmins, absmaxs, plane);
- //if on the front side of the node
- if (side & 1)
- {
- lstack_p->nodenum = aasnode->children[0];
- lstack_p++;
- } //end if
- if (lstack_p >= &linkstack[127])
- {
- botimport.Print(PRT_ERROR, "AAS_LinkEntity: stack overflow\n");
- break;
- } //end if
- //if on the back side of the node
- if (side & 2)
- {
- lstack_p->nodenum = aasnode->children[1];
- lstack_p++;
- } //end if
- if (lstack_p >= &linkstack[127])
- {
- botimport.Print(PRT_ERROR, "AAS_LinkEntity: stack overflow\n");
- break;
- } //end if
- } //end while
- return areas;
-} //end of the function AAS_AASLinkEntity
-//===========================================================================
-//
-// Parameter: -
-// Returns: -
-// Changes Globals: -
-//===========================================================================
-aas_link_t *AAS_LinkEntityClientBBox(vec3_t absmins, vec3_t absmaxs, int entnum, int presencetype)
-{
- vec3_t mins, maxs;
- vec3_t newabsmins, newabsmaxs;
-
- AAS_PresenceTypeBoundingBox(presencetype, mins, maxs);
- VectorSubtract(absmins, maxs, newabsmins);
- VectorSubtract(absmaxs, mins, newabsmaxs);
- //relink the entity
- return AAS_AASLinkEntity(newabsmins, newabsmaxs, entnum);
-} //end of the function AAS_LinkEntityClientBBox
-//===========================================================================
-//
-// Parameter: -
-// Returns: -
-// Changes Globals: -
-//===========================================================================
-int AAS_BBoxAreas(vec3_t absmins, vec3_t absmaxs, int *areas, int maxareas)
-{
- aas_link_t *linkedareas, *link;
- int num;
-
- linkedareas = AAS_AASLinkEntity(absmins, absmaxs, -1);
- num = 0;
- for (link = linkedareas; link; link = link->next_area)
- {
- areas[num] = link->areanum;
- num++;
- if (num >= maxareas)
- break;
- } //end for
- AAS_UnlinkFromAreas(linkedareas);
- return num;
-} //end of the function AAS_BBoxAreas
-//===========================================================================
-//
-// Parameter: -
-// Returns: -
-// Changes Globals: -
-//===========================================================================
-int AAS_AreaInfo( int areanum, aas_areainfo_t *info )
-{
- aas_areasettings_t *settings;
- if (!info)
- return 0;
- if (areanum <= 0 || areanum >= aasworld.numareas)
- {
- botimport.Print(PRT_ERROR, "AAS_AreaInfo: areanum %d out of range\n", areanum);
- return 0;
- } //end if
- settings = &aasworld.areasettings[areanum];
- info->cluster = settings->cluster;
- info->contents = settings->contents;
- info->flags = settings->areaflags;
- info->presencetype = settings->presencetype;
- VectorCopy(aasworld.areas[areanum].mins, info->mins);
- VectorCopy(aasworld.areas[areanum].maxs, info->maxs);
- VectorCopy(aasworld.areas[areanum].center, info->center);
- return sizeof(aas_areainfo_t);
-} //end of the function AAS_AreaInfo
-//===========================================================================
-//
-// Parameter: -
-// Returns: -
-// Changes Globals: -
-//===========================================================================
-aas_plane_t *AAS_PlaneFromNum(int planenum)
-{
- if (!aasworld.loaded) return NULL;
-
- return &aasworld.planes[planenum];
-} //end of the function AAS_PlaneFromNum
--
cgit