dtNodePool Class Reference

#include <DetourNode.h>

Public Member Functions
	dtNodePool (int maxNodes, int hashSize)
	~dtNodePool ()
void	operator= (const dtNodePool &)
void	clear ()
dtNode *	getNode (dtPolyRef id, unsigned char state=0)
dtNode *	findNode (dtPolyRef id, unsigned char state)
unsigned int	findNodes (dtPolyRef id, dtNode **nodes, const int maxNodes)
unsigned int	getNodeIdx (const dtNode *node) const
dtNode *	getNodeAtIdx (unsigned int idx)
const dtNode *	getNodeAtIdx (unsigned int idx) const
int	getMemUsed () const
int	getMaxNodes () const
int	getHashSize () const
dtNodeIndex	getFirst (int bucket) const
dtNodeIndex	getNext (int i) const
int	getNodeCount () const

Private Attributes
dtNode *	m_nodes
dtNodeIndex *	m_first
dtNodeIndex *	m_next
const int	m_maxNodes
const int	m_hashSize
int	m_nodeCount

Constructor & Destructor Documentation

dtNodePool::dtNodePool	(	int	maxNodes,
		int	hashSize
	)

 :
 m_nodes(0),
 m_first(0),
 m_next(0),
 m_maxNodes(maxNodes),
 m_hashSize(hashSize),
 m_nodeCount(0)
{
 dtAssert(dtNextPow2(m_hashSize) == (unsigned int)m_hashSize);
 dtAssert(m_maxNodes > 0);

 m_nodes = (dtNode*)dtAlloc(sizeof(dtNode)*m_maxNodes, DT_ALLOC_PERM);
 m_next = (dtNodeIndex*)dtAlloc(sizeof(dtNodeIndex)*m_maxNodes, DT_ALLOC_PERM);
 m_first = (dtNodeIndex*)dtAlloc(sizeof(dtNodeIndex)*hashSize, DT_ALLOC_PERM);

 dtAssert(m_nodes);
 dtAssert(m_next);
 dtAssert(m_first);

 memset(m_first, 0xff, sizeof(dtNodeIndex)*m_hashSize);
 memset(m_next, 0xff, sizeof(dtNodeIndex)*m_maxNodes);
}

Here is the call graph for this function:

dtNodePool::~dtNodePool

(

)

{
 dtFree(m_nodes);
 dtFree(m_next);
 dtFree(m_first);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

void dtNodePool::clear

(

)

{
 memset(m_first, 0xff, sizeof(dtNodeIndex)*m_hashSize);
 m_nodeCount = 0;
}

Here is the caller graph for this function:

dtNode * dtNodePool::findNode	(	dtPolyRef	id,
		unsigned char	state
	)

{
 unsigned int bucket = dtHashRef(id) & (m_hashSize-1);
 dtNodeIndex i = m_first[bucket];
 while (i != DT_NULL_IDX)
 {
 if (m_nodes[i].id == id && m_nodes[i].state == state)
 return &m_nodes[i];
 i = m_next[i];
 }
 return 0;
}

Here is the call graph for this function:

unsigned int dtNodePool::findNodes	(	dtPolyRef	id,
		dtNode **	nodes,
		const int	maxNodes
	)

{
 int n = 0;
 unsigned int bucket = dtHashRef(id) & (m_hashSize-1);
 dtNodeIndex i = m_first[bucket];
 while (i != DT_NULL_IDX)
 {
 if (m_nodes[i].id == id)
 {
 if (n >= maxNodes)
 return n;
 nodes[n++] = &m_nodes[i];
 }
 i = m_next[i];
 }

 return n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

dtNodeIndex dtNodePool::getFirst ( int  bucket ) const

inline

{ return m_first[bucket]; }

int dtNodePool::getHashSize ( ) const

inline

{ return m_hashSize; }

int dtNodePool::getMaxNodes ( ) const

inline

{ return m_maxNodes; }

Here is the caller graph for this function:

int dtNodePool::getMemUsed ( ) const

inline

 {
 return sizeof(*this) +
 sizeof(dtNode)*m_maxNodes +
 sizeof(dtNodeIndex)*m_maxNodes +
 sizeof(dtNodeIndex)*m_hashSize;
 }

dtNodeIndex dtNodePool::getNext ( int  i ) const

inline

{ return m_next[i]; }

dtNode * dtNodePool::getNode	(	dtPolyRef	id,
		unsigned char	state = 0
	)

{
 unsigned int bucket = dtHashRef(id) & (m_hashSize-1);
 dtNodeIndex i = m_first[bucket];
 dtNode* node = 0;
 while (i != DT_NULL_IDX)
 {
 if (m_nodes[i].id == id && m_nodes[i].state == state)
 return &m_nodes[i];
 i = m_next[i];
 }
 
 if (m_nodeCount >= m_maxNodes)
 return 0;
 
 i = (dtNodeIndex)m_nodeCount;
 m_nodeCount++;
 
 // Init node
 node = &m_nodes[i];
 node->pidx = 0;
 node->cost = 0;
 node->total = 0;
 node->id = id;
 node->state = state;
 node->flags = 0;
 
 m_next[i] = m_first[bucket];
 m_first[bucket] = i;
 
 return node;
}

Here is the call graph for this function:

Here is the caller graph for this function:

dtNode* dtNodePool::getNodeAtIdx ( unsigned int  idx )

inline

 {
 if (!idx) return 0;
 return &m_nodes[idx-1];
 }

Here is the caller graph for this function:

const dtNode* dtNodePool::getNodeAtIdx ( unsigned int  idx ) const

inline

 {
 if (!idx) return 0;
 return &m_nodes[idx-1];
 }

int dtNodePool::getNodeCount ( ) const

inline

{ return m_nodeCount; }

unsigned int dtNodePool::getNodeIdx ( const dtNode *  node ) const

inline

 {
 if (!node) return 0;
 return (unsigned int)(node - m_nodes)+1;
 }

Here is the caller graph for this function:

void dtNodePool::operator= ( const dtNodePool &  )

inline

{}

Member Data Documentation

dtNodeIndex* dtNodePool::m_first

private

const int dtNodePool::m_hashSize

private

const int dtNodePool::m_maxNodes

private

dtNodeIndex* dtNodePool::m_next

private

int dtNodePool::m_nodeCount

private

dtNode* dtNodePool::m_nodes

private

---

The documentation for this class was generated from the following files:

• dep/recastnavigation/Detour/Include/DetourNode.h
• dep/recastnavigation/Detour/Source/DetourNode.cpp