mirror of
https://github.com/dhewm/dhewm3.git
synced 2024-11-24 05:11:21 +00:00
351 lines
14 KiB
C++
351 lines
14 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 GPL Source Code
|
|
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 GPL Source Code (?Doom 3 Source Code?).
|
|
|
|
Doom 3 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 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Doom 3 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 Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#ifndef __AASFILE_H__
|
|
#define __AASFILE_H__
|
|
|
|
/*
|
|
===============================================================================
|
|
|
|
AAS File
|
|
|
|
===============================================================================
|
|
*/
|
|
|
|
#define AAS_FILEID "DewmAAS"
|
|
#define AAS_FILEVERSION "1.07"
|
|
|
|
// travel flags
|
|
#define TFL_INVALID BIT(0) // not valid
|
|
#define TFL_WALK BIT(1) // walking
|
|
#define TFL_CROUCH BIT(2) // crouching
|
|
#define TFL_WALKOFFLEDGE BIT(3) // walking of a ledge
|
|
#define TFL_BARRIERJUMP BIT(4) // jumping onto a barrier
|
|
#define TFL_JUMP BIT(5) // jumping
|
|
#define TFL_LADDER BIT(6) // climbing a ladder
|
|
#define TFL_SWIM BIT(7) // swimming
|
|
#define TFL_WATERJUMP BIT(8) // jump out of the water
|
|
#define TFL_TELEPORT BIT(9) // teleportation
|
|
#define TFL_ELEVATOR BIT(10) // travel by elevator
|
|
#define TFL_FLY BIT(11) // fly
|
|
#define TFL_SPECIAL BIT(12) // special
|
|
#define TFL_WATER BIT(21) // travel through water
|
|
#define TFL_AIR BIT(22) // travel through air
|
|
|
|
// face flags
|
|
#define FACE_SOLID BIT(0) // solid at the other side
|
|
#define FACE_LADDER BIT(1) // ladder surface
|
|
#define FACE_FLOOR BIT(2) // standing on floor when on this face
|
|
#define FACE_LIQUID BIT(3) // face seperating two areas with liquid
|
|
#define FACE_LIQUIDSURFACE BIT(4) // face seperating liquid and air
|
|
|
|
// area flags
|
|
#define AREA_FLOOR BIT(0) // AI can stand on the floor in this area
|
|
#define AREA_GAP BIT(1) // area has a gap
|
|
#define AREA_LEDGE BIT(2) // if entered the AI bbox partly floats above a ledge
|
|
#define AREA_LADDER BIT(3) // area contains one or more ladder faces
|
|
#define AREA_LIQUID BIT(4) // area contains a liquid
|
|
#define AREA_CROUCH BIT(5) // AI cannot walk but can only crouch in this area
|
|
#define AREA_REACHABLE_WALK BIT(6) // area is reachable by walking or swimming
|
|
#define AREA_REACHABLE_FLY BIT(7) // area is reachable by flying
|
|
|
|
// area contents flags
|
|
#define AREACONTENTS_SOLID BIT(0) // solid, not a valid area
|
|
#define AREACONTENTS_WATER BIT(1) // area contains water
|
|
#define AREACONTENTS_CLUSTERPORTAL BIT(2) // area is a cluster portal
|
|
#define AREACONTENTS_OBSTACLE BIT(3) // area contains (part of) a dynamic obstacle
|
|
#define AREACONTENTS_TELEPORTER BIT(4) // area contains (part of) a teleporter trigger
|
|
|
|
// bits for different bboxes
|
|
#define AREACONTENTS_BBOX_BIT 24
|
|
|
|
#define MAX_REACH_PER_AREA 256
|
|
#define MAX_AAS_TREE_DEPTH 128
|
|
|
|
#define MAX_AAS_BOUNDING_BOXES 4
|
|
|
|
// reachability to another area
|
|
class idReachability {
|
|
public:
|
|
int travelType; // type of travel required to get to the area
|
|
short toAreaNum; // number of the reachable area
|
|
short fromAreaNum; // number of area the reachability starts
|
|
idVec3 start; // start point of inter area movement
|
|
idVec3 end; // end point of inter area movement
|
|
int edgeNum; // edge crossed by this reachability
|
|
unsigned short travelTime; // travel time of the inter area movement
|
|
byte number; // reachability number within the fromAreaNum (must be < 256)
|
|
byte disableCount; // number of times this reachability has been disabled
|
|
idReachability * next; // next reachability in list
|
|
idReachability * rev_next; // next reachability in reversed list
|
|
unsigned short * areaTravelTimes; // travel times within the fromAreaNum from reachabilities that lead towards this area
|
|
public:
|
|
void CopyBase( idReachability &reach );
|
|
};
|
|
|
|
class idReachability_Walk : public idReachability {
|
|
};
|
|
|
|
class idReachability_BarrierJump : public idReachability {
|
|
};
|
|
|
|
class idReachability_WaterJump : public idReachability {
|
|
};
|
|
|
|
class idReachability_WalkOffLedge : public idReachability {
|
|
};
|
|
|
|
class idReachability_Swim : public idReachability {
|
|
};
|
|
|
|
class idReachability_Fly : public idReachability {
|
|
};
|
|
|
|
class idReachability_Special : public idReachability {
|
|
public:
|
|
idDict dict;
|
|
};
|
|
|
|
// index
|
|
typedef int aasIndex_t;
|
|
|
|
// vertex
|
|
typedef idVec3 aasVertex_t;
|
|
|
|
// edge
|
|
typedef struct aasEdge_s {
|
|
int vertexNum[2]; // numbers of the vertexes of this edge
|
|
} aasEdge_t;
|
|
|
|
// area boundary face
|
|
typedef struct aasFace_s {
|
|
unsigned short planeNum; // number of the plane this face is on
|
|
unsigned short flags; // face flags
|
|
int numEdges; // number of edges in the boundary of the face
|
|
int firstEdge; // first edge in the edge index
|
|
short areas[2]; // area at the front and back of this face
|
|
} aasFace_t;
|
|
|
|
// area with a boundary of faces
|
|
typedef struct aasArea_s {
|
|
int numFaces; // number of faces used for the boundary of the area
|
|
int firstFace; // first face in the face index used for the boundary of the area
|
|
idBounds bounds; // bounds of the area
|
|
idVec3 center; // center of the area an AI can move towards
|
|
unsigned short flags; // several area flags
|
|
unsigned short contents; // contents of the area
|
|
short cluster; // cluster the area belongs to, if negative it's a portal
|
|
short clusterAreaNum; // number of the area in the cluster
|
|
int travelFlags; // travel flags for traveling through this area
|
|
idReachability * reach; // reachabilities that start from this area
|
|
idReachability * rev_reach; // reachabilities that lead to this area
|
|
} aasArea_t;
|
|
|
|
// nodes of the bsp tree
|
|
typedef struct aasNode_s {
|
|
unsigned short planeNum; // number of the plane that splits the subspace at this node
|
|
int children[2]; // child nodes, zero is solid, negative is -(area number)
|
|
} aasNode_t;
|
|
|
|
// cluster portal
|
|
typedef struct aasPortal_s {
|
|
short areaNum; // number of the area that is the actual portal
|
|
short clusters[2]; // number of cluster at the front and back of the portal
|
|
short clusterAreaNum[2]; // number of this portal area in the front and back cluster
|
|
unsigned short maxAreaTravelTime; // maximum travel time through the portal area
|
|
} aasPortal_t;
|
|
|
|
// cluster
|
|
typedef struct aasCluster_s {
|
|
int numAreas; // number of areas in the cluster
|
|
int numReachableAreas; // number of areas with reachabilities
|
|
int numPortals; // number of cluster portals
|
|
int firstPortal; // first cluster portal in the index
|
|
} aasCluster_t;
|
|
|
|
// trace through the world
|
|
typedef struct aasTrace_s {
|
|
// parameters
|
|
int flags; // areas with these flags block the trace
|
|
int travelFlags; // areas with these travel flags block the trace
|
|
int maxAreas; // size of the 'areas' array
|
|
int getOutOfSolid; // trace out of solid if the trace starts in solid
|
|
// output
|
|
float fraction; // fraction of trace completed
|
|
idVec3 endpos; // end position of trace
|
|
int planeNum; // plane hit
|
|
int lastAreaNum; // number of last area the trace went through
|
|
int blockingAreaNum; // area that could not be entered
|
|
int numAreas; // number of areas the trace went through
|
|
int * areas; // array to store areas the trace went through
|
|
idVec3 * points; // points where the trace entered each new area
|
|
aasTrace_s( void ) { areas = NULL; points = NULL; getOutOfSolid = false; flags = travelFlags = maxAreas = 0; }
|
|
} aasTrace_t;
|
|
|
|
// settings
|
|
class idAASSettings {
|
|
public:
|
|
// collision settings
|
|
int numBoundingBoxes;
|
|
idBounds boundingBoxes[MAX_AAS_BOUNDING_BOXES];
|
|
bool usePatches;
|
|
bool writeBrushMap;
|
|
bool playerFlood;
|
|
bool noOptimize;
|
|
bool allowSwimReachabilities;
|
|
bool allowFlyReachabilities;
|
|
idStr fileExtension;
|
|
// physics settings
|
|
idVec3 gravity;
|
|
idVec3 gravityDir;
|
|
idVec3 invGravityDir;
|
|
float gravityValue;
|
|
float maxStepHeight;
|
|
float maxBarrierHeight;
|
|
float maxWaterJumpHeight;
|
|
float maxFallHeight;
|
|
float minFloorCos;
|
|
// fixed travel times
|
|
int tt_barrierJump;
|
|
int tt_startCrouching;
|
|
int tt_waterJump;
|
|
int tt_startWalkOffLedge;
|
|
|
|
public:
|
|
idAASSettings( void );
|
|
|
|
bool FromFile( const idStr &fileName );
|
|
bool FromParser( idLexer &src );
|
|
bool FromDict( const char *name, const idDict *dict );
|
|
bool WriteToFile( idFile *fp ) const;
|
|
bool ValidForBounds( const idBounds &bounds ) const;
|
|
bool ValidEntity( const char *classname ) const;
|
|
|
|
private:
|
|
bool ParseBool( idLexer &src, bool &b );
|
|
bool ParseInt( idLexer &src, int &i );
|
|
bool ParseFloat( idLexer &src, float &f );
|
|
bool ParseVector( idLexer &src, idVec3 &vec );
|
|
bool ParseBBoxes( idLexer &src );
|
|
};
|
|
|
|
|
|
/*
|
|
|
|
- when a node child is a solid leaf the node child number is zero
|
|
- two adjacent areas (sharing a plane at opposite sides) share a face
|
|
this face is a portal between the areas
|
|
- when an area uses a face from the faceindex with a positive index
|
|
then the face plane normal points into the area
|
|
- the face edges are stored counter clockwise using the edgeindex
|
|
- two adjacent convex areas (sharing a face) only share One face
|
|
this is a simple result of the areas being convex
|
|
- the areas can't have a mixture of ground and gap faces
|
|
other mixtures of faces in one area are allowed
|
|
- areas with the AREACONTENTS_CLUSTERPORTAL in the settings have
|
|
the cluster number set to the negative portal number
|
|
- edge zero is a dummy
|
|
- face zero is a dummy
|
|
- area zero is a dummy
|
|
- node zero is a dummy
|
|
- portal zero is a dummy
|
|
- cluster zero is a dummy
|
|
|
|
*/
|
|
|
|
|
|
class idAASFile {
|
|
public:
|
|
virtual ~idAASFile( void ) {}
|
|
|
|
const char * GetName( void ) const { return name.c_str(); }
|
|
unsigned int GetCRC( void ) const { return crc; }
|
|
|
|
int GetNumPlanes( void ) const { return planeList.Num(); }
|
|
const idPlane & GetPlane( int index ) const { return planeList[index]; }
|
|
int GetNumVertices( void ) const { return vertices.Num(); }
|
|
const aasVertex_t & GetVertex( int index ) const { return vertices[index]; }
|
|
int GetNumEdges( void ) const { return edges.Num(); }
|
|
const aasEdge_t & GetEdge( int index ) const { return edges[index]; }
|
|
int GetNumEdgeIndexes( void ) const { return edgeIndex.Num(); }
|
|
const aasIndex_t & GetEdgeIndex( int index ) const { return edgeIndex[index]; }
|
|
int GetNumFaces( void ) const { return faces.Num(); }
|
|
const aasFace_t & GetFace( int index ) const { return faces[index]; }
|
|
int GetNumFaceIndexes( void ) const { return faceIndex.Num(); }
|
|
const aasIndex_t & GetFaceIndex( int index ) const { return faceIndex[index]; }
|
|
int GetNumAreas( void ) const { return areas.Num(); }
|
|
const aasArea_t & GetArea( int index ) { return areas[index]; }
|
|
int GetNumNodes( void ) const { return nodes.Num(); }
|
|
const aasNode_t & GetNode( int index ) const { return nodes[index]; }
|
|
int GetNumPortals( void ) const { return portals.Num(); }
|
|
const aasPortal_t & GetPortal( int index ) { return portals[index]; }
|
|
int GetNumPortalIndexes( void ) const { return portalIndex.Num(); }
|
|
const aasIndex_t & GetPortalIndex( int index ) const { return portalIndex[index]; }
|
|
int GetNumClusters( void ) const { return clusters.Num(); }
|
|
const aasCluster_t & GetCluster( int index ) const { return clusters[index]; }
|
|
|
|
const idAASSettings & GetSettings( void ) const { return settings; }
|
|
|
|
void SetPortalMaxTravelTime( int index, int time ) { portals[index].maxAreaTravelTime = time; }
|
|
void SetAreaTravelFlag( int index, int flag ) { areas[index].travelFlags |= flag; }
|
|
void RemoveAreaTravelFlag( int index, int flag ) { areas[index].travelFlags &= ~flag; }
|
|
|
|
virtual idVec3 EdgeCenter( int edgeNum ) const = 0;
|
|
virtual idVec3 FaceCenter( int faceNum ) const = 0;
|
|
virtual idVec3 AreaCenter( int areaNum ) const = 0;
|
|
|
|
virtual idBounds EdgeBounds( int edgeNum ) const = 0;
|
|
virtual idBounds FaceBounds( int faceNum ) const = 0;
|
|
virtual idBounds AreaBounds( int areaNum ) const = 0;
|
|
|
|
virtual int PointAreaNum( const idVec3 &origin ) const = 0;
|
|
virtual int PointReachableAreaNum( const idVec3 &origin, const idBounds &searchBounds, const int areaFlags, const int excludeTravelFlags ) const = 0;
|
|
virtual int BoundsReachableAreaNum( const idBounds &bounds, const int areaFlags, const int excludeTravelFlags ) const = 0;
|
|
virtual void PushPointIntoAreaNum( int areaNum, idVec3 &point ) const = 0;
|
|
virtual bool Trace( aasTrace_t &trace, const idVec3 &start, const idVec3 &end ) const = 0;
|
|
virtual void PrintInfo( void ) const = 0;
|
|
|
|
protected:
|
|
idStr name;
|
|
unsigned int crc;
|
|
|
|
idPlaneSet planeList;
|
|
idList<aasVertex_t> vertices;
|
|
idList<aasEdge_t> edges;
|
|
idList<aasIndex_t> edgeIndex;
|
|
idList<aasFace_t> faces;
|
|
idList<aasIndex_t> faceIndex;
|
|
idList<aasArea_t> areas;
|
|
idList<aasNode_t> nodes;
|
|
idList<aasPortal_t> portals;
|
|
idList<aasIndex_t> portalIndex;
|
|
idList<aasCluster_t> clusters;
|
|
idAASSettings settings;
|
|
};
|
|
|
|
#endif /* !__AASFILE_H__ */
|