Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

151 lines
6.0 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//
//=============================================================================//
// nav_node.h
// Navigation Nodes are used when generating a Navigation Mesh by point sampling the map
// Author: Michael S. Booth (mike@turtlerockstudios.com), January 2003
#ifndef _NAV_NODE_H_
#define _NAV_NODE_H_
#include "nav.h"
// If DEBUG_NAV_NODES is true, nav_show_nodes controls drawing node positions, and
// nav_show_node_id allows you to show the IDs of nodes that didn't get used to create areas.
#define DEBUG_NAV_NODES 1
//--------------------------------------------------------------------------------------------------------------
/**
* Navigation Nodes.
* These Nodes encapsulate world locations, and ways to get from one location to an adjacent one.
* Note that these links are not necessarily commutative (falling off of a ledge, for example).
*/
class CNavNode
{
public:
CNavNode( const Vector &pos, const Vector &normal, CNavNode *parent, bool onDisplacement );
~CNavNode();
static CNavNode *GetNode( const Vector &pos ); ///< return navigation node at the position, or NULL if none exists
static void CleanupGeneration();
CNavNode *GetConnectedNode( NavDirType dir ) const; ///< get navigation node connected in given direction, or NULL if cant go that way
const Vector *GetPosition( void ) const;
const Vector *GetNormal( void ) const { return &m_normal; }
unsigned int GetID( void ) const { return m_id; }
static CNavNode *GetFirst( void ) { return m_list; }
static unsigned int GetListLength( void ) { return m_listLength; }
CNavNode *GetNext( void ) { return m_next; }
void Draw( void );
void ConnectTo( CNavNode *node, NavDirType dir, float obstacleHeight, float flObstacleStartDist, float flObstacleEndDist ); ///< create a connection FROM this node TO the given node, in the given direction
CNavNode *GetParent( void ) const;
void MarkAsVisited( NavDirType dir ); ///< mark the given direction as having been visited
BOOL HasVisited( NavDirType dir ); ///< return TRUE if the given direction has already been searched
BOOL IsBiLinked( NavDirType dir ) const; ///< node is bidirectionally linked to another node in the given direction
BOOL IsClosedCell( void ) const; ///< node is the NW corner of a bi-linked quad of nodes
void Cover( void ) { m_isCovered = true; } ///< @todo Should pass in area that is covering
BOOL IsCovered( void ) const { return m_isCovered; } ///< return true if this node has been covered by an area
void AssignArea( CNavArea *area ); ///< assign the given area to this node
CNavArea *GetArea( void ) const; ///< return associated area
void SetAttributes( int bits ) { m_attributeFlags = bits; }
int GetAttributes( void ) const { return m_attributeFlags; }
float GetGroundHeightAboveNode( NavCornerType cornerType ) const; ///< return ground height above node in given corner direction (NUM_CORNERS for highest in any direction)
bool IsBlockedInAnyDirection( void) const; ///< return true if the node is blocked in any direction
bool IsOnDisplacement( void ) const { return m_isOnDisplacement; }
private:
CNavNode() {} // constructor used only for hash lookup
friend class CNavMesh;
bool TestForCrouchArea( NavCornerType cornerNum, const Vector& mins, const Vector& maxs, float *groundHeightAboveNode );
void CheckCrouch( void );
Vector m_pos; ///< position of this node in the world
Vector m_normal; ///< surface normal at this location
CNavNode *m_to[ NUM_DIRECTIONS ]; ///< links to north, south, east, and west. NULL if no link
float m_obstacleHeight[ NUM_DIRECTIONS ]; ///< obstacle height (delta from nav node z position) that must be climbed to reach next node in this direction
float m_obstacleStartDist[ NUM_DIRECTIONS ]; ///< distance along this direction to reach the beginning of the obstacle
float m_obstacleEndDist[ NUM_DIRECTIONS ]; ///< distance along this direction to reach the end of the obstacle
unsigned int m_id; ///< unique ID of this node
int m_attributeFlags; ///< set of attribute bit flags (see NavAttributeType)
static CNavNode *m_list; ///< the master list of all nodes for this map
static unsigned int m_listLength;
static unsigned int m_nextID;
CNavNode *m_next; ///< next link in master list
CNavNode *m_nextAtXY; ///< next link at a particular position
// below are only needed when generating
unsigned char m_visited; ///< flags for automatic node generation. If direction bit is clear, that direction hasn't been explored yet.
CNavNode *m_parent; ///< the node prior to this in the search, which we pop back to when this node's search is done (a stack)
bool m_isCovered; ///< true when this node is "covered" by a CNavArea
CNavArea *m_area; ///< the area this node is contained within
bool m_isBlocked[ NUM_CORNERS ];
bool m_crouch[ NUM_CORNERS ];
float m_groundHeightAboveNode[ NUM_CORNERS ];
bool m_isOnDisplacement;
};
//--------------------------------------------------------------------------------------------------------------
//
// Inlines
//
inline CNavNode *CNavNode::GetConnectedNode( NavDirType dir ) const
{
return m_to[ dir ];
}
inline const Vector *CNavNode::GetPosition( void ) const
{
return &m_pos;
}
inline CNavNode *CNavNode::GetParent( void ) const
{
return m_parent;
}
inline void CNavNode::MarkAsVisited( NavDirType dir )
{
m_visited |= (1 << dir);
}
inline BOOL CNavNode::HasVisited( NavDirType dir )
{
if (m_visited & (1 << dir))
return true;
return false;
}
inline void CNavNode::AssignArea( CNavArea *area )
{
m_area = area;
}
inline CNavArea *CNavNode::GetArea( void ) const
{
return m_area;
}
inline bool CNavNode::IsBlockedInAnyDirection( void ) const
{
return m_isBlocked[ SOUTH_EAST ] || m_isBlocked[ SOUTH_WEST ] || m_isBlocked[ NORTH_EAST ] || m_isBlocked[ NORTH_WEST ];
}
#endif // _NAV_NODE_H_