khanat-opennel-code/code/nel/src/pacs/quad_grid.h
2010-05-06 02:08:41 +02:00

548 lines
15 KiB
C++

// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#ifndef NLPACS_QUAD_GRID_H
#define NLPACS_QUAD_GRID_H
#include "nel/misc/debug.h"
#include "nel/misc/vector.h"
#include "nel/misc/plane.h"
#include "nel/misc/matrix.h"
#include <list>
#include <vector>
namespace NLPACS
{
using NLMISC::CVector;
// ***************************************************************************
/**
* 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...
*
* \author Lionel Berenguier
* \author Nevrax France
* \date 2000
*/
template<class T> class CQuadGrid
{
public:
/// Iterator of the contener
class CIterator;
friend class CIterator;
public:
/// Default constructor, use axes XY!!!, has a size of 16, and EltSize is 1.
CQuadGrid();
/// dtor.
~CQuadGrid();
/// \name Initialization
//@{
/** Change the base matrix of the quad grid. For exemple this code init the grid tree in the plane XZ:
* \code
* 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);
* \endcode
*
* \param base Base of the quad grid
*/
void changeBase(const NLMISC::CMatrix& base);
/** Init the container. container is first clear() ed.
*
* \param 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 ...)
* \param eltSize is the width and height of an element. Must be >0. Notice that the quadgrid MUST be square!!
*/
void create(uint size, float eltSize);
//@}
/// \name Container operation
//@{
/// Clear the container. Elements are deleted, but the quadgrid is not erased.
void clear();
/** Erase an interator from the container
*
* \param it is the iterator to erase.
* \return if element is currently selected, the next selected element is returned, (or end()).
* if the element is not selected, end() is returned.
*/
CIterator erase(CIterator it);
/** Insert a new element in the container.
*
* \param bboxmin is the corner of the bounding box of the element to insert with minimal coordinates.
* \param bboxmax is the corner of the bounding box of the element to insert with maximal coordinates.
* \param val is a reference on the value to insert.
*/
CIterator insert(const NLMISC::CVector &bboxmin, const NLMISC::CVector &bboxmax, const T &val);
//@}
/// \name Selection
//@{
/** Clear the selection list
*/
void clearSelection();
/** Select all the container
*/
void selectAll();
/** Select element intersecting a bounding box. Clear the selection first.
*
* \param bboxmin is the corner of the bounding box used to select
* \param bboxmax is the corner of the bounding box used to select
*/
void select(const NLMISC::CVector &bboxmin, const NLMISC::CVector &bboxmax);
/** Return the first iterator of the selected element list. begin and end are valid till the next insert.
*/
CIterator begin();
/** Return the end iterator of the selected element list. begin and end are valid till the next insert.
*/
CIterator end();
//@}
// =================
// =================
// IMPLEMENTATION.
// =================
// =================
private:// Classes.
class CBaseNode
{
public:
CBaseNode *Prev,*Next; // For selection.
CBaseNode() {Prev= Next= NULL;}
};
class CNode : public CBaseNode
{
public:
T Elt;
uint16 x0,x1; // The location of the elt in the grid. Used for erase().
uint16 y0,y1;
};
class CQuadNode
{
public:
std::list<CNode*> Nodes;
};
private:// Atttributes.
std::vector<CQuadNode> _Grid;
sint _Size;
sint _SizePower;
float _EltSize;
NLMISC::CMatrix _ChangeBasis;
// Selection.
CBaseNode _Selection;
private:// Methods.
// return the coordinates on the grid of what include the bbox.
void selectQuads(CVector bmin, CVector bmax, sint &x0, sint &x1, sint &y0, sint &y1)
{
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;
}
}
// If not done, add the node to the selection.
void addToSelection(CNode *ptr)
{
if(ptr->Prev==NULL)
{
// Append to front of the list.
ptr->Prev= &_Selection;
ptr->Next= _Selection.Next;
if(_Selection.Next)
_Selection.Next->Prev= ptr;
_Selection.Next= ptr;
}
}
// Try to add each node of the quad node list.
void addQuadNodeToSelection(CQuadNode &quad)
{
typename std::list<CNode*>::iterator itNode;
for(itNode= quad.Nodes.begin();itNode!=quad.Nodes.end();itNode++)
{
addToSelection(*itNode);
}
}
public:
// CLASS const_iterator.
class const_iterator
{
public:
const_iterator() {_Ptr=NULL;}
const_iterator(CNode *p) : _Ptr(p) {}
const_iterator(const CIterator& x) : _Ptr(x._Ptr) {}
const T& operator*() const
{return _Ptr->Elt; }
// Doesn't work...
/*const T* operator->() const
{return (&**this); }*/
const_iterator& operator++()
{_Ptr = (CNode*)(_Ptr->Next); return (*this); }
const_iterator operator++(int)
{const_iterator tmp = *this; ++*this; return (tmp); }
const_iterator& operator--()
{_Ptr = (CNode*)(_Ptr->Prev); return (*this); }
const_iterator operator--(int)
{const_iterator tmp = *this; --*this; return (tmp); }
bool operator==(const const_iterator& x) const
{return (_Ptr == x._Ptr); }
bool operator!=(const const_iterator& x) const
{return (!(*this == x)); }
protected:
CNode *_Ptr;
friend class CQuadGrid<T>;
friend class CIterator;
};
// CLASS CIterator
class CIterator : public const_iterator
{
public:
CIterator() {this->_Ptr=NULL;}
CIterator(CNode *p) : const_iterator(p) {}
T& operator*() const
{return this->_Ptr->Elt; }
// Doesn't work...
/*T* operator->() const
{return (&**this); }*/
CIterator& operator++()
{this->_Ptr = (CNode*)(this->_Ptr->Next); return (*this); }
CIterator operator++(int)
{CIterator tmp = *this; ++*this; return (tmp); }
CIterator& operator--()
{this->_Ptr = (CNode*)(this->_Ptr->Prev); return (*this); }
CIterator operator--(int)
{CIterator tmp = *this; --*this; return (tmp); }
bool operator==(const const_iterator& x) const
{return (this->_Ptr == x._Ptr); }
bool operator!=(const const_iterator& x) const
{return (!(*this == x)); }
protected:
friend class CQuadGrid<T>;
};
};
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// Template CQuadGrid implementation.
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// Init.
// ***************************************************************************
// ***************************************************************************
template<class T> CQuadGrid<T>::CQuadGrid()
{
_SizePower=4;
_Size=1<<_SizePower;
_EltSize=1;
_ChangeBasis.identity();
}
// ***************************************************************************
template<class T> CQuadGrid<T>::~CQuadGrid()
{
clear();
}
// ***************************************************************************
template<class T> void CQuadGrid<T>::changeBase(const NLMISC::CMatrix& base)
{
_ChangeBasis= base;
}
// ***************************************************************************
template<class T> void CQuadGrid<T>::create(uint size, float eltSize)
{
clear();
nlassert(NLMISC::isPowerOf2(size));
nlassert(size<=32768);
_SizePower= NLMISC::getPowerOf2(size);
_Size=1<<_SizePower;
_Grid.resize(_Size*_Size);
nlassert(eltSize>0);
_EltSize= eltSize;
}
// ***************************************************************************
// insert/erase.
// ***************************************************************************
// ***************************************************************************
template<class T> void CQuadGrid<T>::clear()
{
CIterator it;
selectAll();
while( (it=begin())!=end())
{
erase(it);
}
// Clear the selection...
_Selection.Next= NULL;
}
// ***************************************************************************
template<class T> typename CQuadGrid<T>::CIterator CQuadGrid<T>::erase(typename CQuadGrid<T>::CIterator it)
{
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 std::list<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.
//=====================================================
// if selected.
CBaseNode *next= NULL;
if(ptr->Prev)
{
next= ptr->Next;
if(next)
next->Prev=ptr->Prev;
ptr->Prev->Next= next;
}
delete ptr;
return CIterator((CNode*)next);
}
// ***************************************************************************
template<class T> typename CQuadGrid<T>::CIterator CQuadGrid<T>::insert(const NLMISC::CVector &bboxmin, const NLMISC::CVector &bboxmax, const T &val)
{
CVector bmin,bmax;
bmin= _ChangeBasis*bboxmin;
bmax= _ChangeBasis*bboxmax;
CNode *ptr= new CNode;
ptr->Elt= val;
// Find which quad include the object.
//===================================
sint x0,y0;
sint x1,y1;
selectQuads(bmin, bmax, x0,x1, y0,y1);
ptr->x0= uint16(x0);
ptr->x1= uint16(x1);
ptr->y0= uint16(y0);
ptr->y1= uint16(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);
}
// ***************************************************************************
// selection.
// ***************************************************************************
// ***************************************************************************
template<class T> void CQuadGrid<T>::clearSelection()
{
CBaseNode *ptr= _Selection.Next;
while(ptr)
{
ptr->Prev= NULL;
CBaseNode *next= ptr->Next;
ptr->Next= NULL;
ptr= next;
}
_Selection.Next= NULL;
}
// ***************************************************************************
template<class T> void CQuadGrid<T>::selectAll()
{
clearSelection();
for(sint i=0;i<(sint)_Grid.size();i++)
{
CQuadNode &quad= _Grid[i];
addQuadNodeToSelection(quad);
}
}
// ***************************************************************************
template<class T> void CQuadGrid<T>::select(const NLMISC::CVector &bboxmin, const NLMISC::CVector &bboxmax)
{
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> typename CQuadGrid<T>::CIterator CQuadGrid<T>::begin()
{
return CIterator((CNode*)(_Selection.Next));
}
// ***************************************************************************
template<class T> typename CQuadGrid<T>::CIterator CQuadGrid<T>::end()
{
return CIterator(NULL);
}
} // NLPACS
#endif // NLPACS_QUAD_GRID_H
/* End of quad_grid.h */