RegularGrid2D< T, Node, NodeCreatorFunc, PositionFunc > Class Template Reference

#include <RegularGrid.h>

Classes
struct	Cell

Public Types
enum	{ CELL_NUMBER = 64 }
typedef G3D::Table< const T *, Node * >	MemberTable

Public Member Functions
	RegularGrid2D ()
	~RegularGrid2D ()
void	insert (const T &value)
void	remove (const T &value)
void	balance ()
bool	contains (const T &value) const
int	size () const
Node &	getGridFor (float fx, float fy)
Node &	getGrid (int x, int y)
template<typename RayCallback >
void	intersectRay (const G3D::Ray &ray, RayCallback &intersectCallback, float max_dist)
template<typename RayCallback >
void	intersectRay (const G3D::Ray &ray, RayCallback &intersectCallback, float &max_dist, const G3D::Vector3 &end)
template<typename IsectCallback >
void	intersectPoint (const G3D::Vector3 &point, IsectCallback &intersectCallback)
template<typename RayCallback >
void	intersectZAllignedRay (const G3D::Ray &ray, RayCallback &intersectCallback, float &max_dist)

Public Attributes
MemberTable	memberTable
Node *	nodes [CELL_NUMBER][CELL_NUMBER]

Member Typedef Documentation

template<class T , class Node , class NodeCreatorFunc = NodeCreator<Node>, class PositionFunc = PositionTrait<T>>

typedef G3D::Table<const T*, Node*> RegularGrid2D< T, Node, NodeCreatorFunc, PositionFunc >::MemberTable

Member Enumeration Documentation

template<class T , class Node , class NodeCreatorFunc = NodeCreator<Node>, class PositionFunc = PositionTrait<T>>

anonymous enum

Enumerator
CELL_NUMBER

 {
 CELL_NUMBER = 64,
 };

Constructor & Destructor Documentation

template<class T , class Node , class NodeCreatorFunc = NodeCreator<Node>, class PositionFunc = PositionTrait<T>>

RegularGrid2D< T, Node, NodeCreatorFunc, PositionFunc >::RegularGrid2D ( )

inline

 {
 memset(nodes, 0, sizeof(nodes));
 }

template<class T , class Node , class NodeCreatorFunc = NodeCreator<Node>, class PositionFunc = PositionTrait<T>>

RegularGrid2D< T, Node, NodeCreatorFunc, PositionFunc >::~RegularGrid2D ( )

inline

 {
 for (int x = 0; x < CELL_NUMBER; ++x)
 for (int y = 0; y < CELL_NUMBER; ++y)
 delete nodes[x][y];
 }

Member Function Documentation

template<class T , class Node , class NodeCreatorFunc = NodeCreator<Node>, class PositionFunc = PositionTrait<T>>

void RegularGrid2D< T, Node, NodeCreatorFunc, PositionFunc >::balance ( )

inline

 {
 for (int x = 0; x < CELL_NUMBER; ++x)
 for (int y = 0; y < CELL_NUMBER; ++y)
 if (Node* n = nodes[x][y])
 n->balance();
 }

Here is the caller graph for this function:

template<class T , class Node , class NodeCreatorFunc = NodeCreator<Node>, class PositionFunc = PositionTrait<T>>

bool RegularGrid2D< T, Node, NodeCreatorFunc, PositionFunc >::contains ( const T &  value ) const

inline

{ return memberTable.containsKey(&value); }

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T , class Node , class NodeCreatorFunc = NodeCreator<Node>, class PositionFunc = PositionTrait<T>>

Node& RegularGrid2D< T, Node, NodeCreatorFunc, PositionFunc >::getGrid ( int  x, int  y  )

inline

 {
 ASSERT(x < CELL_NUMBER && y < CELL_NUMBER);
 if (!nodes[x][y])
 nodes[x][y] = NodeCreatorFunc::makeNode(x, y);
 return *nodes[x][y];
 }

template<class T , class Node , class NodeCreatorFunc = NodeCreator<Node>, class PositionFunc = PositionTrait<T>>

Node& RegularGrid2D< T, Node, NodeCreatorFunc, PositionFunc >::getGridFor ( float  fx, float  fy  )

inline

 {
 Cell c = Cell::ComputeCell(fx, fy);
 return getGrid(c.x, c.y);
 }

template<class T , class Node , class NodeCreatorFunc = NodeCreator<Node>, class PositionFunc = PositionTrait<T>>

void RegularGrid2D< T, Node, NodeCreatorFunc, PositionFunc >::insert ( const T &  value )

inline

 {
 G3D::Vector3 pos;
 PositionFunc::getPosition(value, pos);
 Node& node = getGridFor(pos.x, pos.y);
 node.insert(value);
 memberTable.set(&value, &node);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T , class Node , class NodeCreatorFunc = NodeCreator<Node>, class PositionFunc = PositionTrait<T>>

template<typename IsectCallback >

void RegularGrid2D< T, Node, NodeCreatorFunc, PositionFunc >::intersectPoint ( const G3D::Vector3 &  point, IsectCallback &  intersectCallback  )

inline

 {
 Cell cell = Cell::ComputeCell(point.x, point.y);
 if (!cell.isValid())
 return;
 if (Node* node = nodes[cell.x][cell.y])
 node->intersectPoint(point, intersectCallback);
 }

Here is the call graph for this function:

template<class T , class Node , class NodeCreatorFunc = NodeCreator<Node>, class PositionFunc = PositionTrait<T>>

template<typename RayCallback >

void RegularGrid2D< T, Node, NodeCreatorFunc, PositionFunc >::intersectRay ( const G3D::Ray &  ray, RayCallback &  intersectCallback, float  max_dist  )

inline

 {
 intersectRay(ray, intersectCallback, max_dist, ray.origin() + ray.direction() * max_dist);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T , class Node , class NodeCreatorFunc = NodeCreator<Node>, class PositionFunc = PositionTrait<T>>

template<typename RayCallback >

void RegularGrid2D< T, Node, NodeCreatorFunc, PositionFunc >::intersectRay ( const G3D::Ray &  ray, RayCallback &  intersectCallback, float &  max_dist, const G3D::Vector3 &  end  )

inline

 {
 Cell cell = Cell::ComputeCell(ray.origin().x, ray.origin().y);
 if (!cell.isValid())
 return;

 Cell last_cell = Cell::ComputeCell(end.x, end.y);

 if (cell == last_cell)
 {
 if (Node* node = nodes[cell.x][cell.y])
 node->intersectRay(ray, intersectCallback, max_dist);
 return;
 }

 float voxel = (float)CELL_SIZE;
 float kx_inv = ray.invDirection().x, bx = ray.origin().x;
 float ky_inv = ray.invDirection().y, by = ray.origin().y;

 int stepX, stepY;
 float tMaxX, tMaxY;
 if (kx_inv >= 0)
 {
 stepX = 1;
 float x_border = (cell.x+1) * voxel;
 tMaxX = (x_border - bx) * kx_inv;
 }
 else
 {
 stepX = -1;
 float x_border = (cell.x-1) * voxel;
 tMaxX = (x_border - bx) * kx_inv;
 }

 if (ky_inv >= 0)
 {
 stepY = 1;
 float y_border = (cell.y+1) * voxel;
 tMaxY = (y_border - by) * ky_inv;
 }
 else
 {
 stepY = -1;
 float y_border = (cell.y-1) * voxel;
 tMaxY = (y_border - by) * ky_inv;
 }

 //int Cycles = std::max((int)ceilf(max_dist/tMaxX),(int)ceilf(max_dist/tMaxY));
 //int i = 0;

 float tDeltaX = voxel * std::fabs(kx_inv);
 float tDeltaY = voxel * std::fabs(ky_inv);
 do
 {
 if (Node* node = nodes[cell.x][cell.y])
 {
 //float enterdist = max_dist;
 node->intersectRay(ray, intersectCallback, max_dist);
 }
 if (cell == last_cell)
 break;
 if (tMaxX < tMaxY)
 {
 tMaxX += tDeltaX;
 cell.x += stepX;
 }
 else
 {
 tMaxY += tDeltaY;
 cell.y += stepY;
 }
 //++i;
 } while (cell.isValid());
 }

Here is the call graph for this function:

template<class T , class Node , class NodeCreatorFunc = NodeCreator<Node>, class PositionFunc = PositionTrait<T>>

template<typename RayCallback >

void RegularGrid2D< T, Node, NodeCreatorFunc, PositionFunc >::intersectZAllignedRay ( const G3D::Ray &  ray, RayCallback &  intersectCallback, float &  max_dist  )

inline

 {
 Cell cell = Cell::ComputeCell(ray.origin().x, ray.origin().y);
 if (!cell.isValid())
 return;
 if (Node* node = nodes[cell.x][cell.y])
 node->intersectRay(ray, intersectCallback, max_dist);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T , class Node , class NodeCreatorFunc = NodeCreator<Node>, class PositionFunc = PositionTrait<T>>

void RegularGrid2D< T, Node, NodeCreatorFunc, PositionFunc >::remove ( const T &  value )

inline

 {
 memberTable[&value]->remove(value);
 // Remove the member
 memberTable.remove(&value);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<class T , class Node , class NodeCreatorFunc = NodeCreator<Node>, class PositionFunc = PositionTrait<T>>

int RegularGrid2D< T, Node, NodeCreatorFunc, PositionFunc >::size ( ) const

inline

{ return uint32(memberTable.size()); }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

template<class T , class Node , class NodeCreatorFunc = NodeCreator<Node>, class PositionFunc = PositionTrait<T>>

MemberTable RegularGrid2D< T, Node, NodeCreatorFunc, PositionFunc >::memberTable

template<class T , class Node , class NodeCreatorFunc = NodeCreator<Node>, class PositionFunc = PositionTrait<T>>

Node* RegularGrid2D< T, Node, NodeCreatorFunc, PositionFunc >::nodes[CELL_NUMBER][CELL_NUMBER]

---

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

• src/common/Collision/RegularGrid.h