khanat-opennel-code/code/nel/src/pacs/local_retriever.h

647 lines
19 KiB
C
Raw Normal View History

2010-05-06 00:08:41 +00:00
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#ifndef NL_LOCAL_RETRIEVER_H
#define NL_LOCAL_RETRIEVER_H
#include <vector>
#include <string>
#include <list>
#include "nel/misc/types_nl.h"
#include "nel/misc/vector.h"
#include "nel/misc/file.h"
#include "nel/misc/aabbox.h"
#include "nel/misc/polygon.h"
#include "vector_2s.h"
#include "surface_quad.h"
#include "chain.h"
#include "retrievable_surface.h"
#include "chain_quad.h"
#include "exterior_mesh.h"
#include "face_grid.h"
#include "nel/pacs/u_global_position.h"
namespace NLPACS
{
class CCollisionSurfaceTemp;
/**
* A surface retriever, located by its bounding box.
* \author Benjamin Legros
* \author Nevrax France
* \date 2001
*/
class CLocalRetriever
{
public:
/**
* A tip of several chains. A CTip can contain more than 2 chains.
* \author Benjamin Legros
* \author Nevrax France
* \date 2001
*/
class CTip
{
public:
/**
* A chain tip. Contains the id of the chain and whether this tip is the start of the chain.
* \author Benjamin Legros
* \author Nevrax France
* \date 2001
*/
struct CChainTip
{
/// The id of the chain.
sint32 Chain;
/// True if this tip is the beginning of the chain.
bool Start;
/// Constructor.
CChainTip(sint32 chainId = 0, bool start = 0) : Chain(chainId), Start(start) {}
/// Serielaises the CChainTip
void serial(NLMISC::IStream &f) { f.serial(Chain, Start); }
};
CTip() : Point(NLMISC::CVector::Null) {}
/// The position of the tip.x
NLMISC::CVector Point;
// The chains linked to that tip.
std::vector<CChainTip> Chains;
public:
/// Serialises the CTip.
void serial(NLMISC::IStream &f)
{
f.serial(Point);
f.serialCont(Chains);
}
/// Translates the CTip by the translation vector.
void translate(const NLMISC::CVector &translation)
{
Point += translation;
}
};
/**
* A topology. It's a set of surfaces which are definning a connex master surface.
* \author Benjamin Legros
* \author Nevrax France
* \date 2001
*/
class CTopology : public std::vector<sint32>
{
public:
void serial(NLMISC::IStream &f) { f.serialCont(*this); }
};
/**
* An estimation of the position of a point on a specified surface.
* The estimated position is LOCAL reference to the retriever axis.
* \author Benjamin Legros
* \author Nevrax France
* \date 2001
*/
class CLocalPosition : public ULocalPosition
{
public:
/// Constructor.
CLocalPosition(sint32 surface=-1, const NLMISC::CVector &estimation=NLMISC::CVector::Null)
{
Surface=surface;
Estimation=estimation;
}
/// Serialises the CLocalPosition.
//void serial(NLMISC::IStream &f) { f.serial(Surface, Estimation); }
};
/**
* The different types of retriever (landscape or interior.)
* \author Benjamin Legros
* \author Nevrax France
* \date 2001
*/
enum EType
{
Landscape = 0,
Interior
};
/**
* The faces used for snapping in interior retrievers.
* \author Benjamin Legros
* \author Nevrax France
* \date 2001
*/
class CInteriorFace
{
public:
uint32 Verts[3];
uint32 Surface;
public:
void serial(NLMISC::IStream &f) { f.serial(Verts[0], Verts[1], Verts[2], Surface); }
};
/**
* An iterator to go through chains without bothering about ordered chains and those kind of f*cking stuffs
* \author Benjamin Legros
* \author Nevrax France
* \date 2003
*/
class CIterator
{
friend class CLocalRetriever;
protected:
/// The referent retriever
const CLocalRetriever *_Retriever;
/// Chain Id
uint16 _Chain;
/// The current ochain in chain
uint16 _OChainIndex;
/// The current vertex in ochain
sint16 _IndexInOChain;
/// Max index in ochain
sint16 _MaxIndexInOChain;
/// Is ochain forward?
bool _OChainForward;
public:
/// Constructor
CIterator(const CLocalRetriever *retriever, uint chain)
{
_Retriever = retriever;
_Chain = uint16(chain);
_OChainIndex = 0;
setupIndex();
}
CIterator &operator ++ ()
{
const CChain &chain = _Retriever->getChain(_Chain);
if (_OChainIndex >= chain.getSubChains().size())
return *this;
if (_OChainForward)
{
++_IndexInOChain;
if (((sint)_OChainIndex < (sint)chain.getSubChains().size()-1 && _IndexInOChain == _MaxIndexInOChain) || _IndexInOChain > _MaxIndexInOChain)
{
++_OChainIndex;
setupIndex();
}
}
else
{
--_IndexInOChain;
if (((sint)_OChainIndex < (sint)chain.getSubChains().size()-1 && _IndexInOChain == 0) || _IndexInOChain < 0)
{
++_OChainIndex;
setupIndex();
}
}
return *this;
}
CVector2s operator * () const
{
if (end())
return CVector2s();
return _Retriever->getOrderedChain(_Retriever->getChain(_Chain).getSubChain(_OChainIndex))[_IndexInOChain];
}
CVector get3d() const
{
if (end())
return CVector::Null;
return _Retriever->getFullOrderedChain(_Retriever->getChain(_Chain).getSubChain(_OChainIndex))[_IndexInOChain];
}
/// Test end
bool end() const
{
return (_OChainIndex >= _Retriever->getChain(_Chain).getSubChains().size());
}
private:
/// Setup index in ochain
void setupIndex()
{
const CChain &chain = _Retriever->getChain(_Chain);
if (_OChainIndex >= chain.getSubChains().size())
return;
const COrderedChain &ochain = _Retriever->getOrderedChain(chain.getSubChain(_OChainIndex));
_OChainForward = ochain.isForward();
_MaxIndexInOChain = sint16(ochain.getVertices().size()-1);
_IndexInOChain = (_OChainForward ? 0 : _MaxIndexInOChain);
}
};
protected:
friend class CRetrieverInstance;
/// The chains insinde the zone.
std::vector<COrderedChain> _OrderedChains;
std::vector<COrderedChain3f> _FullOrderedChains;
/// The chains insinde the zone.
std::vector<CChain> _Chains;
/// The surfaces inside the zone.
std::vector<CRetrievableSurface> _Surfaces;
/// The bbox of the local retriever
NLMISC::CAABBox _BBox;
/// The tips making links between different chains.
std::vector<CTip> __Tips;
/// The chains on the edges of the zone.
std::vector<uint16> _BorderChains;
/// The topologies within the zone.
std::vector<CTopology> _Topologies[NumMaxCreatureModels];
/// The tip recognition threshold
static const float _TipThreshold;
/// The tip recognition threshold
static const float _EdgeTipThreshold;
/// For collisions, the chainquad.
CChainQuad _ChainQuad;
/// The type of the retriever
EType _Type;
/// \name Internior retriever specific
// @{
/// The exterior mesh, for collisions
CExteriorMesh _ExteriorMesh;
/// The vertices of the collision mesh
std::vector<NLMISC::CVector> _InteriorVertices;
/// The faces of the collision mesh
std::vector<CInteriorFace> _InteriorFaces;
/// The face selection grid
CFaceGrid _FaceGrid;
/// An human readable identifier of the retriever.
std::string _Id;
// @}
/// Tells if retriever is loaded
bool _Loaded;
public:
///
bool LoadCheckFlag;
private:
/// The intersection between an ordered chain and the path.
struct CIntersectionMarker
{
float Position;
uint16 OChain;
uint16 Edge;
bool In;
CIntersectionMarker() {}
CIntersectionMarker(float position, uint16 ochain, uint16 edge, bool in) : Position(position), OChain(ochain), Edge(edge), In(in) {}
bool operator< (const CIntersectionMarker &comp) const { return Position < comp.Position; }
};
public:
/// @name Constructors
// @{
CLocalRetriever();
// @}
/// @name Selectors
// @{
/// Returns the chain tips inside the local retrievers.
//const std::vector<CTip> &getTips() const { return _Tips; }
/// Returns the nth tip in the retriever.
//const CTip &getTip(uint n) const { return _Tips[n]; }
/// Returns the ordered chains.
const std::vector<COrderedChain> &getOrderedChains() const { return _OrderedChains; }
/// Returns the nth ordered chain.
const COrderedChain &getOrderedChain(uint n) const { return _OrderedChains[n]; }
/// Returns the full ordered chains.
const std::vector<COrderedChain3f> &getFullOrderedChains() const { return _FullOrderedChains; }
/// Returns the nth full ordered chain.
const COrderedChain3f &getFullOrderedChain(uint n) const { return _FullOrderedChains[n]; }
/// Returns the chains.
const std::vector<CChain> &getChains() const { return _Chains; }
/// retruns the nth chain.
const CChain &getChain(uint n) const { return _Chains[n]; }
/// Returns the ids of the chains on the edges of the retriever.
const std::vector<uint16> &getBorderChains() const { return _BorderChains; }
/// Returns the id of the nth chain on the edges of the retriever.
uint16 getBorderChain(uint n) const { return _BorderChains[n]; }
/// Returns the surfaces.
const std::vector<CRetrievableSurface> &getSurfaces() const { return _Surfaces; }
/// Returns the nth surface.
const CRetrievableSurface &getSurface(uint n) const { return _Surfaces[n]; }
/// Returns the type of the retriever
EType getType() const { return _Type; }
/// Returns the bbox
const NLMISC::CAABBox &getBBox() const { return _BBox; }
/// Returns the exterior mesh of the retriever
const CExteriorMesh &getExteriorMesh() const { return _ExteriorMesh; }
/// Returns the interior vertices
const std::vector<NLMISC::CVector> &getInteriorVertices() const { return _InteriorVertices; }
/// Returns the interior faces
const std::vector<CInteriorFace> &getInteriorFaces() const { return _InteriorFaces; }
/// Returns the identifier of the retriever.
const std::string &getIdentifier() const { return _Id; }
/// Is loaded ?
bool isLoaded() const { return _Loaded; }
/// Force Loaded State.
void forceLoaded(bool state) { _Loaded= state; }
/// build BBoxes of interior surfaces in surfaceBBoxes (cleared first)
void buildInteriorSurfaceBBoxes(std::vector<NLMISC::CAABBox> &surfaceBBoxes) const;
/// Builds the polygons (loops) of a given surface
void buildSurfacePolygons(uint32 surface, std::list<NLMISC::CPolygon> &polygons) const;
/// Builds the polygons (loops) of all surfaces in the retriever
void buildSurfacePolygons(std::list< std::list<NLMISC::CPolygon> > &polygons) const
{
uint i;
for (i=0; i<_Surfaces.size(); ++i)
{
polygons.push_back(std::list<NLMISC::CPolygon>());
buildSurfacePolygons(i, polygons.back());
}
}
/// Builds the polygons (loops) of a given surface
void build3dSurfacePolygons(uint32 surface, std::list<NLMISC::CPolygon> &polygons) const;
/// Builds the polygons (loops) of all surfaces in the retriever
void build3dSurfacePolygons(std::list< std::list<NLMISC::CPolygon> > &polygons) const
{
uint i;
for (i=0; i<_Surfaces.size(); ++i)
{
polygons.push_back(std::list<NLMISC::CPolygon>());
build3dSurfacePolygons(i, polygons.back());
}
}
// @}
/// @name Mutators
//@{
/// Adds a surface to the local retriever, using its features. Returns the id of the newly created surface.
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 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
*/
sint32 addChain(const std::vector<NLMISC::CVector> &vertices,
sint32 left, sint32 right);
/// Set the type of the retriever (see EType)
void setType(EType type) { _Type = type; }
/// Sets the exterior mesh
void setExteriorMesh(const CExteriorMesh &em) { _ExteriorMesh = em; }
/// Sets the bbox of the retriever
void setBBox(const NLMISC::CAABBox &bbox) { _BBox = bbox; }
/// Returns the interior vertices
std::vector<NLMISC::CVector> &getInteriorVertices() { return _InteriorVertices; }
/// Returns the interior faces
std::vector<CInteriorFace> &getInteriorFaces() { return _InteriorFaces; }
/// Returns the identifier of the retriever.
void setIdentifier(const std::string &id) { _Id = id; }
/// Returns the chain quad
CChainQuad &getChainQuad() { return _ChainQuad; }
/// Inits the face grid
void initFaceGrid();
/// Builds topologies tables.
void computeTopologies();
/// Builds tips
void computeLoopsAndTips();
/// Found chains on the edges of the retriever and fills _BorderChains tables.
void findBorderChains();
/// Updates surfaces links from the links contained in the chains...
void updateChainIds();
/// Sorts chains references inside the tips. NOT IMPLEMENTED YET.
void sortTips();
/// Translates the local retriever by the translation vector.
void translate(const NLMISC::CVector &translation);
///
void flushFullOrderedChains() { _FullOrderedChains.clear(); }
///
void setFullOrderedChains(const std::vector<COrderedChain3f> &foc) { _FullOrderedChains = foc; }
/// Serialises the CLocalRetriever.
void serial(NLMISC::IStream &f);
/// Clear
void clear();
// @}
/// \name Collisions part.
// @{
/// compute the chain quad, used for collisions. the ChainQuad is serialised in serial(). _OrderedChains must be OK.
void computeCollisionChainQuad();
/** add possible collisions chains to the temp result.
* \param cst the temp result to store collision chains. they are appened to cst.CollisionChains.
* \param bboxMove the bbox which bounds the movement of the entity.
* \param transBase the vector we use to translate local position of edge.
*/
void testCollision(CCollisionSurfaceTemp &cst, const NLMISC::CAABBox &bboxMove, const NLMISC::CVector2f &transBase) const;
/**
* Check all surfaces integrity
*/
bool checkSurfacesIntegrity(NLMISC::CVector translation = NLMISC::CVector::Null, bool verbose = false) const;
/**
* Check surface integrity
*/
bool checkSurfaceIntegrity(uint surf, NLMISC::CVector translation = NLMISC::CVector::Null, bool verbose = false) const;
// @}
/*
protected:
*/
/// Assures a position is really inside a surface (and independent from any accuracy issue) and returns true if the position was moved.
bool insurePosition(ULocalPosition &local) 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 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
bool testPosition(ULocalPosition &local, CCollisionSurfaceTemp &cst) const;
/// Snaps on the ground
void snapToInteriorGround(ULocalPosition &position, bool &snapped) const;
/// Get the height of surface that matches the best this position
float getHeight(const ULocalPosition &position) const;
/// Finds a path in a given surface, from the point A to the point B.
void findPath(const CLocalPosition &A, const CLocalPosition &B, std::vector<CVector2s> &path, NLPACS::CCollisionSurfaceTemp &cst) const;
///
void unify();
/** Get the height of interior surface that matches the best this position. Allows the position to be a bit outside the triangles.
* return 0 if not loaded or not an interior surface.
* \param outsideTolerance how much are we allowed to look outside the triangles
*/
float getInteriorHeightAround(const ULocalPosition &position, float outsideTolerance) const;
public:
// Last minute fix... Some issues appeared when linking (trying to link 2 chains with only 1 in the neighbourhood)
class CChainReplacement
{
public:
uint Chain;
sint Left, Right;
std::vector<NLMISC::CVector> Vertices;
};
// temp object to store replaced ochain ids
std::vector<uint> FreeOChains;
void replaceChain(uint32 chainId, const std::vector<CChainReplacement> &replacement);
void forceBorderChainId(uint32 chainId, uint32 borderId)
{
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);
}
public:
const NLMISC::CVector &getStartVector(uint32 chain) const;
const NLMISC::CVector &getStopVector(uint32 chain) const;
const NLMISC::CVector &getStartVector(uint32 chain, sint32 surface) const;
const NLMISC::CVector &getStopVector(uint32 chain, sint32 surface) const;
/*
uint16 getStartTip(uint32 chain, sint32 surface) const;
uint16 getStopTip(uint32 chain, sint32 surface) const;
void setStartTip(uint32 chain, sint32 surface, uint16 startTip);
void setStopTip(uint32 chain, sint32 surface, uint16 stopTip);
*/
uint32 getPreviousChain(uint32 chain, sint32 surface) const;
uint32 getNextChain(uint32 chain, sint32 surface) const;
public:
void dumpSurface(uint surf, const NLMISC::CVector &vect = NLMISC::CVector::Null) const;
float distanceToBorder(const ULocalPosition &pos) const;
};
}; // NLPACS
#endif // NL_LOCAL_RETRIEVER_H
/* End of local_retriever.h */