NeL: NL3D::CShadowPolyReceiver class Reference

00044 {
+00045         _Vertices.reserve(64);
+00046         _FreeVertices.reserve(64);
+00047         _FreeTriangles.reserve(64);
+00048         _Triangles.reserve(64);
+00049 
+00050         _TriangleGrid.create(quadGridSize, quadGridCellSize);
+00051 
+00052         _VB.setVertexFormat(CVertexBuffer::PositionFlag);
+00053 }
+

00058 {
+00059         uint    id;
+00060 
+00061         // Look for a free triangle entry.
+00062         if(_FreeTriangles.empty())
+00063         {
+00064                 _Triangles.push_back(TTriangleGrid::CIterator());
+00065                 id= _Triangles.size()-1;
+00066                 // enlarge render size.
+00067                 _RenderTriangles.resize(_Triangles.size() * 3);
+00068         }
+00069         else
+00070         {
+00071                 id= _FreeTriangles.back();
+00072                 _FreeTriangles.pop_back();
+00073         }
+00074 
+00075         // Allocate vertices, reusing same ones.
+00076         CTriangleId             triId;
+00077         CVector                 v[3];
+00078         v[0]= tri.V0;
+00079         v[1]= tri.V1;
+00080         v[2]= tri.V2;
+00081         for(uint i=0;i<3;i++)
+00082         {
+00083                 // Find the vertex in the map.
+00084                 TVertexMap::iterator    it;
+00085                 it= _VertexMap.find(v[i]);
+00086                 // if not found, allocate it
+00087                 if(it==_VertexMap.end())
+00088                 {
+00089                         triId.Vertex[i]= allocateVertex(v[i]);
+00090                 }
+00091                 // else get its id
+00092                 else
+00093                 {
+00094                         triId.Vertex[i]= it->second;
+00095                 }
+00096 
+00097                 // increment the reference of this vertex
+00098                 incVertexRefCount(triId.Vertex[i]);
+00099         }
+00100         
+00101         // Insert the triangle in the quadGrid.
+00102         CAABBox         bb;
+00103         bb.setCenter(tri.V0);
+00104         bb.extend(tri.V1);
+00105         bb.extend(tri.V2);
+00106         // insert in QuadGrid and store iterator for future remove
+00107         _Triangles[id]= _TriangleGrid.insert(bb.getMin(), bb.getMax(), triId);
+00108 
+00109         return id;
+00110 }
+

00135 {
+00136         uint    id;
+00137 
+00138         // Look for a free vertex entry.
+00139         if(_FreeVertices.empty())
+00140         {
+00141                 // Add the vertex, and init refCount to 0.
+00142                 _Vertices.push_back(v);
+00143                 id= _Vertices.size()-1;
+00144 
+00145                 // Resize the VBuffer at max possible
+00146                 _VB.setNumVertices(_Vertices.size());
+00147         }
+00148         else
+00149         {
+00150                 id= _FreeVertices.back();
+00151                 _FreeVertices.pop_back();
+00152                 // init entry
+00153                 _Vertices[id]= v;
+00154                 _Vertices[id].RefCount= 0;
+00155         }
+00156 
+00157         // insert in the map (should not be here)
+00158         _VertexMap.insert( make_pair(v, id) );
+00159 
+00160         return id;
+00161 }
+

00309 {
+00310         // **** build the camera collision info
+00311         CCameraCol      camCol;
+00312         camCol.build(start, end, radius, cone);
+00313         
+00314         // select with quadGrid
+00315         _TriangleGrid.select(camCol.BBox.getMin(), camCol.BBox.getMax());
+00316         
+00317         // **** For all triangles, test if intersect the camera collision
+00318         TTriangleGrid::CIterator        it;
+00319         float           sqrMinDist= FLT_MAX;
+00320         for(it=_TriangleGrid.begin();it!=_TriangleGrid.end();it++)
+00321         {
+00322                 CTriangleId             &triId= *it;
+00323                 camCol.minimizeDistanceAgainstTri(
+00324                         _Vertices[triId.Vertex[0]], 
+00325                         _Vertices[triId.Vertex[1]],
+00326                         _Vertices[triId.Vertex[2]],
+00327                         sqrMinDist);
+00328         }
+00329 
+00330         // **** return the collision found, between [0,1]
+00331         if(sqrMinDist == FLT_MAX)
+00332                 return 1;
+00333         else
+00334         {
+00335                 float   f= 1;
+00336                 float   d= (end-start).norm();
+00337                 if(d>0)
+00338                 {
+00339                         f= sqrtf(sqrMinDist) / d;
+00340                         f= min(f, 1.f);
+00341                 }
+00342                 return f;
+00343         }
+00344 
+00345 }
+

00184 {
+00185         nlassert(id<_Vertices.size());
+00186         nlassert(_Vertices[id].RefCount < NL3D_SPR_MAX_REF_COUNT);
+00187         _Vertices[id].RefCount++;
+00188 }
+

00165 {
+00166         nlassert(id<_Vertices.size());
+00167         // dec ref
+00168         nlassert(_Vertices[id].RefCount>0);
+00169         _Vertices[id].RefCount--;
+00170         // no more used?
+00171         if(_Vertices[id].RefCount==0)
+00172         {
+00173                 // Free it.
+00174                 _FreeVertices.push_back(id);
+00175                 // Remove it from map.
+00176                 TVertexMap::iterator    it= _VertexMap.find(_Vertices[id]);
+00177                 nlassert(it!=_VertexMap.end());
+00178                 _VertexMap.erase(it);
+00179         }
+00180 }
+

00114 {
+00115         nlassert(id<_Triangles.size());
+00116         // Must not be NULL iterator.
+00117         nlassert(_Triangles[id]!=_TriangleGrid.end());
+00118 
+00119         // Release Vertices
+00120         const CTriangleId               &triId= *_Triangles[id];
+00121         releaseVertex(triId.Vertex[0]);
+00122         releaseVertex(triId.Vertex[1]);
+00123         releaseVertex(triId.Vertex[2]);
+00124 
+00125         // Delete Triangle.
+00126         _TriangleGrid.erase(_Triangles[id]);
+00127         _Triangles[id]= _TriangleGrid.end();
+00128         // Append to free list.
+00129         _FreeTriangles.push_back(id);
+00130 }
+

00193 {
+00194         uint    i, j;
+00195 
+00196         // **** Fill Triangles that are hit by the Caster
+00197         // First select with quadGrid
+00198         CAABBox         worldBB;
+00199         worldBB= shadowMap->LocalBoundingBox;
+00200         worldBB.setCenter(worldBB.getCenter() + casterPos);
+00201         _TriangleGrid.select(worldBB.getMin(), worldBB.getMax());
+00202 
+00203         // For all triangles, reset vertices flags.
+00204         TTriangleGrid::CIterator        it;
+00205         for(it=_TriangleGrid.begin();it!=_TriangleGrid.end();it++)
+00206         {
+00207                 CTriangleId             &triId= *it;
+00208                 for(i=0;i<3;i++)
+00209                 {
+00210                         _Vertices[triId.Vertex[i]].Flags= 0;
+00211                         _Vertices[triId.Vertex[i]].VBIdx= -1;
+00212                 }
+00213         }
+00214 
+00215         // Copute the world Clip Volume
+00216         static  std::vector<CPlane>             worldClipPlanes;
+00217         CMatrix         worldMat;
+00218         // set -casterPos, because to transform a plane, we must do plane * M-1
+00219         worldMat.setPos(-casterPos);
+00220         // Allow max bits of planes clip.
+00221         worldClipPlanes.resize(min((uint)shadowMap->LocalClipPlanes.size(), (uint)NL3D_SPR_NUM_CLIP_PLANE));
+00222         // Transform into world
+00223         for(i=0;i<worldClipPlanes.size();i++)
+00224         {
+00225                 worldClipPlanes[i]= shadowMap->LocalClipPlanes[i] * worldMat;
+00226         }
+00227 
+00228         // For All triangles, clip them.
+00229         uint    currentTriIdx= 0;
+00230         uint    currentVbIdx= 0;
+00231         for(it=_TriangleGrid.begin();it!=_TriangleGrid.end();it++)
+00232         {
+00233                 CTriangleId             &triId= *it;
+00234                 uint                    triFlag= NL3D_SPR_NUM_CLIP_PLANE_MASK;
+00235 
+00236                 // for all vertices, clip them
+00237                 for(i=0;i<3;i++)
+00238                 {
+00239                         uint    vid= triId.Vertex[i];
+00240                         uint    vertexFlags= _Vertices[vid].Flags;
+00241 
+00242                         // if this vertex is still not computed
+00243                         if(!vertexFlags)
+00244                         {
+00245                                 // For all planes of the Clip Volume, clip this vertex.
+00246                                 for(j=0;j<worldClipPlanes.size();j++)
+00247                                 {
+00248                                         // out if in front
+00249                                         bool    out= worldClipPlanes[j]*_Vertices[vid] > 0;
+00250 
+00251                                         vertexFlags|= ((uint)out)<<j;
+00252                                 }
+00253 
+00254                                 // add the bit flag to say "computed".
+00255                                 vertexFlags|= NL3D_SPR_NUM_CLIP_PLANE_SHIFT;
+00256 
+00257                                 // store
+00258                                 _Vertices[vid].Flags= vertexFlags;
+00259                         }
+00260 
+00261                         // And all vertex bits.
+00262                         triFlag&= vertexFlags;
+00263                 }
+00264 
+00265                 // if triangle not clipped, add the triangle
+00266                 if( (triFlag & NL3D_SPR_NUM_CLIP_PLANE_MASK)==0 )
+00267                 {
+00268                         // Add the 3 vertices to the VB, and to the index buffer.
+00269                         for(i=0;i<3;i++)
+00270                         {
+00271                                 uint    vid= triId.Vertex[i];
+00272                                 sint    vbId= _Vertices[vid].VBIdx;
+00273 
+00274                                 // if not yet inserted in the VB, do it.
+00275                                 if(vbId==-1)
+00276                                 {
+00277                                         // allocate a new place in the VBuffer
+00278                                         vbId= currentVbIdx++;
+00279                                         _Vertices[vid].VBIdx= vbId;
+00280                                         // set the coord
+00281                                         _VB.setVertexCoord(vbId, _Vertices[vid]+vertDelta);
+00282                                 }
+00283 
+00284                                 // add the index to the tri list.
+00285                                 _RenderTriangles[currentTriIdx++]= vbId;
+00286                         }
+00287                 }
+00288         }
+00289 
+00290 
+00291         // **** Render
+00292         drv->activeVertexBuffer(_VB);
+00293         drv->renderTriangles(shadowMat, &_RenderTriangles[0], currentTriIdx/3);
+00294         // TestYoyo. Show in Red triangles selected
+00295         /*static        CMaterial       tam;
+00296         tam.initUnlit();
+00297         tam.setColor(CRGBA(255,0,0,128));
+00298         tam.setZFunc(CMaterial::always);
+00299         tam.setZWrite(false);
+00300         tam.setBlend(true);
+00301         tam.setBlendFunc(CMaterial::srcalpha, CMaterial::invsrcalpha);
+00302         tam.setDoubleSided(true);
+00303         drv->renderTriangles(tam, &_RenderTriangles[0], currentTriIdx/3);*/
+00304 }
+


Public Member Functions
uint	addTriangle (const NLMISC::CTriangle &tri)
	Append a triangle to the poly receiver.
	CShadowPolyReceiver (uint quadGridSize=32, float quadGridCellSize=4.f)
	Constructor.
float	getCameraCollision (const CVector &start, const CVector &end, float radius, bool cone)
void	removeTriangle (uint id)
	remove a triangle from the poly receiver.
void	render (IDriver drv, CMaterial &shadowMat, const CShadowMap shadowMap, const CVector &casterPos, const CVector &vertDelta)
Private Types
typedef CQuadGrid< CTriangleId >	TTriangleGrid
typedef std::map< CVector, + uint >	TVertexMap
Private Member Functions
uint	allocateVertex (const CVector &v)
void	incVertexRefCount (uint id)
void	releaseVertex (uint id)
Private Attributes
std::vector< uint >	_FreeTriangles
std::vector< uint >	_FreeVertices
std::vector< uint32 >	_RenderTriangles
TTriangleGrid	_TriangleGrid
std::vector< TTriangleGrid::CIterator >	_Triangles
CVertexBuffer	_VB
TVertexMap	_VertexMap
std::vector< CVectorId >	_Vertices

NL3D::CShadowPolyReceiver Class Reference

Detailed Description

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation