NL3D::CInstanceLighter Class Reference

#include <instance_lighter.h>

---

Detailed Description

A class to precompute "StaticSetup" lighting for instances in an InstanceGroup. Class "inspired" from CZoneLighter :)

Author:

Lionel Berenguier

Nevrax France

Date:

2001

Definition at line 55 of file instance_lighter.h.

Cell Iteration. ie iteration on _IGRetrieverGridMap cells and _IGSurfaceLightBuild cells
void	beginCell ()
CSurfaceLightGrid::CCellCorner &	getCurrentCell ()
CIGSurfaceLightBuild::CCellCorner &	getCurrentCellInfo ()
uint	getCurrentCellNumber () const
CSurfaceLightGrid::CCellCorner &	getCurrentNeighborCell (sint xnb, sint ynb)
CIGSurfaceLightBuild::CCellCorner &	getCurrentNeighborCellInfo (sint xnb, sint ynb)
uint	getTotalCellNumber () const
bool	isCurrentNeighborCellInSurface (sint xnb, sint ynb)
bool	isEndCell ()
void	nextCell ()
void	progressCell (const char *message)
bool	_IsEndCell
uint	_ItCellId
uint	_ItCurrentCellNumber
CIGSurfaceLight::ItRetrieverGridMap	_ItRetriever
CIGSurfaceLightBuild::ItRetrieverGridMap	_ItRetrieverInfo
uint	_ItSurfId
float	_LastCellProgress
uint	_TotalCellNumber
Public Types
enum	{ MaxOverSamples = 16 }
Public Member Functions
	CInstanceLighter ()
	Constructor.
void	init ()
void	light (const CInstanceGroup &igIn, CInstanceGroup &igOut, const CLightDesc &lightDesc, std::vector< CTriangle > &obstacles, CLandscape *landscape=NULL, CIGSurfaceLightBuild *igSurfaceLightBuild=NULL)
virtual void	progress (const char *message, float progress)
virtual	~CInstanceLighter ()
	Destructor.
Static PointLights mgt.
void	addStaticPointLight (const CPointLightNamed &pln, const char *igName)
Static Public Member Functions
void	addTriangles (const IShape &shape, const NLMISC::CMatrix &modelMT, std::vector< CTriangle > &triangleArray, sint instanceId)
void	addTriangles (CLandscape &landscape, std::vector< uint > &listZone, uint order, std::vector< CTriangle > &triangleArray)
void	lightIgSimple (CInstanceLighter &instLighter, const CInstanceGroup &igIn, CInstanceGroup &igOut, const CLightDesc &lightDesc, const char *igName)
Private Member Functions
void	compilePointLightRT (uint gridSize, float gridCellSize, std::vector< CTriangle > &obstacles, bool doShadow)
	Fill CubeGrid, and set PointLightRT in _StaticPointLightQuadGrid.
void	computeSunContribution (const CLightDesc &lightDesc, std::vector< CTriangle > &obstacles, CLandscape *landscape)
void	dilateLightingOnSurfaceCells ()
void	processIGPointLightRT (std::vector< CPointLightNamed > &listPointLight)
Static Private Member Functions
void	addTriangles (const CMeshMRMGeom &meshGeom, const NLMISC::CMatrix &modelMT, std::vector< CTriangle > &triangleArray, sint instanceId)
void	addTriangles (const CMeshGeom &meshGeom, const NLMISC::CMatrix &modelMT, std::vector< CTriangle > &triangleArray, sint instanceId)
void	excludeAllPatchFromRefineAll (CLandscape &landscape, std::vector< uint > &listZone, bool exclude)
Private Attributes
sint	_CurrentInstanceComputed
CIGSurfaceLight::TRetrieverGridMap	_IGRetrieverGridMap
CIGSurfaceLightBuild *	_IGSurfaceLightBuild
std::vector< CInstanceInfo >	_InstanceInfos
std::vector< CInstanceGroup::CInstance >	_Instances
CQuadGrid< CPointLightRT * >	_StaticPointLightQuadGrid
	QuadGrid of PointLights. Builded from _StaticPointLights.
std::vector< CPointLightRT >	_StaticPointLights
	List of PointLights.

---

Member Enumeration Documentation

anonymous enum

Enumeration values: MaxOverSamples  Definition at line 59 of file instance_lighter.h. {MaxOverSamples= 16};

---

Constructor & Destructor Documentation

NL3D::CInstanceLighter::CInstanceLighter (   )

Constructor. Definition at line 66 of file instance_lighter.cpp. References _IGSurfaceLightBuild. { _IGSurfaceLightBuild= NULL; }

virtual NL3D::CInstanceLighter::~CInstanceLighter (   )  [inline, virtual]

Destructor. Definition at line 131 of file instance_lighter.h. {}

---

Member Function Documentation

void NL3D::CInstanceLighter::addStaticPointLight (  const CPointLightNamed &  pln, const char *  igName )

Append a static point light to compute. call at setup stage (before light() ). NB: you must append all PointLights of intersets, even ones from the IG to compute. Definition at line 999 of file instance_lighter.cpp. References _StaticPointLights, NL3D::CInstanceLighter::CPointLightRT::BSphere, NLMISC::CBSphere::Center, NL3D::CPointLight::getAttenuationBegin(), NL3D::CPointLight::getAttenuationEnd(), NL3D::CPointLight::getPosition(), NL3D::CInstanceLighter::CPointLightRT::OODeltaAttenuation, NL3D::CInstanceLighter::CPointLightRT::PointLight, and NLMISC::CBSphere::Radius. Referenced by lightIgSimple(). { // NB: adding light more than 255 is allowed here, since the important thig is to not overflow really usefull lights // build the plRT. CPointLightRT plRT; plRT.PointLight= pln; // compute plRT.OODeltaAttenuation plRT.OODeltaAttenuation= pln.getAttenuationEnd() - pln.getAttenuationBegin(); if(plRT.OODeltaAttenuation <=0 ) plRT.OODeltaAttenuation= 1e10f; else plRT.OODeltaAttenuation= 1.0f / plRT.OODeltaAttenuation; // compute plRT.BSphere plRT.BSphere.Center= pln.getPosition(); plRT.BSphere.Radius= pln.getAttenuationEnd(); // NB: FaceCubeGrid will be computed during light() // add the plRT _StaticPointLights.push_back(plRT); }

void NL3D::CInstanceLighter::addTriangles (  const CMeshMRMGeom &  meshGeom, const NLMISC::CMatrix &  modelMT, std::vector< CTriangle > &  triangleArray, sint  instanceId )  [static, private]

Definition at line 231 of file instance_lighter.cpp. References NL3D::CMeshMRMGeom::getNbRdrPass(), NL3D::CPrimitiveBlock::getNumQuad(), NL3D::CPrimitiveBlock::getNumTri(), NL3D::CPrimitiveBlock::getQuadPointer(), NL3D::CMeshMRMGeom::getRdrPassPrimitiveBlock(), NL3D::CPrimitiveBlock::getTriPointer(), NL3D::CMeshMRMGeom::getVertexBuffer(), NL3D::CVertexBuffer::getVertexCoordPointer(), sint, uint, and uint32. { // Get the vertex buffer const CVertexBuffer &vb=meshGeom.getVertexBuffer(); // For each render pass uint numRenderPass=meshGeom.getNbRdrPass(0); for (uint pass=0; pass<numRenderPass; pass++) { // Get the primitive block const CPrimitiveBlock &primitive=meshGeom.getRdrPassPrimitiveBlock ( 0, pass); // Dump triangles const uint32* triIndex=primitive.getTriPointer (); uint numTri=primitive.getNumTri (); uint tri; for (tri=0; tri<numTri; tri++) { // Vertex CVector v0=modelMT*(*(CVector*)vb.getVertexCoordPointer (triIndex[tri*3])); CVector v1=modelMT*(*(CVector*)vb.getVertexCoordPointer (triIndex[tri*3+1])); CVector v2=modelMT*(*(CVector*)vb.getVertexCoordPointer (triIndex[tri*3+2])); // Make a triangle triangleArray.push_back (CTriangle (NLMISC::CTriangle (v0, v1, v2), instanceId)); } // Dump quad triIndex=primitive.getQuadPointer (); numTri=primitive.getNumQuad (); for (tri=0; tri<numTri; tri++) { // Vertex CVector v0=modelMT*(*(CVector*)vb.getVertexCoordPointer (triIndex[tri*4])); CVector v1=modelMT*(*(CVector*)vb.getVertexCoordPointer (triIndex[tri*4+1])); CVector v2=modelMT*(*(CVector*)vb.getVertexCoordPointer (triIndex[tri*4+2])); CVector v3=modelMT*(*(CVector*)vb.getVertexCoordPointer (triIndex[tri*4+3])); // Make 2 triangles triangleArray.push_back (CTriangle (NLMISC::CTriangle (v0, v1, v2), instanceId)); triangleArray.push_back (CTriangle (NLMISC::CTriangle (v0, v2, v3), instanceId)); } } }

void NL3D::CInstanceLighter::addTriangles (  const CMeshGeom &  meshGeom, const NLMISC::CMatrix &  modelMT, std::vector< CTriangle > &  triangleArray, sint  instanceId )  [static, private]

Definition at line 179 of file instance_lighter.cpp. References NL3D::CMeshGeom::getNbMatrixBlock(), NL3D::CMeshGeom::getNbRdrPass(), NL3D::CPrimitiveBlock::getNumQuad(), NL3D::CPrimitiveBlock::getNumTri(), NL3D::CPrimitiveBlock::getQuadPointer(), NL3D::CMeshGeom::getRdrPassPrimitiveBlock(), NL3D::CPrimitiveBlock::getTriPointer(), NL3D::CMeshGeom::getVertexBuffer(), NL3D::CVertexBuffer::getVertexCoordPointer(), sint, uint, and uint32. { // Get the vertex buffer const CVertexBuffer &vb=meshGeom.getVertexBuffer(); // For each matrix block uint numBlock=meshGeom.getNbMatrixBlock(); for (uint block=0; block<numBlock; block++) { // For each render pass uint numRenderPass=meshGeom.getNbRdrPass(block); for (uint pass=0; pass<numRenderPass; pass++) { // Get the primitive block const CPrimitiveBlock &primitive=meshGeom.getRdrPassPrimitiveBlock ( block, pass); // Dump triangles const uint32* triIndex=primitive.getTriPointer (); uint numTri=primitive.getNumTri (); uint tri; for (tri=0; tri<numTri; tri++) { // Vertex CVector v0=modelMT*(*(CVector*)vb.getVertexCoordPointer (triIndex[tri*3])); CVector v1=modelMT*(*(CVector*)vb.getVertexCoordPointer (triIndex[tri*3+1])); CVector v2=modelMT*(*(CVector*)vb.getVertexCoordPointer (triIndex[tri*3+2])); // Make a triangle triangleArray.push_back (CTriangle (NLMISC::CTriangle (v0, v1, v2), instanceId)); } // Dump quad triIndex=primitive.getQuadPointer (); numTri=primitive.getNumQuad (); for (tri=0; tri<numTri; tri++) { // Vertex CVector v0=modelMT*(*(CVector*)vb.getVertexCoordPointer (triIndex[tri*4])); CVector v1=modelMT*(*(CVector*)vb.getVertexCoordPointer (triIndex[tri*4+1])); CVector v2=modelMT*(*(CVector*)vb.getVertexCoordPointer (triIndex[tri*4+2])); CVector v3=modelMT*(*(CVector*)vb.getVertexCoordPointer (triIndex[tri*4+3])); // Make 2 triangles triangleArray.push_back (CTriangle (NLMISC::CTriangle (v0, v1, v2), instanceId)); triangleArray.push_back (CTriangle (NLMISC::CTriangle (v0, v2, v3), instanceId)); } } } }

void NL3D::CInstanceLighter::addTriangles (  const IShape &  shape, const NLMISC::CMatrix &  modelMT, std::vector< CTriangle > &  triangleArray, sint  instanceId )  [static]

Add triangles from a transform shape. Work only for CMesh, CMultiMesh and CMeshMRM all without skinning. Give An instanceId!=-1 only for instances of the IG to compute. This is to avoid auto-shadowing. Definition at line 129 of file instance_lighter.cpp. References addTriangles(), NL3D::CMeshMRM::getMeshGeom(), NL3D::CMeshMultiLod::getMeshGeom(), NL3D::CMesh::getMeshGeom(), and sint. { // Lamed from CZoneLighter. // Cast to CMesh const CMesh *mesh=dynamic_cast<const CMesh*>(&shape); // Cast to CMeshMultiLod const CMeshMultiLod *meshMulti=dynamic_cast<const CMeshMultiLod*>(&shape); // Cast to CMeshMultiLod const CMeshMRM *meshMRM=dynamic_cast<const CMeshMRM*>(&shape); // It is a mesh ? if (mesh) { // Add its triangles addTriangles (mesh->getMeshGeom (), modelMT, triangleArray, instanceId); } // It is a CMeshMultiLod ? else if (meshMulti) { // Get the first geommesh const IMeshGeom *meshGeom=&meshMulti->getMeshGeom (0); // Dynamic cast const CMeshGeom *geomMesh=dynamic_cast<const CMeshGeom*>(meshGeom); if (geomMesh) { addTriangles (*geomMesh, modelMT, triangleArray, instanceId); } // Dynamic cast const CMeshMRMGeom *mrmGeomMesh=dynamic_cast<const CMeshMRMGeom*>(meshGeom); if (mrmGeomMesh) { addTriangles (*mrmGeomMesh, modelMT, triangleArray, instanceId); } } // It is a CMeshMultiLod ? else if (meshMRM) { // Get the first lod mesh geom addTriangles (meshMRM->getMeshGeom (), modelMT, triangleArray, instanceId); } }

void NL3D::CInstanceLighter::addTriangles (  CLandscape &  landscape, std::vector< uint > &  listZone, uint  order, std::vector< CTriangle > &  triangleArray )  [static]

Definition at line 77 of file instance_lighter.cpp. References NL3D::CTessVertex::EndPos, excludeAllPatchFromRefineAll(), NL3D::CLandscape::getTessellationLeaves(), NL3D::CLandscape::refineAll(), NL3D::CLandscape::setThreshold(), NL3D::CLandscape::setTileMaxSubdivision(), uint, NL3D::CTessFace::VBase, NL3D::CTessFace::VLeft, and NL3D::CTessFace::VRight. Referenced by addTriangles(). { // Lamed from CZoneLighter. // Set all to refine excludeAllPatchFromRefineAll (landscape, listZone, false); // Setup the landscape landscape.setThreshold (0); landscape.setTileMaxSubdivision (order); // Refine it landscape.refineAll (CVector (0, 0, 0)); // Dump tesselated triangles std::vector<const CTessFace*> leaves; landscape.getTessellationLeaves(leaves); // Number of leaves uint leavesCount=leaves.size(); // Reserve the array triangleArray.reserve (triangleArray.size()+leavesCount); // Scan each leaves for (uint leave=0; leave<leavesCount; leave++) { // Leave const CTessFace *face=leaves[leave]; // Add a triangle. -1 because not an instance from an IG triangleArray.push_back (CTriangle (NLMISC::CTriangle (face->VBase->EndPos, face->VLeft->EndPos, face->VRight->EndPos), -1 )); } // Setup the landscape landscape.setThreshold (1000); landscape.setTileMaxSubdivision (0); // Remove all triangles landscape.refineAll (CVector (0, 0, 0)); landscape.refineAll (CVector (0, 0, 0)); landscape.refineAll (CVector (0, 0, 0)); landscape.refineAll (CVector (0, 0, 0)); landscape.refineAll (CVector (0, 0, 0)); landscape.refineAll (CVector (0, 0, 0)); landscape.refineAll (CVector (0, 0, 0)); landscape.refineAll (CVector (0, 0, 0)); landscape.refineAll (CVector (0, 0, 0)); landscape.refineAll (CVector (0, 0, 0)); }

void NL3D::CInstanceLighter::beginCell (   )  [private]

Definition at line 1635 of file instance_lighter.cpp. References _IGRetrieverGridMap, _IGSurfaceLightBuild, _IsEndCell, _ItCellId, _ItCurrentCellNumber, _ItRetriever, _ItRetrieverInfo, _ItSurfId, _LastCellProgress, nlassert, and NL3D::CIGSurfaceLightBuild::RetrieverGridMap. Referenced by computeSunContribution(), dilateLightingOnSurfaceCells(), and processIGPointLightRT(). { if(_IGSurfaceLightBuild) { _ItRetriever= _IGRetrieverGridMap.begin(); if(_ItRetriever != _IGRetrieverGridMap.end() ) { _ItRetrieverInfo= _IGSurfaceLightBuild->RetrieverGridMap.find(_ItRetriever->first); nlassert(_ItRetrieverInfo != _IGSurfaceLightBuild->RetrieverGridMap.end() ); // We are suze here that the retriever is not empty, and that the grid herself is not empty too _ItSurfId= 0; _ItCellId= 0; _ItCurrentCellNumber= 0; _IsEndCell= false; _LastCellProgress= 0; } else { _IsEndCell= true; } } else { _IsEndCell= true; } }

void NL3D::CInstanceLighter::compilePointLightRT (  uint  gridSize, float  gridCellSize, std::vector< CTriangle > &  obstacles, bool  doShadow )  [private]

Fill CubeGrid, and set PointLightRT in _StaticPointLightQuadGrid. Definition at line 1023 of file instance_lighter.cpp. References _StaticPointLightQuadGrid, _StaticPointLights, NL3D::CQuadGrid< T >::begin(), NL3D::CInstanceLighter::CPointLightRT::BSphere, NLMISC::CBSphere::Center, NL3D::CCubeGrid< const CTriangle * >::compile(), NL3D::CCubeGrid< const CTriangle * >::create(), NL3D::CQuadGrid< T >::create(), NL3D::CQuadGrid< CPointLightRT * >::create(), NL3D::CQuadGrid< T >::end(), NLMISC::CAABBox::extend(), NL3D::CInstanceLighter::CPointLightRT::FaceCubeGrid, NL3D::CPointLight::getAttenuationEnd(), NLMISC::CAABBox::getMax(), NLMISC::CAABBox::getMin(), NL3D::CPointLight::getPosition(), NL3D::CPointLight::getType(), NL3D::CCubeGrid< const CTriangle * >::insert(), NL3D::CQuadGrid< T >::insert(), NL3D::CQuadGrid< CPointLightRT * >::insert(), NL3D_INSTANCE_LIGHTER_CUBE_GRID_SIZE, NL3D::CInstanceLighter::CPointLightRT::PointLight, progress(), NLMISC::CBSphere::Radius, NL3D::CInstanceLighter::CPointLightRT::RefCount, NL3D::CQuadGrid< T >::select(), NLMISC::CAABBox::setCenter(), NLMISC::CAABBox::setHalfSize(), size, NL3D::CInstanceLighter::CTriangle::Triangle, and uint. Referenced by light(). { uint i; // Fill the quadGrid of Lights. // =========== _StaticPointLightQuadGrid.create(gridSize, gridCellSize); for(i=0; i<_StaticPointLights.size();i++) { CPointLightRT &plRT= _StaticPointLights[i]; // Compute the bbox of the light CAABBox bbox; bbox.setCenter(plRT.BSphere.Center); float hl= plRT.BSphere.Radius; bbox.setHalfSize(CVector(hl,hl,hl)); // Insert the pointLight in the quadGrid. _StaticPointLightQuadGrid.insert(bbox.getMin(), bbox.getMax(), &plRT); } // Append triangles to cubeGrid ?? if(doShadow) { // For all obstacles, Fill a quadGrid. // =========== CQuadGrid<CTriangle*> obstacleGrid; obstacleGrid.create(gridSize, gridCellSize); uint size= obstacles.size(); for(i=0; i<size; i++) { // bbox of triangle CAABBox bbox; bbox.setCenter(obstacles[i].Triangle.V0); bbox.extend(obstacles[i].Triangle.V1); bbox.extend(obstacles[i].Triangle.V2); // insert triangle in quadGrid. obstacleGrid.insert(bbox.getMin(), bbox.getMax(), &obstacles[i]); } // For all PointLights, fill his CubeGrid // =========== for(i=0; i<_StaticPointLights.size();i++) { // progress progress ("Compute Influences of PointLights 1/2", i / (float)_StaticPointLights.size()); CPointLightRT &plRT= _StaticPointLights[i]; // Create the cubeGrid plRT.FaceCubeGrid.create(plRT.PointLight.getPosition(), NL3D_INSTANCE_LIGHTER_CUBE_GRID_SIZE); // AmbiantLIghts: do nothing. if(plRT.PointLight.getType()!=CPointLight::AmbientLight) { // Select only obstacle Faces around the light. Other are not usefull CAABBox bbox; bbox.setCenter(plRT.PointLight.getPosition()); float hl= plRT.PointLight.getAttenuationEnd(); bbox.setHalfSize(CVector(hl,hl,hl)); obstacleGrid.select(bbox.getMin(), bbox.getMax()); // For all faces, fill the cubeGrid. CQuadGrid<CTriangle*>::CIterator itObstacle; itObstacle= obstacleGrid.begin(); while( itObstacle!=obstacleGrid.end() ) { CTriangle &tri= *(*itObstacle); /* Don't Test BackFace culling Here (unlike in CZoneLighter !!). For objects: AutoOccluding problem is avoided with _CurrentInstanceComputed scheme. Also, With pointLights, there is no multiSampling (since no factor stored) Hence we are sure that no Object samples will lies under floor, and that the center of the object is far away. For IGSurface lighting: notice that we already add 20cm in height because of "stairs problem" so floor/surface auto_shadowing is not a problem here... */ // Insert the triangle in the CubeGrid plRT.FaceCubeGrid.insert( tri.Triangle, &tri); itObstacle++; } } // Compile the CubeGrid. plRT.FaceCubeGrid.compile(); // And Reset RefCount. plRT.RefCount= 0; } } // else, just build empty grid else { for(i=0; i<_StaticPointLights.size();i++) { // progress progress ("Compute Influences of PointLights 1/2", i / (float)_StaticPointLights.size()); CPointLightRT &plRT= _StaticPointLights[i]; // Create a dummy empty cubeGrid => no rayTrace :) plRT.FaceCubeGrid.create(plRT.PointLight.getPosition(), 4); // Compile the CubeGrid. plRT.FaceCubeGrid.compile(); // And Reset RefCount. plRT.RefCount= 0; } } }

void NL3D::CInstanceLighter::computeSunContribution (  const CLightDesc &  lightDesc, std::vector< CTriangle > &  obstacles, CLandscape *  landscape )  [private]

Definition at line 633 of file instance_lighter.cpp. References _CurrentInstanceComputed, _IGSurfaceLightBuild, _InstanceInfos, NL3D::CQuadGrid< T >::begin(), beginCell(), NL3D::CQuadGrid< T >::changeBase(), NL3D::CQuadGrid< T >::create(), NL3D::CVisualCollisionManager::createEntity(), NL3D::CVisualCollisionManager::deleteEntity(), NL3D::CInstanceLighter::CLightDesc::DisableSunContribution, NL3D::CQuadGrid< T >::end(), NLMISC::CAABBox::extend(), getCurrentCell(), getCurrentCellInfo(), NLMISC::CAABBox::getMax(), NLMISC::CAABBox::getMin(), NL3D::CVisualCollisionEntity::getStaticLightSetup(), NL3D::CInstanceLighter::CLightDesc::GridCellSize, NL3D::CInstanceLighter::CLightDesc::GridSize, NL3D::CQuadGrid< T >::insert(), NL3D::CInstanceLighter::CTriangle::InstanceId, NL3D::CIGSurfaceLightBuild::CCellCorner::InSurface, NLMISC::CTriangle::intersect(), NLMISC::CMatrix::inverted(), isEndCell(), NL3D::CInstanceLighter::CLightDesc::LightDirection, NL3D::NEL3DCalcBase(), nextCell(), nlassert, NLMISC::CVector::normalize(), NL3D::CIGSurfaceLightBuild::CCellCorner::NumOverSamples, NL3D::CIGSurfaceLightBuild::CCellCorner::OverSamples, NL3D::CInstanceLighter::CLightDesc::OverSampling, NL3D::CInstanceLighter::CTriangle::Plane, progress(), progressCell(), NL3D::CQuadGrid< T >::select(), NLMISC::CAABBox::setCenter(), NL3D::CVisualCollisionManager::setLandscape(), NL3D::CInstanceLighter::CLightDesc::Shadow, sint, NL3D::CIGSurfaceLightBuild::CCellCorner::SunContribution, NL3D::CSurfaceLightGrid::CCellCorner::SunContribution, NL3D::CInstanceLighter::CTriangle::Triangle, uint, and uint8. Referenced by light(). { sint i; // Use precoputed landscape SunContribution CVisualCollisionManager *VCM= NULL; CVisualCollisionEntity *VCE= NULL; if(landscape) { // create a CVisualCollisionManager and a CVisualCollisionEntity VCM= new CVisualCollisionManager; VCM->setLandscape(landscape); VCE= VCM->createEntity(); } std::vector<CPointLightInfluence> dummyPointLightFromLandscape; dummyPointLightFromLandscape.reserve(1024); // If DisableSunContribution, easy, if(lightDesc.DisableSunContribution) { // Light all instances. //========== for(i=0; i<(sint)_Instances.size(); i++) { // If staticLight not enabled, skip. if( !_Instances[i].StaticLightEnabled ) continue; // fill SunContribution to 0 _Instances[i].SunContribution= 0; } // Light SurfaceGrid Cells. //========== if(_IGSurfaceLightBuild) { // Begin cell iteration beginCell(); // For all surface cell corners while( !isEndCell() ) { // get the current cell and cellInfo iterated. CIGSurfaceLightBuild::CCellCorner &cellInfo= getCurrentCellInfo(); CSurfaceLightGrid::CCellCorner &cell= getCurrentCell(); // if the cell corner lies in the polygon surface. if(cellInfo.InSurface) { // fill SunContribution to 0 cell.SunContribution= 0; // copy it to cellInfo cellInfo.SunContribution= cell.SunContribution; } // next cell nextCell(); } } } // If no Raytrace Shadow, easy, else if(!lightDesc.Shadow) { // Light all instances. //========== for(i=0; i<(sint)_Instances.size(); i++) { progress ("Compute SunContribution on Instances", i / float(_Instances.size()) ); // If staticLight not enabled, skip. if( !_Instances[i].StaticLightEnabled ) continue; // by default, fill SunContribution to 255 _Instances[i].SunContribution= 255; // Try to get landscape SunContribution (better) if(landscape) { CVector pos= _InstanceInfos[i].CenterPos; uint8 landSunContribution; dummyPointLightFromLandscape.clear(); // If find faces under me NLMISC::CRGBA dummyAmbient; if(VCE->getStaticLightSetup(pos, dummyPointLightFromLandscape, landSunContribution, dummyAmbient) ) { _Instances[i].SunContribution= landSunContribution; } } } // Light SurfaceGrid Cells. //========== if(_IGSurfaceLightBuild) { // Begin cell iteration beginCell(); // For all surface cell corners while( !isEndCell() ) { progressCell("Compute SunContribution on Surfaces"); // get the current cell and cellInfo iterated. CIGSurfaceLightBuild::CCellCorner &cellInfo= getCurrentCellInfo(); CSurfaceLightGrid::CCellCorner &cell= getCurrentCell(); // if the cell corner lies in the polygon surface. if(cellInfo.InSurface) { // Just init SunContribution to 255, since no shadowing. cell.SunContribution= 255; // copy it to cellInfo cellInfo.SunContribution= cell.SunContribution; } // next cell nextCell(); } } } else { // Compute rayBasis CVector rayDir= lightDesc.LightDirection; CMatrix rayBasis; rayDir.normalize(); NEL3DCalcBase(rayDir, rayBasis); CMatrix invRayBasis; invRayBasis= rayBasis.inverted(); // Build QuadGrid of obstacles. //========= // setup quadGrid CQuadGrid<const CTriangle*> quadGrid; quadGrid.changeBase (invRayBasis); quadGrid.create(lightDesc.GridSize, lightDesc.GridCellSize); // Insert all obstacles in quadGrid for(i=0; i<(sint)obstacles.size(); i++) { CAABBox triBBox; // Compute the bbox in rayBasis. triBBox.setCenter(invRayBasis * obstacles[i].Triangle.V0); triBBox.extend(invRayBasis * obstacles[i].Triangle.V1); triBBox.extend(invRayBasis * obstacles[i].Triangle.V2); // And set the coord in our world, because will be multiplied with invRayBasis in insert() quadGrid.insert(rayBasis * triBBox.getMin(), rayBasis * triBBox.getMax(), &obstacles[i]); } // For all instances, light them. //========= for(i=0; i<(sint)_Instances.size(); i++) { progress ("Compute SunContribution on Instances", i / float(_Instances.size()) ); // If staticLight not enabled, skip. if( !_Instances[i].StaticLightEnabled ) continue; // try to use landscape SunContribution. bool landUsed= false; if(landscape) { CVector pos= _InstanceInfos[i].CenterPos; uint8 landSunContribution; dummyPointLightFromLandscape.clear(); // If find faces under me NLMISC::CRGBA dummyAmbient; if(VCE->getStaticLightSetup(pos, dummyPointLightFromLandscape, landSunContribution, dummyAmbient) ) { _Instances[i].SunContribution= landSunContribution; landUsed= true; } } // If failed to use landscape SunContribution, rayTrace if(!landUsed) { // number of samples (1 if no overSampling) uint nSamples= max(1U, lightDesc.OverSampling); // Default is full lighted. uint sunAccum= 255*nSamples; // For all samples for(uint sample=0; sample<nSamples; sample++) { // pos to rayTrace against CVector pos= _InstanceInfos[i].OverSamples[sample]; // rayTrace from this pos. CVector lightPos= pos-(rayDir*1000.f); // Select an element with the X axis as a 3d ray quadGrid.select (lightPos, lightPos); // For each triangle selected CQuadGrid<const CTriangle*>::CIterator it=quadGrid.begin(); while (it!=quadGrid.end()) { const CTriangle *tri= *it; // If same instanceId, skip if(tri->InstanceId != i) { CVector hit; // If triangle occlude the ray, no sun Contribution if(tri->Triangle.intersect(lightPos, pos, hit, tri->Plane)) { // The sample is not touched by sun. sub his contribution sunAccum-= 255; // End break; } } it++; } } // Average samples _Instances[i].SunContribution= sunAccum / nSamples; } } // Light SurfaceGrid Cells. //========== if(_IGSurfaceLightBuild) { // No instance currenlty computed, since we compute surface cells. _CurrentInstanceComputed= -1; // Begin cell iteration beginCell(); // For all surface cell corners while( !isEndCell() ) { progressCell("Compute SunContribution on Surfaces"); // get the current cell and cellInfo iterated. CIGSurfaceLightBuild::CCellCorner &cellInfo= getCurrentCellInfo(); CSurfaceLightGrid::CCellCorner &cell= getCurrentCell(); // if the cell corner lies in the polygon surface. if(cellInfo.InSurface) { // number of samples (at least 1 if no overSampling) uint nSamples= cellInfo.NumOverSamples; nlassert(nSamples>=1); // Default is full lighted. uint sunAccum= 255*nSamples; // For all samples for(uint sample=0; sample<nSamples; sample++) { // Get pos to rayTrace. CVector pos= cellInfo.OverSamples[sample]; // rayTrace from the pos of this Cell sample. CVector lightPos= pos-(rayDir*1000.f); // Select an element with the X axis as a 3d ray quadGrid.select (lightPos, lightPos); // For each triangle selected CQuadGrid<const CTriangle*>::CIterator it=quadGrid.begin(); while (it!=quadGrid.end()) { const CTriangle *tri= *it; CVector hit; // If triangle occlude the ray, no sun Contribution if(tri->Triangle.intersect(lightPos, pos, hit, tri->Plane)) { // The cell sample is not touched by sun. sub his contribution sunAccum-= 255; // End break; } it++; } } // Average SunContribution cell.SunContribution= sunAccum / nSamples; // copy it to cellInfo cellInfo.SunContribution= cell.SunContribution; } // next cell nextCell(); } } } // Clean VCM and VCE if(landscape) { // delete CVisualCollisionManager and CVisualCollisionEntity VCM->deleteEntity(VCE); delete VCM; } }

void NL3D::CInstanceLighter::dilateLightingOnSurfaceCells (   )  [private]

Definition at line 1801 of file instance_lighter.cpp. References beginCell(), NL3D::CIGSurfaceLightBuild::CCellCorner::CenterPos, NL3D::CIGSurfaceLightBuild::CCellCorner::Dilated, getCurrentCell(), getCurrentCellInfo(), getCurrentNeighborCell(), getCurrentNeighborCellInfo(), NL3D::CIGSurfaceLightBuild::CCellCorner::InSurface, isCurrentNeighborCellInSurface(), isEndCell(), NL3D::CSurfaceLightGrid::CCellCorner::Light, NL3D::CSurfaceLightGrid::CCellCorner::LocalAmbientId, nextCell(), progressCell(), sint, NL3D::CIGSurfaceLightBuild::CCellCorner::SunContribution, NL3D::CSurfaceLightGrid::CCellCorner::SunContribution, uint, and NLMISC::CVector::z. Referenced by light(). { // Begin cell iteration beginCell(); // For all surface cell corners while( !isEndCell() ) { progressCell("Dilate Surfaces grids"); // get the current cell and cellInfo iterated. CIGSurfaceLightBuild::CCellCorner &cellInfo= getCurrentCellInfo(); CSurfaceLightGrid::CCellCorner &cell= getCurrentCell(); // if the cell is not in the polygon surface, try to get from his neighbors. if(!cellInfo.InSurface) { // Add Weighted influence of SunContribution, and get one of the PointLightContribution (random). uint wgtSunContribution= 0; uint wgtSunCount= 0; // search if one of 8 neighbors is InSurface. for(sint ynb= -1; ynb<= 1; ynb++) { for(sint xnb= -1; xnb<= 1; xnb++) { // center => skip. if( xnb==0 && ynb==0 ) continue; // If the neighbor point is not out of the grid, and if in Surface. if( isCurrentNeighborCellInSurface(xnb, ynb) ) { // get the neighbor cell CIGSurfaceLightBuild::CCellCorner &nbCellInfo= getCurrentNeighborCellInfo(xnb, ynb); CSurfaceLightGrid::CCellCorner &nbCell= getCurrentNeighborCell(xnb, ynb); // Add SunContribution. wgtSunContribution+= nbCell.SunContribution; wgtSunCount++; // Just Copy PointLight info. for(uint lightId= 0; lightId<CSurfaceLightGrid::NumLightPerCorner; lightId++) cell.Light[lightId]= nbCell.Light[lightId]; // Just Copy AmbientLight info. cell.LocalAmbientId= nbCell.LocalAmbientId; // For debug mesh only, copy z from nb cellInfo cellInfo.CenterPos.z= nbCellInfo.CenterPos.z; } } } // average SunContribution. if(wgtSunCount>0) { cell.SunContribution= wgtSunContribution / wgtSunCount; // For debug mesh only, copy SunContribution into cellInfo cellInfo.SunContribution= cell.SunContribution; cellInfo.Dilated= true; } } // next cell nextCell(); } }

void NL3D::CInstanceLighter::excludeAllPatchFromRefineAll (  CLandscape &  landscape, std::vector< uint > &  listZone, bool  exclude )  [static, private]

Definition at line 278 of file instance_lighter.cpp. References NL3D::CLandscape::excludePatchFromRefineAll(), NL3D::CZone::getNumPatchs(), NL3D::CLandscape::getZone(), and uint. Referenced by addTriangles(). { // For each zone for (uint zone=0; zone<listZone.size(); zone++) { // Get num patches uint patchCount=landscape.getZone(listZone[zone])->getNumPatchs(); // For each patches for (uint patch=0; patch<patchCount; patch++) { // Exclude all the patches from refine all landscape.excludePatchFromRefineAll (listZone[zone], patch, exclude); } } }

CSurfaceLightGrid::CCellCorner & NL3D::CInstanceLighter::getCurrentCell (   )  [private]

Definition at line 1705 of file instance_lighter.cpp. References _ItCellId, _ItRetriever, _ItSurfId, isEndCell(), and nlassert. Referenced by computeSunContribution(), dilateLightingOnSurfaceCells(), and processIGPointLightRT(). { nlassert(!isEndCell()); // return ref on Cell. return _ItRetriever->second.Grids[_ItSurfId].Cells[_ItCellId]; }

CIGSurfaceLightBuild::CCellCorner & NL3D::CInstanceLighter::getCurrentCellInfo (   )  [private]

Definition at line 1714 of file instance_lighter.cpp. References _ItCellId, _ItRetrieverInfo, _ItSurfId, isEndCell(), and nlassert. Referenced by computeSunContribution(), dilateLightingOnSurfaceCells(), and processIGPointLightRT(). { nlassert(!isEndCell()); // return ref on CellInfo. return _ItRetrieverInfo->second.Grids[_ItSurfId].Cells[_ItCellId]; }

uint NL3D::CInstanceLighter::getCurrentCellNumber (   )  const [inline, private]

Definition at line 284 of file instance_lighter.h. References _ItCurrentCellNumber, and uint. Referenced by progressCell(). {return _ItCurrentCellNumber;}

CSurfaceLightGrid::CCellCorner & NL3D::CInstanceLighter::getCurrentNeighborCell (  sint  xnb, sint  ynb )  [private]

Definition at line 1757 of file instance_lighter.cpp. References _ItCellId, _ItRetriever, _ItSurfId, NL3D::CSurfaceLightGrid::Cells, isCurrentNeighborCellInSurface(), nlassert, sint, uint, and NL3D::CSurfaceLightGrid::Width. Referenced by dilateLightingOnSurfaceCells(). { nlassert(isCurrentNeighborCellInSurface(xnb, ynb)); // get a ref on the current grid. CSurfaceLightGrid &surfGrid= _ItRetriever->second.Grids[_ItSurfId]; // copute coordinate of the current cellCorner. sint xCell, yCell; xCell= _ItCellId%surfGrid.Width; yCell= _ItCellId/surfGrid.Width; // compute coordinate of the neighbor cell corner xCell+= xnb; yCell+= ynb; // compute the neighbor id uint nbId= yCell*surfGrid.Width + xCell; // then return a ref on it return surfGrid.Cells[nbId]; }

CIGSurfaceLightBuild::CCellCorner & NL3D::CInstanceLighter::getCurrentNeighborCellInfo (  sint  xnb, sint  ynb )  [private]

Definition at line 1779 of file instance_lighter.cpp. References _ItCellId, _ItRetrieverInfo, _ItSurfId, NL3D::CIGSurfaceLightBuild::CSurface::Cells, isCurrentNeighborCellInSurface(), nlassert, sint, uint, and NL3D::CIGSurfaceLightBuild::CSurface::Width. Referenced by dilateLightingOnSurfaceCells(). { nlassert(isCurrentNeighborCellInSurface(xnb, ynb)); // get a ref on the current grid. CIGSurfaceLightBuild::CSurface &surfGrid= _ItRetrieverInfo->second.Grids[_ItSurfId]; // copute coordinate of the current cellCorner. sint xCell, yCell; xCell= _ItCellId%surfGrid.Width; yCell= _ItCellId/surfGrid.Width; // compute coordinate of the neighbor cell corner xCell+= xnb; yCell+= ynb; // compute the neighbor id uint nbId= yCell*surfGrid.Width + xCell; // then return a ref on it return surfGrid.Cells[nbId]; }

uint NL3D::CInstanceLighter::getTotalCellNumber (   )  const [inline, private]

Definition at line 285 of file instance_lighter.h. References _TotalCellNumber, and uint. Referenced by progressCell(). {return _TotalCellNumber;}

void NL3D::CInstanceLighter::init (   )

Definition at line 72 of file instance_lighter.cpp. Referenced by lightIgSimple(). { }

bool NL3D::CInstanceLighter::isCurrentNeighborCellInSurface (  sint  xnb, sint  ynb )  [private]

Definition at line 1724 of file instance_lighter.cpp. References _ItCellId, _ItRetriever, _ItRetrieverInfo, _ItSurfId, NL3D::CSurfaceLightGrid::Height, isEndCell(), nlassert, sint, uint, and NL3D::CSurfaceLightGrid::Width. Referenced by dilateLightingOnSurfaceCells(), getCurrentNeighborCell(), and getCurrentNeighborCellInfo(). { nlassert(!isEndCell()); // get a ref on the current grid. CSurfaceLightGrid &surfGrid= _ItRetriever->second.Grids[_ItSurfId]; // copute coordinate of the current cellCorner. sint xCell, yCell; xCell= _ItCellId%surfGrid.Width; yCell= _ItCellId/surfGrid.Width; // compute coordinate of the neighbor cell corner xCell+= xnb; yCell+= ynb; // check if in the surfaceGrid if(xCell<0 || xCell>=(sint)surfGrid.Width) return false; if(yCell<0 || yCell>=(sint)surfGrid.Height) return false; // compute the neighbor id uint nbId= yCell*surfGrid.Width + xCell; // Now check in the cellInfo if this cell is InSurface. if( !_ItRetrieverInfo->second.Grids[_ItSurfId].Cells[nbId].InSurface ) return false; // Ok, the neighbor cell is valid. return true; }

bool NL3D::CInstanceLighter::isEndCell (   )  [private]

Definition at line 1699 of file instance_lighter.cpp. References _IsEndCell. Referenced by computeSunContribution(), dilateLightingOnSurfaceCells(), getCurrentCell(), getCurrentCellInfo(), isCurrentNeighborCellInSurface(), nextCell(), and processIGPointLightRT(). { return _IsEndCell; }

void NL3D::CInstanceLighter::light (  const CInstanceGroup &  igIn, CInstanceGroup &  igOut, const CLightDesc &  lightDesc, std::vector< CTriangle > &  obstacles, CLandscape *  landscape = NULL, CIGSurfaceLightBuild *  igSurfaceLightBuild = NULL )

Light an InstanceGroup igOut has different PointLights than igIn. eg: if a pointLight do not light anything, then it is not present in igOut. NB: shapes are used to retrieve usefull info on them (center of AABBox ...) . They are taken from lightDesc.UserShapeMap, or loaded from lightDesc.ShapePath if not found. Parameters: landscape  if !NULL use this Landscape SunContribution, looking landscape faces under each instance, for faster computing, and to get influence of Sky. NB: this landscape does not have to be tesselated, but all Zones that lies under igIn should be loaded in. igSurfaceLightBuild  if !NULL, light() will compute igOut.IGSurfaceLight, else it is just cleared. Definition at line 305 of file instance_lighter.cpp. References _IGRetrieverGridMap, _IGSurfaceLightBuild, _InstanceInfos, _IsEndCell, _TotalCellNumber, NL3D::CInstanceGroup::build(), NL3D::CIGSurfaceLightBuild::CSurface::Cells, NL3D::CSurfaceLightGrid::Cells, NL3D::CIGSurfaceLightBuild::CellSize, compilePointLightRT(), computeSunContribution(), dilateLightingOnSurfaceCells(), NLMISC::CObjectVector< CCellCorner >::fill(), NLMISC::CAABBox::getCenter(), NLMISC::CAABBox::getHalfSize(), NL3D::CShapeStream::getShapePointer(), NL3D::CInstanceLighter::CLightDesc::GridCellSize, NL3D::CIGSurfaceLight::CRetrieverLightGrid::Grids, NL3D::CInstanceLighter::CLightDesc::GridSize, NL3D::CIGSurfaceLightBuild::CSurface::Height, NL3D::CSurfaceLightGrid::Height, NL3D::CMeshBase::isLightable(), NL3D::CSurfaceLightGrid::CCellCorner::Light, NL3D::CSurfaceLightGrid::CCellCorner::LocalAmbientId, NLMISC::CPlane::make(), nlassert, nlwarning, NLMISC::CIFile::open(), NL3D::CIGSurfaceLightBuild::CSurface::Origin, NL3D::CSurfaceLightGrid::Origin, NL3D::CInstanceLighter::CLightDesc::OverSampling, NL3D::CInstanceLighter::CTriangle::Plane, processIGPointLightRT(), NLMISC::CObjectVector< CCellCorner >::resize(), NLMISC::CObjectVector< CSurfaceLightGrid >::resize(), NL3D::CInstanceGroup::retrieve(), NL3D::CIGSurfaceLightBuild::RetrieverGridMap, NLMISC::CMatrix::scale(), NL3D::CShapeStream::serial(), NLMISC::CAABBox::setCenter(), NLMISC::CAABBox::setHalfSize(), NLMISC::CMatrix::setPos(), NLMISC::CMatrix::setRot(), NL3D::CInstanceLighter::CLightDesc::Shadow, sint, NLMISC::CObjectVector< CCellCorner >::size(), NL3D::CSurfaceLightGrid::CCellCorner::SunContribution, NL3D::CInstanceLighter::CTriangle::Triangle, uint, NL3D::CInstanceLighter::CLightDesc::UserShapeMap, NLMISC::CTriangle::V0, NLMISC::CTriangle::V1, NLMISC::CTriangle::V2, NL3D::CIGSurfaceLightBuild::CSurface::Width, NL3D::CSurfaceLightGrid::Width, NLMISC::CVector::x, NLMISC::CVector::y, and NLMISC::CVector::z. Referenced by lightIgSimple(). { sint i; CVector outGlobalPos; std::vector<CCluster> outClusters; std::vector<CPortal> outPortals; std::vector<CPointLightNamed> pointLightList; nlassert(lightDesc.OverSampling==0 || lightDesc.OverSampling==2 || lightDesc.OverSampling==4 || lightDesc.OverSampling==8 || lightDesc.OverSampling==16); // Setup. //======== // Prepare IGSurfaceLight lighting //----------- // Bkup SurfaceLightBuild to know if must light the surfaces, in differents part of the process. _IGSurfaceLightBuild= igSurfaceLightBuild; // Prepare _IGRetrieverGridMap. _IGRetrieverGridMap.clear(); if(_IGSurfaceLightBuild) { _TotalCellNumber= 0; CIGSurfaceLightBuild::ItRetrieverGridMap itSrc; itSrc= _IGSurfaceLightBuild->RetrieverGridMap.begin(); // For all retrievers Infos in _IGSurfaceLightBuild while(itSrc!=_IGSurfaceLightBuild->RetrieverGridMap.end()) { uint numSurfaces= itSrc->second.Grids.size(); // If !empty retriever. if(numSurfaces>0) { // Add it to the map, CIGSurfaceLight::CRetrieverLightGrid &rlgDst= _IGRetrieverGridMap[itSrc->first]; // resize Array of surfaces. rlgDst.Grids.resize(numSurfaces); // For all surfaces, init them in rlgDst. for(uint i=0; i<numSurfaces; i++) { CIGSurfaceLightBuild::CSurface &surfSrc= itSrc->second.Grids[i]; CSurfaceLightGrid &surfDst= rlgDst.Grids[i]; // Init Cells with a default CellCorner CSurfaceLightGrid::CCellCorner defaultCellCorner; defaultCellCorner.SunContribution= 0; defaultCellCorner.Light[0]= 0xFF; defaultCellCorner.LocalAmbientId= 0xFF; // Init the grid. surfDst.Origin= surfSrc.Origin; surfDst.Width= surfSrc.Width; surfDst.Height= surfSrc.Height; surfDst.Cells.resize(surfSrc.Cells.size()); surfDst.Cells.fill(defaultCellCorner); // The grid must be valid an not empty nlassert( surfDst.Cells.size() == surfDst.Width*surfDst.Height ); nlassert( surfDst.Width>= 2 ); nlassert( surfDst.Height>= 2 ); _TotalCellNumber+= surfDst.Cells.size(); } } // Next localRetriever info. itSrc++; } } // Reset cell iteration. _IsEndCell= true; // Retrieve info from igIn. //----------- igIn.retrieve (outGlobalPos, _Instances, outClusters, outPortals, pointLightList); // set All Instances StaticLightEnabled= true, and Build _InstanceInfos. //----------- // Map of shape std::map<string, IShape*> shapeMap; _InstanceInfos.resize(_Instances.size()); for(i=0; i<(sint)_Instances.size();i++) { // Avoid StaticLight precomputing?? if(_Instances[i].AvoidStaticLightPreCompute) { _Instances[i].StaticLightEnabled= false; // Next instance. continue; } // Else let's do it. _Instances[i].StaticLightEnabled= true; // Get the shape centerPos; //------------ CVector shapeCenterPos; CVector overSamples[MaxOverSamples]; // Get the instance shape name string name= _Instances[i].Name; bool shapeFound= true; // Try to find the shape in the UseShapeMap. std::map<string, IShape*>::const_iterator iteMap= lightDesc.UserShapeMap.find (name); // If not found in userShape map, try to load it from the temp loaded ShapeBank. if( iteMap == lightDesc.UserShapeMap.end() ) { // Add a .shape at the end ? if (name.find('.') == std::string::npos) name += ".shape"; // Get the instance shape name string nameLookup = CPath::lookup (name, false, false); if (!nameLookup.empty()) name = nameLookup; // Find the shape in the bank iteMap= shapeMap.find (name); if (iteMap==shapeMap.end()) { // Input file CIFile inputFile; if (!name.empty() && inputFile.open (name)) { // Load it CShapeStream stream; stream.serial (inputFile); // Get the pointer iteMap=shapeMap.insert (std::map<string, IShape*>::value_type (name, stream.getShapePointer ())).first; } else { // Error nlwarning ("WARNING can't load shape %s\n", name.c_str()); shapeFound= false; } } } // Last chance to skip it: fully LightMapped ?? //----------- if(shapeFound) { CMeshBase *mesh= dynamic_cast<CMeshBase*>(iteMap->second); if(mesh) { // If this mesh is not lightable (fully lightMapped) if(!mesh->isLightable()) { // Force Avoid StaticLight precomputing _Instances[i].AvoidStaticLightPreCompute= true; // Disable static lighting. _Instances[i].StaticLightEnabled= false; // Next instance. continue; } } } // Compute pos and OverSamples //----------- { // Compute bbox, or default bbox CAABBox bbox; if(!shapeFound) { bbox.setCenter(CVector::Null); bbox.setHalfSize(CVector::Null); } else { iteMap->second->getAABBox(bbox); } // get pos shapeCenterPos= bbox.getCenter(); // Compute overSamples float qx= bbox.getHalfSize().x/2; float qy= bbox.getHalfSize().y/2; float qz= bbox.getHalfSize().z/2; // No OverSampling => just copy. if(lightDesc.OverSampling==0) overSamples[0]= shapeCenterPos; else if(lightDesc.OverSampling==2) { // Prefer Z Axis. overSamples[0]= shapeCenterPos + CVector(0, 0, qz); overSamples[1]= shapeCenterPos - CVector(0, 0, qz); } else if(lightDesc.OverSampling==4) { // Apply an overSampling such that we see 4 points if we look on each side of the bbox. overSamples[0]= shapeCenterPos + CVector(-qx, -qy, -qz); overSamples[1]= shapeCenterPos + CVector(+qx, -qy, +qz); overSamples[2]= shapeCenterPos + CVector(-qx, +qy, +qz); overSamples[3]= shapeCenterPos + CVector(+qx, +qy, -qz); } else if(lightDesc.OverSampling==8 || lightDesc.OverSampling==16) { // 8x is the best overSampling shceme for bbox overSamples[0]= shapeCenterPos + CVector(-qx, -qy, -qz); overSamples[1]= shapeCenterPos + CVector(+qx, -qy, -qz); overSamples[2]= shapeCenterPos + CVector(-qx, +qy, -qz); overSamples[3]= shapeCenterPos + CVector(+qx, +qy, -qz); overSamples[4]= shapeCenterPos + CVector(-qx, -qy, +qz); overSamples[5]= shapeCenterPos + CVector(+qx, -qy, +qz); overSamples[6]= shapeCenterPos + CVector(-qx, +qy, +qz); overSamples[7]= shapeCenterPos + CVector(+qx, +qy, +qz); // 16x => use this setup, and decal from 1/8 if(lightDesc.OverSampling==16) { CVector decal(qx/2, qy/2, qz/2); for(uint sample=0; sample<8; sample++) { // Copy and decal overSamples[sample+8]= overSamples[sample] + decal; // neg decal me overSamples[sample]-= decal; } } } } // Compute pos of the instance //------------ CMatrix matInst; matInst.setPos(_Instances[i].Pos); matInst.setRot(_Instances[i].Rot); matInst.scale(_Instances[i].Scale); _InstanceInfos[i].CenterPos= matInst * shapeCenterPos; // Apply matInst to samples. uint nSamples= max(1U, lightDesc.OverSampling); for(uint sample=0; sample<nSamples; sample++) { _InstanceInfos[i].OverSamples[sample]= matInst * overSamples[sample]; } } // Clean Up shapes. //----------- std::map<string, IShape*>::iterator iteMap; iteMap= shapeMap.begin(); while(iteMap!= shapeMap.end()) { // delte shape delete iteMap->second; // delete entry in map shapeMap.erase(iteMap); // next iteMap= shapeMap.begin(); } // Build all obstacles plane. //----------- for(i=0; i<(sint)obstacles.size();i++) { CInstanceLighter::CTriangle& triangle=obstacles[i]; // Calc the plane triangle.Plane.make (triangle.Triangle.V0, triangle.Triangle.V1, triangle.Triangle.V2); } // Lighting //======== // Light With Sun: build the grid, and do it on all _Instances, using _InstanceInfos // Compute also Lighting on surface. computeSunContribution(lightDesc, obstacles, landscape); // Light With PointLights // build the cubeGrids compilePointLightRT(lightDesc.GridSize, lightDesc.GridCellSize, obstacles, lightDesc.Shadow); // kill pointLightList, because will use mine. pointLightList.clear(); // Light for all _Instances, using _InstanceInfos // Compute also Lighting on surface. processIGPointLightRT(pointLightList); // If _IGSurfaceLightBuild, then dilate lighting if(_IGSurfaceLightBuild) { dilateLightingOnSurfaceCells(); } // Build result. //======== if(_IGSurfaceLightBuild) { // build with IGSurfaceLight lighting igOut.build(outGlobalPos, _Instances, outClusters, outPortals, pointLightList, &_IGRetrieverGridMap, _IGSurfaceLightBuild->CellSize); } else { // build without IGSurfaceLight lighting igOut.build(outGlobalPos, _Instances, outClusters, outPortals, pointLightList); } }

void NL3D::CInstanceLighter::lightIgSimple (  CInstanceLighter &  instLighter, const CInstanceGroup &  igIn, CInstanceGroup &  igOut, const CLightDesc &  lightDesc, const char *  igName )  [static]

Tool method which take a single IG, and do all the god job to light this one, with no other dependencies NB: it uses instLighter passed, init() ing it. It use lightDesc.UserShapeMap or it load Shape in directory lightDesc.ShapePath Definition at line 1502 of file instance_lighter.cpp. References addStaticPointLight(), NL3D::CInstanceGroup::getInstance(), NL3D::CInstanceGroup::getInstancePos(), NL3D::CInstanceGroup::getInstanceRot(), NL3D::CInstanceGroup::getInstanceScale(), NL3D::CInstanceGroup::getNumInstance(), NL3D::CInstanceGroup::getPointLightList(), NL3D::CInstanceGroup::getShapeName(), NL3D::CShapeStream::getShapePointer(), init(), light(), nlwarning, NLMISC::CIFile::open(), progress(), NLMISC::CMatrix::scale(), NL3D::CShapeStream::serial(), NLMISC::CMatrix::setPos(), NLMISC::CMatrix::setRot(), NL3D::CInstanceLighter::CLightDesc::Shadow, sint, and NL3D::CInstanceLighter::CLightDesc::UserShapeMap. { sint i; // Setup. //======= // Init instLighter.init(); // Add obstacles. std::vector<CInstanceLighter::CTriangle> obstacles; // only if Shadowing On. if(lightDesc.Shadow) { // Map of shape to load std::map<string, IShape*> shapeMap; // For all instances of igIn. for(i=0; i<(sint)igIn.getNumInstance();i++) { // progress instLighter.progress("Loading Shapes obstacles", float(i)/igIn.getNumInstance()); // Skip it?? if(igIn.getInstance(i).DontCastShadow) continue; // Get the instance shape name string name= igIn.getShapeName(i); bool shapeFound= true; // Try to find the shape in the UseShapeMap. std::map<string, IShape*>::const_iterator iteMap= lightDesc.UserShapeMap.find (name); // If not found in userShape map, try to load it from the temp loaded ShapeBank. if( iteMap == lightDesc.UserShapeMap.end() ) { // Add a .shape at the end ? if (name.find('.') == std::string::npos) name += ".shape"; // Get the instance shape name string nameLookup = CPath::lookup (name, false, false); if (!nameLookup.empty()) name = nameLookup; // Find the shape in the bank iteMap= shapeMap.find (name); if (iteMap==shapeMap.end()) { // Input file CIFile inputFile; if (!name.empty() && inputFile.open (name)) { // Load it CShapeStream stream; stream.serial (inputFile); // Get the pointer iteMap=shapeMap.insert (std::map<string, IShape*>::value_type (name, stream.getShapePointer ())).first; } else { // Error nlwarning ("WARNING can't load shape %s\n", name.c_str()); shapeFound= false; } } } if(shapeFound) { CMatrix matInst; matInst.setPos(igIn.getInstancePos(i)); matInst.setRot(igIn.getInstanceRot(i)); matInst.scale(igIn.getInstanceScale(i)); // Add triangles of this shape CInstanceLighter::addTriangles(*iteMap->second, matInst, obstacles, i); } } // Clean Up shapes. //----------- std::map<string, IShape*>::iterator iteMap; iteMap= shapeMap.begin(); while(iteMap!= shapeMap.end()) { // delte shape delete iteMap->second; // delete entry in map shapeMap.erase(iteMap); // next iteMap= shapeMap.begin(); } } // Add pointLights of the IG. for(i=0; i<(sint)igIn.getPointLightList().size();i++) { instLighter.addStaticPointLight( igIn.getPointLightList()[i], igName ); } // Run. //======= instLighter.light(igIn, igOut, lightDesc, obstacles); }

void NL3D::CInstanceLighter::nextCell (   )  [private]

Definition at line 1663 of file instance_lighter.cpp. References _IGRetrieverGridMap, _IGSurfaceLightBuild, _IsEndCell, _ItCellId, _ItCurrentCellNumber, _ItRetriever, _ItRetrieverInfo, _ItSurfId, isEndCell(), nlassert, and NL3D::CIGSurfaceLightBuild::RetrieverGridMap. Referenced by computeSunContribution(), dilateLightingOnSurfaceCells(), and processIGPointLightRT(). { nlassert(!isEndCell()); // Next Cell. _ItCellId++; _ItCurrentCellNumber++; // If end of Cells, next surface. if(_ItCellId >= _ItRetriever->second.Grids[_ItSurfId].Cells.size() ) { _ItCellId= 0; _ItSurfId ++; } // If end of surface, next retriever. if(_ItSurfId >= _ItRetriever->second.Grids.size() ) { _ItSurfId= 0; _ItRetriever++; if(_ItRetriever != _IGRetrieverGridMap.end()) { // Get info. _ItRetrieverInfo= _IGSurfaceLightBuild->RetrieverGridMap.find(_ItRetriever->first); nlassert(_ItRetrieverInfo != _IGSurfaceLightBuild->RetrieverGridMap.end() ); } } // If end of retreiver, End. if(_ItRetriever == _IGRetrieverGridMap.end()) { _IsEndCell= true; } }

void NL3D::CInstanceLighter::processIGPointLightRT (  std::vector< CPointLightNamed > &  listPointLight  )  [private]

Process the IG, ie process _InstanceInfos. Also process SurfaceLightGrid MultiCPU: not done for now. Be aware of CPointLightRT::RefCount!!!! Definition at line 1161 of file instance_lighter.cpp. References _CurrentInstanceComputed, _IGSurfaceLightBuild, _InstanceInfos, _StaticPointLightQuadGrid, _StaticPointLights, NL3D::CQuadGrid< CPointLightRT * >::begin(), beginCell(), NL3D::CInstanceLighter::CPointLightRT::BSphere, NLMISC::CBSphere::Center, NL3D::CIGSurfaceLightBuild::CCellCorner::CenterPos, NL3D::CInstanceLighter::CInstanceInfo::CenterPos, NL3D::CInstanceLighter::CPointLightRT::DstId, NL3D::CQuadGrid< CPointLightRT * >::end(), getCurrentCell(), getCurrentCellInfo(), NL3D::CPointLight::getType(), NL3D::CIGSurfaceLightBuild::CCellCorner::InSurface, isEndCell(), NL3D::CSurfaceLightGrid::CCellCorner::Light, NL3D::CInstanceGroup::CInstance::Light, NL3D::CInstanceLighter::CInstanceInfo::Light, NL3D::CIGSurfaceLightBuild::CCellCorner::LightInfo, NL3D::CSurfaceLightGrid::CCellCorner::LocalAmbientId, NL3D::CInstanceGroup::CInstance::LocalAmbientId, NL3D::CIGSurfaceLightBuild::CCellCorner::LocalAmbientLight, NL3D::CInstanceLighter::CInstanceInfo::LocalAmbientLight, min, nextCell(), nlctassert, nlwarning, NL3D::CInstanceLighter::CPredPointLightToPoint::Point, NL3D::CInstanceLighter::CPointLightRT::PointLight, progress(), progressCell(), NLMISC::CBSphere::Radius, NL3D::CInstanceLighter::CPointLightRT::RefCount, NL3D::CQuadGrid< CPointLightRT * >::select(), NL3D::CInstanceLighter::CPointLightRT::testRaytrace(), and uint. Referenced by light(). { uint i; vector<CPointLightRT*> lightInfs; lightInfs.reserve(1024); // clear result list listPointLight.clear(); // Compute each Instance //=========== for(i=0; i<_InstanceInfos.size(); i++) { // If staticLight not enabled, skip. if( !_Instances[i].StaticLightEnabled ) continue; CInstanceInfo &inst= _InstanceInfos[i]; // Avoid autoShadowing _CurrentInstanceComputed= i; // progress progress ("Compute Influences of PointLights 2/2", i / (float)_InstanceInfos.size()); // get the point of the instance. CVector pos= inst.CenterPos; // Default: takes no LocalAmbientLight; inst.LocalAmbientLight= NULL; float furtherAmbLight= 0; // Compute Which light influences him. //--------- lightInfs.clear(); // Search possible lights around the position. _StaticPointLightQuadGrid.select(pos, pos); // For all of them, get the ones which touch this point. CQuadGrid<CPointLightRT*>::CIterator it= _StaticPointLightQuadGrid.begin(); while(it != _StaticPointLightQuadGrid.end()) { CPointLightRT *pl= *it; // Test if really in the radius of the light, no occlusion, not an ambient, and in Spot Angle setup if( pl->testRaytrace(pos, _CurrentInstanceComputed) ) { // Ok, add the light to the lights which influence the instance lightInfs.push_back(pl); } // Ambient Light ?? if( pl->PointLight.getType() == CPointLight::AmbientLight ) { // If the instance is in radius of the ambiant light. float dRadius= pl->BSphere.Radius - (pl->BSphere.Center - pos).norm(); if(dRadius>0) { // Take the best ambient light: the one which is further from the circumference if(dRadius > furtherAmbLight) { furtherAmbLight= dRadius; inst.LocalAmbientLight= pl; } } } // next it++; } // If ambientLight chosen, inc Ref count of it if(inst.LocalAmbientLight) inst.LocalAmbientLight->RefCount++; // Choose the Best ones. //--------- CPredPointLightToPoint predPLTP; predPLTP.Point= pos; // sort. sort(lightInfs.begin(), lightInfs.end(), predPLTP); // truncate. lightInfs.resize( min((uint)lightInfs.size(), (uint)CInstanceGroup::NumStaticLightPerInstance) ); // For each of them, fill instance //--------- uint lightInfId; for(lightInfId=0; lightInfId<lightInfs.size(); lightInfId++) { CPointLightRT *pl= lightInfs[lightInfId]; // copy light. inst.Light[lightInfId]= pl; // Inc RefCount of the light. pl->RefCount++; } // Reset any empty slot to NULL. for(; lightInfId<CInstanceGroup::NumStaticLightPerInstance; lightInfId++) { inst.Light[lightInfId]= NULL; } } // Compute Lighting on SurfaceLightGrid //=========== // Must do it before compression !! // NB: big copy/Past from above if(_IGSurfaceLightBuild) { // No instance currenlty computed, since we compute surface cells. _CurrentInstanceComputed= -1; // Begin cell iteration beginCell(); // For all surface cell corners while( !isEndCell() ) { progressCell("Compute PointLights on Surfaces"); // get the current cellInfo iterated. CIGSurfaceLightBuild::CCellCorner &cellInfo= getCurrentCellInfo(); // if the cell corner lies in the polygon surface. if(cellInfo.InSurface) { // get the point of the cell. CVector pos= cellInfo.CenterPos; // Default: takes no LocalAmbientLight; cellInfo.LocalAmbientLight= NULL; float furtherAmbLight= 0; // Compute Which light influences him. //--------- lightInfs.clear(); // Search possible lights around the position. _StaticPointLightQuadGrid.select(pos, pos); // For all of them, get the ones which touch this point. CQuadGrid<CPointLightRT*>::CIterator it= _StaticPointLightQuadGrid.begin(); while(it != _StaticPointLightQuadGrid.end()) { CPointLightRT *pl= *it; // Test if really in the radius of the light, no occlusion, not an ambient, and in Spot Angle setup if( pl->testRaytrace(pos, _CurrentInstanceComputed) ) { // Ok, add the light to the lights which influence the cell lightInfs.push_back(pl); } // Ambient Light ?? if( pl->PointLight.getType() == CPointLight::AmbientLight ) { // If the instance is in radius of the ambiant light. float dRadius= pl->BSphere.Radius - (pl->BSphere.Center - pos).norm(); if(dRadius>0) { // Take the best ambient light: the one which is further from the circumference if(dRadius > furtherAmbLight) { furtherAmbLight= dRadius; cellInfo.LocalAmbientLight= pl; } } } // next it++; } // If ambientLight chosen, inc Ref count of it if(cellInfo.LocalAmbientLight) ((CPointLightRT*)cellInfo.LocalAmbientLight)->RefCount++; // Choose the Best ones. //--------- CPredPointLightToPoint predPLTP; predPLTP.Point= pos; // sort. sort(lightInfs.begin(), lightInfs.end(), predPLTP); // truncate. lightInfs.resize( min((uint)lightInfs.size(), (uint)CSurfaceLightGrid::NumLightPerCorner) ); // For each of them, fill cellInfo //--------- uint lightInfId; for(lightInfId=0; lightInfId<lightInfs.size(); lightInfId++) { CPointLightRT *pl= lightInfs[lightInfId]; // copy light. cellInfo.LightInfo[lightInfId]= pl; // Inc RefCount of the light. pl->RefCount++; } // Reset any empty slot to NULL. for(; lightInfId<CSurfaceLightGrid::NumLightPerCorner; lightInfId++) { cellInfo.LightInfo[lightInfId]= NULL; } } // next cell nextCell(); } } // Compress and setup _Instances with compressed data. //=========== uint plId= 0; // Process each pointLights for(i=0; i<_StaticPointLights.size(); i++) { CPointLightRT &plRT= _StaticPointLights[i]; // If this light is used. if(plRT.RefCount > 0) { // Valid light ? if (plId <=0xFF) { // Must Copy it into Ig. listPointLight.push_back(plRT.PointLight); plRT.DstId= plId++; // If index >= 255, too many lights (NB: => because 255 is a NULL code). } else { nlwarning("ERROR: Too many Static Point Lights influence the IG!!"); // Set 0xFF. Special code indicating that the light CAN'T BE USED => any instance using // it is buggy (won't be lighted by this light). plRT.DstId= plId++; } } } // For each instance, compress Point light info for(i=0; i<_Instances.size(); i++) { // If staticLight not enabled, skip. if( !_Instances[i].StaticLightEnabled ) continue; CInstanceInfo &instSrc= _InstanceInfos[i]; CInstanceGroup::CInstance &instDst= _Instances[i]; // Do it for PointLights for(uint lightId= 0; lightId<CInstanceGroup::NumStaticLightPerInstance; lightId++) { if(instSrc.Light[lightId] == NULL) { // Mark as unused. instDst.Light[lightId]= 0xFF; } else { // Get index. NB: may still be 0xFF if 'Too many static light' bug. instDst.Light[lightId]= instSrc.Light[lightId]->DstId; } } // Ensure that all FF are at end of the list (possible because of the TooManyStaticLight bug). // But don't do a full sort, to preserve order due to influence... nlctassert(CInstanceGroup::NumStaticLightPerInstance==2); if(instDst.Light[0] == 0xFF) swap(instDst.Light[0], instDst.Light[1]); // Do it for Ambientlight if(instSrc.LocalAmbientLight == NULL) instDst.LocalAmbientId= 0xFF; else // NB: may still be 0xFF if 'Too many static light' bug. instDst.LocalAmbientId= instSrc.LocalAmbientLight->DstId; } // For each cell, compress Point light info if(_IGSurfaceLightBuild) { // Begin cell iteration beginCell(); // For all surface cell corners while( !isEndCell() ) { // get the current cell and cellInfo iterated. CIGSurfaceLightBuild::CCellCorner &cellInfo= getCurrentCellInfo(); CSurfaceLightGrid::CCellCorner &cell= getCurrentCell(); if(cellInfo.InSurface) { // Do it for PointLights for(uint lightId= 0; lightId<CSurfaceLightGrid::NumLightPerCorner; lightId++) { if(cellInfo.LightInfo[lightId] == NULL) { // Mark as unused. cell.Light[lightId]= 0xFF; } else { // Get index. NB: may still be 0xFF if 'Too many static light' bug. cell.Light[lightId]= reinterpret_cast<CPointLightRT*>(cellInfo.LightInfo[lightId])->DstId; } } // Ensure that all FF are at end of the list (possible because of the TooManyStaticLight bug). // But don't do a full sort, to preserve order due to influence... nlctassert(CInstanceGroup::NumStaticLightPerInstance==2); if(cell.Light[0] == 0xFF) swap(cell.Light[0], cell.Light[1]); // Do it for Ambientlight if(cellInfo.LocalAmbientLight == NULL) cell.LocalAmbientId= 0xFF; else // NB: may still be 0xFF if 'Too many static light' bug. cell.LocalAmbientId= ((CPointLightRT*)cellInfo.LocalAmbientLight)->DstId; } // next cell nextCell(); } } }

virtual void NL3D::CInstanceLighter::progress (  const char *  message, float  progress )  [inline, virtual]

Definition at line 159 of file instance_lighter.h. Referenced by compilePointLightRT(), computeSunContribution(), lightIgSimple(), processIGPointLightRT(), and progressCell(). {};

void NL3D::CInstanceLighter::progressCell (  const char *  message  )  [private]

Definition at line 1623 of file instance_lighter.cpp. References _LastCellProgress, getCurrentCellNumber(), getTotalCellNumber(), and progress(). Referenced by computeSunContribution(), dilateLightingOnSurfaceCells(), and processIGPointLightRT(). { float cp= getCurrentCellNumber() / float(getTotalCellNumber()); if( cp > _LastCellProgress+0.05f) { progress(message, cp); _LastCellProgress= cp; } }

---

Field Documentation

sint NL3D::CInstanceLighter::_CurrentInstanceComputed [private]

Definition at line 210 of file instance_lighter.h. Referenced by computeSunContribution(), and processIGPointLightRT().

CIGSurfaceLight::TRetrieverGridMap NL3D::CInstanceLighter::_IGRetrieverGridMap [private]

Definition at line 214 of file instance_lighter.h. Referenced by beginCell(), light(), and nextCell().

CIGSurfaceLightBuild* NL3D::CInstanceLighter::_IGSurfaceLightBuild [private]

Definition at line 212 of file instance_lighter.h. Referenced by beginCell(), CInstanceLighter(), computeSunContribution(), light(), nextCell(), and processIGPointLightRT().

std::vector<CInstanceInfo> NL3D::CInstanceLighter::_InstanceInfos [private]

Definition at line 208 of file instance_lighter.h. Referenced by computeSunContribution(), light(), and processIGPointLightRT().

std::vector<CInstanceGroup::CInstance> NL3D::CInstanceLighter::_Instances [private]

Definition at line 206 of file instance_lighter.h.

bool NL3D::CInstanceLighter::_IsEndCell [private]

Definition at line 293 of file instance_lighter.h. Referenced by beginCell(), isEndCell(), light(), and nextCell().

uint NL3D::CInstanceLighter::_ItCellId [private]

Definition at line 292 of file instance_lighter.h. Referenced by beginCell(), getCurrentCell(), getCurrentCellInfo(), getCurrentNeighborCell(), getCurrentNeighborCellInfo(), isCurrentNeighborCellInSurface(), and nextCell().

uint NL3D::CInstanceLighter::_ItCurrentCellNumber [private]

Definition at line 294 of file instance_lighter.h. Referenced by beginCell(), getCurrentCellNumber(), and nextCell().

CIGSurfaceLight::ItRetrieverGridMap NL3D::CInstanceLighter::_ItRetriever [private]

Definition at line 289 of file instance_lighter.h. Referenced by beginCell(), getCurrentCell(), getCurrentNeighborCell(), isCurrentNeighborCellInSurface(), and nextCell().

CIGSurfaceLightBuild::ItRetrieverGridMap NL3D::CInstanceLighter::_ItRetrieverInfo [private]

Definition at line 290 of file instance_lighter.h. Referenced by beginCell(), getCurrentCellInfo(), getCurrentNeighborCellInfo(), isCurrentNeighborCellInSurface(), and nextCell().

uint NL3D::CInstanceLighter::_ItSurfId [private]

Definition at line 291 of file instance_lighter.h. Referenced by beginCell(), getCurrentCell(), getCurrentCellInfo(), getCurrentNeighborCell(), getCurrentNeighborCellInfo(), isCurrentNeighborCellInSurface(), and nextCell().

float NL3D::CInstanceLighter::_LastCellProgress [private]

Definition at line 296 of file instance_lighter.h. Referenced by beginCell(), and progressCell().

CQuadGrid<CPointLightRT*> NL3D::CInstanceLighter::_StaticPointLightQuadGrid [private]

QuadGrid of PointLights. Builded from _StaticPointLights. Definition at line 255 of file instance_lighter.h. Referenced by compilePointLightRT(), and processIGPointLightRT().

std::vector<CPointLightRT> NL3D::CInstanceLighter::_StaticPointLights [private]

List of PointLights. Definition at line 253 of file instance_lighter.h. Referenced by addStaticPointLight(), compilePointLightRT(), and processIGPointLightRT().

uint NL3D::CInstanceLighter::_TotalCellNumber [private]

Definition at line 295 of file instance_lighter.h. Referenced by getTotalCellNumber(), and light().

---

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

• instance_lighter.h
• instance_lighter.cpp

---