NL3D::CQuadGrid< T > Class Template Reference

#include <quad_grid.h>

---

Detailed Description

template<class T>
class NL3D::CQuadGrid< T >

This container is a simple grid, used to quickly find elements. His purpose is similiar to CQuadTree, but it is a simple grid, so test are in O(1), not in O(log n). It is perfect for local lookup (like in collisions). Use it if you want to select small area, not large. Also, for best use, elements should have approximatively the same size, and this size should be little smaller than the size of a grid element...

By default, the quad grid is aligned on XY. (unlike the quadtree!!!)

Unlike the quadtree, the quadgrid is NOT geographicly delimited, ie, its limits "tiles"!! This is why no "center" is required. As a direct consequence, when you select something, you are REALLY not sure that what you select is not a mile away from your selection :) ....

Also, for memory optimisation, no bbox is stored in the quadgrid. Hence no particular selection is made on the Z components...

For maximum allocation speed Efficiency, it uses a CBlockMemory<CNode> to allocate elements at insert(). DefaultBlockSize is 16, but you can change it at construction.

because elements may lies in multiples squares, QuadGrid use lists per square which points on elements. For faster allocation, it uses a CSTLBlockList<>. The entire quadGrid has its own CBlockMemory for the CSTLBlockLists. memoryBlockSize is the same than the blockSize for allocation of nodes.

Author:

Lionel Berenguier

Nevrax France

Date:

2000

Definition at line 76 of file 3d/quad_grid.h.

Public Member Functions
	CQuadGrid (uint memoryBlockSize=16)
	Default constructor, use axes XY!!!, has a size of 16, and EltSize is 1.
	~CQuadGrid ()
	dtor.
Selection
CIterator	begin ()
void	clearSelection ()
CIterator	end ()
void	select (const NLMISC::CVector &bboxmin, const NLMISC::CVector &bboxmax)
void	selectAll ()
Initialization
void	changeBase (const NLMISC::CMatrix &base)
void	create (uint size, float eltSize)
const NLMISC::CMatrix &	getBasis () const
float	getEltSize () const
uint	getSize () const
Container operation
void	clear ()
CIterator	erase (CIterator it)
CIterator	insert (const NLMISC::CVector &bboxmin, const NLMISC::CVector &bboxmax, const T &val)
Private Member Functions
void	addQuadNodeToSelection (CQuadNode &quad)
void	addToSelection (CNode *ptr)
void	linkToRoot (CBaseNode &root, CBaseNode *ptr)
void	selectQuads (CVector bmin, CVector bmax, sint &x0, sint &x1, sint &y0, sint &y1)
Private Attributes
NLMISC::CMatrix	_ChangeBasis
float	_EltSize
std::vector< CQuadNode >	_Grid
NLMISC::CBlockMemory< CNode >	_NodeBlockMemory
NLMISC::CBlockMemory< CNode *, false >	_NodeListBlockMemory
CBaseNode	_SelectedList
sint	_Size
sint	_SizePower
CBaseNode	_UnSelectedList
Friends
class	CIterator

---

Constructor & Destructor Documentation

template<class T> NL3D::CQuadGrid< T >::CQuadGrid (  uint  memoryBlockSize = 16  )

Default constructor, use axes XY!!!, has a size of 16, and EltSize is 1. Definition at line 412 of file 3d/quad_grid.h. References NL3D::CQuadGrid< T >::_ChangeBasis, NL3D::CQuadGrid< T >::_EltSize, NLMISC::CMatrix::identity(), and uint. : _NodeBlockMemory(memoryBlockSize), _NodeListBlockMemory(memoryBlockSize) { _SizePower=4; _Size=1<<_SizePower; _EltSize=1; _ChangeBasis.identity(); }

template<class T> NL3D::CQuadGrid< T >::~CQuadGrid (   )

dtor. Definition at line 421 of file 3d/quad_grid.h. References NL3D::CQuadGrid< T >::clear(). { clear(); // must clear the array, before _NodeListBlockMemory.purge() is called. _Grid.clear(); }

---

Member Function Documentation

template<class T> void NL3D::CQuadGrid< T >::addQuadNodeToSelection (  CQuadNode &  quad  )  [inline, private]

Definition at line 322 of file 3d/quad_grid.h. Referenced by NL3D::CQuadGrid< T >::select(). { typename NLMISC::CSTLBlockList<CNode*>::iterator itNode; for(itNode= quad.Nodes.begin();itNode!=quad.Nodes.end();itNode++) { addToSelection(*itNode); } }

template<class T> void NL3D::CQuadGrid< T >::addToSelection (  CNode *  ptr  )  [inline, private]

Definition at line 303 of file 3d/quad_grid.h. Referenced by NL3D::CQuadGrid< CWaterShape * >::addQuadNodeToSelection(). { // if not selected if(!ptr->Selected) { // remove from the unselected list. ptr->Prev->Next= ptr->Next; if(ptr->Next) ptr->Next->Prev= ptr->Prev; // Append to front of the _Selected list. linkToRoot(_SelectedList, ptr); // mark it ptr->Selected= true; } }

template<class T> CQuadGrid< T >::CIterator NL3D::CQuadGrid< T >::begin (   )

Return the first iterator of the selected element list. begin and end are valid till the next insert. Speed is in O(1) Definition at line 641 of file 3d/quad_grid.h. References NL3D::CQuadGrid< T >::_SelectedList, NL3D::CQuadGrid< T >::CIterator, and NL3D::CQuadGrid< T >::CBaseNode::Next. Referenced by NL3D::CStaticQuadGrid< T >::build(), NL3D::CQuadGrid< T >::clear(), NL3D::CZoneLighter::compilePointLightRT(), NL3D::CInstanceLighter::compilePointLightRT(), NL3D::CInstanceLighter::computeSunContribution(), NL3D::CZoneLighter::computeTileFlagsForPositionTowardWater(), NL3D::CShadowPolyReceiver::getCameraCollision(), NL3D::CLightingManager::getDynamicPointLightList(), NL3D::CMiniCol::getFaces(), NL3D::CMiniCol::getGroundNormal(), NL3D::CMiniCol::removeLandScapePart(), NL3D::CShadowPolyReceiver::render(), and NL3D::CMiniCol::snapToGround(). { return CIterator((CNode*)(_SelectedList.Next)); }

template<class T> void NL3D::CQuadGrid< T >::changeBase (  const NLMISC::CMatrix &  base  )

Change the base matrix of the quad grid. For exemple this code init the grid tree in the plane XZ: CQuadGrid grid; NLMISC::CMatrix tmp; NLMISC::CVector I(1,0,0); NLMISC::CVector J(0,0,1); NLMISC::CVector K(0,-1,0); tmp.identity(); tmp.setRot(I,J,K, true); quadTree.changeBase (tmp); Parameters: base  Base of the quad grid Definition at line 428 of file 3d/quad_grid.h. References NL3D::CQuadGrid< T >::_ChangeBasis. Referenced by NL3D::CInstanceLighter::computeSunContribution(). { _ChangeBasis= base; }

template<class T> void NL3D::CQuadGrid< T >::clear (   )

Clear the container. Elements are deleted, but the quadgrid is not erased. Speed is in O(Nelts) Definition at line 454 of file 3d/quad_grid.h. References NL3D::CQuadGrid< T >::_SelectedList, NL3D::CQuadGrid< T >::_UnSelectedList, NL3D::CQuadGrid< T >::begin(), NL3D::CQuadGrid< T >::end(), NL3D::CQuadGrid< T >::erase(), NL3D::CQuadGrid< T >::CBaseNode::Next, and NL3D::CQuadGrid< T >::selectAll(). Referenced by NL3D::CQuadGrid< T >::create(), and NL3D::CQuadGrid< T >::~CQuadGrid(). { CIterator it; selectAll(); while( (it=begin())!=end()) { erase(it); } // Clear the 2 selection... _SelectedList.Next= NULL; _UnSelectedList.Next= NULL; }

template<class T> void NL3D::CQuadGrid< T >::clearSelection (   )

Clear the selection list Speed is in O(Nelts) Definition at line 567 of file 3d/quad_grid.h. References NL3D::CQuadGrid< T >::_SelectedList, NL3D::CQuadGrid< T >::_UnSelectedList, NL3D::CQuadGrid< T >::linkToRoot(), NL3D::CQuadGrid< T >::CBaseNode::Next, and NL3D::CQuadGrid< T >::CBaseNode::Selected. Referenced by NL3D::CStaticQuadGrid< T >::build(), NL3D::CZoneLighter::computeTileFlagsForPositionTowardWater(), and NL3D::CQuadGrid< T >::select(). { CBaseNode *ptr= _SelectedList.Next; while(ptr) { // next selected. CBaseNode *nextSelected= ptr->Next; // Link to _Unselected list. linkToRoot(_UnSelectedList, ptr); // mark as not selected. ptr->Selected= false; // next. ptr= nextSelected; } // the selected list is now empty. _SelectedList.Next= NULL; }

template<class T> void NL3D::CQuadGrid< T >::create (  uint  size, float  eltSize )

Init the container. container is first clear() ed. Parameters: size  is the width and the height of the initial quad tree, in number of square. For performance view, this should be a power of 2, and <=32768. (eg: 256,512, 8, 16 ...) eltSize  is the width and height of an element. Must be >0. Notice that the quadgrid MUST be square!! Definition at line 433 of file 3d/quad_grid.h. References NL3D::CQuadGrid< T >::_EltSize, NL3D::CQuadGrid< T >::_NodeListBlockMemory, NL3D::CQuadGrid< T >::clear(), NLMISC::getPowerOf2(), nlassert, size, and uint. Referenced by NL3D::CMiniCol::CMiniCol(), NL3D::CZoneLighter::compilePointLightRT(), NL3D::CInstanceLighter::compilePointLightRT(), NL3D::CInstanceLighter::computeSunContribution(), NL3D::CShadowPolyReceiver::CShadowPolyReceiver(), and NL3D::CZoneLighter::makeQuadGridFromWaterShapes(). { clear(); nlassert(NLMISC::isPowerOf2(size)); nlassert(size<=32768); _SizePower= NLMISC::getPowerOf2(size); _Size=1<<_SizePower; _Grid.resize(_Size*_Size, CQuadNode(&_NodeListBlockMemory)); nlassert(eltSize>0); _EltSize= eltSize; }

template<class T> CQuadGrid< T >::CIterator NL3D::CQuadGrid< T >::end (   )

Return the end iterator of the selected element list. begin and end are valid till the next insert. Speed is in O(1) Definition at line 646 of file 3d/quad_grid.h. References NL3D::CQuadGrid< T >::CIterator. Referenced by NL3D::CLightingManager::addDynamicLight(), NL3D::CStaticQuadGrid< T >::build(), NL3D::CQuadGrid< T >::clear(), NL3D::CZoneLighter::compilePointLightRT(), NL3D::CInstanceLighter::compilePointLightRT(), NL3D::CInstanceLighter::computeSunContribution(), NL3D::CZoneLighter::computeTileFlagsForPositionTowardWater(), NL3D::CQuadGrid< T >::erase(), NL3D::CShadowPolyReceiver::getCameraCollision(), NL3D::CLightingManager::getDynamicPointLightList(), NL3D::CMiniCol::getFaces(), NL3D::CMiniCol::getGroundNormal(), NL3D::CMiniCol::removeLandScapePart(), NL3D::CShadowPolyReceiver::removeTriangle(), NL3D::CShadowPolyReceiver::render(), and NL3D::CMiniCol::snapToGround(). { return CIterator(NULL); }

template<class T> CQuadGrid< T >::CIterator NL3D::CQuadGrid< T >::erase (  CIterator  it  )

Erase an interator from the container Speed is in O(1 * L*H) where L*H is the number of squares surrounded by the element Parameters: it  is the iterator to erase. Returns: if element is currently selected, the next selected element is returned, (or end()). if the element is not selected, end() is returned. Definition at line 468 of file 3d/quad_grid.h. References NL3D::CQuadGrid< T >::_NodeBlockMemory, NL3D::CQuadGrid< T >::CIterator, NL3D::CQuadGrid< T >::end(), NLMISC::CBlockMemory< CNode >::free(), NL3D::CQuadGrid< T >::CBaseNode::Next, NL3D::CQuadGrid< T >::CQuadNode::Nodes, NL3D::CQuadGrid< T >::CBaseNode::Prev, NL3D::CQuadGrid< T >::CBaseNode::Selected, sint, x, NL3D::CQuadGrid< T >::CNode::x0, NL3D::CQuadGrid< T >::CNode::x1, y, NL3D::CQuadGrid< T >::CNode::y0, and NL3D::CQuadGrid< T >::CNode::y1. Referenced by NL3D::CQuadGrid< T >::clear(), NL3D::CMiniCol::removeLandScapePart(), and NL3D::CShadowPolyReceiver::removeTriangle(). { sint x,y; CNode *ptr= it._Ptr; if(!ptr) return end(); // First erase all references to it. //================================== for(y= ptr->y0;y<ptr->y1;y++) { sint xe,ye; ye= y &(_Size-1); for(x= ptr->x0;x<ptr->x1;x++) { xe= x &(_Size-1); CQuadNode &quad= _Grid[(ye<<_SizePower)+xe]; typename NLMISC::CSTLBlockList<CNode*>::iterator itNode; for(itNode= quad.Nodes.begin();itNode!=quad.Nodes.end();itNode++) { if((*itNode)==ptr) { quad.Nodes.erase(itNode); break; } } } } // Then delete it..., and update selection linked list. //===================================================== // remove it from _SelectedList or _UnSelectedList CBaseNode *next= NULL; next= ptr->Next; if(next) next->Prev=ptr->Prev; ptr->Prev->Next= next; // if not selected, then must return NULL if(!ptr->Selected) next= NULL; // delete the object. _NodeBlockMemory.free(ptr); return CIterator((CNode*)next); }

template<class T> const NLMISC::CMatrix& NL3D::CQuadGrid< T >::getBasis (   )  const [inline]

Change the base matrix of the quad grid. For exemple this code init the grid tree in the plane XZ: CQuadGrid grid; NLMISC::CMatrix tmp; NLMISC::CVector I(1,0,0); NLMISC::CVector J(0,0,1); NLMISC::CVector K(0,-1,0); tmp.identity(); tmp.setRot(I,J,K, true); quadTree.changeBase (tmp); Parameters: base  Base of the quad grid Definition at line 119 of file 3d/quad_grid.h. Referenced by NL3D::CStaticQuadGrid< T >::build(). {return _ChangeBasis;}

template<class T> float NL3D::CQuadGrid< T >::getEltSize (   )  const [inline]

Change the base matrix of the quad grid. For exemple this code init the grid tree in the plane XZ: CQuadGrid grid; NLMISC::CMatrix tmp; NLMISC::CVector I(1,0,0); NLMISC::CVector J(0,0,1); NLMISC::CVector K(0,-1,0); tmp.identity(); tmp.setRot(I,J,K, true); quadTree.changeBase (tmp); Parameters: base  Base of the quad grid Definition at line 121 of file 3d/quad_grid.h. Referenced by NL3D::CStaticQuadGrid< T >::build(). {return _EltSize;}

template<class T> uint NL3D::CQuadGrid< T >::getSize (  void   )  const [inline]

Change the base matrix of the quad grid. For exemple this code init the grid tree in the plane XZ: CQuadGrid grid; NLMISC::CMatrix tmp; NLMISC::CVector I(1,0,0); NLMISC::CVector J(0,0,1); NLMISC::CVector K(0,-1,0); tmp.identity(); tmp.setRot(I,J,K, true); quadTree.changeBase (tmp); Parameters: base  Base of the quad grid Definition at line 120 of file 3d/quad_grid.h. Referenced by NL3D::CStaticQuadGrid< T >::build(). {return _Size;}

template<class T> CQuadGrid< T >::CIterator NL3D::CQuadGrid< T >::insert (  const NLMISC::CVector &  bboxmin, const NLMISC::CVector &  bboxmax, const T &  val )

Insert a new element in the container. Speed is in O(1 * L*H) where L*H is the number of squares surrounded by the element Warning! : bboxmin and bboxmax are multiplied by matrix setuped by changeBase. This work for any matrix with 90deg rotations (min and max are recomputed internally), but not with any rotation (43° ...) because of the nature of AABBox. To do this correclty you should compute the bbox min and max in the basis given in changeBase, and insert() with multiplying min and max with inverse of this basis. eg: CMatrix base= getSomeBase(); CMatrix invBase= base.inverted(); // create quadGrid. CQuadGrid<CTriangle> quadGrid; quadGrid.changeBase(base); quadGrid.create(...); // Insert a triangle tri correctly CAABBox bbox; bbox.setCenter(base * tri.V0); bbox.extend(base * tri.V1); bbox.extend(base * tri.V2); quadGrid.insert(invBase*bbox.getMin(), invBase*bbox.getMax(), tri); Parameters: bboxmin  is the corner of the bounding box of the element to insert with minimal coordinates. bboxmax  is the corner of the bounding box of the element to insert with maximal coordinates. val  is a reference on the value to insert. Definition at line 516 of file 3d/quad_grid.h. References NL3D::CQuadGrid< T >::_ChangeBasis, NL3D::CQuadGrid< T >::_NodeBlockMemory, NL3D::CQuadGrid< T >::_UnSelectedList, NLMISC::CBlockMemory< CNode >::allocate(), NL3D::CQuadGrid< T >::CIterator, NL3D::CQuadGrid< T >::CNode::Elt, NL3D::CQuadGrid< T >::linkToRoot(), NL3D::CQuadGrid< T >::CQuadNode::Nodes, NL3D::CQuadGrid< T >::CBaseNode::Selected, NL3D::CQuadGrid< T >::selectQuads(), sint, x, NL3D::CQuadGrid< T >::CNode::x0, NL3D::CQuadGrid< T >::CNode::x1, y, NL3D::CQuadGrid< T >::CNode::y0, and NL3D::CQuadGrid< T >::CNode::y1. Referenced by NL3D::CMiniCol::addFaces(), NL3D::CShadowPolyReceiver::addTriangle(), NL3D::CZoneLighter::compilePointLightRT(), NL3D::CInstanceLighter::compilePointLightRT(), NL3D::CInstanceLighter::computeSunContribution(), and NL3D::CZoneLighter::makeQuadGridFromWaterShapes(). { CVector bmin,bmax; bmin= _ChangeBasis*bboxmin; bmax= _ChangeBasis*bboxmax; // init the object. CNode *ptr= _NodeBlockMemory.allocate(); ptr->Elt= val; // Link to _Unselected list. linkToRoot(_UnSelectedList, ptr); // mark as not selected. ptr->Selected= false; // Find which quad include the object. //=================================== sint x0,y0; sint x1,y1; selectQuads(bmin, bmax, x0,x1, y0,y1); ptr->x0= x0; ptr->x1= x1; ptr->y0= y0; ptr->y1= y1; // Then for all of them, insert the node in their list. //===================================================== sint x,y; for(y= ptr->y0;y<ptr->y1;y++) { sint xe,ye; ye= y &(_Size-1); for(x= ptr->x0;x<ptr->x1;x++) { xe= x &(_Size-1); CQuadNode &quad= _Grid[(ye<<_SizePower)+xe]; quad.Nodes.push_back(ptr); } } return CIterator(ptr); }

template<class T> void NL3D::CQuadGrid< T >::linkToRoot (  CBaseNode &  root, CBaseNode *  ptr )  [inline, private]

Definition at line 251 of file 3d/quad_grid.h. Referenced by NL3D::CQuadGrid< CWaterShape * >::addToSelection(), NL3D::CQuadGrid< T >::clearSelection(), NL3D::CQuadGrid< T >::insert(), and NL3D::CQuadGrid< T >::selectAll(). { ptr->Prev= &root; ptr->Next= root.Next; ptr->Prev->Next= ptr; if(ptr->Next) ptr->Next->Prev= ptr; }

template<class T> void NL3D::CQuadGrid< T >::select (  const NLMISC::CVector &  bboxmin, const NLMISC::CVector &  bboxmax )

Select element intersecting a bounding box. Clear the selection first. Speed is in O(Nelts * L*H), where L*H is the number of squares surrounded by the selection Parameters: bboxmin  is the corner of the bounding box used to select bboxmax  is the corner of the bounding box used to select Definition at line 613 of file 3d/quad_grid.h. References NL3D::CQuadGrid< T >::_ChangeBasis, NL3D::CQuadGrid< T >::addQuadNodeToSelection(), NL3D::CQuadGrid< T >::clearSelection(), NL3D::CQuadGrid< T >::selectQuads(), sint, x, and y. Referenced by NL3D::CStaticQuadGrid< T >::build(), NL3D::CZoneLighter::compilePointLightRT(), NL3D::CInstanceLighter::compilePointLightRT(), NL3D::CInstanceLighter::computeSunContribution(), NL3D::CZoneLighter::computeTileFlagsForPositionTowardWater(), NL3D::CShadowPolyReceiver::getCameraCollision(), NL3D::CLightingManager::getDynamicPointLightList(), NL3D::CMiniCol::getFaces(), NL3D::CMiniCol::getGroundNormal(), NL3D::CMiniCol::removeLandScapePart(), NL3D::CShadowPolyReceiver::render(), and NL3D::CMiniCol::snapToGround(). { CVector bmin,bmax; bmin= _ChangeBasis*bboxmin; bmax= _ChangeBasis*bboxmax; clearSelection(); // What are the quads to access? sint x0,y0; sint x1,y1; selectQuads(bmin, bmax, x0,x1, y0,y1); sint x,y; for(y= y0;y<y1;y++) { sint xe,ye; ye= y &(_Size-1); for(x= x0;x<x1;x++) { xe= x &(_Size-1); CQuadNode &quad= _Grid[(ye<<_SizePower)+xe]; addQuadNodeToSelection(quad); } } }

template<class T> void NL3D::CQuadGrid< T >::selectAll (   )

Select all the container. Speed is in O(Nelts) Definition at line 589 of file 3d/quad_grid.h. References NL3D::CQuadGrid< T >::_SelectedList, NL3D::CQuadGrid< T >::_UnSelectedList, NL3D::CQuadGrid< T >::linkToRoot(), NL3D::CQuadGrid< T >::CBaseNode::Next, and NL3D::CQuadGrid< T >::CBaseNode::Selected. Referenced by NL3D::CQuadGrid< T >::clear(). { // This is the opposite of clearSelection(). get all that are in _UnSelectedList, // and put them in _SelectedList CBaseNode *ptr= _UnSelectedList.Next; while(ptr) { // next selected. CBaseNode *nextUnSelected= ptr->Next; // Link to _Selected list. linkToRoot(_SelectedList, ptr); // mark as selected. ptr->Selected= true; // next. ptr= nextUnSelected; } // the Unselected list is now empty. _UnSelectedList.Next= NULL; }

template<class T> void NL3D::CQuadGrid< T >::selectQuads (  CVector  bmin, CVector  bmax, sint &  x0, sint &  x1, sint &  y0, sint &  y1 )  [inline, private]

Definition at line 261 of file 3d/quad_grid.h. Referenced by NL3D::CQuadGrid< T >::insert(), and NL3D::CQuadGrid< T >::select(). { CVector bminp, bmaxp; bminp= bmin; bmaxp= bmax; bmin.minof(bminp, bmaxp); bmax.maxof(bminp, bmaxp); bmin/= _EltSize; bmax/= _EltSize; x0= (sint)(floor(bmin.x)); x1= (sint)(ceil(bmax.x)); y0= (sint)(floor(bmin.y)); y1= (sint)(ceil(bmax.y)); // Very special case where the bbox.size==0 AND position is JUST on an edge of a case. if(x0==x1) x1++; if(y0==y1) y1++; // Manage tiling. if(x1-x0>=_Size) x0=0, x1= _Size; else { x0&= _Size-1; x1&= _Size-1; if(x1<=x0) x1+=_Size; } if(y1-y0>=_Size) y0=0, y1= _Size; else { y0&= _Size-1; y1&= _Size-1; if(y1<=y0) y1+=_Size; } }

---

Friends And Related Function Documentation

template<class T> friend class CIterator [friend]

Definition at line 81 of file 3d/quad_grid.h. Referenced by NL3D::CQuadGrid< T >::begin(), NL3D::CQuadGrid< T >::end(), NL3D::CQuadGrid< T >::erase(), and NL3D::CQuadGrid< T >::insert().

---

Field Documentation

template<class T> NLMISC::CMatrix NL3D::CQuadGrid< T >::_ChangeBasis [private]

Definition at line 238 of file 3d/quad_grid.h. Referenced by NL3D::CQuadGrid< T >::changeBase(), NL3D::CQuadGrid< T >::CQuadGrid(), NL3D::CQuadGrid< T >::insert(), and NL3D::CQuadGrid< T >::select().

template<class T> float NL3D::CQuadGrid< T >::_EltSize [private]

Definition at line 237 of file 3d/quad_grid.h. Referenced by NL3D::CQuadGrid< T >::CQuadGrid(), and NL3D::CQuadGrid< T >::create().

template<class T> std::vector<CQuadNode> NL3D::CQuadGrid< T >::_Grid [private]

Definition at line 234 of file 3d/quad_grid.h.

template<class T> NLMISC::CBlockMemory<CNode> NL3D::CQuadGrid< T >::_NodeBlockMemory [private]

Definition at line 243 of file 3d/quad_grid.h. Referenced by NL3D::CQuadGrid< T >::erase(), and NL3D::CQuadGrid< T >::insert().

template<class T> NLMISC::CBlockMemory<CNode*, false> NL3D::CQuadGrid< T >::_NodeListBlockMemory [private]

Definition at line 245 of file 3d/quad_grid.h. Referenced by NL3D::CQuadGrid< T >::create().

template<class T> CBaseNode NL3D::CQuadGrid< T >::_SelectedList [private]

Definition at line 240 of file 3d/quad_grid.h. Referenced by NL3D::CQuadGrid< T >::begin(), NL3D::CQuadGrid< T >::clear(), NL3D::CQuadGrid< T >::clearSelection(), and NL3D::CQuadGrid< T >::selectAll().

template<class T> sint NL3D::CQuadGrid< T >::_Size [private]

Definition at line 235 of file 3d/quad_grid.h.

template<class T> sint NL3D::CQuadGrid< T >::_SizePower [private]

Definition at line 236 of file 3d/quad_grid.h.

template<class T> CBaseNode NL3D::CQuadGrid< T >::_UnSelectedList [private]

Definition at line 241 of file 3d/quad_grid.h. Referenced by NL3D::CQuadGrid< T >::clear(), NL3D::CQuadGrid< T >::clearSelection(), NL3D::CQuadGrid< T >::insert(), and NL3D::CQuadGrid< T >::selectAll().

---

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

• 3d/quad_grid.h

---