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::CVector &	getStartVector (uint32 chain, sint32 surface) const
const NLMISC::CVector &	getStartVector (uint32 chain) const
const NLMISC::CVector &	getStopVector (uint32 chain, sint32 surface) const
const NLMISC::CVector &	getStopVector (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 ()
CChainQuad &	getChainQuad ()
	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::CAABBox &	getBBox () 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 CChain &	getChain (uint n) const
	retruns the nth chain.
const std::vector< CChain > &	getChains () const
	Returns the chains.
const CExteriorMesh &	getExteriorMesh () const
	Returns the exterior mesh of the retriever.
const COrderedChain3f &	getFullOrderedChain (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 COrderedChain &	getOrderedChain (uint n) const
	Returns the nth ordered chain.
const std::vector< COrderedChain > &	getOrderedChains () const
	Returns the ordered chains.
const CRetrievableSurface &	getSurface (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< uint >	FreeOChains
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(). { Landscape = 0, Interior };

---

Constructor & Destructor Documentation

NLPACS::CLocalRetriever::CLocalRetriever (   )

Definition at line 56 of file local_retriever.cpp. References _Loaded, and LoadCheckFlag. { _Type = Landscape; _Loaded = false; LoadCheckFlag = false; }

---

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(). { vector<CVector> vertices = verts; uint i; if (vertices.size() < 2) { nlwarning("in NLPACS::CLocalRetriever::addChain()"); nlwarning("The chain has less than 2 vertices"); return -1; } // Remove doubled vertices due to CVector2s snapping vector<CVector2s> converts; for (i=0; i<vertices.size(); ++i) converts.push_back(CVector2s(vertices[i])); vector<CVector2s>::iterator next2s = converts.begin(), it2s, prev2s; prev2s = next2s; ++next2s; it2s = next2s; ++next2s; vector<CVector>::iterator it3f = vertices.begin(); CVector prev3f = *it3f; ++it3f; for (; it2s != converts.end() && next2s != converts.end(); ) { // if the next point is equal to the previous if (*it2s == *prev2s || *it2s == *next2s) { // then remove the next point it2s = converts.erase(it2s); it3f = vertices.erase(it3f); prev2s = it2s; --prev2s; next2s = it2s; ++next2s; } else { // else remember the next point, and step to the next... ++prev2s; ++it2s; ++next2s; ++it3f; prev3f = *it3f; } } if (vertices.size() < 2) { nlwarning("in NLPACS::CLocalRetriever::addChain()"); nlwarning("The chain was snapped to a single point"); return -1; } sint32 newId = _Chains.size(); _Chains.resize(newId+1); CChain &chain = _Chains.back(); if (left>(sint)_Surfaces.size()) nlerror ("left surface id MUST be id<%d (id=%d)", _Surfaces.size(), left); if (right>(sint)_Surfaces.size()) nlerror ("right surface id MUST be id<%d (id=%d)", _Surfaces.size(), right); // checks if we can build the chain. if (newId > 65535) nlerror("in NLPACS::CLocalRetriever::addChain(): reached the maximum number of chains"); CRetrievableSurface *leftSurface = (left>=0) ? &(_Surfaces[left]) : NULL; CRetrievableSurface *rightSurface = (right>=0) ? &(_Surfaces[right]) : NULL; // adds the chain and the link to the surface links vector. if (leftSurface != NULL) leftSurface->_Chains.push_back(CRetrievableSurface::CSurfaceLink(newId, right)); if (rightSurface != NULL) rightSurface->_Chains.push_back(CRetrievableSurface::CSurfaceLink(newId, left)); chain._StartTip = 0xffff; chain._StopTip = 0xffff; // make the chain and its subchains. vector<uint> empty; chain.make(vertices, left, right, _OrderedChains, (uint16)newId, _FullOrderedChains, empty); return newId; }

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(). { // creates a new surface... sint32 newId = _Surfaces.size(); _Surfaces.resize(newId+1); CRetrievableSurface &surf = _Surfaces.back(); // ... and fills it surf._NormalQuanta = normalq; surf._OrientationQuanta = orientationq; surf._Material = mat; surf._Character = charact; surf._Level = level; surf._Quad = quad; surf._Center = center; surf._QuantHeight = quantHeight; // WARNING!! MODIFY THESE IF QUANTAS VALUES CHANGE !! surf._IsFloor = (surf._NormalQuanta <= 1); surf._IsCeiling = (surf._NormalQuanta >= 3); surf._Flags = 0; surf._Flags |= (surf._IsFloor) ? (1<<CRetrievableSurface::IsFloorBit) : 0; surf._Flags |= (surf._IsCeiling) ? (1<<CRetrievableSurface::IsCeilingBit) : 0; surf._Flags |= (!surf._IsFloor && !surf._IsCeiling) ? (1<<CRetrievableSurface::IsSlantBit) : 0; surf._Flags |= clusterHint ? (1<<CRetrievableSurface::ClusterHintBit) : 0; surf._Flags |= (isUnderWater) ? (1<<CRetrievableSurface::IsUnderWaterBit) : 0; surf._WaterHeight = waterHeight; surf._Flags |= ((0xffffffff<<(CRetrievableSurface::NormalQuantasStartBit)) & CRetrievableSurface::NormalQuantasBitMask); return newId; }

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. { uint i; for (i=0; i<_Surfaces.size(); ++i) { polygons.push_back(); build3dSurfacePolygons(i, polygons.back()); } }

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(). { const CRetrievableSurface &surf = _Surfaces[surface]; uint i, j, k, l; for (i=0; i<surf._Loops.size(); ++i) { polygons.push_back(); CPolygon &poly = polygons.back(); for (j=0; j<surf._Loops[i].size(); ++j) { const CRetrievableSurface::TLoop &loop = surf._Loops[i]; const CChain &chain = _Chains[surf._Chains[loop[j]].Chain]; bool chainforward = ((uint32)chain._Left == surface); if (chainforward) { for (k=0; k<chain._SubChains.size(); ++k) { const COrderedChain3f &ochain = _FullOrderedChains[chain._SubChains[k]]; bool ochainforward = ochain.isForward(); if (ochainforward) { for (l=0; l<ochain.getVertices().size()-1; ++l) poly.Vertices.push_back(ochain[l]); } else { for (l=ochain.getVertices().size()-1; l>0; --l) poly.Vertices.push_back(ochain[l]); } } } else { for (k=chain._SubChains.size()-1; (sint)k>=0; --k) { const COrderedChain3f &ochain = _FullOrderedChains[chain._SubChains[k]]; bool ochainforward = ochain.isForward(); if (ochainforward) { for (l=ochain.getVertices().size()-1; (sint)l>0; --l) poly.Vertices.push_back(ochain[l]); } else { for (l=0; l<ochain.getVertices().size()-1; ++l) poly.Vertices.push_back(ochain[l]); } } } } } }

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. { // resize dest, and init. vector<bool> firstTriangle; surfaceBBoxes.clear(); surfaceBBoxes.resize(_Surfaces.size()); firstTriangle.resize(_Surfaces.size(), true); // For all _InteriorFaces. for(uint iIntFace=0; iIntFace<_InteriorFaces.size(); iIntFace++) { const CInteriorFace &intFace= _InteriorFaces[iIntFace]; // Extend the surface of this face with her 3 points. // check good id. if(intFace.Surface==(uint)-1) continue; nlassert(intFace.Surface<_Surfaces.size()); // If first time we extend the bbox of this surface if(firstTriangle[intFace.Surface]) { surfaceBBoxes[intFace.Surface].setCenter(_InteriorVertices[intFace.Verts[0]] ); firstTriangle[intFace.Surface]= false; } else surfaceBBoxes[intFace.Surface].extend(_InteriorVertices[intFace.Verts[0]] ); // extend with other 2 points surfaceBBoxes[intFace.Surface].extend(_InteriorVertices[intFace.Verts[1]] ); surfaceBBoxes[intFace.Surface].extend(_InteriorVertices[intFace.Verts[2]] ); } }

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. { uint i; for (i=0; i<_Surfaces.size(); ++i) { polygons.push_back(); buildSurfacePolygons(i, polygons.back()); } }

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(). { const CRetrievableSurface &surf = _Surfaces[surface]; uint i, j, k, l; for (i=0; i<surf._Loops.size(); ++i) { polygons.push_back(); CPolygon &poly = polygons.back(); for (j=0; j<surf._Loops[i].size(); ++j) { const CChain &chain = _Chains[surf._Loops[i][j]]; bool chainforward = ((uint32)chain._Left == surface); if (chainforward) { for (k=0; k<chain._SubChains.size(); ++k) { const COrderedChain &ochain = _OrderedChains[chain._SubChains[k]]; bool ochainforward = ochain.isForward(); if (ochainforward) { for (l=0; l<ochain.getVertices().size()-1; ++l) poly.Vertices.push_back(ochain[l].unpack3f()); } else { for (l=ochain.getVertices().size()-1; l>0; --l) poly.Vertices.push_back(ochain[l].unpack3f()); } } } else { for (k=chain._SubChains.size(); (sint)k>0; --k) { const COrderedChain &ochain = _OrderedChains[chain._SubChains[k]]; bool ochainforward = ochain.isForward(); if (ochainforward) { for (l=ochain.getVertices().size()-1; (sint)l>0; --l) poly.Vertices.push_back(ochain[l].unpack3f()); } else { for (l=0; l<ochain.getVertices().size()-1; ++l) poly.Vertices.push_back(ochain[l].unpack3f()); } } } } } }

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. { contReset(_OrderedChains); contReset(_FullOrderedChains); contReset(_Chains); contReset(_Surfaces); contReset(__Tips); contReset(_BorderChains); uint i; for (i=0; i<NumMaxCreatureModels; ++i) contReset(_Topologies[i]); _ChainQuad.clear(); _ExteriorMesh.clear(); contReset(_InteriorVertices); contReset(_InteriorFaces); _FaceGrid.clear(); _Id.resize(0); _Loaded = false; LoadCheckFlag = false; }

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(). { _ChainQuad.build(_OrderedChains); }

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(). { // for each surface, // examine each chain tip to match another tip inside the surface tips // if there is no matching tip, then creates a new one uint i, j; for (i=0; i<_Surfaces.size(); ++i) { CRetrievableSurface &surface = _Surfaces[i]; vector<bool> chainFlags; chainFlags.resize(surface._Chains.size()); for (j=0; j<chainFlags.size(); ++j) chainFlags[j] = false; uint totalAdded = 0; while (true) { for (j=0; j<chainFlags.size() && chainFlags[j]; ++j) ; if (j == chainFlags.size()) break; uint32 loopId = surface._Loops.size(); surface._Loops.push_back(CRetrievableSurface::TLoop()); CRetrievableSurface::TLoop &loop = surface._Loops.back(); CVector loopStart = getStartVector(surface._Chains[j].Chain, i); CVector currentEnd = getStopVector(surface._Chains[j].Chain, i); _Chains[surface._Chains[j].Chain].setLoopIndexes(i, loopId, loop.size()); loop.push_back(j); chainFlags[j] = true; float loopCloseDistance; while (true) { // loopCloseDistance = hybrid2dNorm(loopStart-currentEnd); loopCloseDistance = (loopStart-currentEnd).norm(); // choose the best matching start vector sint bestChain = -1; float best = 1.0e10f; CVector thisStart; for (j=0; j<chainFlags.size(); ++j) { if (chainFlags[j]) continue; thisStart = getStartVector(surface._Chains[j].Chain, i); // float d = hybrid2dNorm(thisStart-currentEnd); float d = (thisStart-currentEnd).norm(); if (d < best) { best = d; bestChain = j; } } if ((bestChain == -1 || best > 3.0e-2f)&& loopCloseDistance > 3.0e-2f) { nlwarning("in NLPACS::CLocalRetriever::computeTips()"); dumpSurface(i); for (j=0; j<surface._Chains.size(); ++j) { CVector start = getStartVector(surface._Chains[j].Chain, i); CVector end = getStopVector(surface._Chains[j].Chain, i); nlinfo("surf=%d chain=%d", i, surface._Chains[j].Chain); nlinfo("start=(%f,%f,%f)", start.x, start.y, start.z); nlinfo("end=(%f,%f,%f)", end.x, end.y, end.z); } nlwarning("bestChain=%d best=%f", bestChain, best); nlwarning("loopCloseDistance=%f", loopCloseDistance); nlerror("Couldn't close loop on surface=%d", i); } else if (best > 1.0e0f && loopCloseDistance < 3.0e-2f || loopCloseDistance < 1.0e-3f) { break; } currentEnd = getStopVector(surface._Chains[bestChain].Chain, i); _Chains[surface._Chains[bestChain].Chain].setLoopIndexes(i, loopId, loop.size()); loop.push_back(bestChain); chainFlags[bestChain] = true; ++totalAdded; } } } /* dumpSurface(9); dumpSurface(10); for (i=0; i<_Chains.size(); ++i) { if (i == 127) nlinfo(""); uint whichTip; // for both tips (start and stop) for (whichTip=0; whichTip<=1; ++whichTip) { // get the tip id uint thisTip = (whichTip) ? _Chains[i].getStopTip() : _Chains[i].getStartTip(); if (thisTip != 0xffff && thisTip >= _Tips.size()) { nlwarning("in NLPACS::CLocalRetriever::computeLoopsAndTips()"); nlerror("checked a tip that doesn't exist on chain %d (tipId=%d)", i, thisTip); } // if it is unaffected yet creates an new tip and affect it to the common chains if (thisTip == 0xffff) { uint turn; uint tipId = _Tips.size(); if (tipId == 62) nlinfo(""); _Tips.resize(tipId+1); CTip &tip = _Tips[tipId]; tip.Point = (whichTip) ? getStopVector(i) : getStartVector(i); for (turn=0; turn<=1; ++turn) { uint chain = i; // if (whichTip) _Chains[chain]._StopTip = tipId; else _Chains[chain]._StartTip = tipId; sint32 surf = (!turn && !whichTip || turn && whichTip) ? _Chains[chain].getLeft() : _Chains[chain].getRight(); while (surf >= 0) { CChain &nextChain = (turn) ? _Chains[chain = getNextChain(chain, surf)] : _Chains[chain = getPreviousChain(chain, surf)]; bool isForward = (nextChain.getLeft() == surf); // tells if the left surf is the current surf bool selectTip = isForward && !turn || !isForward && turn; uint16 &tipRef = selectTip ? nextChain._StopTip : nextChain._StartTip; surf = (isForward) ? nextChain.getRight() : nextChain.getLeft(); if (tipRef != 0xffff && tipRef != tipId) { nlwarning("in NLPACS::CLocalRetriever::computeLoopsAndTips()"); nlerror("Trying to setup a already created tip (tipId=%d, previous=%d)", tipId, tipRef); } else if (tipRef != 0xffff) { break; } tipRef = tipId; } } } } } for (i=0; i<_Chains.size(); ++i) { uint startTip = _Chains[i].getStartTip(), stopTip = _Chains[i].getStopTip(); // if (_Chains[i].getEdge() >= 0 && startTip == stopTip) // { // nlwarning("NLPACS::CLocalRetriever::computeLoopsAndTips(): chain %d on edge %d has same StartTip and StopTip", i, _Chains[i].getEdge(), startTip, stopTip); // } _Tips[startTip].Chains.push_back(CTip::CChainTip(i, true)); _Tips[stopTip].Chains.push_back(CTip::CChainTip(i, false)); } */ for (i=0; i<_Surfaces.size(); ++i) { for (j=0; j<_Surfaces[i]._Loops.size(); ++j) { _Surfaces[i]._Loops[j].Length = 0.0f; uint k; for (k=0; k<_Surfaces[i]._Loops[j].size(); ++k) _Surfaces[i]._Loops[j].Length += _Chains[_Surfaces[i]._Chains[_Surfaces[i]._Loops[j][k]].Chain].getLength(); } } }

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(). { //nlinfo("compute topologies"); // Find topologies out... uint character; for (character=0; character<NumCreatureModels; ++character) { // for each type of creature, flood fill surfaces... sint32 surface; uint topology = 0; for (surface=0; surface<(sint)_Surfaces.size(); ++surface) { if (_Surfaces[surface]._Topologies[character] == -1 && _Surfaces[surface]._Character == character) { vector<sint32> surfacesStack; surfacesStack.push_back(surface); while (!surfacesStack.empty()) { CRetrievableSurface &current = _Surfaces[surfacesStack.back()]; surfacesStack.pop_back(); current._Topologies[character] = topology; uint i; for (i=0; i<current._Chains.size(); ++i) { CChain &chain = _Chains[current._Chains[i].Chain]; sint32 link = (chain.getLeft() == surface) ? chain.getRight() : chain.getLeft(); if (link>=0 && link<(sint)_Surfaces.size() && _Surfaces[link]._Topologies[character] == -1 && _Surfaces[link]._Character >= character) { surfacesStack.push_back(link); _Surfaces[link]._Topologies[character] = topology; } } } ++topology; } } _Topologies[character].resize(topology); //nlinfo("generated %d topologies for character %d", topology, character); } uint surface; for (surface=0; surface<_Surfaces.size(); ++surface) { CRetrievableSurface &current = _Surfaces[surface]; for (character=0; character<NumCreatureModels; ++character) if (current._Topologies[character] >= 0) _Topologies[character][current._Topologies[character]].push_back(surface); } }

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(). { if (!isLoaded()) return 0.0f; const CRetrievableSurface &surf = _Surfaces[pos.Surface]; uint i, j; float minDist = 1.0e10f, dist; for (i=0; i<surf._Chains.size(); ++i) { const CChain &chain = _Chains[surf._Chains[i].Chain]; for (j=0; j<chain.getSubChains().size(); ++j) { dist = _OrderedChains[chain.getSubChain(j)].distance(pos.Estimation); if (dist < minDist) { minDist = dist; } } } return minDist; }

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(). { const CRetrievableSurface &surface = _Surfaces[surf]; nlinfo("dump surf %d", surf); nlinfo("%d chains, %d loops", surface._Chains.size(), surface._Loops.size()); uint i, j, k; for (i=0; i<surface._Chains.size(); ++i) { uint chainId = surface._Chains[i].Chain; const CChain &chain = _Chains[chainId]; 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()); for (j=0; j<chain.getSubChains().size(); ++j) { const COrderedChain3f &ochain = _FullOrderedChains[chain.getSubChain(j)]; const COrderedChain &ochains = _OrderedChains[chain.getSubChain(j)]; nlinfo(" subchain %d[%d]: fwd=%d parent=%d idx=%d", j, chain.getSubChain(j), ochain.isForward(), ochain.getParentId(), ochain.getIndexInParent()); for (k=0; k<ochain.getVertices().size(); ++k) 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); } } for (i=0; i<surface._Loops.size(); ++i) { const CRetrievableSurface::TLoop &loop = surface._Loops[i]; nlinfo("-- loop %d: %d chains length=%.2f", i, loop.size(), loop.Length); static char wbuffer[256]; static char buffer[10240]; sprintf(buffer, " chains:"); for (j=0; j<loop.size(); ++j) { sprintf(wbuffer, " %d[%d]", loop[j], surface._Chains[loop[j]].Chain); strcat(buffer, wbuffer); } nlinfo("%s", buffer); } }

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(). { uint chain; // for each chain, if it belongs to an edge of the // local retriever, then adds it to the _BorderChains. for (chain=0; chain<_Chains.size(); ++chain) if (_Chains[chain].isBorderChain()) { sint32 index = _BorderChains.size(); _BorderChains.push_back(chain); _Chains[chain].setBorderChainIndex(index); } }

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(). { if (A.Surface != B.Surface) { nlwarning("in NLPACS::CLocalRetriever::findPath()"); nlerror("Try to find a path between 2 points that are not in the same surface (A=%d, B=%d)", A.Surface, B.Surface); } CVector a = A.Estimation, b = B.Estimation, n = CVector(a.y-b.y, b.x-a.x, 0.0f); _ChainQuad.selectEdges(a, b, cst); vector<CIntersectionMarker> intersections; uint i, j; sint32 surfaceId = A.Surface; const CRetrievableSurface &surface = _Surfaces[surfaceId]; for (i=0; i<cst.EdgeChainEntries.size(); ++i) { CEdgeChainEntry &entry = cst.EdgeChainEntries[i]; const COrderedChain &chain = _OrderedChains[entry.OChainId]; if (_Chains[chain.getParentId()].getLeft() != surfaceId && _Chains[chain.getParentId()].getRight() != surfaceId) continue; for (j=entry.EdgeStart; j<entry.EdgeEnd; ++j) { // here the edge collision test CVector p0 = chain[j].unpack3f(), p1 = chain[j+1].unpack3f(); float vp0 = (p0-a)*n, vp1 = (p1-a)*n; if (vp0*vp1 <= 0.0f) { CVector np = CVector(p0.y-p1.y, p1.x-p0.x, 0.0f); float va = (a-p0)*np, vb = (b-p0)*np; // here we have an intersection if (va*vb <= 0.0f) { const CChain &parent = _Chains[chain.getParentId()]; bool isIn = (va-vb < 0.0f) ^ (parent.getLeft() == surfaceId) ^ chain.isForward(); intersections.push_back(CIntersectionMarker(va/(va-vb), entry.OChainId, j, isIn)); } } } } sort(intersections.begin(), intersections.end()); uint intersStart = 0; uint intersEnd = intersections.size(); if (intersEnd > 0) { while (intersStart < intersections.size() && intersections[intersStart].In && intersections[intersStart].Position < 1.0e-4f) ++intersStart; while (intersStart < intersEnd && !intersections[intersEnd-1].In && intersections[intersEnd-1].Position > 1.0f-1.0e-4f) --intersEnd; // Check intersections have a valid order if ((intersEnd-intersStart) & 1) { nlwarning("in NLPACS::CLocalRetriever::findPath()"); nlerror("Found an odd (%d) number of intersections", intersections.size()); } for (i=intersStart; i<intersEnd; ) { uint exitLoop, enterLoop; const CChain &exitChain = _Chains[_OrderedChains[intersections[i].OChain].getParentId()]; exitLoop = (exitChain.getLeft() == surfaceId) ? exitChain.getLeftLoop() : exitChain.getRightLoop(); if (intersections[i++].In) { nlwarning("in NLPACS::CLocalRetriever::findPath()"); nlerror("Entered the surface before exited", intersections.size()); } const CChain &enterChain = _Chains[_OrderedChains[intersections[i].OChain].getParentId()]; enterLoop = (enterChain.getLeft() == surfaceId) ? enterChain.getLeftLoop() : enterChain.getRightLoop(); if (!intersections[i++].In) { nlwarning("in NLPACS::CLocalRetriever::findPath()"); nlerror("Exited twice the surface", intersections.size()); } if (exitLoop != enterLoop) { nlwarning("in NLPACS::CLocalRetriever::findPath()"); nlerror("Exited and rentered by a different loop"); } } } // dumpSurface(surfaceId); path.push_back(CVector2s(A.Estimation)); for (i=intersStart; i<intersEnd; ) { uint exitChainId = _OrderedChains[intersections[i].OChain].getParentId(), enterChainId = _OrderedChains[intersections[i+1].OChain].getParentId(); const CChain &exitChain = _Chains[exitChainId], &enterChain = _Chains[enterChainId]; uint loopId, exitLoopIndex, enterLoopIndex; if (exitChain.getLeft() == surfaceId) { loopId = exitChain.getLeftLoop(); exitLoopIndex = exitChain.getLeftLoopIndex(); } else { loopId = exitChain.getRightLoop(); exitLoopIndex = exitChain.getRightLoopIndex(); } const CRetrievableSurface::TLoop &loop = surface._Loops[loopId]; if (enterChain.getLeft() == surfaceId) enterLoopIndex = enterChain.getLeftLoopIndex(); else enterLoopIndex = enterChain.getRightLoopIndex(); float forwardLength = (exitChain.getLength()+enterChain.getLength())*0.5f; sint loopIndex = exitLoopIndex; uint thisChainId = exitChainId; bool thisChainForward = (enterChain.getLeft() == surfaceId); uint thisOChainId = intersections[i].OChain; sint thisOChainIndex = _OrderedChains[thisOChainId].getIndexInParent(); bool forward; if (exitChainId != enterChainId) { for (j=(exitLoopIndex+1)%loop.size(); j!=enterLoopIndex; j=(j+1)%loop.size()) forwardLength += _Chains[surface._Chains[loop[j]].Chain].getLength(); forward = (forwardLength <= loop.Length-forwardLength); } else { forward = !thisChainForward ^ (_OrderedChains[intersections[i].OChain].getIndexInParent() < _OrderedChains[intersections[i+1].OChain].getIndexInParent()); } path.push_back(CVector2s(A.Estimation+intersections[i].Position*(B.Estimation-A.Estimation))); while (true) { sint from = (thisOChainId == intersections[i].OChain) ? intersections[i].Edge : -1, to = (thisOChainId == intersections[i+1].OChain) ? intersections[i+1].Edge : -1; bool oforward = thisChainForward ^ forward ^ _OrderedChains[thisOChainId].isForward(); if (from != -1 && to != -1) oforward = (intersections[i].Edge < intersections[i+1].Edge); _OrderedChains[thisOChainId].traverse(from, to, oforward, path); if (thisOChainId == intersections[i+1].OChain) break; thisOChainIndex = (thisChainForward ^ forward) ? thisOChainIndex-1 : thisOChainIndex+1; if (thisOChainIndex < 0 || thisOChainIndex >= (sint)_Chains[thisChainId]._SubChains.size()) { if (forward) { loopIndex++; if (loopIndex == (sint)loop.size()) loopIndex = 0; } else { loopIndex--; if (loopIndex < 0) loopIndex = loop.size()-1; } thisChainId = surface._Chains[loop[loopIndex]].Chain; thisChainForward = (_Chains[thisChainId].getLeft() == surfaceId); thisOChainIndex = (thisChainForward && forward || !thisChainForward && !forward) ? 0 : _Chains[thisChainId]._SubChains.size()-1; } thisOChainId = _Chains[thisChainId]._SubChains[thisOChainIndex]; } path.push_back(CVector2s(A.Estimation+intersections[i+1].Position*(B.Estimation-A.Estimation))); i += 2; } path.push_back(CVector2s(B.Estimation)); }

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. { _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. { if (chainId >= _Chains.size()) { nlwarning("forceBorderChainId(): couldn't force border id %d for chain %d, doesn't exist", borderId, chainId); return; } _Chains[chainId].setBorderChainIndex(borderId); }

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

Force Loaded State. Definition at line 425 of file local_retriever.h. References _Loaded. { _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(). { 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. { 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(). { 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(). { 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(). { 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(). { 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(). { 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(). { 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(). { 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(). { if (!_Loaded) return 0.0f; if (_Type == Interior) { // first preselect faces around the (x, y) position (CQuadGrid ?) vector<uint32> selection; _FaceGrid.select(position.Estimation, selection); // from the preselect faces, look for the only face that belongs to the surface // and that contains the position CVector pos = position.Estimation; CVector posh = pos+CVector(0.0f, 0.0f, 1.0f); float bestDist = 1.0e10f; CVector best; vector<uint32>::iterator it; for (it=selection.begin(); it!=selection.end(); ++it) { const CInteriorFace &f = _InteriorFaces[*it]; if (f.Surface == (uint32)position.Surface) { CVector v[3]; v[0] = _InteriorVertices[f.Verts[0]]; v[1] = _InteriorVertices[f.Verts[1]]; v[2] = _InteriorVertices[f.Verts[2]]; float a,b,c; // 2D cartesian coefficients of line in plane X/Y. // Line p0-p1. a = -(v[1].y-v[0].y); b = (v[1].x-v[0].x); c = -(v[0].x*a + v[0].y*b); if (a*pos.x + b*pos.y + c < 0) continue; // Line p1-p2. a = -(v[2].y-v[1].y); b = (v[2].x-v[1].x); c = -(v[1].x*a + v[1].y*b); if (a*pos.x + b*pos.y + c < 0) continue; // Line p2-p0. a = -(v[0].y-v[2].y); b = (v[0].x-v[2].x); c = -(v[2].x*a + v[2].y*b); if (a*pos.x + b*pos.y + c < 0) continue; CPlane p; p.make(v[0], v[1], v[2]); CVector i = p.intersect(pos, posh); float d = (float)fabs(pos.z-i.z); if (d < bestDist) { bestDist = d; best = i; } } } // and computes the real position on this face return (bestDist < 200.0f) ? best.z : position.Estimation.z; } else { if (_Surfaces[position.Surface].getQuadTree().getRoot() != NULL) { // find quad leaf. const CQuadLeaf *leaf = _Surfaces[position.Surface].getQuadTree().getLeaf(position.Estimation); // if there is no acceptable leaf, just give up if (leaf == NULL) { //nlinfo("COL: quadtree: don't find the quadLeaf!"); return position.Estimation.z; } else { // else return mean height. float meanHeight = (leaf->getMinHeight()+leaf->getMaxHeight())*0.5f; return meanHeight; } } else { sint8 qh = _Surfaces[position.Surface].getQuantHeight(); return qh*2.0f + 1.0f; } } }

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(). { return _Id; }

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

Returns the interior faces. Definition at line 493 of file local_retriever.h. References _InteriorFaces. { 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(). { 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. { 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(). { 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. { uint loop; uint loopIndex; if (_Chains[chain].getLeft() == surface) { loop = _Chains[chain]._LeftLoop; loopIndex = _Chains[chain]._LeftLoopIndex; } else { loop = _Chains[chain]._RightLoop; loopIndex = _Chains[chain]._RightLoopIndex; } const CRetrievableSurface &surf = _Surfaces[surface]; const CRetrievableSurface::TLoop &sLoop = surf._Loops[loop]; return surf._Chains[sLoop[(loopIndex+1)%sLoop.size()]].Chain; }

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(). { 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(). { 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. { uint loop; uint loopIndex; if (_Chains[chain].getLeft() == surface) { loop = _Chains[chain]._LeftLoop; loopIndex = _Chains[chain]._LeftLoopIndex; } else { loop = _Chains[chain]._RightLoop; loopIndex = _Chains[chain]._RightLoopIndex; } const CRetrievableSurface &surf = _Surfaces[surface]; const CRetrievableSurface::TLoop &sLoop = surf._Loops[loop]; return surf._Chains[sLoop[(loopIndex+sLoop.size()-1)%sLoop.size()]].Chain; }

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. { bool onLeft = _Chains[chain].getLeft() == surface; const COrderedChain3f &ochain = onLeft ? _FullOrderedChains[_Chains[chain].getSubChains().front()] : _FullOrderedChains[_Chains[chain].getSubChains().back()]; if (ochain.isForward() && onLeft || !ochain.isForward() && !onLeft) return ochain.getVertices().front(); else return ochain.getVertices().back(); }

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(). { const COrderedChain3f &ochain = _FullOrderedChains[_Chains[chain].getSubChains().front()]; return (ochain.isForward()) ? ochain.getVertices().front() : ochain.getVertices().back(); }

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. { bool onLeft = _Chains[chain].getLeft() == surface; const COrderedChain3f &ochain = onLeft ? _FullOrderedChains[_Chains[chain].getSubChains().back()] : _FullOrderedChains[_Chains[chain].getSubChains().front()]; if (ochain.isForward() && onLeft || !ochain.isForward() && !onLeft) return ochain.getVertices().back(); else return ochain.getVertices().front(); }

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(). { const COrderedChain3f &ochain = _FullOrderedChains[_Chains[chain].getSubChains().back()]; return (ochain.isForward()) ? ochain.getVertices().back() : ochain.getVertices().front(); }

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(). { 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(). { 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(). { 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(). { CFaceGrid::CFaceGridBuild fgb; fgb.init(64, 4.0f); uint i; for (i=0; i<_InteriorFaces.size(); ++i) { CAABBox box; CInteriorFace &f = _InteriorFaces[i]; box.setCenter(_InteriorVertices[f.Verts[0]]); box.extend(_InteriorVertices[f.Verts[1]]); box.extend(_InteriorVertices[f.Verts[2]]); fgb.insert(box.getMin(), box.getMax(), i); } _FaceGrid.create(fgb); }

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(). { if (!_Loaded) return false; if (local.Surface < 0 || local.Surface >= (sint)_Surfaces.size()) { nlwarning("PACS: can't insure position to inexistant surface %d", local.Surface); return false; } // the surface const NLPACS::CRetrievableSurface &surface = _Surfaces[local.Surface]; uint i, j, k; CVector2f M = CVector2f(local.Estimation); bool moved = false; // for each chain and each subchain of the surface, // check if point is located on the good side of the border (and far enough to avoid accuracy issues) for (i=0; i<surface.getChains().size(); ++i) { uint ichain = surface.getChain(i).Chain; const NLPACS::CChain &chain = _Chains[ichain]; for (j=0; j<chain.getSubChains().size(); ++j) { uint iochain = chain.getSubChain(j); const NLPACS::COrderedChain &ochain = _OrderedChains[iochain]; uint isAtLeft = ((chain.getLeft() == local.Surface) ? 1 : 0); uint isForward = (ochain.isForward() ? 1 : 0); bool shouldBeUpper = !((isAtLeft ^ isForward) != 0); // shouldBeAtLeft for vertical segment for (k=0; (sint)k<(sint)(ochain.getVertices().size()-1); ++k) { CVector2f A = ochain[k].unpack(); CVector2f B = ochain[k+1].unpack(); CVector2f AB = B-A; float lambda = ((M-A)*AB)/AB.sqrnorm(); if (lambda<0.0f || lambda>1.0f) continue; CVector2f n = (shouldBeUpper ? CVector2f(-AB.y, AB.x) : CVector2f(AB.y, -AB.x)).normed(); float d = (M-A)*n; // if point is too close of the border or on the wrong side // move it far enough if (d < InsurePositionThreshold && d > -InsurePositionThreshold) { M += (InsurePositionThreshold*1.1f-d)*n; moved = true; } } } } NLPACS::CRetrieverInstance::snapVector(M); local.Estimation.x = M.x; local.Estimation.y = M.y; { float fx1024 = local.Estimation.x * 1024.0f; float fy1024 = local.Estimation.x * 1024.0f; sint32 ix1024 = (sint32)floor(fx1024); sint32 iy1024 = (sint32)floor(fy1024); nlassert ((float)ix1024 == fx1024); nlassert ((float)iy1024 == fy1024); } return moved; }

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(). { 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. { // free subchains uint i, j; for (i=0; i<_Chains[chainId]._SubChains.size(); ++i) { FreeOChains.push_back(_Chains[chainId]._SubChains[i]); _OrderedChains[_Chains[chainId]._SubChains[i]] = COrderedChain(); _FullOrderedChains[_Chains[chainId]._SubChains[i]] = COrderedChain3f(); } // create new chains in replacement of this chain for (i=0; i<replacement.size(); ++i) { vector<CVector> vertices = replacement[i].Vertices; sint left = replacement[i].Left; sint right = replacement[i].Right; if (CChain::isBorderChainId(right)) { // check border already exists for this particular chain sint32 border = CChain::convertBorderChainId(right); if (border < (sint)_BorderChains.size() && (chainId != _BorderChains[border] || chainId != replacement[i].Chain)) { nlwarning("replaceChain(): replacement of a border is forced whereas this border is already used and not replaced!"); } if (border >= (sint)_BorderChains.size()) { if (border > (sint)_BorderChains.size()) { nlwarning("replaceChain(): _BorderChains size increased of more than 1 step, holes may result!"); } _BorderChains.resize(border+1, 0xffff); } _BorderChains[border] = replacement[i].Chain; } nlassert(vertices.size() >= 2); // Remove doubled vertices due to CVector2s snapping vector<CVector2s> converts; for (j=0; j<vertices.size(); ++j) converts.push_back(CVector2s(vertices[j])); vector<CVector2s>::iterator next2s = converts.begin(), it2s, prev2s; prev2s = next2s; ++next2s; it2s = next2s; ++next2s; vector<CVector>::iterator it3f = vertices.begin(); CVector prev3f = *it3f; ++it3f; for (; it2s != converts.end() && next2s != converts.end(); ) { // if the next point is equal to the previous if (*it2s == *prev2s || *it2s == *next2s) { // then remove the next point it2s = converts.erase(it2s); it3f = vertices.erase(it3f); prev2s = it2s; --prev2s; next2s = it2s; ++next2s; } else { // else remember the next point, and step to the next... ++prev2s; ++it2s; ++next2s; ++it3f; prev3f = *it3f; } } nlassert(vertices.size() >= 2); sint32 newId = replacement[i].Chain; if (newId >= (sint)_Chains.size()) _Chains.resize(newId+1); //CChain &nchain = _Chains[newId]; if (left>(sint)_Surfaces.size()) nlerror ("left surface id MUST be id<%d (id=%d)", _Surfaces.size(), left); if (right>(sint)_Surfaces.size()) nlerror ("right surface id MUST be id<%d (id=%d)", _Surfaces.size(), right); // checks if we can build the chain. if (newId > 65535) nlerror("in NLPACS::CLocalRetriever::addChain(): reached the maximum number of chains"); //CRetrievableSurface *leftSurface = (left>=0) ? &(_Surfaces[left]) : NULL; //CRetrievableSurface *rightSurface = (right>=0) ? &(_Surfaces[right]) : NULL; CChain &chain = _Chains[newId]; chain._StartTip = 0xffff; chain._StopTip = 0xffff; // make the chain and its subchains. chain.make(vertices, left, right, _OrderedChains, (uint16)newId, _FullOrderedChains, FreeOChains); } for (i=0; i<_Surfaces.size(); ++i) { // remove old chain and replace by new chains in surface links for (j=0; j<_Surfaces[i]._Chains.size(); ++j) { if (_Surfaces[i]._Chains[j].Chain == (sint)chainId) { _Surfaces[i]._Chains.erase(_Surfaces[i]._Chains.begin()+j); uint k; for (k=0; k<replacement.size(); ++k) { CRetrievableSurface::CSurfaceLink link; link.Chain = replacement[k].Chain; link.Surface = (replacement[k].Left == (sint)i ? replacement[k].Right : replacement[k].Left); _Surfaces[i]._Chains.push_back(link); } break; } } // remove old chain and replace by new chains in surface loops for (j=0; j<_Surfaces[i]._Loops.size(); ++j) { uint k; for (k=0; k<_Surfaces[i]._Loops[j].size(); ++k) { if (_Surfaces[i]._Loops[j][k] == chainId) { _Surfaces[i]._Loops[j].erase(_Surfaces[i]._Loops[j].begin()+k); uint m; for (m=0; m<replacement.size(); ++m) _Surfaces[i]._Loops[j].insert(_Surfaces[i]._Loops[j].begin()+k+m, replacement[m].Chain); break; } } } } }

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. { if (!_Loaded) return; CAABBox box; CVector estimated = estim.unpack3f(); const double BorderThreshold = 2.0e-2f; box.setMinMax(CVector(estimated.x-(float)BorderThreshold, _BBox.getMin().y, 0.0f), CVector(estimated.x+(float)BorderThreshold, _BBox.getMax().y, 0.0f)); uint numEdges = _ChainQuad.selectEdges(box, cst); uint ochain, i; onBorder = false; cst.PossibleSurfaces.clear(); // WARNING!! // cst.SurfaceLUT is assumed to be 0 filled !! //nldebug("estim=(%d,%d)", estim.x, estim.y); // for each ordered chain, checks if the estimated position is between the min and max. for (i=0; i<numEdges; ++i) { ochain = cst.EdgeChainEntries[i].OChainId; const COrderedChain &sub = _OrderedChains[ochain]; const CVector2s &min = sub.getMin(), &max = sub.getMax(); // checks the position against the min and max of the chain if (estim.x < min.x || estim.x > max.x) continue; bool isUpper; //bool isOnBorder = false; sint32 left = _Chains[sub.getParentId()].getLeft(), right = _Chains[sub.getParentId()].getRight(); if (estim.y < min.y) { if (estim.x == max.x) continue; isUpper = false; } else if (estim.y > max.y) { if (estim.x == max.x) continue; isUpper = true; } else { const vector<CVector2s> &vertices = sub.getVertices(); uint start = 0, stop = vertices.size()-1; // then finds the smallest segment of the chain that includes the estimated position. while (stop-start > 1) { uint mid = (start+stop)/2; if (vertices[mid].x > estim.x) stop = mid; else start = mid; } // if a vertical edge if (vertices[start].x == vertices[stop].x) { // look for maximal bounds while (start > 0 && vertices[start].x == vertices[start-1].x) --start; while (stop < vertices.size()-1 && vertices[stop].x == vertices[stop+1].x) ++stop; // if upper or lower the bounds, do nothing if (estim.y > vertices[start].y && estim.y > vertices[stop].y || estim.y < vertices[start].y && estim.y < vertices[stop].y) continue; onBorder = true; continue; } else if (vertices[stop].x == estim.x) { // if (yes) continue; } // and then checks if the estimated position is up or down the chain. // first trivial case (up both tips) if (estim.y > vertices[start].y && estim.y > vertices[stop].y) { isUpper = true; } // second trivial case (down both tips) else if (estim.y < vertices[start].y && estim.y < vertices[stop].y) { isUpper = false; } // full test... else { const CVector2s &vstart = vertices[start], &vstop = vertices[stop]; // this test is somewhat more accurate // no division performed sint32 det = (estim.y-vstart.y)*(vstop.x-vstart.x) - (estim.x-vstart.x)*(vstop.y-vstart.y); isUpper = (det > 0); if (det == 0) onBorder = true; } } // Depending on the chain is forward, up the position, increase/decrease the surface table... if (sub.isForward()) { if (isUpper) { cst.incSurface(left); cst.decSurface(right); } else { cst.decSurface(left); cst.incSurface(right); } } else { if (isUpper) { cst.decSurface(left); cst.incSurface(right); } else { cst.incSurface(left); cst.decSurface(right); } } } }

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(). { if (!_Loaded) return; CAABBox box; const double BorderThreshold = 2.0e-2f; box.setMinMax(CVector(estimated.x-(float)BorderThreshold, _BBox.getMin().y, 0.0f), CVector(estimated.x+(float)BorderThreshold, _BBox.getMax().y, 0.0f)); uint numEdges = _ChainQuad.selectEdges(box, cst); uint ochain, i; CVector2s estim = CVector2s(estimated); cst.PossibleSurfaces.clear(); // WARNING!! // cst.SurfaceLUT is assumed to be 0 filled !! //nldebug("estim=(%d,%d)", estim.x, estim.y); // for each ordered chain, checks if the estimated position is between the min and max. for (i=0; i<numEdges; ++i) { ochain = cst.EdgeChainEntries[i].OChainId; const COrderedChain &sub = _OrderedChains[ochain]; const CVector2s &min = sub.getMin(), &max = sub.getMax(); // checks the position against the min and max of the chain if (estim.x < min.x || estim.x > max.x) continue; bool isUpper; bool isOnBorder = false; sint32 left = _Chains[sub.getParentId()].getLeft(), right = _Chains[sub.getParentId()].getRight(); if (estim.y < min.y) { if (estim.x == max.x) continue; isUpper = false; // 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); } else if (estim.y > max.y) { if (estim.x == max.x) continue; isUpper = true; // 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); } else { const vector<CVector2s> &vertices = sub.getVertices(); uint start = 0, stop = vertices.size()-1; // then finds the smallest segment of the chain that includes the estimated position. while (stop-start > 1) { uint mid = (start+stop)/2; if (vertices[mid].x > estim.x) stop = mid; else start = mid; } // if a vertical edge if (vertices[start].x == vertices[stop].x) { // look for maximal bounds while (start > 0 && vertices[start].x == vertices[start-1].x) --start; while (stop < vertices.size()-1 && vertices[stop].x == vertices[stop+1].x) ++stop; // if upper or lower the bounds, do nothing if (estim.y > vertices[start].y && estim.y > vertices[stop].y || estim.y < vertices[start].y && estim.y < vertices[stop].y) continue; isOnBorder = true; if (left >= 0) { cst.SurfaceLUT[left].FoundCloseEdge = true; cst.SurfaceLUT[left].OnVerticalEdge = true; } if (right >= 0) { cst.SurfaceLUT[right].FoundCloseEdge = true; cst.SurfaceLUT[right].OnVerticalEdge = true; } // 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); continue; } else if (vertices[stop].x == estim.x) { // if (yes) continue; } // and then checks if the estimated position is up or down the chain. // first trivial case (up both tips) if (estim.y > vertices[start].y && estim.y > vertices[stop].y) { isUpper = true; // 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); } // second trivial case (down both tips) else if (estim.y < vertices[start].y && estim.y < vertices[stop].y) { isUpper = false; // 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); } // full test... else { const CVector2s &vstart = vertices[start], &vstop = vertices[stop]; sint16 intersect = vstart.y + (vstop.y-vstart.y)*(estim.x-vstart.x)/(vstop.x-vstart.x); isUpper = estim.y > intersect; isOnBorder = (fabs(estim.y - intersect)<BorderThreshold*Vector2sAccuracy); // 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"); } } if (isOnBorder) { cst.incSurface(left); cst.incSurface(right); if (left >= 0) cst.SurfaceLUT[left].FoundCloseEdge = true; if (right >= 0) cst.SurfaceLUT[right].FoundCloseEdge = true; continue; } // Depending on the chain is forward, up the position, increase/decrease the surface table... if (sub.isForward()) { if (isUpper) { cst.incSurface(left); cst.decSurface(right); } else { cst.decSurface(left); cst.incSurface(right); } } else { if (isUpper) { cst.decSurface(left); cst.incSurface(right); } else { cst.incSurface(left); cst.decSurface(right); } } } }

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(). { /* Version 0: - base version (with collision info). Version 1: - interior vertices and faces, for interior ground snapping Version 2: - face grid added. Version 3: - identifier added. Version 4: - topologies no more in stream (obsolete) */ sint ver= f.serialVersion(4); if (ver < 4) throw EOlderStream(); uint i; f.serialCont(_Chains); f.serialCont(_OrderedChains); f.serialCont(_FullOrderedChains); f.serialCont(_Surfaces); f.serialCont(__Tips); f.serialCont(_BorderChains); if (ver < 4) { for (i=0; i<NumMaxCreatureModels; ++i) f.serialCont(_Topologies[i]); } f.serial(_ChainQuad); f.serial(_BBox); f.serialEnum(_Type); f.serial(_ExteriorMesh); // a fix for old versions (with wrong _Type value) if (_Type != CLocalRetriever::Interior) _Type = CLocalRetriever::Landscape; if (ver >= 1) { f.serialCont(_InteriorVertices); f.serialCont(_InteriorFaces); } if (ver >= 2) { f.serial(_FaceGrid); } if (ver >= 3) { f.serial(_Id); } _Loaded = true; LoadCheckFlag = false; }

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(). { _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(). { _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. { _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. { _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(). { _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(). { if (!_Loaded) return; // first preselect faces around the (x, y) position (CQuadGrid ?) vector<uint32> selection; _FaceGrid.select(position.Estimation, selection); // from the preselect faces, look for the only face that belongs to the surface // and that contains the position CVector pos = position.Estimation; CVector posh = pos+CVector(0.0f, 0.0f, 1.0f); CVector2f pos2d = position.Estimation; float bestDist = 1.0e10f; CVector best; vector<uint32>::iterator it; snapped = false; for (it=selection.begin(); it!=selection.end(); ++it) { const CInteriorFace &f = _InteriorFaces[*it]; if (f.Surface == (uint32)position.Surface) { CVector v[3]; v[0] = _InteriorVertices[f.Verts[0]]; v[1] = _InteriorVertices[f.Verts[1]]; v[2] = _InteriorVertices[f.Verts[2]]; CVector2f n; float c; // 2D cartesian coefficients of line in plane X/Y. // Line p0-p1. n = CVector2f(-(v[1].y-v[0].y), (v[1].x-v[0].x)).normed(); c = -(v[0].x*n.x + v[0].y*n.y); if (n*pos2d + c < -1.0f/Vector2sAccuracy) continue; // Line p1-p2. n = CVector2f(-(v[2].y-v[1].y), (v[2].x-v[1].x)).normed(); c = -(v[1].x*n.x + v[1].y*n.y); if (n*pos2d + c < -1.0f/Vector2sAccuracy) continue; // Line p2-p0. n = CVector2f(-(v[0].y-v[2].y), (v[0].x-v[2].x)).normed(); c = -(v[2].x*n.x + v[2].y*n.y); if (n*pos2d + c < -1.0f/Vector2sAccuracy) continue; CPlane p; p.make(v[0], v[1], v[2]); CVector i = p.intersect(pos, posh); float d = (float)fabs(pos.z-i.z); if (d < bestDist) { bestDist = d; best = i; } } } // and computes the real position on this face if (bestDist < 400.0f) { snapped = true; position.Estimation = best; } }

void NLPACS::CLocalRetriever::sortTips (   )

Sorts chains references inside the tips. NOT IMPLEMENTED YET. Definition at line 775 of file local_retriever.cpp. { }

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(). { if (!_Loaded) return; // H_AUTO(PACS_LR_testCollision); sint i; // 0. select ordered chains in the chainquad. //===================================== // H_BEFORE(PACS_LR_testCol_selEdges); sint nEce= _ChainQuad.selectEdges(bboxMove, cst); // H_AFTER(PACS_LR_testCol_selEdges); // NB: cst.OChainLUT is assured to be full of 0xFFFF after this call (if was right before). // 1. regroup them in chains. build cst.CollisionChains //===================================== // NB: use cst.OChainLUT to look if a Chain has been inserted before. uint16 *chainLUT= cst.OChainLUT; // bkup where we begin to add chains. uint firstChainAdded= cst.CollisionChains.size(); // For all edgechain entry. for(i=0;i<nEce;i++) { CEdgeChainEntry &ece= cst.EdgeChainEntries[i]; // this is the ordered chain in the retriever. const COrderedChain &oChain= this->getOrderedChains()[ece.OChainId]; // this is the id of the chain is the local retriever. uint16 chainId= oChain.getParentId(); // test if edge is interior and points to another instance // \todo Ben: flag interior chains that points to doors to speed up the test if (_Type == Interior && CChain::isBorderChainId(this->getChains()[chainId].getRight())) { // then look for a door that match this edge uint l; for (l=0; l<_ExteriorMesh.getLinks().size() && _ExteriorMesh.getLink(l).ChainId != chainId; ++l) ; // if found a door, then leave the edge as is if (l < _ExteriorMesh.getLinks().size()) continue; } // add/retrieve the id in cst.CollisionChains. //================================= uint ccId; // if never added. if(chainLUT[chainId]==0xFFFF) { // H_AUTO(PACS_LR_testCol_addToLUT); // add a new CCollisionChain. ccId= cst.CollisionChains.size(); cst.CollisionChains.push_back(CCollisionChain()); // Fill it with default. cst.CollisionChains[ccId].Tested= false; cst.CollisionChains[ccId].ExteriorEdge = false; cst.CollisionChains[ccId].FirstEdgeCollide= 0xFFFFFFFF; cst.CollisionChains[ccId].ChainId= chainId; // Fill Left right info. cst.CollisionChains[ccId].LeftSurface.SurfaceId= this->getChains()[chainId].getLeft(); cst.CollisionChains[ccId].RightSurface.SurfaceId= this->getChains()[chainId].getRight(); // NB: cst.CollisionChains[ccId].*Surface.RetrieverInstanceId is not filled here because we don't have // this info at this level. // store this Id in the LUT of chains. chainLUT[chainId]= ccId; } else { // get the id of this collision chain. ccId= chainLUT[chainId]; } // add edge collide to the list. //================================= // H_BEFORE(PACS_LR_testCol_addToList); CCollisionChain &colChain= cst.CollisionChains[ccId]; const std::vector<CVector2s> &oChainVertices= oChain.getVertices(); for(sint edge=ece.EdgeStart; edge<ece.EdgeEnd; edge++) { CVector2f p0= oChainVertices[edge].unpack(); CVector2f p1= oChainVertices[edge+1].unpack(); // alloc a new edgeCollide. uint32 ecnId= cst.allocEdgeCollideNode(); CEdgeCollideNode &ecn= cst.getEdgeCollideNode(ecnId); // append to the front of the list. ecn.Next= colChain.FirstEdgeCollide; colChain.FirstEdgeCollide= ecnId; // build this edge. p0+= transBase; p1+= transBase; ecn.make(p0, p1); } // H_AFTER(PACS_LR_testCol_addToList); } // 2. Reset LUT to 0xFFFF. //===================================== // H_BEFORE(PACS_LR_testCol_resetLUT); // for all collisions chains inserted (starting from firstChainAdded), reset LUT. for(i=firstChainAdded; i<(sint)cst.CollisionChains.size(); i++) { uint ccId= cst.CollisionChains[i].ChainId; chainLUT[ccId]= 0xFFFF; } // H_AFTER(PACS_LR_testCol_resetLUT); }

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(). { if (!_Loaded) return false; if (local.Surface < 0 || local.Surface >= (sint)_Surfaces.size()) { nlwarning("PACS: can't test inexistant surface %d", local.Surface); return false; } if (fabs(local.Estimation.x) >= 256.0 || fabs(local.Estimation.y) >= 256.0) return false; retrievePosition(local.Estimation, cst); bool result = (cst.SurfaceLUT[local.Surface].Counter == 2 || cst.SurfaceLUT[local.Surface].OnVerticalEdge); uint i; for (i=0; i<cst.PossibleSurfaces.size(); ++i) cst.SurfaceLUT[cst.PossibleSurfaces[i]].reset(); return result; }

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. { uint i; for (i=0; i<_OrderedChains.size(); ++i) _OrderedChains[i].translate(translation); for (i=0; i<_Surfaces.size(); ++i) _Surfaces[i].translate(translation); /* for (i=0; i<_Tips.size(); ++i) _Tips[i].translate(translation); */ }

void NLPACS::CLocalRetriever::unify (   )

Definition at line 206 of file local_retriever.cpp. Referenced by NLPACS::computeRetriever(). { /* uint i, j; for (i=0; i<_Chains.size(); ++i) _Chains[i].unify(_OrderedChains); for (i=0; i<_Tips.size(); ++i) { NLPACS::CLocalRetriever::CTip &tip = _Tips[i]; CVector2s ptip = tip.Point; for (j=0; j<tip.Chains.size(); ++j) { if (tip.Chains[j].Start) { if (_Chains[tip.Chains[j].Chain].getStartVector(_OrderedChains) != ptip) nlwarning("chain %d is not stuck to tip %d", tip.Chains[j].Chain, i); _Chains[tip.Chains[j].Chain].setStartVector(ptip, _OrderedChains); } else { if (_Chains[tip.Chains[j].Chain].getStopVector(_OrderedChains) != ptip) nlwarning("chain %d is not stuck to tip %d", tip.Chains[j].Chain, i); _Chains[tip.Chains[j].Chain].setStopVector(ptip, _OrderedChains); } } } _FullOrderedChains.resize(_OrderedChains.size()); for (i=0; i<_OrderedChains.size(); ++i) _FullOrderedChains[i].unpack(_OrderedChains[i]); */ }

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(). { uint surf, link; for (surf=0; surf<_Surfaces.size(); ++surf) { CRetrievableSurface &surface = _Surfaces[surf]; for (link=0; link<surface._Chains.size(); ++link) { sint32 chain = surface._Chains[link].Chain; if (_Chains[chain]._Left == (sint32)surf) surface._Chains[link].Surface = _Chains[chain]._Right; else if (_Chains[chain]._Right == (sint32)surf) surface._Chains[link].Surface = _Chains[chain]._Left; else { nlwarning("in NLPACS::CLocalRetriever::updateEdgesOnSurfaces()"); nlerror("Can't find back point to surface %d on chain %d", surf, chain); } } } }

---

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:

• local_retriever.h
• local_retriever.cpp

---