mirror of
https://github.com/dhewm/dhewm3-sdk.git
synced 2024-11-23 21:12:19 +00:00
afebd7e1e5
Don't include the lazy precompiled.h everywhere, only what's required for the compilation unit. platform.h needs to be included instead to provide all essential defines and types. All includes use the relative path to the neo or the game specific root. Move all idlib related includes from idlib/Lib.h to precompiled.h. precompiled.h still exists for the MFC stuff in tools/. Add some missing header guards.
355 lines
14 KiB
C++
355 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__
|
|
|
|
#include "idlib/containers/PlaneSet.h"
|
|
#include "idlib/bv/Bounds.h"
|
|
#include "idlib/Dict.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__ */
|