NLPACS::CLocalRetriever Class Reference

#include <local_retriever.h>


Detailed Description

A surface retriever, located by its bounding box.
Author:
Benjamin Legros

Nevrax France

Date:
2001

Definition at line 63 of file local_retriever.h.

Public Types

enum  EType { Landscape = 0, Interior }

Public Member Functions

float distanceToBorder (const ULocalPosition &pos) const
void dumpSurface (uint surf, const NLMISC::CVector &vect=NLMISC::CVector::Null) const
void findPath (const CLocalPosition &A, const CLocalPosition &B, std::vector< CVector2s > &path, NLPACS::CCollisionSurfaceTemp &cst) const
 Finds a path in a given surface, from the point A to the point B.

void forceBorderChainId (uint32 chainId, uint32 borderId)
float getHeight (const ULocalPosition &position) const
uint32 getNextChain (uint32 chain, sint32 surface) const
uint32 getPreviousChain (uint32 chain, sint32 surface) const
const NLMISC::CVectorgetStartVector (uint32 chain, sint32 surface) const
const NLMISC::CVectorgetStartVector (uint32 chain) const
const NLMISC::CVectorgetStopVector (uint32 chain, sint32 surface) const
const NLMISC::CVectorgetStopVector (uint32 chain) const
bool insurePosition (ULocalPosition &local) const
 Assures a position is really inside a surface (and independent from any accuracy issue) and returns true if the position was moved.

void replaceChain (uint32 chainId, const std::vector< CChainReplacement > &replacement)
void retrieveAccuratePosition (CVector2s estimated, CCollisionSurfaceTemp &cst, bool &onBorder) const
 Retrieves a position inside the retriever (from the local position), returns true if the position is close to a border.

void retrievePosition (NLMISC::CVector estimated, CCollisionSurfaceTemp &cst) const
 Retrieves a position inside the retriever (from the local position), returns true if the position is close to a border.

void snapToInteriorGround (ULocalPosition &position, bool &snapped) const
 Snaps on the ground.

bool testPosition (ULocalPosition &local, CCollisionSurfaceTemp &cst) const
 Retrieves a position inside the retriever (from the local position), returns true if the position is close to a border.

void unify ()
Mutators
sint32 addChain (const std::vector< NLMISC::CVector > &vertices, sint32 left, sint32 right)
sint32 addSurface (uint8 normalq, uint8 orientationq, uint8 mat, uint8 charact, uint8 level, bool isUnderWater, float waterHeight, bool clusterHint, const NLMISC::CVector &center, const CSurfaceQuadTree &quad, sint8 quantHeight=0)
 Adds a surface to the local retriever, using its features. Returns the id of the newly created surface.

void clear ()
 Clear.

void computeLoopsAndTips ()
 Builds tips.

void computeTopologies ()
 Builds topologies tables.

void findBorderChains ()
 Found chains on the edges of the retriever and fills _BorderChains tables.

void flushFullOrderedChains ()
CChainQuadgetChainQuad ()
 Returns the chain quad.

std::vector< CInteriorFace > & getInteriorFaces ()
 Returns the interior faces.

std::vector< NLMISC::CVector > & getInteriorVertices ()
 Returns the interior vertices.

void initFaceGrid ()
 Inits the face grid.

void serial (NLMISC::IStream &f)
 Serialises the CLocalRetriever.

void setBBox (const NLMISC::CAABBox &bbox)
 Sets the bbox of the retriever.

void setExteriorMesh (const CExteriorMesh &em)
 Sets the exterior mesh.

void setFullOrderedChains (const std::vector< COrderedChain3f > &foc)
void setIdentifier (const std::string &id)
 Returns the identifier of the retriever.

void setType (EType type)
 Set the type of the retriever (see EType).

void sortTips ()
 Sorts chains references inside the tips. NOT IMPLEMENTED YET.

void translate (const NLMISC::CVector &translation)
 Translates the local retriever by the translation vector.

void updateChainIds ()
 Updates surfaces links from the links contained in the chains...

Selectors
void build3dSurfacePolygons (std::list< std::list< NLMISC::CPolygon > > &polygons) const
 Builds the polygons (loops) of all surfaces in the retriever.

void build3dSurfacePolygons (uint32 surface, std::list< NLMISC::CPolygon > &polygons) const
 Builds the polygons (loops) of a given surface.

void buildInteriorSurfaceBBoxes (std::vector< NLMISC::CAABBox > &surfaceBBoxes) const
 build BBoxes of interior surfaces in surfaceBBoxes (cleared first)

void buildSurfacePolygons (std::list< std::list< NLMISC::CPolygon > > &polygons) const
 Builds the polygons (loops) of all surfaces in the retriever.

void buildSurfacePolygons (uint32 surface, std::list< NLMISC::CPolygon > &polygons) const
 Builds the polygons (loops) of a given surface.

void forceLoaded (bool state)
 Force Loaded State.

const NLMISC::CAABBoxgetBBox () const
 Returns the bbox.

uint16 getBorderChain (uint n) const
 Returns the id of the nth chain on the edges of the retriever.

const std::vector< uint16 > & getBorderChains () const
 Returns the ids of the chains on the edges of the retriever.

const CChaingetChain (uint n) const
 retruns the nth chain.

const std::vector< CChain > & getChains () const
 Returns the chains.

const CExteriorMeshgetExteriorMesh () const
 Returns the exterior mesh of the retriever.

const COrderedChain3fgetFullOrderedChain (uint n) const
 Returns the nth full ordered chain.

const std::vector< COrderedChain3f > & getFullOrderedChains () const
 Returns the full ordered chains.

const std::string & getIdentifier () const
 Returns the identifier of the retriever.

const std::vector< CInteriorFace > & getInteriorFaces () const
 Returns the interior faces.

const std::vector< NLMISC::CVector > & getInteriorVertices () const
 Returns the interior vertices.

const COrderedChaingetOrderedChain (uint n) const
 Returns the nth ordered chain.

const std::vector< COrderedChain > & getOrderedChains () const
 Returns the ordered chains.

const CRetrievableSurfacegetSurface (uint n) const
 Returns the nth surface.

const std::vector< CRetrievableSurface > & getSurfaces () const
 Returns the surfaces.

EType getType () const
 Returns the type of the retriever.

bool isLoaded () const
 Is loaded ?

Constructors
 CLocalRetriever ()
Collisions part.
void computeCollisionChainQuad ()
 compute the chain quad, used for collisions. the ChainQuad is serialised in serial(). _OrderedChains must be OK.

void testCollision (CCollisionSurfaceTemp &cst, const NLMISC::CAABBox &bboxMove, const NLMISC::CVector2f &transBase) const

Data Fields

std::vector< uintFreeOChains
bool LoadCheckFlag

Protected Attributes

std::vector< CTip__Tips
 The tips making links between different chains.

NLMISC::CAABBox _BBox
 The bbox of the local retriever.

std::vector< uint16_BorderChains
 The chains on the edges of the zone.

CChainQuad _ChainQuad
 For collisions, the chainquad.

std::vector< CChain_Chains
 The chains insinde the zone.

std::vector< COrderedChain3f_FullOrderedChains
bool _Loaded
 Tells if retriever is loaded.

std::vector< COrderedChain_OrderedChains
 The chains insinde the zone.

std::vector< CRetrievableSurface_Surfaces
 The surfaces inside the zone.

std::vector< CTopology_Topologies [NumMaxCreatureModels]
 The topologies within the zone.

EType _Type
 The type of the retriever.

Internior retriever specific
CExteriorMesh _ExteriorMesh
 The exterior mesh, for collisions.

CFaceGrid _FaceGrid
 The face selection grid.

std::string _Id
 An human readable identifier of the retriever.

std::vector< CInteriorFace_InteriorFaces
 The faces of the collision mesh.

std::vector< NLMISC::CVector_InteriorVertices
 The vertices of the collision mesh.


Static Protected Attributes

const float _EdgeTipThreshold = 0.1f
 The tip recognition threshold.

const float _TipThreshold = 0.1f
 The tip recognition threshold.


Friends

class CRetrieverInstance


Member Enumeration Documentation

enum NLPACS::CLocalRetriever::EType
 

The different types of retriever (landscape or interior.)

Author:
Benjamin Legros

Nevrax France

Date:
2001
Enumeration values:
Landscape 
Interior 

Definition at line 160 of file local_retriever.h.

Referenced by getType().

00161         {
00162                 Landscape = 0,
00163                 Interior
00164         };


Constructor & Destructor Documentation

NLPACS::CLocalRetriever::CLocalRetriever  ) 
 

Definition at line 56 of file local_retriever.cpp.

References _Loaded, and LoadCheckFlag.

00057 {
00058         _Type = Landscape;
00059         _Loaded = false;
00060         LoadCheckFlag = false;
00061 }


Member Function Documentation

sint32 NLPACS::CLocalRetriever::addChain const std::vector< NLMISC::CVector > &  vertices,
sint32  left,
sint32  right
 

Adds a chain to the local retriever, using the vertices of the chain, the left and right surfaces id and the edge on which the chain is stuck

Definition at line 361 of file local_retriever.cpp.

References NLPACS::CRetrievableSurface::_Chains, _Chains, _FullOrderedChains, _OrderedChains, NLPACS::CChain::_StartTip, NLPACS::CChain::_StopTip, _Surfaces, NLPACS::CChain::make(), nlerror, nlwarning, sint, sint32, uint, and uint16.

Referenced by NLPACS::buildSurfaces().

00363 {
00364         vector<CVector> vertices = verts;
00365         uint            i;
00366 
00367         if (vertices.size() < 2)
00368         {
00369                 nlwarning("in NLPACS::CLocalRetriever::addChain()");
00370                 nlwarning("The chain has less than 2 vertices");
00371                 return -1;
00372         }
00373 
00374         // Remove doubled vertices due to CVector2s snapping
00375         vector<CVector2s>       converts;
00376 
00377         for (i=0; i<vertices.size(); ++i)
00378                 converts.push_back(CVector2s(vertices[i]));
00379 
00380         vector<CVector2s>::iterator     next2s = converts.begin(), it2s, prev2s;
00381         prev2s = next2s; ++next2s;
00382         it2s = next2s; ++next2s;
00383 
00384         vector<CVector>::iterator       it3f = vertices.begin();
00385         CVector                                         prev3f = *it3f;
00386         ++it3f;
00387 
00388 
00389         for (; it2s != converts.end() && next2s != converts.end(); )
00390         {
00391                 // if the next point is equal to the previous
00392                 if (*it2s == *prev2s || *it2s == *next2s)
00393                 {
00394                         // then remove the next point
00395                         it2s = converts.erase(it2s);
00396                         it3f = vertices.erase(it3f);
00397 
00398                         prev2s = it2s;
00399                         --prev2s;
00400                         next2s = it2s;
00401                         ++next2s;
00402                 }
00403                 else
00404                 {
00405                         // else remember the next point, and step to the next...
00406                         ++prev2s;
00407                         ++it2s;
00408                         ++next2s;
00409                         ++it3f;
00410                         prev3f = *it3f;
00411                 }
00412         }
00413         
00414         if (vertices.size() < 2)
00415         {
00416                 nlwarning("in NLPACS::CLocalRetriever::addChain()");
00417                 nlwarning("The chain was snapped to a single point");
00418                 return -1;
00419         }
00420 
00421         sint32          newId = _Chains.size();
00422         _Chains.resize(newId+1);
00423         CChain          &chain = _Chains.back();
00424 
00425         if (left>(sint)_Surfaces.size())
00426                 nlerror ("left surface id MUST be id<%d (id=%d)", _Surfaces.size(), left);
00427         if (right>(sint)_Surfaces.size())
00428                 nlerror ("right surface id MUST be id<%d (id=%d)", _Surfaces.size(), right);
00429 
00430         // checks if we can build the chain.
00431         if (newId > 65535)
00432                 nlerror("in NLPACS::CLocalRetriever::addChain(): reached the maximum number of chains");
00433 
00434         CRetrievableSurface     *leftSurface = (left>=0) ? &(_Surfaces[left]) : NULL;
00435         CRetrievableSurface     *rightSurface = (right>=0) ? &(_Surfaces[right]) : NULL;
00436 
00437         // adds the chain and the link to the surface links vector.
00438         if (leftSurface != NULL)
00439                 leftSurface->_Chains.push_back(CRetrievableSurface::CSurfaceLink(newId, right));
00440         if (rightSurface != NULL)
00441                 rightSurface->_Chains.push_back(CRetrievableSurface::CSurfaceLink(newId, left));
00442 
00443         chain._StartTip = 0xffff;
00444         chain._StopTip = 0xffff;
00445 
00446         // make the chain and its subchains.
00447         vector<uint>    empty;
00448         chain.make(vertices, left, right, _OrderedChains, (uint16)newId, _FullOrderedChains, empty);
00449 
00450         return newId;
00451 }

sint32 NLPACS::CLocalRetriever::addSurface uint8  normalq,
uint8  orientationq,
uint8  mat,
uint8  charact,
uint8  level,
bool  isUnderWater,
float  waterHeight,
bool  clusterHint,
const NLMISC::CVector center,
const CSurfaceQuadTree quad,
sint8  quantHeight = 0
 

Adds a surface to the local retriever, using its features. Returns the id of the newly created surface.

Definition at line 320 of file local_retriever.cpp.

References NLPACS::CRetrievableSurface::_Center, NLPACS::CRetrievableSurface::_Character, NLPACS::CRetrievableSurface::_Flags, NLPACS::CRetrievableSurface::_IsCeiling, NLPACS::CRetrievableSurface::_IsFloor, NLPACS::CRetrievableSurface::_Level, NLPACS::CRetrievableSurface::_Material, NLPACS::CRetrievableSurface::_NormalQuanta, NLPACS::CRetrievableSurface::_OrientationQuanta, NLPACS::CRetrievableSurface::_Quad, NLPACS::CRetrievableSurface::_QuantHeight, _Surfaces, NLPACS::CRetrievableSurface::_WaterHeight, level, sint32, sint8, and uint8.

Referenced by NLPACS::buildSurfaces().

00327 {
00328         // creates a new surface...
00329         sint32  newId = _Surfaces.size();
00330         _Surfaces.resize(newId+1);
00331         CRetrievableSurface     &surf = _Surfaces.back();
00332 
00333         // ... and fills it
00334         surf._NormalQuanta = normalq;
00335         surf._OrientationQuanta = orientationq;
00336         surf._Material = mat;
00337         surf._Character = charact;
00338         surf._Level = level;
00339         surf._Quad = quad;
00340         surf._Center = center;
00341         surf._QuantHeight = quantHeight;
00342 
00343         // WARNING!! MODIFY THESE IF QUANTAS VALUES CHANGE !!
00344         surf._IsFloor = (surf._NormalQuanta <= 1);
00345         surf._IsCeiling = (surf._NormalQuanta >= 3);
00346 
00347         surf._Flags = 0;
00348         surf._Flags |= (surf._IsFloor) ? (1<<CRetrievableSurface::IsFloorBit) : 0;
00349         surf._Flags |= (surf._IsCeiling) ? (1<<CRetrievableSurface::IsCeilingBit) : 0;
00350         surf._Flags |= (!surf._IsFloor && !surf._IsCeiling) ? (1<<CRetrievableSurface::IsSlantBit) : 0;
00351         surf._Flags |= clusterHint ? (1<<CRetrievableSurface::ClusterHintBit) : 0;
00352 
00353         surf._Flags |= (isUnderWater) ? (1<<CRetrievableSurface::IsUnderWaterBit) : 0;
00354         surf._WaterHeight = waterHeight;
00355 
00356         surf._Flags |= ((0xffffffff<<(CRetrievableSurface::NormalQuantasStartBit)) & CRetrievableSurface::NormalQuantasBitMask);
00357 
00358         return newId;
00359 }

void NLPACS::CLocalRetriever::build3dSurfacePolygons std::list< std::list< NLMISC::CPolygon > > &  polygons  )  const [inline]
 

Builds the polygons (loops) of all surfaces in the retriever.

Definition at line 448 of file local_retriever.h.

References _Surfaces, build3dSurfacePolygons(), and uint.

00449         {
00450                 uint    i;
00451                 for (i=0; i<_Surfaces.size(); ++i)
00452                 {
00453                         polygons.push_back();
00454                         build3dSurfacePolygons(i, polygons.back());
00455                 }
00456         }

void NLPACS::CLocalRetriever::build3dSurfacePolygons uint32  surface,
std::list< NLMISC::CPolygon > &  polygons
const
 

Builds the polygons (loops) of a given surface.

Definition at line 714 of file local_retriever.cpp.

References NLPACS::CRetrievableSurface::_Chains, _Chains, _FullOrderedChains, NLPACS::CChain::_Left, NLPACS::CRetrievableSurface::_Loops, NLPACS::CChain::_SubChains, _Surfaces, NLPACS::COrderedChain3f::getVertices(), NLPACS::COrderedChain3f::isForward(), sint, uint, uint32, and NLMISC::CPolygon::Vertices.

Referenced by build3dSurfacePolygons().

00715 {
00716         const CRetrievableSurface       &surf = _Surfaces[surface];
00717 
00718         uint    i, j, k, l;
00719 
00720         for (i=0; i<surf._Loops.size(); ++i)
00721         {
00722                 polygons.push_back();
00723                 CPolygon        &poly = polygons.back();
00724 
00725                 for (j=0; j<surf._Loops[i].size(); ++j)
00726                 {
00727                         const CRetrievableSurface::TLoop        &loop = surf._Loops[i];
00728                         const CChain                                            &chain = _Chains[surf._Chains[loop[j]].Chain];
00729                         bool                                                            chainforward = ((uint32)chain._Left == surface);
00730 
00731                         if (chainforward)
00732                         {
00733                                 for (k=0; k<chain._SubChains.size(); ++k)
00734                                 {
00735                                         const COrderedChain3f   &ochain = _FullOrderedChains[chain._SubChains[k]];
00736                                         bool                                    ochainforward = ochain.isForward();
00737 
00738                                         if (ochainforward)
00739                                         {
00740                                                 for (l=0; l<ochain.getVertices().size()-1; ++l)
00741                                                         poly.Vertices.push_back(ochain[l]);
00742                                         }
00743                                         else
00744                                         {
00745                                                 for (l=ochain.getVertices().size()-1; l>0; --l)
00746                                                         poly.Vertices.push_back(ochain[l]);
00747                                         }
00748                                 }
00749                         }
00750                         else
00751                         {
00752                                 for (k=chain._SubChains.size()-1; (sint)k>=0; --k)
00753                                 {
00754                                         const COrderedChain3f   &ochain = _FullOrderedChains[chain._SubChains[k]];
00755                                         bool                                    ochainforward = ochain.isForward();
00756 
00757                                         if (ochainforward)
00758                                         {
00759                                                 for (l=ochain.getVertices().size()-1; (sint)l>0; --l)
00760                                                         poly.Vertices.push_back(ochain[l]);
00761                                         }
00762                                         else
00763                                         {
00764                                                 for (l=0; l<ochain.getVertices().size()-1; ++l)
00765                                                         poly.Vertices.push_back(ochain[l]);
00766                                         }
00767                                 }
00768                         }
00769                 }
00770         }
00771 }

void NLPACS::CLocalRetriever::buildInteriorSurfaceBBoxes std::vector< NLMISC::CAABBox > &  surfaceBBoxes  )  const
 

build BBoxes of interior surfaces in surfaceBBoxes (cleared first)

Definition at line 1935 of file local_retriever.cpp.

References _InteriorFaces, _InteriorVertices, _Surfaces, nlassert, NLPACS::CLocalRetriever::CInteriorFace::Surface, uint, and NLPACS::CLocalRetriever::CInteriorFace::Verts.

01936 {
01937         // resize dest, and init.
01938         vector<bool>    firstTriangle;
01939         surfaceBBoxes.clear();
01940         surfaceBBoxes.resize(_Surfaces.size());
01941         firstTriangle.resize(_Surfaces.size(), true);
01942 
01943         // For all _InteriorFaces.
01944         for(uint iIntFace=0; iIntFace<_InteriorFaces.size(); iIntFace++)
01945         {
01946                 const CInteriorFace     &intFace= _InteriorFaces[iIntFace];
01947 
01948                 // Extend the surface of this face with her 3 points.
01949 
01950                 // check good id.
01951                 if(intFace.Surface==(uint)-1)
01952                         continue;
01953                 nlassert(intFace.Surface<_Surfaces.size());
01954 
01955                 // If first time we extend the bbox of this surface
01956                 if(firstTriangle[intFace.Surface])
01957                 {
01958                         surfaceBBoxes[intFace.Surface].setCenter(_InteriorVertices[intFace.Verts[0]] );
01959                         firstTriangle[intFace.Surface]= false;
01960                 }
01961                 else
01962                         surfaceBBoxes[intFace.Surface].extend(_InteriorVertices[intFace.Verts[0]] );
01963 
01964                 // extend with other 2 points
01965                 surfaceBBoxes[intFace.Surface].extend(_InteriorVertices[intFace.Verts[1]] );
01966                 surfaceBBoxes[intFace.Surface].extend(_InteriorVertices[intFace.Verts[2]] );
01967         }
01968 
01969 }

void NLPACS::CLocalRetriever::buildSurfacePolygons std::list< std::list< NLMISC::CPolygon > > &  polygons  )  const [inline]
 

Builds the polygons (loops) of all surfaces in the retriever.

Definition at line 434 of file local_retriever.h.

References _Surfaces, buildSurfacePolygons(), and uint.

00435         {
00436                 uint    i;
00437                 for (i=0; i<_Surfaces.size(); ++i)
00438                 {
00439                         polygons.push_back();
00440                         buildSurfacePolygons(i, polygons.back());
00441                 }
00442         }

void NLPACS::CLocalRetriever::buildSurfacePolygons uint32  surface,
std::list< NLMISC::CPolygon > &  polygons
const
 

Builds the polygons (loops) of a given surface.

Definition at line 655 of file local_retriever.cpp.

References _Chains, NLPACS::CChain::_Left, NLPACS::CRetrievableSurface::_Loops, _OrderedChains, NLPACS::CChain::_SubChains, _Surfaces, NLPACS::COrderedChain::getVertices(), NLPACS::COrderedChain::isForward(), sint, uint, uint32, and NLMISC::CPolygon::Vertices.

Referenced by buildSurfacePolygons().

00656 {
00657         const CRetrievableSurface       &surf = _Surfaces[surface];
00658 
00659         uint    i, j, k, l;
00660 
00661         for (i=0; i<surf._Loops.size(); ++i)
00662         {
00663                 polygons.push_back();
00664                 CPolygon        &poly = polygons.back();
00665 
00666                 for (j=0; j<surf._Loops[i].size(); ++j)
00667                 {
00668                         const CChain    &chain = _Chains[surf._Loops[i][j]];
00669                         bool                    chainforward = ((uint32)chain._Left == surface);
00670 
00671                         if (chainforward)
00672                         {
00673                                 for (k=0; k<chain._SubChains.size(); ++k)
00674                                 {
00675                                         const COrderedChain             &ochain = _OrderedChains[chain._SubChains[k]];
00676                                         bool                                    ochainforward = ochain.isForward();
00677 
00678                                         if (ochainforward)
00679                                         {
00680                                                 for (l=0; l<ochain.getVertices().size()-1; ++l)
00681                                                         poly.Vertices.push_back(ochain[l].unpack3f());
00682                                         }
00683                                         else
00684                                         {
00685                                                 for (l=ochain.getVertices().size()-1; l>0; --l)
00686                                                         poly.Vertices.push_back(ochain[l].unpack3f());
00687                                         }
00688                                 }
00689                         }
00690                         else
00691                         {
00692                                 for (k=chain._SubChains.size(); (sint)k>0; --k)
00693                                 {
00694                                         const COrderedChain             &ochain = _OrderedChains[chain._SubChains[k]];
00695                                         bool                                    ochainforward = ochain.isForward();
00696 
00697                                         if (ochainforward)
00698                                         {
00699                                                 for (l=ochain.getVertices().size()-1; (sint)l>0; --l)
00700                                                         poly.Vertices.push_back(ochain[l].unpack3f());
00701                                         }
00702                                         else
00703                                         {
00704                                                 for (l=0; l<ochain.getVertices().size()-1; ++l)
00705                                                         poly.Vertices.push_back(ochain[l].unpack3f());
00706                                         }
00707                                 }
00708                         }
00709                 }
00710         }
00711 }

void NLPACS::CLocalRetriever::clear  ) 
 

Clear.

Definition at line 64 of file local_retriever.cpp.

References __Tips, _BorderChains, _ChainQuad, _Chains, _ExteriorMesh, _FaceGrid, _FullOrderedChains, _InteriorFaces, _InteriorVertices, _Loaded, _OrderedChains, _Surfaces, _Topologies, NLPACS::CFaceGrid::clear(), NLPACS::CExteriorMesh::clear(), NLPACS::CChainQuad::clear(), LoadCheckFlag, NLPACS::NumMaxCreatureModels, and uint.

00065 {
00066         contReset(_OrderedChains);
00067         contReset(_FullOrderedChains);
00068         contReset(_Chains);
00069         contReset(_Surfaces);
00070         contReset(__Tips);
00071         contReset(_BorderChains);
00072         uint    i;
00073         for (i=0; i<NumMaxCreatureModels; ++i)
00074                 contReset(_Topologies[i]);
00075         _ChainQuad.clear();
00076         _ExteriorMesh.clear();
00077         contReset(_InteriorVertices);
00078         contReset(_InteriorFaces);
00079         _FaceGrid.clear();
00080         _Id.resize(0);
00081         _Loaded = false;
00082         LoadCheckFlag = false;
00083 }

void NLPACS::CLocalRetriever::computeCollisionChainQuad  ) 
 

compute the chain quad, used for collisions. the ChainQuad is serialised in serial(). _OrderedChains must be OK.

Definition at line 1800 of file local_retriever.cpp.

References _ChainQuad, _OrderedChains, and NLPACS::CChainQuad::build().

Referenced by NLPACS::computeRetriever().

01801 {
01802         _ChainQuad.build(_OrderedChains);
01803 }

void NLPACS::CLocalRetriever::computeLoopsAndTips  ) 
 

Builds tips.

Definition at line 456 of file local_retriever.cpp.

References _Chains, NLPACS::CRetrievableSurface::_Chains, NLPACS::CRetrievableSurface::_Loops, _Surfaces, dumpSurface(), getStartVector(), getStopVector(), nlerror, nlinfo, nlwarning, sint, uint, uint32, NLMISC::CVector::x, NLMISC::CVector::y, and NLMISC::CVector::z.

Referenced by NLPACS::computeRetriever().

00457 {
00458         // for each surface,
00459         // examine each chain tip to match another tip inside the surface tips
00460         // if there is no matching tip, then creates a new one
00461 
00462         uint    i, j;
00463 
00464         for (i=0; i<_Surfaces.size(); ++i)
00465         {
00466                 CRetrievableSurface     &surface = _Surfaces[i];
00467 
00468                 vector<bool>            chainFlags;
00469                 chainFlags.resize(surface._Chains.size());
00470                 for (j=0; j<chainFlags.size(); ++j)
00471                         chainFlags[j] = false;
00472 
00473                 uint    totalAdded = 0;
00474 
00475                 while (true)
00476                 {
00477                         for (j=0; j<chainFlags.size() && chainFlags[j]; ++j)
00478                                 ;
00479 
00480                         if (j == chainFlags.size())
00481                                 break;
00482 
00483                         uint32                                          loopId = surface._Loops.size();
00484                         surface._Loops.push_back(CRetrievableSurface::TLoop());
00485                         CRetrievableSurface::TLoop      &loop = surface._Loops.back();
00486 
00487                         CVector loopStart = getStartVector(surface._Chains[j].Chain, i);
00488                         CVector currentEnd = getStopVector(surface._Chains[j].Chain, i);
00489                         _Chains[surface._Chains[j].Chain].setLoopIndexes(i, loopId, loop.size());
00490                         loop.push_back(j);
00491                         chainFlags[j] = true;
00492 
00493                         float   loopCloseDistance;
00494 
00495                         while (true)
00496                         {
00497 //                              loopCloseDistance = hybrid2dNorm(loopStart-currentEnd);
00498                                 loopCloseDistance = (loopStart-currentEnd).norm();
00499 
00500                                 // choose the best matching start vector
00501                                 sint    bestChain = -1;
00502                                 float   best = 1.0e10f;
00503                                 CVector thisStart;
00504                                 for (j=0; j<chainFlags.size(); ++j)
00505                                 {
00506                                         if (chainFlags[j])
00507                                                 continue;
00508                                         thisStart = getStartVector(surface._Chains[j].Chain, i);
00509 //                                      float   d = hybrid2dNorm(thisStart-currentEnd);
00510                                         float   d = (thisStart-currentEnd).norm();
00511                                         if (d < best)
00512                                         {
00513                                                 best = d;
00514                                                 bestChain = j;
00515                                         }
00516                                 }
00517 
00518                                 if ((bestChain == -1 || best > 3.0e-2f)&& loopCloseDistance > 3.0e-2f)
00519                                 {
00520                                         nlwarning("in NLPACS::CLocalRetriever::computeTips()");
00521 
00522                                         dumpSurface(i);
00523 
00524                                         for (j=0; j<surface._Chains.size(); ++j)
00525                                         {
00526                                                 CVector start = getStartVector(surface._Chains[j].Chain, i);
00527                                                 CVector end = getStopVector(surface._Chains[j].Chain, i);
00528                                                 nlinfo("surf=%d chain=%d", i, surface._Chains[j].Chain);
00529                                                 nlinfo("start=(%f,%f,%f)", start.x, start.y, start.z);
00530                                                 nlinfo("end=(%f,%f,%f)", end.x, end.y, end.z);
00531                                         }
00532                                         
00533                                         nlwarning("bestChain=%d best=%f", bestChain, best);
00534                                         nlwarning("loopCloseDistance=%f", loopCloseDistance);
00535                                         nlerror("Couldn't close loop on surface=%d", i);
00536                                 }
00537                                 else if (best > 1.0e0f && loopCloseDistance < 3.0e-2f ||
00538                                                  loopCloseDistance < 1.0e-3f)
00539                                 {
00540                                         break;
00541                                 }
00542 
00543                                 currentEnd = getStopVector(surface._Chains[bestChain].Chain, i);
00544                                 _Chains[surface._Chains[bestChain].Chain].setLoopIndexes(i, loopId, loop.size());
00545                                 loop.push_back(bestChain);
00546                                 chainFlags[bestChain] = true;
00547                                 ++totalAdded;
00548                         }
00549                 }
00550         }
00551 /*
00552         dumpSurface(9);
00553         dumpSurface(10);
00554 
00555         for (i=0; i<_Chains.size(); ++i)
00556         {
00557                 if (i == 127)
00558                         nlinfo("");
00559 
00560                 uint    whichTip;
00561                 // for both tips (start and stop)
00562                 for (whichTip=0; whichTip<=1; ++whichTip)
00563                 {
00564                         // get the tip id
00565                         uint    thisTip = (whichTip) ? _Chains[i].getStopTip() : _Chains[i].getStartTip();
00566 
00567                         if (thisTip != 0xffff && thisTip >= _Tips.size())
00568                         {
00569                                 nlwarning("in NLPACS::CLocalRetriever::computeLoopsAndTips()");
00570                                 nlerror("checked a tip that doesn't exist on chain %d (tipId=%d)", i, thisTip);
00571                         }
00572 
00573                         // if it is unaffected yet creates an new tip and affect it to the common chains
00574                         if (thisTip == 0xffff)
00575                         {
00576                                 uint    turn;
00577                                 uint    tipId = _Tips.size();
00578 
00579                                 if (tipId == 62)
00580                                         nlinfo("");
00581 
00582                                 _Tips.resize(tipId+1);
00583                                 CTip    &tip = _Tips[tipId];
00584                                 tip.Point = (whichTip) ? getStopVector(i) : getStartVector(i);
00585 
00586                                 for (turn=0; turn<=1; ++turn)
00587                                 {
00588                                         uint    chain = i;
00589 
00590                                         //
00591                                         if (whichTip)
00592                                                 _Chains[chain]._StopTip = tipId;
00593                                         else
00594                                                 _Chains[chain]._StartTip = tipId;
00595 
00596                                         sint32  surf = (!turn && !whichTip || turn && whichTip) ? _Chains[chain].getLeft() : _Chains[chain].getRight();
00597 
00598                                         while (surf >= 0)
00599                                         {
00600 
00601                                                 CChain  &nextChain = (turn) ? _Chains[chain = getNextChain(chain, surf)] : _Chains[chain = getPreviousChain(chain, surf)];
00602                                                 bool    isForward = (nextChain.getLeft() == surf);      // tells if the left surf is the current surf
00603                                                 bool    selectTip = isForward && !turn || !isForward && turn;
00604                                                 uint16  &tipRef = selectTip ? nextChain._StopTip : nextChain._StartTip;
00605                                                 surf = (isForward) ? nextChain.getRight() : nextChain.getLeft();
00606 
00607                                                 if (tipRef != 0xffff && tipRef != tipId)
00608                                                 {
00609                                                         nlwarning("in NLPACS::CLocalRetriever::computeLoopsAndTips()");
00610                                                         nlerror("Trying to setup a already created tip (tipId=%d, previous=%d)", tipId, tipRef);
00611                                                 }
00612                                                 else if (tipRef != 0xffff)
00613                                                 {
00614                                                         break;
00615                                                 }
00616 
00617                                                 tipRef = tipId;
00618                                         }
00619                                 }
00620                         }
00621                 }
00622         }
00623 
00624         for (i=0; i<_Chains.size(); ++i)
00625         {
00626                 uint    startTip = _Chains[i].getStartTip(),
00627                                 stopTip = _Chains[i].getStopTip();
00628 
00629 
00630 //              if (_Chains[i].getEdge() >= 0 && startTip == stopTip)
00631 //              {
00632 //                      nlwarning("NLPACS::CLocalRetriever::computeLoopsAndTips(): chain %d on edge %d has same StartTip and StopTip", i, _Chains[i].getEdge(), startTip, stopTip);
00633 //              }
00634 
00635 
00636                 _Tips[startTip].Chains.push_back(CTip::CChainTip(i, true));
00637                 _Tips[stopTip].Chains.push_back(CTip::CChainTip(i, false));
00638         }
00639 */
00640         for (i=0; i<_Surfaces.size(); ++i)
00641         {
00642                 for (j=0; j<_Surfaces[i]._Loops.size(); ++j)
00643                 {
00644                         _Surfaces[i]._Loops[j].Length = 0.0f;
00645                         uint    k;
00646 
00647                         for (k=0; k<_Surfaces[i]._Loops[j].size(); ++k)
00648                                 _Surfaces[i]._Loops[j].Length += _Chains[_Surfaces[i]._Chains[_Surfaces[i]._Loops[j][k]].Chain].getLength();
00649                 }
00650         }
00651 }

void NLPACS::CLocalRetriever::computeTopologies  ) 
 

Builds topologies tables.

Definition at line 822 of file local_retriever.cpp.

References _Chains, NLPACS::CRetrievableSurface::_Chains, NLPACS::CRetrievableSurface::_Character, _Surfaces, _Topologies, NLPACS::CRetrievableSurface::_Topologies, NLPACS::CChain::getLeft(), NLPACS::CChain::getRight(), NLPACS::NumCreatureModels, sint, sint32, and uint.

Referenced by NLPACS::computeRetriever().

00823 {
00824         //nlinfo("compute topologies");
00825 
00826         // Find topologies out...
00827         uint            character;
00828         for (character=0; character<NumCreatureModels; ++character)
00829         {
00830                 // for each type of creature, flood fill surfaces...
00831                 sint32  surface;
00832                 uint    topology = 0;
00833 
00834                 for (surface=0; surface<(sint)_Surfaces.size(); ++surface)
00835                 {
00836                         if (_Surfaces[surface]._Topologies[character] == -1 &&
00837                                 _Surfaces[surface]._Character == character)
00838                         {
00839                                 vector<sint32>  surfacesStack;
00840                                 surfacesStack.push_back(surface);
00841 
00842                                 while (!surfacesStack.empty())
00843                                 {
00844                                         CRetrievableSurface     &current = _Surfaces[surfacesStack.back()];
00845                                         surfacesStack.pop_back();
00846                                         current._Topologies[character] = topology;
00847 
00848                                         uint    i;
00849                                         for (i=0; i<current._Chains.size(); ++i)
00850                                         {
00851                                                 CChain  &chain = _Chains[current._Chains[i].Chain];
00852                                                 sint32  link = (chain.getLeft() == surface) ? chain.getRight() : chain.getLeft();
00853                                                 if (link>=0 && link<(sint)_Surfaces.size() &&
00854                                                         _Surfaces[link]._Topologies[character] == -1 &&
00855                                                         _Surfaces[link]._Character >= character)
00856                                                 {
00857                                                         surfacesStack.push_back(link);
00858                                                         _Surfaces[link]._Topologies[character] = topology;
00859                                                 }
00860                                         }
00861                                 }
00862 
00863                                 ++topology;
00864                         }
00865                 }
00866 
00867                 _Topologies[character].resize(topology);
00868                 //nlinfo("generated %d topologies for character %d", topology, character);
00869         }
00870 
00871         uint            surface;
00872         for (surface=0; surface<_Surfaces.size(); ++surface)
00873         {
00874                 CRetrievableSurface     &current = _Surfaces[surface];
00875 
00876                 for (character=0; character<NumCreatureModels; ++character)
00877                         if (current._Topologies[character] >= 0)
00878                                 _Topologies[character][current._Topologies[character]].push_back(surface);
00879         }
00880 }

float NLPACS::CLocalRetriever::distanceToBorder const ULocalPosition pos  )  const
 

Definition at line 291 of file local_retriever.cpp.

References _Chains, NLPACS::CRetrievableSurface::_Chains, _OrderedChains, _Surfaces, NLPACS::ULocalPosition::Estimation, NLPACS::CChain::getSubChain(), NLPACS::CChain::getSubChains(), isLoaded(), NLPACS::ULocalPosition::Surface, and uint.

Referenced by NLPACS::CGlobalRetriever::distanceToBorder().

00292 {
00293         if (!isLoaded())
00294                 return 0.0f;
00295 
00296         const CRetrievableSurface       &surf = _Surfaces[pos.Surface];
00297         uint                                            i, j;
00298         float                                           minDist = 1.0e10f, dist;
00299 
00300         for (i=0; i<surf._Chains.size(); ++i)
00301         {
00302                 const CChain    &chain = _Chains[surf._Chains[i].Chain];
00303                 for (j=0; j<chain.getSubChains().size(); ++j)
00304                 {
00305                         dist = _OrderedChains[chain.getSubChain(j)].distance(pos.Estimation);
00306                         if (dist < minDist)
00307                         {
00308                                 minDist = dist;
00309                         }
00310                 }
00311         }
00312 
00313         return minDist;
00314 }

void NLPACS::CLocalRetriever::dumpSurface uint  surf,
const NLMISC::CVector vect = NLMISC::CVector::Null
const
 

Definition at line 248 of file local_retriever.cpp.

References _Chains, NLPACS::CRetrievableSurface::_Chains, _FullOrderedChains, NLPACS::CRetrievableSurface::_Loops, _OrderedChains, _Surfaces, buffer, NLPACS::COrderedChain3f::getIndexInParent(), NLPACS::CChain::getLeft(), NLPACS::COrderedChain3f::getParentId(), NLPACS::CChain::getRight(), NLPACS::CChain::getStartTip(), NLPACS::CChain::getStopTip(), NLPACS::CChain::getSubChain(), NLPACS::CChain::getSubChains(), NLPACS::COrderedChain::getVertices(), NLPACS::COrderedChain3f::getVertices(), NLPACS::COrderedChain3f::isForward(), NLPACS::CRetrievableSurface::TLoop::Length, nlinfo, uint, NLMISC::CVector::x, NLMISC::CVector::y, and NLMISC::CVector::z.

Referenced by computeLoopsAndTips().

00249 {
00250         const CRetrievableSurface       &surface = _Surfaces[surf];
00251 
00252         nlinfo("dump surf %d", surf);
00253         nlinfo("%d chains, %d loops", surface._Chains.size(), surface._Loops.size());
00254         
00255         uint    i, j, k;
00256 
00257         for (i=0; i<surface._Chains.size(); ++i)
00258         {
00259                 uint                    chainId = surface._Chains[i].Chain;
00260                 const CChain    &chain = _Chains[chainId];
00261                 nlinfo("-- chain %d[%d]: %d sub left=%d right=%d start=%d stop=%d", i, chainId, chain.getSubChains().size(), chain.getLeft(), chain.getRight(), chain.getStartTip(), chain.getStopTip());
00262 
00263                 for (j=0; j<chain.getSubChains().size(); ++j)
00264                 {
00265                         const COrderedChain3f   &ochain = _FullOrderedChains[chain.getSubChain(j)];
00266                         const COrderedChain             &ochains = _OrderedChains[chain.getSubChain(j)];
00267                         nlinfo("     subchain %d[%d]: fwd=%d parent=%d idx=%d", j, chain.getSubChain(j), ochain.isForward(), ochain.getParentId(), ochain.getIndexInParent());
00268                         for (k=0; k<ochain.getVertices().size(); ++k)
00269                                 nlinfo("       v[%d]=(%.3f,%.3f,%.3f) (%d,%d)", k, ochain.getVertices()[k].x+vect.x, ochain.getVertices()[k].y+vect.y, ochain.getVertices()[k].z+vect.z, ochains.getVertices()[k].x, ochains.getVertices()[k].y);
00270                 }
00271 
00272         }
00273 
00274         for (i=0; i<surface._Loops.size(); ++i)
00275         {
00276                 const CRetrievableSurface::TLoop        &loop = surface._Loops[i];
00277                 nlinfo("-- loop %d: %d chains length=%.2f", i, loop.size(), loop.Length);
00278                 static char     wbuffer[256];
00279                 static char     buffer[10240];
00280                 sprintf(buffer, "    chains:");
00281                 for (j=0; j<loop.size(); ++j)
00282                 {
00283                         sprintf(wbuffer, " %d[%d]", loop[j], surface._Chains[loop[j]].Chain);
00284                         strcat(buffer, wbuffer);
00285                 }
00286                 nlinfo("%s", buffer);
00287         }
00288 }

void NLPACS::CLocalRetriever::findBorderChains  ) 
 

Found chains on the edges of the retriever and fills _BorderChains tables.

Definition at line 782 of file local_retriever.cpp.

References _BorderChains, _Chains, index, sint32, and uint.

Referenced by NLPACS::computeRetriever().

00783 {
00784         uint    chain;
00785 
00786         // for each chain, if it belongs to an edge of the
00787         // local retriever, then adds it to the _BorderChains.
00788         for (chain=0; chain<_Chains.size(); ++chain)
00789                 if (_Chains[chain].isBorderChain())
00790                 {
00791                         sint32  index = _BorderChains.size();
00792                         _BorderChains.push_back(chain);
00793                         _Chains[chain].setBorderChainIndex(index);
00794                 }
00795 }

void NLPACS::CLocalRetriever::findPath const CLocalPosition A,
const CLocalPosition B,
std::vector< CVector2s > &  path,
NLPACS::CCollisionSurfaceTemp cst
const
 

Finds a path in a given surface, from the point A to the point B.

Todo:
Ben use smart allocations here

Definition at line 1576 of file local_retriever.cpp.

References _ChainQuad, NLPACS::CRetrievableSurface::_Chains, _Chains, NLPACS::CRetrievableSurface::_Loops, _OrderedChains, NLPACS::CChain::_SubChains, _Surfaces, NLPACS::CCollisionSurfaceTemp::EdgeChainEntries, NLPACS::CEdgeChainEntry::EdgeEnd, NLPACS::CEdgeChainEntry::EdgeStart, NLPACS::ULocalPosition::Estimation, from, NLPACS::CChain::getLeft(), NLPACS::CChain::getLeftLoop(), NLPACS::CChain::getLeftLoopIndex(), NLPACS::CChain::getLength(), NLPACS::COrderedChain::getParentId(), NLPACS::CChain::getRightLoop(), NLPACS::CChain::getRightLoopIndex(), NLPACS::CRetrievableSurface::TLoop::Length, nlerror, nlwarning, NLPACS::CEdgeChainEntry::OChainId, NLPACS::CChainQuad::selectEdges(), sint, sint32, NLPACS::ULocalPosition::Surface, uint, NLMISC::CVector::x, and NLMISC::CVector::y.

Referenced by NLPACS::CGlobalRetriever::findPath().

01580 {
01581         if (A.Surface != B.Surface)
01582         {
01583                 nlwarning("in NLPACS::CLocalRetriever::findPath()");
01584                 nlerror("Try to find a path between 2 points that are not in the same surface (A=%d, B=%d)", A.Surface, B.Surface);
01585         }
01586 
01587         CVector         a = A.Estimation,
01588                                 b = B.Estimation,
01589                                 n = CVector(a.y-b.y, b.x-a.x, 0.0f);
01590 
01591         _ChainQuad.selectEdges(a, b, cst);
01592 
01594         vector<CIntersectionMarker>     intersections;
01595 
01596         uint    i, j;
01597         sint32  surfaceId = A.Surface;
01598         const CRetrievableSurface       &surface = _Surfaces[surfaceId];
01599 
01600         for (i=0; i<cst.EdgeChainEntries.size(); ++i)
01601         {
01602                 CEdgeChainEntry         &entry = cst.EdgeChainEntries[i];
01603                 const COrderedChain     &chain = _OrderedChains[entry.OChainId];
01604 
01605                 if (_Chains[chain.getParentId()].getLeft() != surfaceId &&
01606                         _Chains[chain.getParentId()].getRight() != surfaceId)
01607                         continue;
01608 
01609                 for (j=entry.EdgeStart; j<entry.EdgeEnd; ++j)
01610                 {
01611                         // here the edge collision test
01612 
01613                         CVector p0 = chain[j].unpack3f(),
01614                                         p1 = chain[j+1].unpack3f();
01615 
01616                         float   vp0 = (p0-a)*n,
01617                                         vp1 = (p1-a)*n;
01618 
01619                         if (vp0*vp1 <= 0.0f)
01620                         {
01621                                 CVector np = CVector(p0.y-p1.y, p1.x-p0.x, 0.0f);
01622 
01623                                 float   va = (a-p0)*np,
01624                                                 vb = (b-p0)*np;
01625 
01626                                 // here we have an intersection
01627                                 if (va*vb <= 0.0f)
01628                                 {
01629                                         const CChain    &parent = _Chains[chain.getParentId()];
01630                                         bool                    isIn = (va-vb < 0.0f) ^ (parent.getLeft() == surfaceId) ^ chain.isForward();
01631 
01632                                         intersections.push_back(CIntersectionMarker(va/(va-vb), entry.OChainId, j, isIn));
01633                                 }
01634                         }
01635                 }
01636         }
01637 
01638         sort(intersections.begin(), intersections.end());
01639 
01640         uint    intersStart = 0;
01641         uint    intersEnd = intersections.size();
01642 
01643         if (intersEnd > 0)
01644         {
01645                 while (intersStart < intersections.size() &&
01646                            intersections[intersStart].In && intersections[intersStart].Position < 1.0e-4f)
01647                         ++intersStart;
01648 
01649                 while (intersStart < intersEnd &&
01650                            !intersections[intersEnd-1].In && intersections[intersEnd-1].Position > 1.0f-1.0e-4f)
01651                         --intersEnd;
01652 
01653                 // Check intersections have a valid order
01654                 if ((intersEnd-intersStart) & 1)
01655                 {
01656                         nlwarning("in NLPACS::CLocalRetriever::findPath()");
01657                         nlerror("Found an odd (%d) number of intersections", intersections.size());
01658                 }
01659                 
01660                 for (i=intersStart; i<intersEnd; )
01661                 {
01662                         uint    exitLoop, enterLoop;
01663 
01664                         const CChain    &exitChain = _Chains[_OrderedChains[intersections[i].OChain].getParentId()];
01665                         exitLoop = (exitChain.getLeft() == surfaceId) ? exitChain.getLeftLoop() : exitChain.getRightLoop();
01666 
01667                         if (intersections[i++].In)
01668                         {
01669                                 nlwarning("in NLPACS::CLocalRetriever::findPath()");
01670                                 nlerror("Entered the surface before exited", intersections.size());
01671                         }
01672 
01673                         const CChain    &enterChain = _Chains[_OrderedChains[intersections[i].OChain].getParentId()];
01674                         enterLoop = (enterChain.getLeft() == surfaceId) ? enterChain.getLeftLoop() : enterChain.getRightLoop();
01675 
01676                         if (!intersections[i++].In)
01677                         {
01678                                 nlwarning("in NLPACS::CLocalRetriever::findPath()");
01679                                 nlerror("Exited twice the surface", intersections.size());
01680                         }
01681 
01682                         if (exitLoop != enterLoop)
01683                         {
01684                                 nlwarning("in NLPACS::CLocalRetriever::findPath()");
01685                                 nlerror("Exited and rentered by a different loop");
01686                         }
01687                 }
01688         }
01689 
01690 //      dumpSurface(surfaceId);
01691 
01692         path.push_back(CVector2s(A.Estimation));
01693 
01694         for (i=intersStart; i<intersEnd; )
01695         {
01696                 uint                                                            exitChainId = _OrderedChains[intersections[i].OChain].getParentId(),
01697                                                                                         enterChainId = _OrderedChains[intersections[i+1].OChain].getParentId();
01698                 const CChain                                            &exitChain = _Chains[exitChainId],
01699                                                                                         &enterChain = _Chains[enterChainId];
01700                 uint                                                            loopId, exitLoopIndex, enterLoopIndex;
01701 
01702                 if (exitChain.getLeft() == surfaceId)
01703                 {
01704                         loopId = exitChain.getLeftLoop();
01705                         exitLoopIndex = exitChain.getLeftLoopIndex();
01706                 }
01707                 else
01708                 {
01709                         loopId = exitChain.getRightLoop();
01710                         exitLoopIndex = exitChain.getRightLoopIndex();
01711                 }
01712 
01713                 const CRetrievableSurface::TLoop        &loop = surface._Loops[loopId];
01714 
01715                 if (enterChain.getLeft() == surfaceId)
01716                         enterLoopIndex = enterChain.getLeftLoopIndex();
01717                 else
01718                         enterLoopIndex = enterChain.getRightLoopIndex();
01719 
01720                 float                   forwardLength = (exitChain.getLength()+enterChain.getLength())*0.5f;
01721 
01722                 sint    loopIndex = exitLoopIndex;
01723                 uint    thisChainId = exitChainId;
01724                 bool    thisChainForward = (enterChain.getLeft() == surfaceId);
01725                 uint    thisOChainId = intersections[i].OChain;
01726                 sint    thisOChainIndex = _OrderedChains[thisOChainId].getIndexInParent();
01727                 bool    forward;
01728 
01729                 if (exitChainId != enterChainId)
01730                 {
01731                         for (j=(exitLoopIndex+1)%loop.size(); j!=enterLoopIndex; j=(j+1)%loop.size())
01732                                 forwardLength += _Chains[surface._Chains[loop[j]].Chain].getLength();
01733                         forward = (forwardLength <= loop.Length-forwardLength);
01734                 }
01735                 else
01736                 {
01737                         forward = !thisChainForward ^ (_OrderedChains[intersections[i].OChain].getIndexInParent() < _OrderedChains[intersections[i+1].OChain].getIndexInParent());
01738                 }
01739 
01740                 path.push_back(CVector2s(A.Estimation+intersections[i].Position*(B.Estimation-A.Estimation)));
01741 
01742                 while (true)
01743                 {
01744                         sint    from = (thisOChainId == intersections[i].OChain) ? intersections[i].Edge : -1,
01745                                         to = (thisOChainId == intersections[i+1].OChain) ? intersections[i+1].Edge : -1;
01746                         bool    oforward = thisChainForward ^ forward ^ _OrderedChains[thisOChainId].isForward();
01747 
01748                         if (from != -1 && to != -1)
01749                                 oforward = (intersections[i].Edge < intersections[i+1].Edge);
01750 
01751                         _OrderedChains[thisOChainId].traverse(from, to, oforward, path);
01752 
01753                         if (thisOChainId == intersections[i+1].OChain)
01754                                 break;
01755 
01756                         thisOChainIndex = (thisChainForward ^ forward) ? thisOChainIndex-1 : thisOChainIndex+1;
01757 
01758                         if (thisOChainIndex < 0 || thisOChainIndex >= (sint)_Chains[thisChainId]._SubChains.size())
01759                         {
01760                                 if (forward)
01761                                 {
01762                                         loopIndex++;
01763                                         if (loopIndex == (sint)loop.size())
01764                                                 loopIndex = 0;
01765                                 }
01766                                 else
01767                                 {
01768                                         loopIndex--;
01769                                         if (loopIndex < 0)
01770                                                 loopIndex = loop.size()-1;
01771                                 }
01772 
01773                                 thisChainId = surface._Chains[loop[loopIndex]].Chain;
01774                                 thisChainForward = (_Chains[thisChainId].getLeft() == surfaceId);
01775                                 thisOChainIndex = (thisChainForward && forward || !thisChainForward && !forward) ? 
01776                                         0 : _Chains[thisChainId]._SubChains.size()-1;
01777                         }
01778 
01779                         thisOChainId = _Chains[thisChainId]._SubChains[thisOChainIndex];
01780                 }
01781 
01782                 path.push_back(CVector2s(A.Estimation+intersections[i+1].Position*(B.Estimation-A.Estimation)));
01783                 i += 2;
01784         }
01785 
01786         path.push_back(CVector2s(B.Estimation));
01787 }

void NLPACS::CLocalRetriever::flushFullOrderedChains  )  [inline]
 

Adds a chain to the local retriever, using the vertices of the chain, the left and right surfaces id and the edge on which the chain is stuck

Definition at line 529 of file local_retriever.h.

References _FullOrderedChains.

00529 { _FullOrderedChains.clear(); }

void NLPACS::CLocalRetriever::forceBorderChainId uint32  chainId,
uint32  borderId
[inline]
 

Definition at line 602 of file local_retriever.h.

References _Chains, nlwarning, and uint32.

00603         {
00604                 if (chainId >= _Chains.size())
00605                 {
00606                         nlwarning("forceBorderChainId(): couldn't force border id %d for chain %d, doesn't exist", borderId, chainId);
00607                         return;
00608                 }
00609 
00610                 _Chains[chainId].setBorderChainIndex(borderId);
00611         }

void NLPACS::CLocalRetriever::forceLoaded bool  state  )  [inline]
 

Force Loaded State.

Definition at line 425 of file local_retriever.h.

References _Loaded.

00425 { _Loaded= state; }

const NLMISC::CAABBox& NLPACS::CLocalRetriever::getBBox  )  const [inline]
 

Returns the bbox.

Definition at line 407 of file local_retriever.h.

Referenced by NLPACS::CRetrieverInstance::make().

00407 { return _BBox; }

uint16 NLPACS::CLocalRetriever::getBorderChain uint  n  )  const [inline]
 

Returns the id of the nth chain on the edges of the retriever.

Definition at line 396 of file local_retriever.h.

References _BorderChains, uint, and uint16.

00396 { return _BorderChains[n]; }

const std::vector<uint16>& NLPACS::CLocalRetriever::getBorderChains  )  const [inline]
 

Returns the ids of the chains on the edges of the retriever.

Definition at line 394 of file local_retriever.h.

References _BorderChains.

Referenced by NLPACS::CGlobalRetriever::check(), NLPACS::CRetrieverInstance::init(), NLPACS::CRetrieverInstance::link(), and NLPACS::linkExteriorToInterior().

00394 { return _BorderChains; }

const CChain& NLPACS::CLocalRetriever::getChain uint  n  )  const [inline]
 

retruns the nth chain.

Definition at line 391 of file local_retriever.h.

References _Chains, and uint.

Referenced by NLPACS::CGlobalRetriever::check(), NLPACS::CLocalRetriever::CIterator::end(), NLPACS::CGlobalRetriever::findAStarPath(), NLPACS::CGlobalRetriever::findCollisionChains(), NLPACS::CGlobalRetriever::findPath(), NLPACS::CLocalRetriever::CIterator::get3d(), NLPACS::CGlobalRetriever::getBorders(), NLPACS::CLocalRetriever::CIterator::operator *(), NLPACS::CLocalRetriever::CIterator::operator++(), and NLPACS::CLocalRetriever::CIterator::setupIndex().

00391 { return _Chains[n]; }

CChainQuad& NLPACS::CLocalRetriever::getChainQuad  )  [inline]
 

Returns the chain quad.

Definition at line 500 of file local_retriever.h.

References _ChainQuad.

Referenced by NLPACS::CGlobalRetriever::getBorders().

00500 { return _ChainQuad; }

const std::vector<CChain>& NLPACS::CLocalRetriever::getChains  )  const [inline]
 

Returns the chains.

Definition at line 389 of file local_retriever.h.

References _Chains.

Referenced by NLPACS::CGlobalRetriever::check(), NLPACS::CRetrieverInstance::link(), NLPACS::linkExteriorToInterior(), and testCollision().

00389 { return _Chains; }

const CExteriorMesh& NLPACS::CLocalRetriever::getExteriorMesh  )  const [inline]
 

Returns the exterior mesh of the retriever.

Definition at line 410 of file local_retriever.h.

References _ExteriorMesh.

Referenced by NLPACS::CRetrieverInstance::initEdgeQuad(), NLPACS::CRetrieverInstance::linkEdgeQuad(), and NLPACS::linkExteriorToInterior().

00410 { return _ExteriorMesh; }

const COrderedChain3f& NLPACS::CLocalRetriever::getFullOrderedChain uint  n  )  const [inline]
 

Returns the nth full ordered chain.

Definition at line 386 of file local_retriever.h.

References _FullOrderedChains, and uint.

Referenced by NLPACS::CLocalRetriever::CIterator::get3d(), and NLPACS::CGlobalRetriever::getBorders().

00386 { return _FullOrderedChains[n]; }

const std::vector<COrderedChain3f>& NLPACS::CLocalRetriever::getFullOrderedChains  )  const [inline]
 

Returns the full ordered chains.

Definition at line 384 of file local_retriever.h.

References _FullOrderedChains.

Referenced by NLPACS::CGlobalRetriever::getBorders(), and NLPACS::linkExteriorToInterior().

00384 { return _FullOrderedChains; }

float NLPACS::CLocalRetriever::getHeight const ULocalPosition position  )  const
 

Definition at line 1479 of file local_retriever.cpp.

References _FaceGrid, _InteriorFaces, _InteriorVertices, _Loaded, _Surfaces, NLPACS::ULocalPosition::Estimation, NLPACS::IQuadNode::getMaxHeight(), NLPACS::IQuadNode::getMinHeight(), NLMISC::CPlane::intersect(), NLMISC::CPlane::make(), NLPACS::CFaceGrid::select(), sint8, NLPACS::ULocalPosition::Surface, NLPACS::CLocalRetriever::CInteriorFace::Surface, uint32, v, NLPACS::CLocalRetriever::CInteriorFace::Verts, NLMISC::CVector::x, NLMISC::CVector::y, and NLMISC::CVector::z.

Referenced by NLPACS::CGlobalRetriever::getMeanHeight(), and NLPACS::CRetrieverInstance::snap().

01480 {
01481         if (!_Loaded)
01482                 return 0.0f;
01483 
01484         if (_Type == Interior)
01485         {
01486                 // first preselect faces around the (x, y) position (CQuadGrid ?)
01487                 vector<uint32>  selection;
01488                 _FaceGrid.select(position.Estimation, selection);
01489 
01490                 // from the preselect faces, look for the only face that belongs to the surface
01491                 // and that contains the position
01492                 CVector pos = position.Estimation;
01493                 CVector posh = pos+CVector(0.0f, 0.0f, 1.0f);
01494                 float   bestDist = 1.0e10f;
01495                 CVector best;
01496                 vector<uint32>::iterator        it;
01497                 for (it=selection.begin(); it!=selection.end(); ++it)
01498                 {
01499                         const CInteriorFace     &f = _InteriorFaces[*it];
01500                         if (f.Surface == (uint32)position.Surface)
01501                         {
01502                                 CVector v[3];
01503                                 v[0] = _InteriorVertices[f.Verts[0]];
01504                                 v[1] = _InteriorVertices[f.Verts[1]];
01505                                 v[2] = _InteriorVertices[f.Verts[2]];
01506 
01507                                 float           a,b,c;          // 2D cartesian coefficients of line in plane X/Y.
01508                                 // Line p0-p1.
01509                                 a = -(v[1].y-v[0].y);
01510                                 b =  (v[1].x-v[0].x);
01511                                 c = -(v[0].x*a + v[0].y*b);
01512                                 if (a*pos.x + b*pos.y + c < 0)  continue;
01513                                 // Line p1-p2.
01514                                 a = -(v[2].y-v[1].y);
01515                                 b =  (v[2].x-v[1].x);
01516                                 c = -(v[1].x*a + v[1].y*b);
01517                                 if (a*pos.x + b*pos.y + c < 0)  continue;
01518                                 //  Line p2-p0.
01519                                 a = -(v[0].y-v[2].y);
01520                                 b =  (v[0].x-v[2].x);
01521                                 c = -(v[2].x*a + v[2].y*b);
01522                                 if (a*pos.x + b*pos.y + c < 0)  continue;
01523 
01524                                 CPlane  p;
01525                                 p.make(v[0], v[1], v[2]);
01526 
01527                                 CVector i = p.intersect(pos, posh);
01528 
01529                                 float   d = (float)fabs(pos.z-i.z);
01530 
01531                                 if (d < bestDist)
01532                                 {
01533                                         bestDist = d;
01534                                         best = i;
01535                                 }
01536                         }
01537                 }
01538 
01539                 // and computes the real position on this face
01540                 return (bestDist < 200.0f) ? best.z : position.Estimation.z;
01541         }
01542         else
01543         {
01544                 if (_Surfaces[position.Surface].getQuadTree().getRoot() != NULL)
01545                 {
01546                         // find quad leaf.
01547                         const CQuadLeaf *leaf = _Surfaces[position.Surface].getQuadTree().getLeaf(position.Estimation);
01548 
01549                         // if there is no acceptable leaf, just give up
01550                         if (leaf == NULL)
01551                         {
01552                                 //nlinfo("COL: quadtree: don't find the quadLeaf!");
01553                                 return position.Estimation.z;
01554                         }
01555                         else
01556                         {
01557                                 // else return mean height.
01558                                 float   meanHeight = (leaf->getMinHeight()+leaf->getMaxHeight())*0.5f;
01559                                 return meanHeight;
01560                         }
01561                 }
01562                 else
01563                 {
01564                         sint8   qh = _Surfaces[position.Surface].getQuantHeight();
01565                         return qh*2.0f + 1.0f;
01566                 }
01567         }
01568 }

const std::string& NLPACS::CLocalRetriever::getIdentifier  )  const [inline]
 

Returns the identifier of the retriever.

Definition at line 419 of file local_retriever.h.

Referenced by NLPACS::CGlobalRetriever::getIdentifier(), and NLPACS::CGlobalRetriever::retrievePosition().

00419 { return _Id; }

std::vector<CInteriorFace>& NLPACS::CLocalRetriever::getInteriorFaces  )  [inline]
 

Returns the interior faces.

Definition at line 493 of file local_retriever.h.

References _InteriorFaces.

00493 { return _InteriorFaces; }

const std::vector<CInteriorFace>& NLPACS::CLocalRetriever::getInteriorFaces  )  const [inline]
 

Returns the interior faces.

Definition at line 416 of file local_retriever.h.

References _InteriorFaces.

Referenced by NLPACS::buildSnapping().

00416 { return _InteriorFaces; }

std::vector<NLMISC::CVector>& NLPACS::CLocalRetriever::getInteriorVertices  )  [inline]
 

Returns the interior vertices.

Definition at line 490 of file local_retriever.h.

References _InteriorVertices.

00490 { return _InteriorVertices; }

const std::vector<NLMISC::CVector>& NLPACS::CLocalRetriever::getInteriorVertices  )  const [inline]
 

Returns the interior vertices.

Definition at line 413 of file local_retriever.h.

References _InteriorVertices.

Referenced by NLPACS::buildSnapping().

00413 { return _InteriorVertices; }

uint32 NLPACS::CLocalRetriever::getNextChain uint32  chain,
sint32  surface
const
 

Definition at line 182 of file local_retriever.cpp.

References NLPACS::CRetrievableSurface::_Chains, _Chains, NLPACS::CRetrievableSurface::_Loops, _Surfaces, sint32, uint, and uint32.

00183 {
00184         uint                                                            loop;
00185         uint                                                            loopIndex;
00186 
00187         if (_Chains[chain].getLeft() == surface)
00188         {
00189                 loop = _Chains[chain]._LeftLoop;
00190                 loopIndex = _Chains[chain]._LeftLoopIndex;
00191         }
00192         else
00193         {
00194                 loop = _Chains[chain]._RightLoop;
00195                 loopIndex = _Chains[chain]._RightLoopIndex;
00196         }
00197 
00198         const CRetrievableSurface                       &surf = _Surfaces[surface];
00199         const CRetrievableSurface::TLoop        &sLoop = surf._Loops[loop];
00200         return surf._Chains[sLoop[(loopIndex+1)%sLoop.size()]].Chain;
00201 }

const COrderedChain& NLPACS::CLocalRetriever::getOrderedChain uint  n  )  const [inline]
 

Returns the nth ordered chain.

Definition at line 381 of file local_retriever.h.

References _OrderedChains, and uint.

Referenced by NLPACS::CGlobalRetriever::check(), NLPACS::computeRetriever(), NLPACS::CGlobalRetriever::findPath(), NLPACS::CGlobalRetriever::getBorders(), NLPACS::CLocalRetriever::CIterator::operator *(), and NLPACS::CLocalRetriever::CIterator::setupIndex().

00381 { return _OrderedChains[n]; }

const std::vector<COrderedChain>& NLPACS::CLocalRetriever::getOrderedChains  )  const [inline]
 

Returns the ordered chains.

Definition at line 379 of file local_retriever.h.

References _OrderedChains.

Referenced by NLPACS::CGlobalRetriever::check(), NLPACS::computeRetriever(), and testCollision().

00379 { return _OrderedChains; }

uint32 NLPACS::CLocalRetriever::getPreviousChain uint32  chain,
sint32  surface
const
 

Definition at line 161 of file local_retriever.cpp.

References NLPACS::CRetrievableSurface::_Chains, _Chains, NLPACS::CRetrievableSurface::_Loops, _Surfaces, sint32, uint, and uint32.

00162 {
00163         uint                                                            loop;
00164         uint                                                            loopIndex;
00165 
00166         if (_Chains[chain].getLeft() == surface)
00167         {
00168                 loop = _Chains[chain]._LeftLoop;
00169                 loopIndex = _Chains[chain]._LeftLoopIndex;
00170         }
00171         else
00172         {
00173                 loop = _Chains[chain]._RightLoop;
00174                 loopIndex = _Chains[chain]._RightLoopIndex;
00175         }
00176 
00177         const CRetrievableSurface                       &surf = _Surfaces[surface];
00178         const CRetrievableSurface::TLoop        &sLoop = surf._Loops[loop];
00179         return surf._Chains[sLoop[(loopIndex+sLoop.size()-1)%sLoop.size()]].Chain;
00180 }

const CVector & NLPACS::CLocalRetriever::getStartVector uint32  chain,
sint32  surface
const
 

Definition at line 101 of file local_retriever.cpp.

References _Chains, _FullOrderedChains, NLPACS::COrderedChain3f::getVertices(), NLPACS::COrderedChain3f::isForward(), sint32, and uint32.

00102 {
00103         bool                                    onLeft = _Chains[chain].getLeft() == surface;
00104         const COrderedChain3f   &ochain = onLeft ? _FullOrderedChains[_Chains[chain].getSubChains().front()] :
00105                                                                                            _FullOrderedChains[_Chains[chain].getSubChains().back()];
00106 
00107         if (ochain.isForward() && onLeft || !ochain.isForward() && !onLeft)
00108                 return ochain.getVertices().front();
00109         else
00110                 return ochain.getVertices().back();
00111 }

const CVector & NLPACS::CLocalRetriever::getStartVector uint32  chain  )  const
 

Definition at line 86 of file local_retriever.cpp.

References _Chains, _FullOrderedChains, NLPACS::COrderedChain3f::getVertices(), NLPACS::COrderedChain3f::isForward(), and uint32.

Referenced by computeLoopsAndTips(), NLPACS::CRetrieverInstance::link(), and NLPACS::linkExteriorToInterior().

00087 {
00088         const COrderedChain3f   &ochain = _FullOrderedChains[_Chains[chain].getSubChains().front()];
00089         return (ochain.isForward()) ? ochain.getVertices().front() : ochain.getVertices().back();
00090 }

const CVector & NLPACS::CLocalRetriever::getStopVector uint32  chain,
sint32  surface
const
 

Definition at line 113 of file local_retriever.cpp.

References _Chains, _FullOrderedChains, NLPACS::COrderedChain3f::getVertices(), NLPACS::COrderedChain3f::isForward(), sint32, and uint32.

00114 {
00115         bool                                    onLeft = _Chains[chain].getLeft() == surface;
00116         const COrderedChain3f   &ochain = onLeft ? _FullOrderedChains[_Chains[chain].getSubChains().back()] :
00117                                                                                            _FullOrderedChains[_Chains[chain].getSubChains().front()];
00118 
00119         if (ochain.isForward() && onLeft || !ochain.isForward() && !onLeft)
00120                 return ochain.getVertices().back();
00121         else
00122                 return ochain.getVertices().front();
00123 }

const CVector & NLPACS::CLocalRetriever::getStopVector uint32  chain  )  const
 

Definition at line 92 of file local_retriever.cpp.

References _Chains, _FullOrderedChains, NLPACS::COrderedChain3f::getVertices(), NLPACS::COrderedChain3f::isForward(), and uint32.

Referenced by computeLoopsAndTips(), NLPACS::CRetrieverInstance::link(), and NLPACS::linkExteriorToInterior().

00093 {
00094         const COrderedChain3f   &ochain = _FullOrderedChains[_Chains[chain].getSubChains().back()];
00095         return (ochain.isForward()) ? ochain.getVertices().back() : ochain.getVertices().front();
00096 }

const CRetrievableSurface& NLPACS::CLocalRetriever::getSurface uint  n  )  const [inline]
 

Returns the nth surface.

Definition at line 401 of file local_retriever.h.

References _Surfaces, and uint.

Referenced by NLPACS::CGlobalRetriever::findAStarPath(), NLPACS::CGlobalRetriever::getBorders(), NLPACS::CGlobalRetriever::getMaterial(), NLPACS::CGlobalRetriever::getSurfaceById(), NLPACS::CGlobalRetriever::isWaterPosition(), NLPACS::CRetrieverInstance::retrievePosition(), NLPACS::CGlobalRetriever::testCollisionWithCollisionChains(), and NLPACS::CGlobalRetriever::testMovementWithCollisionChains().

00401 { return _Surfaces[n]; }

const std::vector<CRetrievableSurface>& NLPACS::CLocalRetriever::getSurfaces  )  const [inline]
 

Returns the surfaces.

Definition at line 399 of file local_retriever.h.

References _Surfaces.

Referenced by NLPACS::CGlobalRetriever::check(), NLPACS::CGlobalRetriever::getMaterial(), NLPACS::CGlobalRetriever::getSurfaceById(), NLPACS::CGlobalRetriever::initRetrieveTable(), NLPACS::CGlobalRetriever::makeInstance(), and NLPACS::CGlobalRetriever::testCollisionWithCollisionChains().

00399 { return _Surfaces; }

EType NLPACS::CLocalRetriever::getType void   )  const [inline]
 

Returns the type of the retriever.

Definition at line 404 of file local_retriever.h.

References EType.

Referenced by NLPACS::CRetrieverInstance::init(), NLPACS::CRetrieverInstance::initEdgeQuad(), NLPACS::CGlobalRetriever::makeInstance(), NLPACS::CGlobalRetriever::makeLinks(), and NLPACS::CGlobalRetriever::retrievePosition().

00404 { return _Type; }

void NLPACS::CLocalRetriever::initFaceGrid  ) 
 

Inits the face grid.

Definition at line 1393 of file local_retriever.cpp.

References _FaceGrid, _InteriorFaces, _InteriorVertices, NLPACS::CFaceGrid::create(), NLMISC::CAABBox::extend(), NLMISC::CAABBox::getMax(), NLMISC::CAABBox::getMin(), NLPACS::CFaceGrid::CFaceGridBuild::init(), NLPACS::CFaceGrid::CFaceGridBuild::insert(), NLMISC::CAABBox::setCenter(), uint, and NLPACS::CLocalRetriever::CInteriorFace::Verts.

Referenced by NLPACS::buildSnapping().

01394 {
01395         CFaceGrid::CFaceGridBuild       fgb;
01396         fgb.init(64, 4.0f);
01397 
01398         uint    i;
01399         for (i=0; i<_InteriorFaces.size(); ++i)
01400         {
01401                 CAABBox                 box;
01402                 CInteriorFace   &f = _InteriorFaces[i];
01403                 box.setCenter(_InteriorVertices[f.Verts[0]]);
01404                 box.extend(_InteriorVertices[f.Verts[1]]);
01405                 box.extend(_InteriorVertices[f.Verts[2]]);
01406 
01407                 fgb.insert(box.getMin(), box.getMax(), i);
01408         }
01409 
01410         _FaceGrid.create(fgb);
01411 }

bool NLPACS::CLocalRetriever::insurePosition ULocalPosition local  )  const
 

Assures a position is really inside a surface (and independent from any accuracy issue) and returns true if the position was moved.

Definition at line 960 of file local_retriever.cpp.

References _Chains, _Loaded, _OrderedChains, _Surfaces, NLPACS::ULocalPosition::Estimation, NLPACS::CRetrievableSurface::getChain(), NLPACS::CRetrievableSurface::getChains(), NLPACS::CChain::getLeft(), NLPACS::CChain::getSubChain(), NLPACS::CChain::getSubChains(), NLPACS::COrderedChain::getVertices(), InsurePositionThreshold, NLPACS::COrderedChain::isForward(), nlassert, nlwarning, sint, sint32, NLPACS::CRetrieverInstance::snapVector(), NLMISC::CVector2f::sqrnorm(), NLPACS::ULocalPosition::Surface, uint, NLMISC::CVector::x, NLMISC::CVector2f::x, NLMISC::CVector::y, and NLMISC::CVector2f::y.

Referenced by NLPACS::CGlobalRetriever::insurePosition(), and NLPACS::CGlobalRetriever::retrievePosition().

00961 {
00962         if (!_Loaded)
00963                 return false;
00964 
00965         if (local.Surface < 0 || local.Surface >= (sint)_Surfaces.size())
00966         {
00967                 nlwarning("PACS: can't insure position to inexistant surface %d", local.Surface);
00968                 return false;
00969         }
00970 
00971         // the surface
00972         const NLPACS::CRetrievableSurface       &surface = _Surfaces[local.Surface];
00973 
00974         uint            i, j, k;
00975         CVector2f       M = CVector2f(local.Estimation);
00976         bool            moved = false;
00977 
00978         // for each chain and each subchain of the surface,
00979         // check if point is located on the good side of the border (and far enough to avoid accuracy issues)
00980         for (i=0; i<surface.getChains().size(); ++i)
00981         {
00982                 uint                                    ichain = surface.getChain(i).Chain;
00983                 const NLPACS::CChain    &chain = _Chains[ichain];
00984 
00985                 for (j=0; j<chain.getSubChains().size(); ++j)
00986                 {
00987                         uint                                            iochain = chain.getSubChain(j);
00988                         const NLPACS::COrderedChain     &ochain = _OrderedChains[iochain];
00989 
00990                         uint                                            isAtLeft = ((chain.getLeft() == local.Surface) ? 1 : 0);
00991                         uint                                            isForward = (ochain.isForward() ? 1 : 0);
00992                         bool                                            shouldBeUpper = !((isAtLeft ^ isForward) != 0); // shouldBeAtLeft for vertical segment
00993 
00994                         for (k=0; (sint)k<(sint)(ochain.getVertices().size()-1); ++k)
00995                         {
00996                                 CVector2f       A = ochain[k].unpack();
00997                                 CVector2f       B = ochain[k+1].unpack();
00998                                 CVector2f       AB = B-A;
00999 
01000                                 float           lambda = ((M-A)*AB)/AB.sqrnorm();
01001 
01002                                 if (lambda<0.0f || lambda>1.0f)
01003                                         continue;
01004 
01005                                 CVector2f       n = (shouldBeUpper ? CVector2f(-AB.y, AB.x) : CVector2f(AB.y, -AB.x)).normed();
01006                                 float           d = (M-A)*n;
01007 
01008                                 // if point is too close of the border or on the wrong side
01009                                 // move it far enough
01010                                 if (d < InsurePositionThreshold && d > -InsurePositionThreshold)
01011                                 {
01012                                         M += (InsurePositionThreshold*1.1f-d)*n;
01013                                         moved = true;
01014                                 }
01015                         }
01016                 }
01017         }
01018 
01019         NLPACS::CRetrieverInstance::snapVector(M);
01020 
01021         local.Estimation.x = M.x;
01022         local.Estimation.y = M.y;
01023 
01024         {
01025                 float   fx1024 = local.Estimation.x * 1024.0f;
01026                 float   fy1024 = local.Estimation.x * 1024.0f;
01027                 sint32  ix1024 = (sint32)floor(fx1024);
01028                 sint32  iy1024 = (sint32)floor(fy1024);
01029 
01030                 nlassert ((float)ix1024 == fx1024);
01031                 nlassert ((float)iy1024 == fy1024);
01032         }
01033 
01034         return moved;
01035 }

bool NLPACS::CLocalRetriever::isLoaded  )  const [inline]
 

Is loaded ?

Definition at line 422 of file local_retriever.h.

References _Loaded.

Referenced by distanceToBorder(), NLPACS::CGlobalRetriever::findCollisionChains(), NLPACS::CGlobalRetriever::getBorders(), NLPACS::CGlobalRetriever::getMaterial(), NLPACS::CGlobalRetriever::getMeanHeight(), NLPACS::CGlobalRetriever::getSurfaceById(), NLPACS::CRetrieverInstance::init(), NLPACS::CGlobalRetriever::isWaterPosition(), NLPACS::CGlobalRetriever::retrievePosition(), NLPACS::CGlobalRetriever::testCollisionWithCollisionChains(), and NLPACS::CGlobalRetriever::testMovementWithCollisionChains().

00422 { return _Loaded; }

void NLPACS::CLocalRetriever::replaceChain uint32  chainId,
const std::vector< CChainReplacement > &  replacement
 

Definition at line 1973 of file local_retriever.cpp.

References _BorderChains, _Chains, _FullOrderedChains, _OrderedChains, NLPACS::CChain::_StartTip, NLPACS::CChain::_StopTip, _Surfaces, border, NLPACS::CRetrievableSurface::CSurfaceLink::Chain, FreeOChains, NLPACS::CChain::make(), nlassert, nlerror, nlwarning, sint, sint32, NLPACS::CRetrievableSurface::CSurfaceLink::Surface, uint, uint16, and uint32.

01974 {
01975         // free subchains
01976         uint            i, j;
01977         for (i=0; i<_Chains[chainId]._SubChains.size(); ++i)
01978         {
01979                 FreeOChains.push_back(_Chains[chainId]._SubChains[i]);
01980                 _OrderedChains[_Chains[chainId]._SubChains[i]] = COrderedChain();
01981                 _FullOrderedChains[_Chains[chainId]._SubChains[i]] = COrderedChain3f();
01982         }
01983 
01984         // create new chains in replacement of this chain
01985 
01986         for (i=0; i<replacement.size(); ++i)
01987         {
01988                 vector<CVector> vertices = replacement[i].Vertices;
01989                 sint                    left = replacement[i].Left;
01990                 sint                    right = replacement[i].Right;
01991 
01992                 if (CChain::isBorderChainId(right))
01993                 {
01994                         // check border already exists for this particular chain
01995                         sint32  border = CChain::convertBorderChainId(right);
01996 
01997                         if (border < (sint)_BorderChains.size() && (chainId != _BorderChains[border] || chainId != replacement[i].Chain))
01998                         {
01999                                 nlwarning("replaceChain(): replacement of a border is forced whereas this border is already used and not replaced!");
02000                         }
02001 
02002                         if (border >= (sint)_BorderChains.size())
02003                         {
02004                                 if (border > (sint)_BorderChains.size())
02005                                 {
02006                                         nlwarning("replaceChain(): _BorderChains size increased of more than 1 step, holes may result!");
02007                                 }
02008 
02009                                 _BorderChains.resize(border+1, 0xffff);
02010                         }
02011 
02012                         _BorderChains[border] = replacement[i].Chain;
02013                 }
02014 
02015                 nlassert(vertices.size() >= 2);
02016 
02017                 // Remove doubled vertices due to CVector2s snapping
02018                 vector<CVector2s>       converts;
02019 
02020                 for (j=0; j<vertices.size(); ++j)
02021                         converts.push_back(CVector2s(vertices[j]));
02022 
02023                 vector<CVector2s>::iterator     next2s = converts.begin(), it2s, prev2s;
02024                 prev2s = next2s; ++next2s;
02025                 it2s = next2s; ++next2s;
02026 
02027                 vector<CVector>::iterator       it3f = vertices.begin();
02028                 CVector                                         prev3f = *it3f;
02029                 ++it3f;
02030 
02031 
02032                 for (; it2s != converts.end() && next2s != converts.end(); )
02033                 {
02034                         // if the next point is equal to the previous
02035                         if (*it2s == *prev2s || *it2s == *next2s)
02036                         {
02037                                 // then remove the next point
02038                                 it2s = converts.erase(it2s);
02039                                 it3f = vertices.erase(it3f);
02040 
02041                                 prev2s = it2s;
02042                                 --prev2s;
02043                                 next2s = it2s;
02044                                 ++next2s;
02045                         }
02046                         else
02047                         {
02048                                 // else remember the next point, and step to the next...
02049                                 ++prev2s;
02050                                 ++it2s;
02051                                 ++next2s;
02052                                 ++it3f;
02053                                 prev3f = *it3f;
02054                         }
02055                 }
02056 
02057                 nlassert(vertices.size() >= 2);
02058 
02059                 sint32          newId = replacement[i].Chain;
02060                 if (newId >= (sint)_Chains.size())
02061                         _Chains.resize(newId+1);
02062 
02063                 //CChain                &nchain = _Chains[newId];
02064 
02065                 if (left>(sint)_Surfaces.size())
02066                         nlerror ("left surface id MUST be id<%d (id=%d)", _Surfaces.size(), left);
02067                 if (right>(sint)_Surfaces.size())
02068                         nlerror ("right surface id MUST be id<%d (id=%d)", _Surfaces.size(), right);
02069 
02070                 // checks if we can build the chain.
02071                 if (newId > 65535)
02072                         nlerror("in NLPACS::CLocalRetriever::addChain(): reached the maximum number of chains");
02073 
02074                 //CRetrievableSurface   *leftSurface = (left>=0) ? &(_Surfaces[left]) : NULL;
02075                 //CRetrievableSurface   *rightSurface = (right>=0) ? &(_Surfaces[right]) : NULL;
02076 
02077                 CChain          &chain = _Chains[newId];
02078 
02079                 chain._StartTip = 0xffff;
02080                 chain._StopTip = 0xffff;
02081 
02082                 // make the chain and its subchains.
02083                 chain.make(vertices, left, right, _OrderedChains, (uint16)newId, _FullOrderedChains, FreeOChains);
02084         }
02085 
02086         for (i=0; i<_Surfaces.size(); ++i)
02087         {
02088                 // remove old chain and replace by new chains in surface links
02089                 for (j=0; j<_Surfaces[i]._Chains.size(); ++j)
02090                 {
02091                         if (_Surfaces[i]._Chains[j].Chain == (sint)chainId)
02092                         {
02093                                 _Surfaces[i]._Chains.erase(_Surfaces[i]._Chains.begin()+j);
02094 
02095                                 uint    k;
02096                                 for (k=0; k<replacement.size(); ++k)
02097                                 {
02098                                         CRetrievableSurface::CSurfaceLink       link;
02099 
02100                                         link.Chain = replacement[k].Chain;
02101                                         link.Surface = (replacement[k].Left == (sint)i ? replacement[k].Right : replacement[k].Left);
02102                                         _Surfaces[i]._Chains.push_back(link);
02103                                 }
02104 
02105                                 break;
02106                         }
02107                 }
02108 
02109                 // remove old chain and replace by new chains in surface loops
02110                 for (j=0; j<_Surfaces[i]._Loops.size(); ++j)
02111                 {
02112                         uint    k;
02113 
02114                         for (k=0; k<_Surfaces[i]._Loops[j].size(); ++k)
02115                         {
02116                                 if (_Surfaces[i]._Loops[j][k] == chainId)
02117                                 {
02118                                         _Surfaces[i]._Loops[j].erase(_Surfaces[i]._Loops[j].begin()+k);
02119                                         uint    m;
02120 
02121                                         for (m=0; m<replacement.size(); ++m)
02122                                                 _Surfaces[i]._Loops[j].insert(_Surfaces[i]._Loops[j].begin()+k+m, replacement[m].Chain);
02123 
02124                                         break;
02125                                 }
02126                         }
02127                 }
02128         }
02129 }

void NLPACS::CLocalRetriever::retrieveAccuratePosition CVector2s  estimated,
CCollisionSurfaceTemp cst,
bool &  onBorder
const
 

Retrieves a position inside the retriever (from the local position), returns true if the position is close to a border.

Definition at line 1238 of file local_retriever.cpp.

References _ChainQuad, _Chains, _Loaded, _OrderedChains, NLPACS::CCollisionSurfaceTemp::decSurface(), NLPACS::CCollisionSurfaceTemp::EdgeChainEntries, NLPACS::COrderedChain::getMax(), NLMISC::CAABBox::getMax(), NLPACS::COrderedChain::getMin(), NLMISC::CAABBox::getMin(), NLPACS::COrderedChain::getParentId(), NLPACS::COrderedChain::getVertices(), NLPACS::CCollisionSurfaceTemp::incSurface(), NLPACS::COrderedChain::isForward(), min, NLPACS::CCollisionSurfaceTemp::PossibleSurfaces, NLPACS::CChainQuad::selectEdges(), NLMISC::CAABBox::setMinMax(), sint32, uint, NLPACS::CVector2s::unpack3f(), NLPACS::CVector2s::x, NLMISC::CVector::x, NLPACS::CVector2s::y, and NLMISC::CVector::y.

01239 {
01240         if (!_Loaded)
01241                 return;
01242 
01243         CAABBox                 box;
01244         CVector                 estimated = estim.unpack3f();
01245         const double    BorderThreshold = 2.0e-2f;
01246         box.setMinMax(CVector(estimated.x-(float)BorderThreshold, _BBox.getMin().y, 0.0f), 
01247                                   CVector(estimated.x+(float)BorderThreshold, _BBox.getMax().y, 0.0f));
01248         uint                    numEdges = _ChainQuad.selectEdges(box, cst);
01249 
01250         uint                    ochain, i;
01251 
01252         onBorder = false;
01253 
01254         cst.PossibleSurfaces.clear();
01255 
01256         // WARNING!!
01257         // cst.SurfaceLUT is assumed to be 0 filled !!
01258 
01259         //nldebug("estim=(%d,%d)", estim.x, estim.y);
01260 
01261         // for each ordered chain, checks if the estimated position is between the min and max.
01262         for (i=0; i<numEdges; ++i)
01263         {
01264                 ochain = cst.EdgeChainEntries[i].OChainId;
01265 
01266                 const COrderedChain     &sub = _OrderedChains[ochain];
01267                 const CVector2s &min = sub.getMin(),
01268                                                 &max = sub.getMax();
01269 
01270                 // checks the position against the min and max of the chain
01271                 if (estim.x < min.x || estim.x > max.x)
01272                         continue;
01273 
01274                 bool    isUpper;
01275                 //bool  isOnBorder = false;
01276 
01277                 sint32  left = _Chains[sub.getParentId()].getLeft(),
01278                                 right = _Chains[sub.getParentId()].getRight();
01279 
01280                 if (estim.y < min.y)
01281                 {
01282                         if (estim.x == max.x)
01283                                 continue;
01284                         isUpper = false;
01285                 }
01286                 else if (estim.y > max.y)
01287                 {
01288                         if (estim.x == max.x)
01289                                 continue;
01290                         isUpper = true;
01291                 }
01292                 else
01293                 {
01294                         const vector<CVector2s> &vertices = sub.getVertices();
01295                         uint                                    start = 0, stop = vertices.size()-1;
01296 
01297                         // then finds the smallest segment of the chain that includes the estimated position.
01298                         while (stop-start > 1)
01299                         {
01300                                 uint    mid = (start+stop)/2;
01301 
01302                                 if (vertices[mid].x > estim.x)
01303                                         stop = mid;
01304                                 else
01305                                         start = mid;
01306                         }
01307 
01308                         // if a vertical edge
01309                         if (vertices[start].x == vertices[stop].x)
01310                         {
01311                                 // look for maximal bounds
01312                                 while (start > 0 && vertices[start].x == vertices[start-1].x)
01313                                         --start;
01314 
01315                                 while (stop < vertices.size()-1 && vertices[stop].x == vertices[stop+1].x)
01316                                         ++stop;
01317 
01318                                 // if upper or lower the bounds, do nothing
01319                                 if (estim.y > vertices[start].y && estim.y > vertices[stop].y ||
01320                                         estim.y < vertices[start].y && estim.y < vertices[stop].y)
01321                                         continue;
01322 
01323                                 onBorder = true;
01324                                 continue;
01325                         }
01326                         else if (vertices[stop].x == estim.x)
01327                         {
01328                                 // if (yes)
01329                                 continue;
01330                         }
01331 
01332                         // and then checks if the estimated position is up or down the chain.
01333 
01334                         // first trivial case (up both tips)
01335                         if (estim.y > vertices[start].y && estim.y > vertices[stop].y)
01336                         {
01337                                 isUpper = true;
01338                         }
01339                         // second trivial case (down both tips)
01340                         else if (estim.y < vertices[start].y && estim.y < vertices[stop].y)
01341                         {
01342                                 isUpper = false;
01343                         }
01344                         // full test...
01345                         else
01346                         {
01347                                 const CVector2s &vstart = vertices[start],
01348                                                                 &vstop = vertices[stop];
01349 
01350                                 // this test is somewhat more accurate
01351                                 // no division performed
01352                                 sint32  det = (estim.y-vstart.y)*(vstop.x-vstart.x) - (estim.x-vstart.x)*(vstop.y-vstart.y);
01353 
01354                                 isUpper = (det > 0);
01355                                 
01356                                 if (det == 0)
01357                                         onBorder = true;
01358                         }
01359                 }
01360 
01361                 // Depending on the chain is forward, up the position, increase/decrease the surface table...
01362                 if (sub.isForward())
01363                 {
01364                         if (isUpper)
01365                         {
01366                                 cst.incSurface(left);
01367                                 cst.decSurface(right);
01368                         }
01369                         else
01370                         {
01371                                 cst.decSurface(left);
01372                                 cst.incSurface(right);
01373                         }
01374                 }
01375                 else
01376                 {
01377                         if (isUpper)
01378                         {
01379                                 cst.decSurface(left);
01380                                 cst.incSurface(right);
01381                         }
01382                         else
01383                         {
01384                                 cst.incSurface(left);
01385                                 cst.decSurface(right);
01386                         }
01387                 }
01388         }
01389 }

void NLPACS::CLocalRetriever::retrievePosition NLMISC::CVector  estimated,
CCollisionSurfaceTemp cst
const
 

Retrieves a position inside the retriever (from the local position), returns true if the position is close to a border.

Todo:
trivial up/down check using bbox.

Definition at line 1064 of file local_retriever.cpp.

References _ChainQuad, _Chains, _Loaded, _OrderedChains, NLPACS::CCollisionSurfaceTemp::decSurface(), NLPACS::CCollisionSurfaceTemp::EdgeChainEntries, NLPACS::COrderedChain::getMax(), NLMISC::CAABBox::getMax(), NLPACS::COrderedChain::getMin(), NLMISC::CAABBox::getMin(), NLPACS::COrderedChain::getParentId(), NLPACS::COrderedChain::getVertices(), NLPACS::CCollisionSurfaceTemp::incSurface(), NLPACS::COrderedChain::isForward(), min, NLPACS::CCollisionSurfaceTemp::PossibleSurfaces, NLPACS::CChainQuad::selectEdges(), NLMISC::CAABBox::setMinMax(), sint16, sint32, NLPACS::CCollisionSurfaceTemp::SurfaceLUT, uint, NLPACS::Vector2sAccuracy, NLPACS::CVector2s::x, NLMISC::CVector::x, NLPACS::CVector2s::y, and NLMISC::CVector::y.

Referenced by NLPACS::CRetrieverInstance::retrievePosition(), and testPosition().

01065 {
01066         if (!_Loaded)
01067                 return;
01068 
01069         CAABBox                 box;
01070         const double    BorderThreshold = 2.0e-2f;
01071         box.setMinMax(CVector(estimated.x-(float)BorderThreshold, _BBox.getMin().y, 0.0f), CVector(estimated.x+(float)BorderThreshold, _BBox.getMax().y, 0.0f));
01072         uint                    numEdges = _ChainQuad.selectEdges(box, cst);
01073 
01074         uint                    ochain, i;
01075         CVector2s               estim = CVector2s(estimated);
01076 
01077         cst.PossibleSurfaces.clear();
01078 
01079         // WARNING!!
01080         // cst.SurfaceLUT is assumed to be 0 filled !!
01081 
01082         //nldebug("estim=(%d,%d)", estim.x, estim.y);
01083 
01084         // for each ordered chain, checks if the estimated position is between the min and max.
01085         for (i=0; i<numEdges; ++i)
01086         {
01087                 ochain = cst.EdgeChainEntries[i].OChainId;
01088 
01089                 const COrderedChain     &sub = _OrderedChains[ochain];
01090                 const CVector2s &min = sub.getMin(),
01091                                                 &max = sub.getMax();
01092 
01093                 // checks the position against the min and max of the chain
01094                 if (estim.x < min.x || estim.x > max.x)
01095                         continue;
01096 
01097                 bool    isUpper;
01098                 bool    isOnBorder = false;
01099 
01100                 sint32  left = _Chains[sub.getParentId()].getLeft(),
01101                                 right = _Chains[sub.getParentId()].getRight();
01102 
01103                 if (estim.y < min.y)
01104                 {
01105                         if (estim.x == max.x)
01106                                 continue;
01107                         isUpper = false;
01108 //                      nlinfo("Box: min(%d,%d) max(%d,%d) forward=%d left=%d right=%d upper=false", min.x, min.y, max.x, max.y, sub.isForward(), left, right);
01109                 }
01110                 else if (estim.y > max.y)
01111                 {
01112                         if (estim.x == max.x)
01113                                 continue;
01114                         isUpper = true;
01115 //                      nlinfo("Box: min(%d,%d) max(%d,%d) forward=%d left=%d right=%d upper=true", min.x, min.y, max.x, max.y, sub.isForward(), left, right);
01116                 }
01117                 else
01118                 {
01119                         const vector<CVector2s> &vertices = sub.getVertices();
01120                         uint                                    start = 0, stop = vertices.size()-1;
01121 
01123 
01124                         // then finds the smallest segment of the chain that includes the estimated position.
01125                         while (stop-start > 1)
01126                         {
01127                                 uint    mid = (start+stop)/2;
01128 
01129                                 if (vertices[mid].x > estim.x)
01130                                         stop = mid;
01131                                 else
01132                                         start = mid;
01133                         }
01134 
01135                         // if a vertical edge
01136                         if (vertices[start].x == vertices[stop].x)
01137                         {
01138                                 // look for maximal bounds
01139                                 while (start > 0 && vertices[start].x == vertices[start-1].x)
01140                                         --start;
01141 
01142                                 while (stop < vertices.size()-1 && vertices[stop].x == vertices[stop+1].x)
01143                                         ++stop;
01144 
01145                                 // if upper or lower the bounds, do nothing
01146                                 if (estim.y > vertices[start].y && estim.y > vertices[stop].y ||
01147                                         estim.y < vertices[start].y && estim.y < vertices[stop].y)
01148                                         continue;
01149 
01150                                 isOnBorder = true;
01151                                 if (left >= 0)
01152                                 {
01153                                         cst.SurfaceLUT[left].FoundCloseEdge = true;
01154                                         cst.SurfaceLUT[left].OnVerticalEdge = true;
01155                                 }
01156                                 if (right >= 0) 
01157                                 {
01158                                         cst.SurfaceLUT[right].FoundCloseEdge = true;
01159                                         cst.SurfaceLUT[right].OnVerticalEdge = true;
01160                                 }
01161 //                              nlinfo("Edge: start(%d,%d) stop(%d,%d) forward=%d left=%d right=%d border=true", vertices[start].x, vertices[start].y, vertices[stop].x, vertices[stop].y, sub.isForward(), left, right);
01162                                 continue;
01163                         }
01164                         else if (vertices[stop].x == estim.x)
01165                         {
01166                                 // if (yes)
01167                                 continue;
01168                         }
01169 
01170                         // and then checks if the estimated position is up or down the chain.
01171 
01172                         // first trivial case (up both tips)
01173                         if (estim.y > vertices[start].y && estim.y > vertices[stop].y)
01174                         {
01175                                 isUpper = true;
01176 //                              nlinfo("Edge: start(%d,%d) stop(%d,%d) forward=%d left=%d right=%d upper=true", vertices[start].x, vertices[start].y, vertices[stop].x, vertices[stop].y, sub.isForward(), left, right);
01177                         }
01178                         // second trivial case (down both tips)
01179                         else if (estim.y < vertices[start].y && estim.y < vertices[stop].y)
01180                         {
01181                                 isUpper = false;
01182 //                              nlinfo("Edge: start(%d,%d) stop(%d,%d) forward=%d left=%d right=%d upper=false", vertices[start].x, vertices[start].y, vertices[stop].x, vertices[stop].y, sub.isForward(), left, right);
01183                         }
01184                         // full test...
01185                         else
01186                         {
01187                                 const CVector2s &vstart = vertices[start],
01188                                                                 &vstop = vertices[stop];
01189 
01190                                 sint16                  intersect = vstart.y + (vstop.y-vstart.y)*(estim.x-vstart.x)/(vstop.x-vstart.x);
01191 
01192                                 isUpper = estim.y > intersect;
01193                                 isOnBorder = (fabs(estim.y - intersect)<BorderThreshold*Vector2sAccuracy);
01194 //                              nlinfo("Edge: start(%d,%d) stop(%d,%d) forward=%d left=%d right=%d upper=%s border=%s", vertices[start].x, vertices[start].y, vertices[stop].x, vertices[stop].y, sub.isForward(), left, right, isUpper ? "true":"false", isOnBorder ? "true":"false");
01195                         }
01196                 }
01197 
01198                 if (isOnBorder)
01199                 {
01200                         cst.incSurface(left);
01201                         cst.incSurface(right);
01202                         if (left >= 0)  cst.SurfaceLUT[left].FoundCloseEdge = true;
01203                         if (right >= 0) cst.SurfaceLUT[right].FoundCloseEdge = true;
01204                         continue;
01205                 }
01206 
01207                 // Depending on the chain is forward, up the position, increase/decrease the surface table...
01208                 if (sub.isForward())
01209                 {
01210                         if (isUpper)
01211                         {
01212                                 cst.incSurface(left);
01213                                 cst.decSurface(right);
01214                         }
01215                         else
01216                         {
01217                                 cst.decSurface(left);
01218                                 cst.incSurface(right);
01219                         }
01220                 }
01221                 else
01222                 {
01223                         if (isUpper)
01224                         {
01225                                 cst.decSurface(left);
01226                                 cst.incSurface(right);
01227                         }
01228                         else
01229                         {
01230                                 cst.incSurface(left);
01231                                 cst.decSurface(right);
01232                         }
01233                 }
01234         }
01235 }

void NLPACS::CLocalRetriever::serial NLMISC::IStream f  ) 
 

Serialises the CLocalRetriever.

Definition at line 895 of file local_retriever.cpp.

References __Tips, _BorderChains, _ChainQuad, _Chains, _ExteriorMesh, _FaceGrid, _FullOrderedChains, _InteriorFaces, _InteriorVertices, _Loaded, _OrderedChains, _Surfaces, _Topologies, LoadCheckFlag, NLPACS::NumMaxCreatureModels, NLMISC::IStream::serial(), NLMISC::IStream::serialCont(), NLMISC::IStream::serialEnum(), NLMISC::IStream::serialVersion(), sint, and uint.

Referenced by NLPACS::CRetrieverBank::addRetriever().

00896 {
00897         /*
00898         Version 0:
00899                 - base version (with collision info).
00900         Version 1:
00901                 - interior vertices and faces, for interior ground snapping
00902         Version 2:
00903                 - face grid added.
00904         Version 3:
00905                 - identifier added.
00906         Version 4:
00907                 - topologies no more in stream (obsolete)
00908         */
00909         sint    ver= f.serialVersion(4);
00910 
00911         if (ver < 4)
00912                 throw EOlderStream();
00913 
00914         uint    i;
00915         f.serialCont(_Chains);
00916         f.serialCont(_OrderedChains);
00917         f.serialCont(_FullOrderedChains);
00918         f.serialCont(_Surfaces);
00919         f.serialCont(__Tips);
00920         f.serialCont(_BorderChains);
00921         if (ver < 4)
00922         {
00923                 for (i=0; i<NumMaxCreatureModels; ++i)
00924                         f.serialCont(_Topologies[i]);
00925         }
00926         f.serial(_ChainQuad);
00927         f.serial(_BBox);
00928         f.serialEnum(_Type);
00929         f.serial(_ExteriorMesh);
00930         
00931         // a fix for old versions (with wrong _Type value)
00932         if (_Type != CLocalRetriever::Interior) _Type = CLocalRetriever::Landscape;
00933 
00934         if (ver >= 1)
00935         {
00936                 f.serialCont(_InteriorVertices);
00937                 f.serialCont(_InteriorFaces);
00938 
00939         }
00940         if (ver >= 2)
00941         {
00942                 f.serial(_FaceGrid);
00943         }
00944         if (ver >= 3)
00945         {
00946                 f.serial(_Id);
00947         }
00948 
00949         _Loaded = true;
00950         LoadCheckFlag = false;
00951 }

void NLPACS::CLocalRetriever::setBBox const NLMISC::CAABBox bbox  )  [inline]
 

Sets the bbox of the retriever.

Definition at line 486 of file local_retriever.h.

Referenced by NLPACS::computeRetriever().

00486 { _BBox = bbox; }

void NLPACS::CLocalRetriever::setExteriorMesh const CExteriorMesh em  )  [inline]
 

Sets the exterior mesh.

Definition at line 483 of file local_retriever.h.

References _ExteriorMesh.

Referenced by NLPACS::computeRetriever(), and NLPACS::linkExteriorToInterior().

00483 { _ExteriorMesh = em; }

void NLPACS::CLocalRetriever::setFullOrderedChains const std::vector< COrderedChain3f > &  foc  )  [inline]
 

Adds a chain to the local retriever, using the vertices of the chain, the left and right surfaces id and the edge on which the chain is stuck

Definition at line 532 of file local_retriever.h.

References _FullOrderedChains.

00532 { _FullOrderedChains = foc; }

void NLPACS::CLocalRetriever::setIdentifier const std::string &  id  )  [inline]
 

Returns the identifier of the retriever.

Definition at line 496 of file local_retriever.h.

00496 { _Id = id; }

void NLPACS::CLocalRetriever::setType EType  type  )  [inline]
 

Set the type of the retriever (see EType).

Definition at line 480 of file local_retriever.h.

References type.

Referenced by NLPACS::computeRetriever().

00480 { _Type = type; }

void NLPACS::CLocalRetriever::snapToInteriorGround ULocalPosition position,
bool &  snapped
const
 

Snaps on the ground.

Definition at line 1413 of file local_retriever.cpp.

References _FaceGrid, _InteriorFaces, _InteriorVertices, _Loaded, NLPACS::ULocalPosition::Estimation, NLMISC::CPlane::intersect(), NLMISC::CPlane::make(), NLMISC::CVector2f::normed(), NLPACS::CFaceGrid::select(), NLPACS::ULocalPosition::Surface, NLPACS::CLocalRetriever::CInteriorFace::Surface, uint32, v, NLPACS::Vector2sAccuracy, NLPACS::CLocalRetriever::CInteriorFace::Verts, NLMISC::CVector2f::x, x, NLMISC::CVector2f::y, y, and NLMISC::CVector::z.

Referenced by NLPACS::CRetrieverInstance::retrievePosition(), NLPACS::CRetrieverInstance::snap(), and NLPACS::CRetrieverInstance::snapToInteriorGround().

01414 {
01415         if (!_Loaded)
01416                 return;
01417 
01418         // first preselect faces around the (x, y) position (CQuadGrid ?)
01419         vector<uint32>  selection;
01420         _FaceGrid.select(position.Estimation, selection);
01421 
01422         // from the preselect faces, look for the only face that belongs to the surface
01423         // and that contains the position
01424         CVector                                         pos = position.Estimation;
01425         CVector                                         posh = pos+CVector(0.0f, 0.0f, 1.0f);
01426         CVector2f                                       pos2d = position.Estimation;
01427         float                                           bestDist = 1.0e10f;
01428         CVector                                         best;
01429         vector<uint32>::iterator        it;
01430         snapped = false;
01431         for (it=selection.begin(); it!=selection.end(); ++it)
01432         {
01433                 const CInteriorFace     &f = _InteriorFaces[*it];
01434                 if (f.Surface == (uint32)position.Surface)
01435                 {
01436                         CVector v[3];
01437                         v[0] = _InteriorVertices[f.Verts[0]];
01438                         v[1] = _InteriorVertices[f.Verts[1]];
01439                         v[2] = _InteriorVertices[f.Verts[2]];
01440 
01441                         CVector2f       n;
01442                         float           c;                      // 2D cartesian coefficients of line in plane X/Y.
01443                         // Line p0-p1.
01444                         n = CVector2f(-(v[1].y-v[0].y), (v[1].x-v[0].x)).normed();
01445                         c = -(v[0].x*n.x + v[0].y*n.y);
01446                         if (n*pos2d + c < -1.0f/Vector2sAccuracy)       continue;
01447                         // Line p1-p2.
01448                         n = CVector2f(-(v[2].y-v[1].y), (v[2].x-v[1].x)).normed();
01449                         c = -(v[1].x*n.x + v[1].y*n.y);
01450                         if (n*pos2d + c < -1.0f/Vector2sAccuracy)       continue;
01451                         //  Line p2-p0.
01452                         n = CVector2f(-(v[0].y-v[2].y), (v[0].x-v[2].x)).normed();
01453                         c = -(v[2].x*n.x + v[2].y*n.y);
01454                         if (n*pos2d + c < -1.0f/Vector2sAccuracy)       continue;
01455 
01456                         CPlane  p;
01457                         p.make(v[0], v[1], v[2]);
01458 
01459                         CVector i = p.intersect(pos, posh);
01460 
01461                         float   d = (float)fabs(pos.z-i.z);
01462 
01463                         if (d < bestDist)
01464                         {
01465                                 bestDist = d;
01466                                 best = i;
01467                         }
01468                 }
01469         }
01470 
01471         // and computes the real position on this face
01472         if (bestDist < 400.0f)
01473         {
01474                 snapped = true;
01475                 position.Estimation = best;
01476         }
01477 }

void NLPACS::CLocalRetriever::sortTips  ) 
 

Sorts chains references inside the tips. NOT IMPLEMENTED YET.

Definition at line 775 of file local_retriever.cpp.

00776 {
00777 }

void NLPACS::CLocalRetriever::testCollision CCollisionSurfaceTemp cst,
const NLMISC::CAABBox bboxMove,
const NLMISC::CVector2f transBase
const
 

add possible collisions chains to the temp result.

Parameters:
cst the temp result to store collision chains. they are appened to cst.CollisionChains.
bboxMove the bbox which bounds the movement of the entity.
transBase the vector we use to translate local position of edge.

Definition at line 1807 of file local_retriever.cpp.

References _ChainQuad, _ExteriorMesh, _Loaded, NLPACS::CCollisionSurfaceTemp::allocEdgeCollideNode(), NLPACS::CCollisionSurfaceTemp::CollisionChains, NLPACS::CCollisionSurfaceTemp::EdgeChainEntries, NLPACS::CEdgeChainEntry::EdgeEnd, NLPACS::CEdgeChainEntry::EdgeStart, NLPACS::CCollisionChain::FirstEdgeCollide, getChains(), NLPACS::CCollisionSurfaceTemp::getEdgeCollideNode(), NLPACS::CExteriorMesh::getLink(), NLPACS::CExteriorMesh::getLinks(), getOrderedChains(), NLPACS::COrderedChain::getParentId(), NLPACS::COrderedChain::getVertices(), NLPACS::CEdgeCollide::make(), NLPACS::CEdgeCollideNode::Next, NLPACS::CEdgeChainEntry::OChainId, NLPACS::CCollisionSurfaceTemp::OChainLUT, NLPACS::CChainQuad::selectEdges(), sint, uint, uint16, and uint32.

Referenced by NLPACS::CGlobalRetriever::findCollisionChains().

01808 {
01809         if (!_Loaded)
01810                 return;
01811 
01812 //      H_AUTO(PACS_LR_testCollision);
01813 
01814         sint    i;
01815 
01816         // 0. select ordered chains in the chainquad.
01817         //=====================================
01818 //      H_BEFORE(PACS_LR_testCol_selEdges);
01819         sint    nEce= _ChainQuad.selectEdges(bboxMove, cst);
01820 //      H_AFTER(PACS_LR_testCol_selEdges);
01821         // NB: cst.OChainLUT is assured to be full of 0xFFFF after this call (if was right before).
01822 
01823 
01824         // 1. regroup them in chains. build cst.CollisionChains
01825         //=====================================
01826         // NB: use cst.OChainLUT to look if a Chain has been inserted before.
01827         uint16  *chainLUT= cst.OChainLUT;
01828 
01829         // bkup where we begin to add chains.
01830         uint    firstChainAdded= cst.CollisionChains.size();
01831 
01832         // For all edgechain entry.
01833         for(i=0;i<nEce;i++)
01834         {
01835                 CEdgeChainEntry         &ece= cst.EdgeChainEntries[i];
01836                 // this is the ordered chain in the retriever.
01837                 const   COrderedChain   &oChain= this->getOrderedChains()[ece.OChainId];
01838                 // this is the id of the chain is the local retriever.
01839                 uint16                          chainId= oChain.getParentId();
01840 
01841                 // test if edge is interior and points to another instance
01842                 // \todo Ben: flag interior chains that points to doors to speed up the test
01843                 if (_Type == Interior && CChain::isBorderChainId(this->getChains()[chainId].getRight()))
01844                 {
01845                         // then look for a door that match this edge
01846                         uint    l;
01847                         for (l=0; l<_ExteriorMesh.getLinks().size() && _ExteriorMesh.getLink(l).ChainId != chainId; ++l)
01848                                 ;
01849 
01850                         // if found a door, then leave the edge as is
01851                         if (l < _ExteriorMesh.getLinks().size())
01852                                 continue;
01853                 }
01854 
01855 
01856                 // add/retrieve the id in cst.CollisionChains.
01857                 //=================================
01858                 uint                            ccId;
01859                 // if never added.
01860                 if(chainLUT[chainId]==0xFFFF)
01861                 {
01862 //                      H_AUTO(PACS_LR_testCol_addToLUT);
01863                         // add a new CCollisionChain.
01864                         ccId= cst.CollisionChains.size();
01865                         cst.CollisionChains.push_back(CCollisionChain());
01866                         // Fill it with default.
01867                         cst.CollisionChains[ccId].Tested= false;
01868                         cst.CollisionChains[ccId].ExteriorEdge = false;
01869                         cst.CollisionChains[ccId].FirstEdgeCollide= 0xFFFFFFFF;
01870                         cst.CollisionChains[ccId].ChainId= chainId;
01871                         // Fill Left right info.
01872                         cst.CollisionChains[ccId].LeftSurface.SurfaceId= this->getChains()[chainId].getLeft();
01873                         cst.CollisionChains[ccId].RightSurface.SurfaceId= this->getChains()[chainId].getRight();
01874                         // NB: cst.CollisionChains[ccId].*Surface.RetrieverInstanceId is not filled here because we don't have
01875                         // this info at this level.
01876 
01877                         // store this Id in the LUT of chains.
01878                         chainLUT[chainId]= ccId;
01879                 }
01880                 else
01881                 {
01882                         // get the id of this collision chain.
01883                         ccId= chainLUT[chainId];
01884                 }
01885 
01886                 // add edge collide to the list.
01887                 //=================================
01888 //              H_BEFORE(PACS_LR_testCol_addToList);
01889                 CCollisionChain                 &colChain= cst.CollisionChains[ccId];
01890                 const std::vector<CVector2s>    &oChainVertices= oChain.getVertices();
01891                 for(sint edge=ece.EdgeStart; edge<ece.EdgeEnd; edge++)
01892                 {
01893                         CVector2f       p0= oChainVertices[edge].unpack();
01894                         CVector2f       p1= oChainVertices[edge+1].unpack();
01895 
01896                         // alloc a new edgeCollide.
01897                         uint32  ecnId= cst.allocEdgeCollideNode();
01898                         CEdgeCollideNode        &ecn= cst.getEdgeCollideNode(ecnId);
01899 
01900                         // append to the front of the list.
01901                         ecn.Next= colChain.FirstEdgeCollide;
01902                         colChain.FirstEdgeCollide= ecnId;
01903 
01904                         // build this edge.
01905                         p0+= transBase;
01906                         p1+= transBase;
01907                         ecn.make(p0, p1);
01908                 }
01909 //              H_AFTER(PACS_LR_testCol_addToList);
01910         }
01911 
01912 
01913 
01914         // 2. Reset LUT to 0xFFFF.
01915         //=====================================
01916 
01917 //      H_BEFORE(PACS_LR_testCol_resetLUT);
01918         // for all collisions chains inserted (starting from firstChainAdded), reset LUT.
01919         for(i=firstChainAdded; i<(sint)cst.CollisionChains.size(); i++)
01920         {
01921                 uint    ccId= cst.CollisionChains[i].ChainId;
01922                 chainLUT[ccId]= 0xFFFF;
01923         }
01924 //      H_AFTER(PACS_LR_testCol_resetLUT);
01925 }

bool NLPACS::CLocalRetriever::testPosition ULocalPosition local,
CCollisionSurfaceTemp cst
const
 

Retrieves a position inside the retriever (from the local position), returns true if the position is close to a border.

Definition at line 1038 of file local_retriever.cpp.

References _Loaded, _Surfaces, NLPACS::ULocalPosition::Estimation, nlwarning, NLPACS::CCollisionSurfaceTemp::PossibleSurfaces, retrievePosition(), sint, NLPACS::ULocalPosition::Surface, NLPACS::CCollisionSurfaceTemp::SurfaceLUT, uint, NLMISC::CVector::x, and NLMISC::CVector::y.

Referenced by NLPACS::CGlobalRetriever::testPosition().

01039 {
01040         if (!_Loaded)
01041                 return false;
01042 
01043         if (local.Surface < 0 || local.Surface >= (sint)_Surfaces.size())
01044         {
01045                 nlwarning("PACS: can't test inexistant surface %d", local.Surface);
01046                 return false;
01047         }
01048 
01049         if (fabs(local.Estimation.x) >= 256.0 || fabs(local.Estimation.y) >= 256.0)
01050                 return false;
01051 
01052         retrievePosition(local.Estimation, cst);
01053 
01054         bool    result = (cst.SurfaceLUT[local.Surface].Counter == 2 || cst.SurfaceLUT[local.Surface].OnVerticalEdge);
01055 
01056         uint    i;
01057         for (i=0; i<cst.PossibleSurfaces.size(); ++i)
01058                                 cst.SurfaceLUT[cst.PossibleSurfaces[i]].reset();
01059 
01060         return result;
01061 }

void NLPACS::CLocalRetriever::translate const NLMISC::CVector translation  ) 
 

Translates the local retriever by the translation vector.

Definition at line 882 of file local_retriever.cpp.

References _OrderedChains, _Surfaces, and uint.

00883 {
00884         uint    i;
00885         for (i=0; i<_OrderedChains.size(); ++i)
00886                 _OrderedChains[i].translate(translation);
00887         for (i=0; i<_Surfaces.size(); ++i)
00888                 _Surfaces[i].translate(translation);
00889 /*
00890         for (i=0; i<_Tips.size(); ++i)
00891                 _Tips[i].translate(translation);
00892 */
00893 }

void NLPACS::CLocalRetriever::unify  ) 
 

Definition at line 206 of file local_retriever.cpp.

Referenced by NLPACS::computeRetriever().

00207 {
00208 /*
00209         uint    i, j;
00210 
00211         for (i=0; i<_Chains.size(); ++i)
00212                 _Chains[i].unify(_OrderedChains);
00213 
00214         for (i=0; i<_Tips.size(); ++i)
00215         {
00216                 NLPACS::CLocalRetriever::CTip   &tip = _Tips[i];
00217                 CVector2s ptip = tip.Point;
00218 
00219                 for (j=0; j<tip.Chains.size(); ++j)
00220                 {
00221                         if (tip.Chains[j].Start)
00222                         {
00223                                 if (_Chains[tip.Chains[j].Chain].getStartVector(_OrderedChains) != ptip)
00224                                         nlwarning("chain %d is not stuck to tip %d", tip.Chains[j].Chain, i);
00225                                 _Chains[tip.Chains[j].Chain].setStartVector(ptip, _OrderedChains);
00226                         }
00227                         else
00228                         {
00229                                 if (_Chains[tip.Chains[j].Chain].getStopVector(_OrderedChains) != ptip)
00230                                         nlwarning("chain %d is not stuck to tip %d", tip.Chains[j].Chain, i);
00231                                 _Chains[tip.Chains[j].Chain].setStopVector(ptip, _OrderedChains);
00232                         }
00233                 }
00234         }
00235 
00236         _FullOrderedChains.resize(_OrderedChains.size());
00237         for (i=0; i<_OrderedChains.size(); ++i)
00238                 _FullOrderedChains[i].unpack(_OrderedChains[i]);
00239 */
00240 }

void NLPACS::CLocalRetriever::updateChainIds  ) 
 

Updates surfaces links from the links contained in the chains...

Definition at line 797 of file local_retriever.cpp.

References _Chains, NLPACS::CRetrievableSurface::_Chains, _Surfaces, nlerror, nlwarning, sint32, and uint.

Referenced by NLPACS::computeRetriever().

00798 {
00799         uint    surf, link;
00800 
00801         for (surf=0; surf<_Surfaces.size(); ++surf)
00802         {
00803                 CRetrievableSurface     &surface = _Surfaces[surf];
00804 
00805                 for (link=0; link<surface._Chains.size(); ++link)
00806                 {
00807                         sint32  chain = surface._Chains[link].Chain;
00808 
00809                         if (_Chains[chain]._Left == (sint32)surf)
00810                                 surface._Chains[link].Surface = _Chains[chain]._Right;
00811                         else if (_Chains[chain]._Right == (sint32)surf)
00812                                 surface._Chains[link].Surface = _Chains[chain]._Left;
00813                         else
00814                         {
00815                                 nlwarning("in NLPACS::CLocalRetriever::updateEdgesOnSurfaces()");
00816                                 nlerror("Can't find back point to surface %d on chain %d", surf, chain);
00817                         }
00818                 }
00819         }
00820 }


Friends And Related Function Documentation

friend class CRetrieverInstance [friend]
 

Definition at line 285 of file local_retriever.h.


Field Documentation

std::vector<CTip> NLPACS::CLocalRetriever::__Tips [protected]
 

The tips making links between different chains.

Definition at line 301 of file local_retriever.h.

Referenced by clear(), and serial().

NLMISC::CAABBox NLPACS::CLocalRetriever::_BBox [protected]
 

The bbox of the local retriever.

Definition at line 298 of file local_retriever.h.

std::vector<uint16> NLPACS::CLocalRetriever::_BorderChains [protected]
 

The chains on the edges of the zone.

Definition at line 304 of file local_retriever.h.

Referenced by clear(), findBorderChains(), getBorderChain(), getBorderChains(), replaceChain(), and serial().

CChainQuad NLPACS::CLocalRetriever::_ChainQuad [protected]
 

For collisions, the chainquad.

Definition at line 316 of file local_retriever.h.

Referenced by clear(), computeCollisionChainQuad(), findPath(), getChainQuad(), retrieveAccuratePosition(), retrievePosition(), serial(), and testCollision().

std::vector<CChain> NLPACS::CLocalRetriever::_Chains [protected]
 

The chains insinde the zone.

Definition at line 292 of file local_retriever.h.

Referenced by addChain(), build3dSurfacePolygons(), buildSurfacePolygons(), clear(), computeLoopsAndTips(), computeTopologies(), distanceToBorder(), dumpSurface(), findBorderChains(), findPath(), forceBorderChainId(), getChain(), getChains(), getNextChain(), getPreviousChain(), getStartVector(), getStopVector(), insurePosition(), replaceChain(), retrieveAccuratePosition(), retrievePosition(), serial(), and updateChainIds().

const float NLPACS::CLocalRetriever::_EdgeTipThreshold = 0.1f [static, protected]
 

The tip recognition threshold.

Definition at line 42 of file local_retriever.cpp.

CExteriorMesh NLPACS::CLocalRetriever::_ExteriorMesh [protected]
 

The exterior mesh, for collisions.

Definition at line 324 of file local_retriever.h.

Referenced by clear(), getExteriorMesh(), serial(), setExteriorMesh(), testCollision(), and NLPACS::CRetrieverInstance::testExteriorCollision().

CFaceGrid NLPACS::CLocalRetriever::_FaceGrid [protected]
 

The face selection grid.

Definition at line 333 of file local_retriever.h.

Referenced by clear(), getHeight(), initFaceGrid(), serial(), and snapToInteriorGround().

std::vector<COrderedChain3f> NLPACS::CLocalRetriever::_FullOrderedChains [protected]
 

Definition at line 289 of file local_retriever.h.

Referenced by addChain(), build3dSurfacePolygons(), clear(), dumpSurface(), flushFullOrderedChains(), getFullOrderedChain(), getFullOrderedChains(), getStartVector(), getStopVector(), replaceChain(), serial(), and setFullOrderedChains().

std::string NLPACS::CLocalRetriever::_Id [protected]
 

An human readable identifier of the retriever.

Definition at line 336 of file local_retriever.h.

std::vector<CInteriorFace> NLPACS::CLocalRetriever::_InteriorFaces [protected]
 

The faces of the collision mesh.

Definition at line 330 of file local_retriever.h.

Referenced by buildInteriorSurfaceBBoxes(), clear(), getHeight(), getInteriorFaces(), initFaceGrid(), serial(), and snapToInteriorGround().

std::vector<NLMISC::CVector> NLPACS::CLocalRetriever::_InteriorVertices [protected]
 

The vertices of the collision mesh.

Definition at line 327 of file local_retriever.h.

Referenced by buildInteriorSurfaceBBoxes(), clear(), getHeight(), getInteriorVertices(), initFaceGrid(), serial(), and snapToInteriorGround().

bool NLPACS::CLocalRetriever::_Loaded [protected]
 

Tells if retriever is loaded.

Definition at line 341 of file local_retriever.h.

Referenced by clear(), CLocalRetriever(), forceLoaded(), getHeight(), insurePosition(), isLoaded(), retrieveAccuratePosition(), retrievePosition(), serial(), snapToInteriorGround(), testCollision(), and testPosition().

std::vector<COrderedChain> NLPACS::CLocalRetriever::_OrderedChains [protected]
 

The chains insinde the zone.

Definition at line 288 of file local_retriever.h.

Referenced by addChain(), buildSurfacePolygons(), clear(), computeCollisionChainQuad(), distanceToBorder(), dumpSurface(), findPath(), getOrderedChain(), getOrderedChains(), insurePosition(), replaceChain(), retrieveAccuratePosition(), retrievePosition(), serial(), and translate().

std::vector<CRetrievableSurface> NLPACS::CLocalRetriever::_Surfaces [protected]
 

The surfaces inside the zone.

Definition at line 295 of file local_retriever.h.

Referenced by addChain(), addSurface(), build3dSurfacePolygons(), buildInteriorSurfaceBBoxes(), buildSurfacePolygons(), clear(), computeLoopsAndTips(), computeTopologies(), distanceToBorder(), dumpSurface(), findPath(), getHeight(), getNextChain(), getPreviousChain(), getSurface(), getSurfaces(), insurePosition(), replaceChain(), serial(), testPosition(), translate(), and updateChainIds().

const float NLPACS::CLocalRetriever::_TipThreshold = 0.1f [static, protected]
 

The tip recognition threshold.

Definition at line 41 of file local_retriever.cpp.

std::vector<CTopology> NLPACS::CLocalRetriever::_Topologies[NumMaxCreatureModels] [protected]
 

The topologies within the zone.

Definition at line 307 of file local_retriever.h.

Referenced by clear(), computeTopologies(), and serial().

EType NLPACS::CLocalRetriever::_Type [protected]
 

The type of the retriever.

Definition at line 319 of file local_retriever.h.

std::vector<uint> NLPACS::CLocalRetriever::FreeOChains
 

Definition at line 598 of file local_retriever.h.

Referenced by replaceChain().

bool NLPACS::CLocalRetriever::LoadCheckFlag
 

Definition at line 345 of file local_retriever.h.

Referenced by clear(), CLocalRetriever(), and serial().


The documentation for this class was generated from the following files:
Generated on Tue Mar 16 14:16:01 2004 for NeL by doxygen 1.3.6