NL3D::CVisualCollisionEntity Class Reference

#include <visual_collision_entity.h>

---

Detailed Description

An entity created by CVisualCollisionManager.

Author:

Lionel Berenguier

Nevrax France

Date:

2001

Definition at line 50 of file visual_collision_entity.h.

Landscape part.
void	doComputeLandscape (const CVector &pos)
	compute tiles infos around the position.
CTrianglePatch *	getPatchTriangleUnderUs (const CVector &pos, CVector &res)
void	snapToLandscapeCurrentTesselation (CVector &pos, const CTrianglePatch &tri)
	snap to current rendered tesselation.
void	testComputeLandscape (const CVector &pos)
	test if the new position is outside the preceding setuped bbox, and then compute tiles infos around the position.
bool	triangleIntersect (CTriangle &tri, const CVector &pos0, const CVector &pos1, CVector &hit)
	Fast "2D" test of a triangle against ray P0 P1.
CAABBox	_CurrentBBoxValidity
	The current BBox where we don't need to recompute the patchQuadBlocks if the entity is in.
CLandscapeCollisionGrid	_LandscapeQuadGrid
	A quadgrid of chainlist of tileId (CVisualTileDescNode), which are around the entity.
CVector	_LastGPTPosInput
	compute tiles infos around the position.
CVector	_LastGPTPosOutput
	compute tiles infos around the position.
CTrianglePatch	_LastGPTTrianglePatch
	compute tiles infos around the position.
bool	_LastGPTValid
	Cache for getPatchTriangleUnderUs().
std::vector< CPatchQuadBlock * >	_PatchQuadBlocks
void	computeUvForPos (const CTrianglePatch &tri, const CVector &pos, CUV &uv)
	given a CTrianglePatch, compute Patch uv according to position.
bool	triangleIntersect2DCeil (CTriangle &tri, const CVector &pos0)
	compute tiles infos around the position.
bool	triangleIntersect2DGround (CTriangle &tri, const CVector &pos0)
	Fast "2D" test of a triangle against ray P0 P1.
const uint32	_StartPatchQuadBlockSize = 64
	Default capacity of _PatchQuadBlocks.
std::vector< CPatchBlockIdent >	_TmpBlockIds
	This is the temp array of BlockIds filled by landscape search.
std::vector< CPatchQuadBlock * >	_TmpPatchQuadBlocks
	This is the temp array of PatchBlocks ptr.
Public Member Functions
	CVisualCollisionEntity (CVisualCollisionManager *owner)
	Constructor.
bool	getCeilMode () const
bool	getGroundMode () const
bool	getSnapToRenderedTesselation () const
bool	getSurfaceInfo (const CVector &pos, CSurfaceInfo &info)
void	setCeilMode (bool ceilMode)
void	setGroundMode (bool groundMode)
void	setSnapToRenderedTesselation (bool snapMode)
bool	snapToGround (CVector &pos, CVector &normal)
bool	snapToGround (CVector &pos)
	~CVisualCollisionEntity ()
Debug display
void	displayDebugGrid (IDriver &drv) const
	Draw lines for the landscape quadgrid collision faces under us.
Static Lighting
bool	getStaticLightSetup (const CVector &pos, std::vector< CPointLightInfluence > &pointLightList, uint8 &sunContribution, NLMISC::CRGBA &localAmbient)
Static Public Attributes
Parameters.
const float	BBoxRadius = 10
	This is the radius of the bbox around the entity where we have correct collisions: 10m.
const float	BBoxRadiusZ = 20
Private Attributes
bool	_CeilMode
bool	_GroundMode
CVisualCollisionManager *	_Owner
bool	_SnapToRenderedTesselation

---

Constructor & Destructor Documentation

NL3D::CVisualCollisionEntity::CVisualCollisionEntity (  CVisualCollisionManager *  owner  )

Constructor. Definition at line 56 of file visual_collision_entity.cpp. References _CeilMode, _CurrentBBoxValidity, _GroundMode, _LastGPTValid, _PatchQuadBlocks, _SnapToRenderedTesselation, _StartPatchQuadBlockSize, and NLMISC::CAABBox::setHalfSize(). : _LandscapeQuadGrid(owner) { _Owner= owner; _PatchQuadBlocks.reserve(_StartPatchQuadBlockSize); _CurrentBBoxValidity.setHalfSize(CVector::Null); _GroundMode= true; _CeilMode= false; _SnapToRenderedTesselation= true; _LastGPTValid= false; }

NL3D::CVisualCollisionEntity::~CVisualCollisionEntity (   )

Definition at line 72 of file visual_collision_entity.cpp. References _LandscapeQuadGrid, _PatchQuadBlocks, NL3D::CLandscapeCollisionGrid::clear(), NL3D::CVisualCollisionManager::deletePatchQuadBlock(), and sint. { // delete the _PatchQuadBlocks. for(sint i=0; i<(sint)_PatchQuadBlocks.size(); i++) { _Owner->deletePatchQuadBlock(_PatchQuadBlocks[i]); } _PatchQuadBlocks.clear(); // delete the quadgrid. _LandscapeQuadGrid.clear(); }

---

Member Function Documentation

void NL3D::CVisualCollisionEntity::computeUvForPos (  const CTrianglePatch &  tri, const CVector &  pos, CUV &  uv )  [static, private]

given a CTrianglePatch, compute Patch uv according to position. Definition at line 247 of file visual_collision_entity.cpp. References NLMISC::CTriangle::computeGradient(), NLMISC::CUV::U, NLMISC::CTriangleUV::Uv0, NLMISC::CTriangleUV::Uv1, NLMISC::CTriangleUV::Uv2, NLMISC::CUV::V, and NLMISC::CTriangle::V0. Referenced by getStaticLightSetup(), getSurfaceInfo(), and snapToLandscapeCurrentTesselation(). { // compute UV gradients. CVector Gu; CVector Gv; tri.computeGradient(tri.Uv0.U, tri.Uv1.U, tri.Uv2.U, Gu); tri.computeGradient(tri.Uv0.V, tri.Uv1.V, tri.Uv2.V, Gv); // interpolate uv.U= tri.Uv0.U + Gu*(pos-tri.V0); uv.V= tri.Uv0.V + Gv*(pos-tri.V0); }

void NL3D::CVisualCollisionEntity::displayDebugGrid (  IDriver &  drv  )  const

Draw lines for the landscape quadgrid collision faces under us. Definition at line 612 of file visual_collision_entity.cpp. References _PatchQuadBlocks, NL3D::CMaterial::initUnlit(), NL_PATCH_BLOCK_MAX_VERTEX, NL3D::CPatchQuadBlock::PatchBlockId, s, NL3D::CPatchBlockIdent::S0, NL3D::CPatchBlockIdent::S1, t, NL3D::CPatchBlockIdent::T0, NL3D::CPatchBlockIdent::T1, uint, and NL3D::CPatchQuadBlock::Vertices. Referenced by NL3D::CVisualCollisionEntityUser::displayDebugGrid(). { // static to not reallocate each frame static CMaterial mat; static bool inited= false; if(!inited) { inited= true; mat.initUnlit(); } static vector<CLine> lineList; lineList.clear(); // Build lines for all patch quad blocks. for(uint i=0;i<_PatchQuadBlocks.size();i++) { CPatchQuadBlock &pqb= *_PatchQuadBlocks[i]; // Parse all quads of this patch block. CPatchBlockIdent &pbid= pqb.PatchBlockId; for(uint t= pbid.T0; t<pbid.T1; t++) { for(uint s= pbid.S0; s<pbid.S1; s++) { // compute quad coordinate in pqb. uint sd0= (s-pbid.S0); uint td0= (t-pbid.T0); uint sd1= sd0+1; uint td1= td0+1; // get 4 vertex coord of quad const CVector &p0= pqb.Vertices[sd0 + td0*NL_PATCH_BLOCK_MAX_VERTEX]; const CVector &p1= pqb.Vertices[sd0 + td1*NL_PATCH_BLOCK_MAX_VERTEX]; const CVector &p2= pqb.Vertices[sd1 + td1*NL_PATCH_BLOCK_MAX_VERTEX]; const CVector &p3= pqb.Vertices[sd1 + td0*NL_PATCH_BLOCK_MAX_VERTEX]; // build the 5 lines lineList.push_back(CLine(p0, p1)); lineList.push_back(CLine(p1, p2)); lineList.push_back(CLine(p2, p3)); lineList.push_back(CLine(p3, p0)); lineList.push_back(CLine(p0, p2)); } } } // Display the lines. CDRU::drawLinesUnlit(lineList, mat, drv); }

void NL3D::CVisualCollisionEntity::doComputeLandscape (  const CVector &  pos  )  [private]

compute tiles infos around the position. Definition at line 414 of file visual_collision_entity.cpp. References _CurrentBBoxValidity, NL3D::CVisualCollisionManager::_Landscape, _LandscapeQuadGrid, _PatchQuadBlocks, _TmpBlockIds, _TmpPatchQuadBlocks, BBoxRadius, BBoxRadiusZ, NL3D::CLandscapeCollisionGrid::build(), NL3D::CVisualCollisionManager::deletePatchQuadBlock(), NL3D::CVisualCollisionManager::newPatchQuadBlock(), NLMISC::CAABBox::setCenter(), NLMISC::CAABBox::setHalfSize(), sint, uint, NLMISC::CVector::x, NLMISC::CVector::y, and NLMISC::CVector::z. Referenced by testComputeLandscape(). { sint i; // setup new bbox. //================== // compute the bbox which must includes the patchQuadBlocks CAABBox bboxToIncludePatchs; bboxToIncludePatchs.setCenter(pos); bboxToIncludePatchs.setHalfSize(CVector(BBoxRadius, BBoxRadius, BBoxRadiusZ)); // setup the _CurrentBBoxValidity with same values, but BBoxRadiusZ/2 _CurrentBBoxValidity.setCenter(pos); _CurrentBBoxValidity.setHalfSize(CVector(BBoxRadius, BBoxRadius, BBoxRadiusZ/2)); // Search landscape blocks which are in the bbox. //================== _Owner->_Landscape->buildPatchBlocksInBBox(bboxToIncludePatchs, _TmpBlockIds); // Recompute PatchQuadBlockcs. //================== // This parts try to keeps old patch blocks so they are not recomputed if they already here. // sort PatchBlockIdent. sort(_TmpBlockIds.begin(), _TmpBlockIds.end()); // Copy old array of ptr (ptr copy only). _TmpPatchQuadBlocks= _PatchQuadBlocks; // allocate dest array. _PatchQuadBlocks.resize(_TmpBlockIds.size()); // Traverse all current patchBlocks, deleting old ones no longer needed, and creating new ones. // this algorithm suppose both array are sorted. uint iOld=0; // parse until dest is filled. for(i=0; i<(sint)_PatchQuadBlocks.size();) { // get requested new BlockIdent. CPatchBlockIdent newBi= _TmpBlockIds[i]; // get requested old BlockIdent in the array. bool oldEnd= false; CPatchBlockIdent oldBi; if(iOld==_TmpPatchQuadBlocks.size()) oldEnd= true; else oldBi= _TmpPatchQuadBlocks[iOld]->PatchBlockId; // if no more old blocks, or if new Block is < than current, we must create a new block, and insert it. if(oldEnd || newBi < oldBi) { // allocate the patch block. _PatchQuadBlocks[i]= _Owner->newPatchQuadBlock(); // fill the patch block. _PatchQuadBlocks[i]->PatchBlockId= _TmpBlockIds[i]; _Owner->_Landscape->fillPatchQuadBlock(*_PatchQuadBlocks[i]); // next new patch block. i++; } // else if current new Block is same than old block, just copy ptr. else if(newBi==oldBi) { // just copy ptr with the old one. _PatchQuadBlocks[i]= _TmpPatchQuadBlocks[iOld]; // next new and old patch block. i++; iOld++; } // else, this old block is no longer used, delete it. else { _Owner->deletePatchQuadBlock(_TmpPatchQuadBlocks[iOld]); // next old patch block. iOld++; } } // Here, must delete old blocks not yet processed. for(;iOld<_TmpPatchQuadBlocks.size(); iOld++) { _Owner->deletePatchQuadBlock(_TmpPatchQuadBlocks[iOld]); } _TmpPatchQuadBlocks.clear(); // Compute the quadGrid. //================== // Compute a delta so elt position for CLandscapeCollisionGrid are positive, and so fastFloor() used will work. CVector delta; // center the position on 0. // floor may be important for precision when the delta is applied. delta.x= (float)floor(-pos.x); delta.y= (float)floor(-pos.y); delta.z= 0; // We must always have positive values for patchBlocks vertices. float val= (float)ceil(BBoxRadius + 256); // NB: 256 is a security. Because of size of patchs, a value of 32 at max should be sufficient (64 for bigger patch (gfx)) // we are large because doesn't matter, the CLandscapeCollisionGrid tiles. delta.x+= val; delta.y+= val; // rebuild the quadGrid. _LandscapeQuadGrid.build(_PatchQuadBlocks, delta); }

bool NL3D::CVisualCollisionEntity::getCeilMode (   )  const [inline]

Definition at line 90 of file visual_collision_entity.h. References _CeilMode. Referenced by NL3D::CVisualCollisionEntityUser::getCeilMode(). {return _CeilMode;}

bool NL3D::CVisualCollisionEntity::getGroundMode (   )  const [inline]

Definition at line 89 of file visual_collision_entity.h. References _GroundMode. Referenced by NL3D::CVisualCollisionEntityUser::getGroundMode(). {return _GroundMode;}

CTrianglePatch * NL3D::CVisualCollisionEntity::getPatchTriangleUnderUs (  const CVector &  pos, CVector &  res )  [private]

return the best trianglePatch under what we are. NULL if not found. Ptr is valid until next call to getPatchTriangleUnderUs() Actually return NULL or Definition at line 96 of file visual_collision_entity.cpp. References NL3D::CVisualCollisionManager::_Landscape, _LandscapeQuadGrid, _LastGPTPosInput, _LastGPTPosOutput, _LastGPTTrianglePatch, _LastGPTValid, _PatchQuadBlocks, NL3D::CPatchQuadBlock::buildTileTriangles(), NL3D::CVisualTileDescNode::Next, nlassert, NL3D::CVisualTileDescNode::PatchQuadBlocId, NL3D::CVisualTileDescNode::QuadId, res, NL3D::CLandscapeCollisionGrid::select(), sint, NLMISC::sqr(), testComputeLandscape(), triangleIntersect(), and uint8. Referenced by getStaticLightSetup(), getSurfaceInfo(), and snapToGround(). { // verify if landscape (refptr) is here. if(_Owner->_Landscape==NULL) { _LastGPTValid= false; return NULL; } // Test GPT cache. //================== // If last call was valid, and if same pos (input or output), return cached information if(_LastGPTValid && (pos==_LastGPTPosInput || pos==_LastGPTPosOutput) ) { // copy from cache. res= _LastGPTPosOutput; /* don't modify _LastGPTPosInput cache, for best cache behavior in all cases. 1/ this is not necessary (here, if pos!=_LastGPTPosInput, THEN pos==_LastGPTPosOutput, no other possibilities) 2/ it causes problems when getPatchTriangleUnderUs() is called randomly with the unsnapped or snapped position: 1st Time: zin:9.0 => zout:9.5 cache fail (ok, 1st time...) 2nd Time: zin:9.0 => zout:9.5 cache OK (_LastGPTPosInput.z==zin) 3rd Time: zin:9.5 => zout:9.5 cache OK (_LastGPTPosOutput.z==zin) 4th Time: zin:9.0 => zout:9.5 cache FAILS (_LastGPTPosInput.z= 9.5 => !=zin) */ // and return ptr on cache. return &_LastGPTTrianglePatch; } // update the cache of tile info near this position. // ================= testComputeLandscape(pos); // find possible faces under the entity. // ================= CVisualTileDescNode *ptr= _LandscapeQuadGrid.select(pos); // find the better face under the entity. // ================= float sqrBestDist= sqr(1000.f); CVector hit; // build the vertical ray. CVector segP0= pos - CVector(0,0,100); CVector segP1= pos + CVector(0,0,100); // triangles builded from this list. static vector<CTrianglePatch> testTriangles; // NB: not so many reallocation here, because static. testTriangles.clear(); sint bestTriangle= 0; // For all the faces in this quadgrid node. while(ptr) { // what is the quad block of this tile Id. sint qbId= ptr->PatchQuadBlocId; nlassert(qbId>=0 && qbId<(sint)_PatchQuadBlocks.size()); CPatchQuadBlock &qb= *_PatchQuadBlocks[qbId]; // Build the 2 triangles of this tile Id. sint idStart= testTriangles.size(); testTriangles.resize(idStart+2); qb.buildTileTriangles((uint8)ptr->QuadId, &testTriangles[idStart]); // Test the 2 triangles. for(sint i=0; i<2; i++) { CTrianglePatch &tri= testTriangles[idStart+i]; // test if the ray intersect. // NB: triangleIntersect() is faster than CTriangle::intersect(). if(triangleIntersect(tri, segP0, segP1, hit)) { // find the nearest triangle. float sqrdist= (hit-pos).sqrnorm(); if(sqrdist<sqrBestDist) { bestTriangle= idStart+i; res= hit; sqrBestDist= sqrdist; } } } // Next in the list. ptr= ptr->Next; } // found ?? if(sqrBestDist<sqr(1000)) { // copy into cache _LastGPTValid= true; _LastGPTTrianglePatch= testTriangles[bestTriangle]; _LastGPTPosInput= pos; _LastGPTPosOutput= res; // and return ptr on cache. return &_LastGPTTrianglePatch; } else { _LastGPTValid= false; return NULL; } }

bool NL3D::CVisualCollisionEntity::getSnapToRenderedTesselation (   )  const [inline]

Definition at line 98 of file visual_collision_entity.h. References _SnapToRenderedTesselation. Referenced by NL3D::CVisualCollisionEntityUser::getSnapToRenderedTesselation(). {return _SnapToRenderedTesselation;}

bool NL3D::CVisualCollisionEntity::getStaticLightSetup (  const CVector &  pos, std::vector< CPointLightInfluence > &  pointLightList, uint8 &  sunContribution, NLMISC::CRGBA &  localAmbient )

Get the static Light Setup, using landscape under us. append lights to pointLightList. NB: if find no landscape faces, don't modify pointLightList, set sunContribution=255, and return false Else, use CPatch::TileLightInfluences to get lights, and use CPatch::Lumels to get sunContribution. NB: because CPatch::Lumels encode the gouraud shading on the surface, returning lumelValue will darken the object too much. To avoid this, the sunContribution is raised to a power (0..1). See CVisualCollisionManager::setSunContributionPower(). Default is 0.5 Definition at line 527 of file visual_collision_entity.cpp. References NL3D::CVisualCollisionManager::_Landscape, NL3D::CVisualCollisionManager::_SunContributionLUT, computeUvForPos(), getPatchTriangleUnderUs(), NL3D::CTrianglePatch::PatchId, res, NLMISC::CRGBA::set(), and uint8. Referenced by NL3D::CInstanceLighter::computeSunContribution(), and NL3D::CVisualCollisionEntityUser::getStaticLightSetup(). { // Get Patch Triangle Under Us CVector res; CTrianglePatch *tri= getPatchTriangleUnderUs(pos, res); // For now, no localAmbient support on landscape. localAmbient.set(0,0,0,0); // result. NB: if not found, dot not modify. if( tri ) { // compute UV for position. CUV uv; computeUvForPos(*tri, pos, uv); // get the sunContribution sunContribution= _Owner->_Landscape->getLumel(tri->PatchId, uv); // see getStaticLightSetup. sunContribution= _Owner->_SunContributionLUT[sunContribution]; // append any lights of interest. _Owner->_Landscape->appendTileLightInfluences(tri->PatchId, uv, pointLightList); return true; } else { // Suppose full Sun Contribution, and don't add any pointLight sunContribution= 255; return false; } }

bool NL3D::CVisualCollisionEntity::getSurfaceInfo (  const CVector &  pos, CSurfaceInfo &  info )

Get surface informations. pos is checked with polygons that are at least (cache dependent) at +- 10m in altitude. Parameters: info  will be filled with surface informations if the method returns true. Returns: true if the surface has been found and informations has been filled. Definition at line 565 of file visual_collision_entity.cpp. References NL3D::CVisualCollisionManager::_Landscape, computeUvForPos(), getPatchTriangleUnderUs(), NL3D::CTileBank::getTileSet(), NL3D::CTileBank::getTileXRef(), H_AUTO, NL_TILE_ELM_LAYER_EMPTY, NL3D::CTrianglePatch::PatchId, res, NL3D::CTileSet::SurfaceData, NL3D::CTileElement::Tile, type, uint16, and NL3D::CSurfaceInfo::UserSurfaceData. Referenced by NL3D::CVisualCollisionEntityUser::getSurfaceInfo(). { H_AUTO( NL3D_CVisualCollisionEntity_getSurfaceInfo ) // Get Patch Triangle Under Us CVector res; CTrianglePatch *tri= getPatchTriangleUnderUs(pos, res); // result. NB: if not found, dot not modify. if( tri ) { // compute UV for position. CUV uv; computeUvForPos(*tri, pos, uv); // get the tileelement CTileElement *tileElm = _Owner->_Landscape->getTileElement(tri->PatchId, uv); if (tileElm) { // Valid tile ? uint16 tileId = tileElm->Tile[0]; if (tileId != NL_TILE_ELM_LAYER_EMPTY) { // The tilebank CTileBank &tileBank = _Owner->_Landscape->TileBank; // Get xref info for this tile int tileSet; int number; CTileBank::TTileType type; tileBank.getTileXRef ((int)tileId, tileSet, number, type); // Get the tileset from layer 0 const CTileSet* tileSetPtr = tileBank.getTileSet (tileSet); // Fill the surface surfaceInfo.UserSurfaceData = tileSetPtr->SurfaceData; // Ok return true; } } } return false; }

void NL3D::CVisualCollisionEntity::setCeilMode (  bool  ceilMode  )  [inline]

If ceilMode is true, the entity is snapped on faces with normal.z < 0. Default is false. NB: if both groundMode and ceilMode are false, snapToGround is a no-op. Definition at line 86 of file visual_collision_entity.h. References _CeilMode. Referenced by NL3D::CVisualCollisionEntityUser::setCeilMode(). {_CeilMode= ceilMode;}

void NL3D::CVisualCollisionEntity::setGroundMode (  bool  groundMode  )  [inline]

If groundMode is true, the entity is snapped on faces with normal.z > 0. Default is true. NB: if both groundMode and ceilMode are false, snapToGround is a no-op. Definition at line 80 of file visual_collision_entity.h. References _GroundMode. Referenced by NL3D::CVisualCollisionEntityUser::setGroundMode(). {_GroundMode= groundMode;}

void NL3D::CVisualCollisionEntity::setSnapToRenderedTesselation (  bool  snapMode  )  [inline]

By default, the visual collision entity is snapped on rendered/geomorphed tesselation (true). Use this method to change this behavior. if false, the entity is snapped to the tile level tesselation according to noise etc... Definition at line 97 of file visual_collision_entity.h. References _SnapToRenderedTesselation. Referenced by NL3D::CVisualCollisionEntityUser::setSnapToRenderedTesselation(). {_SnapToRenderedTesselation= snapMode;}

bool NL3D::CVisualCollisionEntity::snapToGround (  CVector &  pos, CVector &  normal )

Snap the entity onto the ground. pos.z is modified so that it lies on the ground, according to rendered landscapes and meshes. pos is checked with polygons that are at least (cache dependent) at +- 10m in altitude. Parameters: normal  the ret normal of where it is snapped. NB: if return false, not modified. Returns: true if pos.z has been modified (sometimes it may not find a solution). Definition at line 211 of file visual_collision_entity.cpp. References _SnapToRenderedTesselation, getPatchTriangleUnderUs(), NLMISC::CVector::normalize(), res, snapToLandscapeCurrentTesselation(), NLMISC::CTriangle::V0, NLMISC::CTriangle::V1, and NLMISC::CTriangle::V2. { // Get Patch Triangle Under Us CVector res; CTrianglePatch *tri= getPatchTriangleUnderUs(pos, res); // result. NB: if not found, dot not modify. if( tri ) { if(_SnapToRenderedTesselation) { // snap the position to the nearest tesselation. pos= res; // snap the position to the current rendered tesselation. snapToLandscapeCurrentTesselation(pos, *tri); } else { // just snap to the accurate tile tesselation. pos= res; } // compute the normal. normal= (tri->V1-tri->V0)^(tri->V2-tri->V0); normal.normalize(); return true; } else return false; }

bool NL3D::CVisualCollisionEntity::snapToGround (  CVector &  pos  )

Snap the entity onto the ground. pos.z is modified so that it lies on the ground, according to rendered landscapes and meshes. see setSnapToRenderedTesselation() option. pos is checked with polygons that are at least (cache dependent) at +- 10m in altitude. Returns: true if pos.z has been modified (sometimes it may not find a solution). Definition at line 87 of file visual_collision_entity.cpp. Referenced by NL3D::CVisualCollisionEntityUser::snapToGround(). { CVector normal; // Not optimized, but doesn't matter (one cross product is negligible). return snapToGround(pos, normal); }

void NL3D::CVisualCollisionEntity::snapToLandscapeCurrentTesselation (  CVector &  pos, const CTrianglePatch &  tri )  [private]

snap to current rendered tesselation. Definition at line 261 of file visual_collision_entity.cpp. References NL3D::CVisualCollisionManager::_Landscape, computeUvForPos(), NL3D::CTrianglePatch::PatchId, and NLMISC::CVector::z. Referenced by snapToGround(). { // compute UV for position. CUV uv; computeUvForPos(tri, pos, uv); // Ask pos to landscape. CVector posLand; posLand= _Owner->_Landscape->getTesselatedPos(tri.PatchId, uv); // just keep Z. pos.z= posLand.z; }

void NL3D::CVisualCollisionEntity::testComputeLandscape (  const CVector &  pos  )  [private]

test if the new position is outside the preceding setuped bbox, and then compute tiles infos around the position. Definition at line 403 of file visual_collision_entity.cpp. References _CurrentBBoxValidity, doComputeLandscape(), NLMISC::CAABBox::getHalfSize(), and NLMISC::CAABBox::include(). Referenced by getPatchTriangleUnderUs(). { // if new position is out of the bbox surounding the entity. if(_CurrentBBoxValidity.getHalfSize()==CVector::Null || !_CurrentBBoxValidity.include(pos)) { // must recompute the data around the entity. doComputeLandscape(pos); } }

bool NL3D::CVisualCollisionEntity::triangleIntersect (  CTriangle &  tri, const CVector &  pos0, const CVector &  pos1, CVector &  hit )  [private]

Fast "2D" test of a triangle against ray P0 P1. Definition at line 366 of file visual_collision_entity.cpp. References _CeilMode, _GroundMode, NLMISC::CPlane::intersect(), NLMISC::CPlane::make(), triangleIntersect2DCeil(), triangleIntersect2DGround(), NLMISC::CTriangle::V0, NLMISC::CTriangle::V1, NLMISC::CTriangle::V2, NLMISC::CVector::x, NLMISC::CVector::y, and NLMISC::CVector::z. Referenced by getPatchTriangleUnderUs(). { CVector &p0= tri.V0; CVector &p1= tri.V1; CVector &p2= tri.V2; bool ok= false; if( _GroundMode && triangleIntersect2DGround(tri, pos0) ) ok= true; if(!ok && _CeilMode && triangleIntersect2DCeil(tri, pos0) ) ok= true; if(!ok) return false; // Compute the possible height. CVector tmp; // build the plane CPlane plane; plane.make (p0, p1, p2); // intersect the vertical line with the plane. tmp= plane.intersect(pos0, pos1); float h= tmp.z; // Test if it would fit in the wanted field. if(h>pos1.z) return false; if(h<pos0.z) return false; // OK!! // For cache completness, ensure that X and Y don't move, take same XY than pos0 hit.x= pos0.x; hit.y= pos0.y; hit.z= h; return true; }

bool NL3D::CVisualCollisionEntity::triangleIntersect2DCeil (  CTriangle &  tri, const CVector &  pos0 )  [static, private]

compute tiles infos around the position. Definition at line 336 of file visual_collision_entity.cpp. References NLMISC::CTriangle::V0, NLMISC::CTriangle::V1, NLMISC::CTriangle::V2, NLMISC::CVector::x, and NLMISC::CVector::y. Referenced by triangleIntersect(). { CVector &p0= tri.V0; CVector &p1= tri.V1; CVector &p2= tri.V2; // Test if the face enclose the pos in X/Y plane. // NB: compute and using a BBox to do a rapid test is not a very good idea, since it will // add an overhead which is NOT negligeable compared to the following test. float a,b,c; // 2D cartesian coefficients of line in plane X/Y. // Line p0-p1. a= -(p1.y-p0.y); b= (p1.x-p0.x); c= -(p0.x*a + p0.y*b); if( (a*pos0.x + b*pos0.y + c) > 0) return false; // Line p1-p2. a= -(p2.y-p1.y); b= (p2.x-p1.x); c= -(p1.x*a + p1.y*b); if( (a*pos0.x + b*pos0.y + c) > 0) return false; // Line p2-p0. a= -(p0.y-p2.y); b= (p0.x-p2.x); c= -(p2.x*a + p2.y*b); if( (a*pos0.x + b*pos0.y + c) > 0) return false; return true; }

bool NL3D::CVisualCollisionEntity::triangleIntersect2DGround (  CTriangle &  tri, const CVector &  pos0 )  [static, private]

Fast "2D" test of a triangle against ray P0 P1. Definition at line 299 of file visual_collision_entity.cpp. References NLMISC::CTriangle::V0, NLMISC::CTriangle::V1, NLMISC::CTriangle::V2, NLMISC::CVector::x, and NLMISC::CVector::y. Referenced by triangleIntersect(). { CVector &p0= tri.V0; CVector &p1= tri.V1; CVector &p2= tri.V2; // TestYoyo. Test for precision problems. /*if( testLine(p1, p0, pos0) && testLine(p2, p1, pos0) && testLine(p0, p2, pos0) ) { nlinfo("Found Tri For Pos: %.07f, %.07f\n P0: %.07f, %.07f\n P1: %.07f, %.07f\n P2: %.07f, %.07f", pos0.x, pos0.y, p0.x, p0.y, p1.x, p1.y, p2.x, p2.y); }*/ // Test if the face enclose the pos in X/Y plane. // NB: compute and using a BBox to do a rapid test is not a very good idea, since it will // add an overhead which is NOT negligeable compared to the following test. float a,b,c; // 2D cartesian coefficients of line in plane X/Y. // Line p0-p1. a= -(p1.y-p0.y); b= (p1.x-p0.x); c= -(p0.x*a + p0.y*b); if( (a*pos0.x + b*pos0.y + c) < 0) return false; // Line p1-p2. a= -(p2.y-p1.y); b= (p2.x-p1.x); c= -(p1.x*a + p1.y*b); if( (a*pos0.x + b*pos0.y + c) < 0) return false; // Line p2-p0. a= -(p0.y-p2.y); b= (p0.x-p2.x); c= -(p2.x*a + p2.y*b); if( (a*pos0.x + b*pos0.y + c) < 0) return false; return true; }

---

Field Documentation

bool NL3D::CVisualCollisionEntity::_CeilMode [private]

Definition at line 149 of file visual_collision_entity.h. Referenced by CVisualCollisionEntity(), getCeilMode(), setCeilMode(), and triangleIntersect().

CAABBox NL3D::CVisualCollisionEntity::_CurrentBBoxValidity [private]

The current BBox where we don't need to recompute the patchQuadBlocks if the entity is in. Definition at line 171 of file visual_collision_entity.h. Referenced by CVisualCollisionEntity(), doComputeLandscape(), and testComputeLandscape().

bool NL3D::CVisualCollisionEntity::_GroundMode [private]

Definition at line 150 of file visual_collision_entity.h. Referenced by CVisualCollisionEntity(), getGroundMode(), setGroundMode(), and triangleIntersect().

CLandscapeCollisionGrid NL3D::CVisualCollisionEntity::_LandscapeQuadGrid [private]

A quadgrid of chainlist of tileId (CVisualTileDescNode), which are around the entity. Definition at line 169 of file visual_collision_entity.h. Referenced by doComputeLandscape(), getPatchTriangleUnderUs(), and ~CVisualCollisionEntity().

CVector NL3D::CVisualCollisionEntity::_LastGPTPosInput [private]

compute tiles infos around the position. Definition at line 174 of file visual_collision_entity.h. Referenced by getPatchTriangleUnderUs().

CVector NL3D::CVisualCollisionEntity::_LastGPTPosOutput [private]

compute tiles infos around the position. Definition at line 175 of file visual_collision_entity.h. Referenced by getPatchTriangleUnderUs().

CTrianglePatch NL3D::CVisualCollisionEntity::_LastGPTTrianglePatch [private]

compute tiles infos around the position. Definition at line 176 of file visual_collision_entity.h. Referenced by getPatchTriangleUnderUs().

bool NL3D::CVisualCollisionEntity::_LastGPTValid [private]

Cache for getPatchTriangleUnderUs(). Definition at line 173 of file visual_collision_entity.h. Referenced by CVisualCollisionEntity(), and getPatchTriangleUnderUs().

CVisualCollisionManager* NL3D::CVisualCollisionEntity::_Owner [private]

Definition at line 147 of file visual_collision_entity.h.

std::vector<CPatchQuadBlock*> NL3D::CVisualCollisionEntity::_PatchQuadBlocks [private]

Array of quadBlock which are around the entity. NB: plain vector, because not so big (ptrs). NB: reserve to a big size (64), so reallocation rarely occurs. NB: this array is sorted in ascending order (comparison of CPatchBlockIdent). Definition at line 167 of file visual_collision_entity.h. Referenced by CVisualCollisionEntity(), displayDebugGrid(), doComputeLandscape(), getPatchTriangleUnderUs(), and ~CVisualCollisionEntity().

bool NL3D::CVisualCollisionEntity::_SnapToRenderedTesselation [private]

Definition at line 151 of file visual_collision_entity.h. Referenced by CVisualCollisionEntity(), getSnapToRenderedTesselation(), setSnapToRenderedTesselation(), and snapToGround().

const uint32 NL3D::CVisualCollisionEntity::_StartPatchQuadBlockSize = 64 [static, private]

Default capacity of _PatchQuadBlocks. Definition at line 50 of file visual_collision_entity.cpp. Referenced by CVisualCollisionEntity().

vector< CPatchBlockIdent > NL3D::CVisualCollisionEntity::_TmpBlockIds [static, private]

This is the temp array of BlockIds filled by landscape search. Definition at line 51 of file visual_collision_entity.cpp. Referenced by doComputeLandscape().

vector< CPatchQuadBlock * > NL3D::CVisualCollisionEntity::_TmpPatchQuadBlocks [static, private]

This is the temp array of PatchBlocks ptr. Definition at line 52 of file visual_collision_entity.cpp. Referenced by doComputeLandscape().

const float NL3D::CVisualCollisionEntity::BBoxRadius = 10 [static]

This is the radius of the bbox around the entity where we have correct collisions: 10m. Definition at line 48 of file visual_collision_entity.cpp. Referenced by doComputeLandscape().

const float NL3D::CVisualCollisionEntity::BBoxRadiusZ = 20 [static]

Same as BBoxRadius, but for z value. This later should be greater because of NLPACS surface quadtree imprecision. 20m NB: Because of caching, if the pos.z passed to snapToGround() is outside of the currentBBox with BBoxRadiuZ/2 (=> 10m), then the bbox is recomputed. Hence, this actually means that a pos is checked with patchs that are at least at +- 10m in altitude. Definition at line 49 of file visual_collision_entity.cpp. Referenced by doComputeLandscape().

---

The documentation for this class was generated from the following files:

• visual_collision_entity.h
• visual_collision_entity.cpp

---