NeL: NL3D::CVisualCollisionManager class Reference

00053                                                  : 
00054         _TileDescNodeAllocator(TileDescNodeAllocatorBlockSize), 
00055         _PatchQuadBlockAllocator(PatchQuadBlockAllocatorBlockSize)
00056 {
00057         _Landscape= NULL;
00058 
00059         // Default.
00060         setSunContributionPower(0.5f, 0.5f);
00061 
00062         // init the mesh quadGrid
00063         _MeshQuadGrid.create(MeshColQuadGridSize, MeshColQuadGridEltSize);
00064         // valid id start at 1
00065         _MeshIdPool= 1;
00066 }

00069 {
00070         _Landscape= NULL;
00071 }

00402 {
00403         if(vertices.empty() || triangles.empty())
00404                 return 0;
00405         // triangles id are stored in uint16 form. so their should not be more than 65535*3 indices
00406         if(vertices.size()>65535 || triangles.size()>65535*3)
00407                 return 0;
00408 
00409         // allocate a new id
00410         uint32  id= _MeshIdPool++;
00411 
00412         // insert in map
00413         CMeshCol        &mesh= _Meshs[id];
00414 
00415         // Build the col mesh
00416         mesh.build(vertices, triangles);
00417 
00418         // insert in quadGrid
00419         mesh.QuadGridIt= _MeshQuadGrid.insert(mesh.BBox.getMin(), mesh.BBox.getMax(), &mesh);
00420 
00421         return id;
00422 }

00083 {
00084         return new CVisualCollisionEntity(this);
00085 }

00090 {
00091         delete entity;
00092 }

00115 {
00116         _PatchQuadBlockAllocator.free(ptr);
00117 }

00103 {
00104         _TileDescNodeAllocator.free(ptr);
00105 }

00145 {
00146         float   minCol= 1;
00147 
00148         // try col with landscape
00149         if(_Landscape)
00150         {
00151                 minCol= _Landscape->getCameraCollision(start, end, radius, cone);
00152         }
00153 
00154         // try col with meshes
00155         CCameraCol              camCol;
00156         camCol.build(start, end, radius, cone);
00157         _MeshQuadGrid.select(camCol.BBox.getMin(), camCol.BBox.getMax());
00158         // try to intersect with any meshs
00159         CQuadGrid<CMeshCol*>::CIterator         it;
00160         for(it= _MeshQuadGrid.begin();it!=_MeshQuadGrid.end();it++)
00161         {
00162                 float   meshCol= (*it)->getCameraCollision(camCol);
00163                 // Keep only yhe smallest value
00164                 minCol= min(minCol, meshCol);
00165         }
00166 
00167         return minCol;
00168 }

00109 {
00110         return _PatchQuadBlockAllocator.allocate();
00111 }

00097 {
00098         return _TileDescNodeAllocator.allocate();
00099 }

00426 {
00427         // find in map
00428         TMeshColMap::iterator   it= _Meshs.find(id);
00429         if(it!=_Meshs.end())
00430         {
00431                 // remove from the quadgrid
00432                 _MeshQuadGrid.erase(it->second.QuadGridIt);
00433                 // remove from the map
00434                 _Meshs.erase(it);
00435         }
00436 }

00076 {
00077         _Landscape= landscape;
00078 }

00122 {
00123         NLMISC::clamp(power, 0.f, 1.f);
00124 
00125         for(uint i=0; i<256; i++)
00126         {
00127                 float   f= i/255.f;
00128                 f = powf(f/maxThreshold, power);
00129                 sint    uf= (sint)floor(255*f);
00130                 NLMISC::clamp(uf, 0, 255);
00131                 _SunContributionLUT[i]= uf;
00132         }
00133 
00134 }


Public Member Functions
uint	addMeshCollision (const std::vector< CVector > &vertices, const std::vector< uint16 > &triangles)
CVisualCollisionEntity *	createEntity ()
	CVisualCollisionManager ()
	Constructor.
void	deleteEntity (CVisualCollisionEntity *entity)
float	getCameraCollision (const CVector &start, const CVector &end, float radius, bool cone)
void	removeMeshCollision (uint id)
void	setLandscape (CLandscape *landscape)
void	setSunContributionPower (float power, float maxThreshold)
	~CVisualCollisionManager ()
Private Types
typedef std::map< uint32, CMeshCol >	TMeshColMap
Private Member Functions
void	deletePatchQuadBlock (CPatchQuadBlock *ptr)
void	deleteVisualTileDescNode (CVisualTileDescNode *ptr)
CPatchQuadBlock *	newPatchQuadBlock ()
CVisualTileDescNode *	newVisualTileDescNode ()
Private Attributes
NLMISC::CRefPtr< CLandscape >	_Landscape
	The landscape used to generate tiles, and to snap position to tesselated ground.
uint32	_MeshIdPool
CQuadGrid< CMeshCol * >	_MeshQuadGrid
TMeshColMap	_Meshs
CBlockMemory< CPatchQuadBlock >	_PatchQuadBlockAllocator
uint8	_SunContributionLUT [256]
CBlockMemory< CVisualTileDescNode >	_TileDescNodeAllocator
	Allocators.
Friends
class	CLandscapeCollisionGrid
class	CVisualCollisionEntity

NL3D::CVisualCollisionManager Class Reference

Detailed Description

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Friends

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Field Documentation