NL3D::CLightingManager Class Reference

#include <lighting_manager.h>

---

Detailed Description

Owned by CLightingTrav. This class compute modelContributions. It gets which dynamic light may influence a model, ask to ILogicInfo the contribution of staticLights then decides which light are best suitable to influence the model.

Author:

Lionel Berenguier

Nevrax France

Date:

2001

Definition at line 60 of file lighting_manager.h.

Public Member Functions
	CLightingManager (bool bSmallScene)
	Constructor (bSmallScene is used to setup size of the grids).
void	computeModelLightContributions (CTransform *model, CLightContribution &lightContrib, ILogicInfo *logicInfo=NULL)
Dynamic Lights localisation.
void	addDynamicLight (CPointLight *light)
void	clearDynamicLights ()
	clear for the pass all the lights.
const std::vector< CPointLight * > &	getAllDynamicLightList () const
Static Lighted Objects Localisation. Used for lights to touch nearest static models.
CQGItLightedModel	eraseStaticLightedModel (CQGItLightedModel ite)
CQGItLightedModel	insertStaticLightedModel (CTransform *model)
Parameters
float	getLightTransitionThreshold () const
uint	getMaxLightContribution () const
float	getNoAttLightRadius () const
float	getOutOfAttLightInfFactor () const
void	setLightTransitionThreshold (float lightTransitionThreshold)
void	setMaxLightContribution (uint nlights)
void	setNoAttLightRadius (float noAttLightRadius)
void	setOutOfAttLightInfFactor (float outOfAttLightInfFactor)
Private Member Functions
void	getDynamicPointLightList (const CVector &worldPos, std::vector< CPointLightInfluence > &lightList)
	get the list of dynamic light viewed from a position. append to lightList
Private Attributes
std::vector< CPointLight * >	_DynamicLightList
CQuadGrid< CPointLightInfo >	_LightQuadGrid [4]
float	_LightQuadGridRadiusLimit [4]
CQuadGrid< CTransform * >	_StaticLightedModelQuadGrid [4]
Parameters.
float	_LightTransitionThreshold
uint	_MaxLightContribution
float	_NoAttLightRadius
float	_OutOfAttLightInfFactor

---

Constructor & Destructor Documentation

NL3D::CLightingManager::CLightingManager (  bool  bSmallScene  )

Constructor (bSmallScene is used to setup size of the grids). Definition at line 64 of file lighting_manager.cpp. References _LightQuadGrid, _LightQuadGridRadiusLimit, _LightTransitionThreshold, _NoAttLightRadius, _OutOfAttLightInfFactor, _StaticLightedModelQuadGrid, NL3D::CQuadGrid< CTransform * >::create(), NL3D::CQuadGrid< CPointLightInfo >::create(), NL3D_DEFAULT_LIGHT_TRANSITION_THRESHOLD, NL3D_DEFAULT_NOATT_LIGHT_RADIUS, NL3D_DEFAULT_OUT_OF_ATT_LIGHT_INF_FACTOR, NL3D_LIGHT_QUAD_GRID_ELTSIZE, NL3D_LIGHT_QUAD_GRID_FACTOR, NL3D_LIGHT_QUAD_GRID_RADIUS_LIMIT, NL3D_LIGHT_QUAD_GRID_SIZE, NL3D_QUADGRID_LIGHT_NUM_LEVEL, setMaxLightContribution(), and uint. { // Init the lightQuadGrids and StaticLightedModelQuadGrid // finer level. uint qgSize= NL3D_LIGHT_QUAD_GRID_SIZE; float eltSize= NL3D_LIGHT_QUAD_GRID_ELTSIZE; float radiusLimit= NL3D_LIGHT_QUAD_GRID_RADIUS_LIMIT; if (bSmallScene) { qgSize = 4; } // for all levels for(uint i=0;i<NL3D_QUADGRID_LIGHT_NUM_LEVEL;i++) { // init _LightQuadGrid and _StaticLightedModelQuadGrid _LightQuadGrid[i].create(qgSize, eltSize); _StaticLightedModelQuadGrid[i].create(qgSize, eltSize); _LightQuadGridRadiusLimit[i]= radiusLimit; // coarser quadGrid level qgSize/= NL3D_LIGHT_QUAD_GRID_FACTOR; qgSize= max(qgSize, 1U); eltSize*= NL3D_LIGHT_QUAD_GRID_FACTOR; radiusLimit*= NL3D_LIGHT_QUAD_GRID_FACTOR; } // default paramters _NoAttLightRadius= NL3D_DEFAULT_NOATT_LIGHT_RADIUS; _OutOfAttLightInfFactor= NL3D_DEFAULT_OUT_OF_ATT_LIGHT_INF_FACTOR; _LightTransitionThreshold= NL3D_DEFAULT_LIGHT_TRANSITION_THRESHOLD; // Default number of pointLight on an object. setMaxLightContribution(3); }

---

Member Function Documentation

void NL3D::CLightingManager::addDynamicLight (  CPointLight *  light  )

temp add a dynamic light to the manager. light is added to the _LightQuadGrid. This method calls CTransform::resetLighting() for all models around the light. Additionaly light are added to a list (a vector of pointer), see getDynamicLightList() Definition at line 151 of file lighting_manager.cpp. References _LightQuadGrid, _LightQuadGridRadiusLimit, _NoAttLightRadius, _StaticLightedModelQuadGrid, NL3D::CQuadGrid< CTransform * >::begin(), NLMISC::CBSphere::Center, NL3D::CQuadGrid< T >::end(), NL3D::CPointLight::getAttenuationEnd(), NLMISC::CMatrix::getPos(), NL3D::CPointLight::getPosition(), NL3D::CTransform::getWorldMatrix(), NLMISC::CBSphere::include(), NL3D::CQuadGrid< CPointLightInfo >::insert(), NL3D::CLightingManager::CPointLightInfo::Light, NL3D_QUADGRID_LIGHT_NUM_LEVEL, NLMISC::CBSphere::Radius, NL3D::CTransform::resetLighting(), NL3D::CQuadGrid< CTransform * >::select(), NL3D::CLightingManager::CPointLightInfo::Sphere, and uint. Referenced by NL3D::CPointLightModel::traverseLight(). { // Insert the light in the quadGrid. //---------- CPointLightInfo plInfo; plInfo.Light= light; // build the bounding sphere for this light, with the AttenuationEnd of the light float radius=light->getAttenuationEnd(); // if attenuation is disabled (ie getAttenuationEnd() return 0), then have a dummy radius if(radius==0) radius= _NoAttLightRadius; plInfo.Sphere.Center= light->getPosition(); plInfo.Sphere.Radius= radius; // build a bbox, so it includes the sphere CVector bbmin= light->getPosition(); bbmin-= CVector(radius, radius, radius); CVector bbmax= light->getPosition(); bbmax+= CVector(radius, radius, radius); // choose the correct quadgrid according to the radius of the light. uint qgId; for(qgId= 0; qgId<NL3D_QUADGRID_LIGHT_NUM_LEVEL-1; qgId++) { // if radius is inferior to the requested radius for this quadGrid, ok! if(radius<_LightQuadGridRadiusLimit[qgId]) break; } // insert this light in the correct quadgrid. _LightQuadGrid[qgId].insert(bbmin, bbmax, plInfo); // touch the objects around the lights. //---------- // Select the static lightedModels to update around this light. // Use the same level of _StaticLightedModelQuadGrid than me to not select too many squares in the quadGrid _StaticLightedModelQuadGrid[qgId].select(bbmin, bbmax); // For all those models. CQuadGrid<CTransform*>::CIterator itModel= _StaticLightedModelQuadGrid[qgId].begin(); while(itModel != _StaticLightedModelQuadGrid[qgId].end() ) { CTransform *model= *itModel; const CVector &modelPos= model->getWorldMatrix().getPos(); // test first if this model is in the area of the light. if( plInfo.Sphere.include(modelPos) ) { // yes, then this model must recompute his lighting, because a dynamic light touch him. model->resetLighting(); } // next. itModel++; } // insert the light in the list. //---------- _DynamicLightList.push_back(light); }

void NL3D::CLightingManager::clearDynamicLights (   )

clear for the pass all the lights. Definition at line 137 of file lighting_manager.cpp. References _LightQuadGrid, NL3D::CQuadGrid< CPointLightInfo >::clear(), NL3D_QUADGRID_LIGHT_NUM_LEVEL, and uint. Referenced by NL3D::CLightTrav::traverse(). { // for all levels for(uint i=0;i<NL3D_QUADGRID_LIGHT_NUM_LEVEL;i++) { // clear all the lights in the quadGrid. _LightQuadGrid[i].clear(); } // clear the list. _DynamicLightList.clear(); }

void NL3D::CLightingManager::computeModelLightContributions (  CTransform *  model, CLightContribution &  lightContrib, ILogicInfo *  logicInfo = NULL )

get the description of nearsest lights viewed for this model. Dynamic lights are parsed to get list of lights, and ILogicInfo->getStaticLightDesc() is parsed too. Then, maxLights are returned, which may be a blended result of max influence light. NB: model->_LightContribution is filled with real contributions of lights. NB: model is append to the _LightedModelList of each contributed light NB: this list is valid until model->isNeedUpdateLighting() is true. Definition at line 256 of file lighting_manager.cpp. References _LightTransitionThreshold, _MaxLightContribution, _OutOfAttLightInfFactor, NL3D::CPointLight::appendLightedModel(), NL3D::CLightContribution::AttFactor, NLMISC::CRGBA::B, NLMISC::CRGBAF::B, NLMISC::clamp(), NL3D::CPointLight::computeLinearAttenuation(), NL3D::CLightContribution::Factor, NL3D::CLightContribution::FrozenStaticLightSetup, NLMISC::CRGBA::G, NLMISC::CRGBAF::G, NL3D::CPointLight::getAmbient(), NL3D::CPointLight::getAttenuationBegin(), NL3D::CPointLight::getAttenuationEnd(), NL3D::CPointLight::getDiffuse(), getDynamicPointLightList(), NL3D::CTransform::getLightHotSpotInWorld(), NL3D::CPointLight::getPosition(), NL3D::ILogicInfo::getStaticLightSetup(), NL3D::CPointLight::getType(), NL3D::CLightContribution::LocalAmbient, NL3D::CLightContribution::MergedPointLight, NL3D_MAX_LIGHT_CONTRIBUTION, NL3D::CLightContribution::NumFrozenStaticLight, NLMISC::OptFastFloor(), NL3D::CLightContribution::PointLight, NLMISC::CRGBA::R, NLMISC::CRGBAF::R, NLMISC::CRGBA::set(), sint, NL3D::CLightContribution::SunContribution, NL3D::CLightContribution::TransformIterator, uint, uint8, NL3D::CLightContribution::UseMergedPointLight, and v. Referenced by NL3D::CTransform::traverseLight(). { sint i; // This is the list of light which touch this model. static std::vector<CPointLightInfluence> lightList; // static, for malloc perf. lightList.clear(); // the position of the model. CVector modelPos; float modelRadius; // depends on model model->getLightHotSpotInWorld(modelPos, modelRadius); // First pass, fill the list of light which touch this model. //========= // get the dynamic lights around the model getDynamicPointLightList(modelPos, lightList); // if not already precomputed, append staticLights to this list. if( !lightContrib.FrozenStaticLightSetup ) { // If no logicInfo provided if(!logicInfo) { // Default: suppose full SunLight and no PointLights. lightContrib.SunContribution= 255; // Take full SunAmbient. lightContrib.LocalAmbient.set(0,0,0,0); // do not append any pointLight to the setup } else { // NB: SunContribution is computed by logicInfo logicInfo->getStaticLightSetup(lightList, lightContrib.SunContribution, lightContrib.LocalAmbient); } } // Second pass, in the lightList, choose the best suited light to lit this model //========= // for each light, modulate the factor of influence for(i=0; i<(sint)lightList.size();i++) { CPointLight *pl= lightList[i].PointLight; // get the distance from the light to the model float dist= (pl->getPosition() - modelPos).norm(); float distMinusRadius= dist - modelRadius; // modulate the factor by the distance and the attenuation distance. float inf; float attBegin= pl->getAttenuationBegin(); float attEnd= pl->getAttenuationEnd(); // if no attenuation if( attEnd==0 ) { // influence is awlays 1. inf= 1; // If SpotLight, must modulate with SpotAttenuation. if(pl->getType() == CPointLight::SpotLight) inf*= pl->computeLinearAttenuation(modelPos, dist, modelRadius); } else { // if correct attenuation radius if(distMinusRadius<attBegin) { // NB: we are sure that attBegin>0, because dist>=0. // if < attBegin, inf should be ==1, but must select the nearest lights; for better // understanding of the scene inf= 1 + _OutOfAttLightInfFactor * (attBegin - distMinusRadius); // inf E [1, +oo[ // NB: this formula favour big lights (ie light with big attBegin). // If SpotLight, must modulate with SpotAttenuation. if(pl->getType() == CPointLight::SpotLight) inf*= pl->computeLinearAttenuation(modelPos, dist, modelRadius); } else if(distMinusRadius<attEnd) { // we are sure attEnd-attBegin>0 because of the test // compute influence of the light: attenuation and SpotAttenuation inf= pl->computeLinearAttenuation(modelPos, dist, modelRadius); } else { // if >= attEnd, inf should be ==0, but must select the nearest lights; for better // understanding of the scene inf= _OutOfAttLightInfFactor * (attEnd - distMinusRadius); // inf E ]-oo, 0] } } // modulate the influence with this factor lightList[i].BkupInfluence= lightList[i].Influence; lightList[i].Influence*= inf; // Bkup distance to model. lightList[i].DistanceToModel= dist; } // sort the light by influence sort(lightList.begin(), lightList.end()); // prepare Light Merging. static std::vector<float> lightToMergeWeight; lightToMergeWeight.clear(); lightToMergeWeight.resize(lightList.size(), 1); // and choose only max light. uint startId= 0; uint ligthSrcId= 0; // skip already setuped light (statically) if(lightContrib.FrozenStaticLightSetup) startId= lightContrib.NumFrozenStaticLight; // If there is still place for unFrozen static lights or dynamic lights. if(startId < _MaxLightContribution) { // setup the transition. float deltaMinInfluence= _LightTransitionThreshold; float minInfluence= 0; sint doMerge= 0; sint firstLightToMergeFull= _MaxLightContribution-startId; // If there is more light than we can accept in not merged mode, Must merge if((sint)lightList.size() > firstLightToMergeFull) { doMerge= 1; // the minInfluence is the influence of the first light not taken. minInfluence= lightList[firstLightToMergeFull].Influence; // but must still be >=0. minInfluence= max(minInfluence, 0.f); } // Any light under this minInfluence+deltaMinInfluence will be smoothly darken. float minInfluenceStart = minInfluence + deltaMinInfluence; float OOdeltaMinInfluence= 1.0f / deltaMinInfluence; /* NB: this is not an error if we have only 3 light for example (assuming _MaxLightContribution=3), and still have minInfluenceStart>0. It's to have a continuity in the case of for example we have 3 lights in lightLists at frame T0, resulting in "doMerge=0" and at frame T1 we have 4 lights, the farthest having an influence of 0 or nearly 0. */ // fill maxLight at max. for(i=startId;i<(sint)_MaxLightContribution; i++) { // if not so many pointLights found, end!! if(ligthSrcId>=lightList.size()) break; else { CPointLight *pl= lightList[ligthSrcId].PointLight; float inf= lightList[ligthSrcId].Influence; float bkupInf= lightList[ligthSrcId].BkupInfluence; float distToModel= lightList[ligthSrcId].DistanceToModel; // else fill it. lightContrib.PointLight[i]= pl; // Compute the Final factor of influence of the light. if(inf >= minInfluenceStart) { // For Static LightSetup BiLinear to work correctly, modulate with BkupInfluence // don't worry about the precision of floor, because of *255. lightContrib.Factor[i]= (uint8)NLMISC::OptFastFloor(bkupInf*255); // Indicate that this light don't need to be merged at all! lightToMergeWeight[ligthSrcId]= 0; } else { float f= (inf-minInfluence) * OOdeltaMinInfluence; // For Static LightSetup BiLinear to work correctly, modulate with BkupInfluence // don't worry about the precision of floor, because of *255. sint fi= NLMISC::OptFastFloor( bkupInf*f*255 ); clamp(fi, 0, 255); lightContrib.Factor[i]= fi; // The rest of the light contribution is to be merged. lightToMergeWeight[ligthSrcId]= 1-f; } // Compute the Final Att factor for models using Global Attenuation. NB: modulate with Factor // don't worry about the precision of floor, because of *255. // NB: compute att on the center of the model => modelRadius==0 sint attFactor= NLMISC::OptFastFloor( lightContrib.Factor[i] * pl->computeLinearAttenuation(modelPos, distToModel) ); lightContrib.AttFactor[i]= (uint8)attFactor; // must append this lightedModel to the list in the light. lightContrib.TransformIterator[i]= pl->appendLightedModel(model); // next light. ligthSrcId++; } } // Compute LightToMerge. if(doMerge) { CRGBAF mergedAmbient(0,0,0); uint j; // For all lights in the lightList, merge Diffuse and Ambient term to mergedAmbient. for(j=0;j<lightToMergeWeight.size();j++) { if(lightToMergeWeight[j] && lightList[j].Influence>0) { CPointLight *pl= lightList[j].PointLight; // Get the original influence (ie for static PLs, biLinear influence) float bkupInf= lightList[j].BkupInfluence; // Get the attenuation of the pointLight to the model float distToModel= lightList[j].DistanceToModel; float attInf= pl->computeLinearAttenuation(modelPos, distToModel); // Attenuate the color of the light by biLinear and distance/spot attenuation. float lightInf= attInf * bkupInf; // Modulate also by the percentage to merge lightInf*= lightToMergeWeight[j]; // Add the full ambient term of the light, attenuated by light attenuation and WeightMerge mergedAmbient.R+= pl->getAmbient().R * lightInf; mergedAmbient.G+= pl->getAmbient().G * lightInf; mergedAmbient.B+= pl->getAmbient().B * lightInf; // Add 0.25f of the diffuse term of the light, attenuated by light attenuation and WeightMerge // mul by 0.25f, because this is the averaged contribution of the diffuse part of a // light to a sphere (do the maths...). float f= lightInf*0.25f; mergedAmbient.R+= pl->getDiffuse().R * f; mergedAmbient.G+= pl->getDiffuse().G * f; mergedAmbient.B+= pl->getDiffuse().B * f; } } // Setup the merged Light CRGBA amb; sint v; // Because of floating point error, it appears that sometime result may be slightly below 0. // => clamp necessary v= NLMISC::OptFastFloor(mergedAmbient.R); fastClamp8(v); amb.R= v; v= NLMISC::OptFastFloor(mergedAmbient.G); fastClamp8(v); amb.G= v; v= NLMISC::OptFastFloor(mergedAmbient.B); fastClamp8(v); amb.B= v; lightContrib.MergedPointLight= amb; // Indicate we use the merged pointLight => the model must recompute lighting each frame lightContrib.UseMergedPointLight= true; } else { // If the model is freezeHRC(), need to test each frame only if MergedPointLight is used. lightContrib.UseMergedPointLight= false; } } else { // point to end the list i= startId; } // End the list. if(i<NL3D_MAX_LIGHT_CONTRIBUTION) { lightContrib.PointLight[i]= NULL; } }

CLightingManager::CQGItLightedModel NL3D::CLightingManager::eraseStaticLightedModel (  CQGItLightedModel  ite  )

erase a lighted object to the _StaticLightedModelQuadGrid. must do it at deletion of the model or when it leaves freeHRC state. NB: default CQGItLightedModel (ie NULL) can be passed in. Returns: quadgrid.end(), ie NULL iterator. Definition at line 217 of file lighting_manager.cpp. References _StaticLightedModelQuadGrid, NL3D::CQuadGrid< CTransform * >::erase(), NL3D_QUADGRID_LIGHT_NUM_LEVEL, NL3D::CLightingManager::CQGItLightedModel::QgItes, and uint. Referenced by NL3D::CTransform::unfreezeHRC(), NL3D::CTransform::update(), and NL3D::CTransform::~CTransform(). { // Erase the iterator for all levels for(uint i=0;i<NL3D_QUADGRID_LIGHT_NUM_LEVEL;i++) { // NB: it is possible here that the iterator is NULL (ie end()). _StaticLightedModelQuadGrid[i].erase(ite.QgItes[i]); } // return end(), ie NULL iterators return CQGItLightedModel(); }

const std::vector<CPointLight*>& NL3D::CLightingManager::getAllDynamicLightList (   )  const [inline]

retrieve (for this pass only) list of all pointLights visible in scene Definition at line 126 of file lighting_manager.h. Referenced by NL3D::CLandscapeModel::clipAndRenderLandscape(). {return _DynamicLightList;}

void NL3D::CLightingManager::getDynamicPointLightList (  const CVector &  worldPos, std::vector< CPointLightInfluence > &  lightList )  [private]

get the list of dynamic light viewed from a position. append to lightList Definition at line 525 of file lighting_manager.cpp. References _LightQuadGrid, NL3D::CQuadGrid< T >::begin(), NL3D::CQuadGrid< T >::end(), NL3D::CPointLightInfluence::Influence, NL3D_QUADGRID_LIGHT_NUM_LEVEL, NL3D::CPointLightInfluence::PointLight, NL3D::CQuadGrid< T >::select(), and uint. Referenced by computeModelLightContributions(). { // For all quadGrids. for(uint qgId=0; qgId<NL3D_QUADGRID_LIGHT_NUM_LEVEL; qgId++) { CQuadGrid<CPointLightInfo> &quadGrid= _LightQuadGrid[qgId]; // select the lights around this position in the quadGrids. quadGrid.select(worldPos, worldPos); // for all possible found lights CQuadGrid<CPointLightInfo>::CIterator itLight; for(itLight= quadGrid.begin(); itLight!=quadGrid.end(); itLight++) { // verify it includes the entity if( (*itLight).Sphere.include(worldPos) ) { // ok, insert in list. CPointLightInfluence pli; pli.PointLight= (*itLight).Light; // No special Influence degradation scheme for Dynamic lighting pli.Influence= 1; lightList.push_back( pli ); } } } }

float NL3D::CLightingManager::getLightTransitionThreshold (   )  const [inline]

Definition at line 109 of file lighting_manager.h. References _LightTransitionThreshold. Referenced by NL3D::CScene::getLightTransitionThreshold(). {return _LightTransitionThreshold;}

uint NL3D::CLightingManager::getMaxLightContribution (   )  const [inline]

Definition at line 84 of file lighting_manager.h. References _MaxLightContribution, and uint. Referenced by NL3D::CScene::getMaxLightContribution(). {return _MaxLightContribution;}

float NL3D::CLightingManager::getNoAttLightRadius (   )  const [inline]

Definition at line 91 of file lighting_manager.h. References _NoAttLightRadius. {return _NoAttLightRadius;}

float NL3D::CLightingManager::getOutOfAttLightInfFactor (   )  const [inline]

Definition at line 98 of file lighting_manager.h. References _OutOfAttLightInfFactor. {return _OutOfAttLightInfFactor;}

CLightingManager::CQGItLightedModel NL3D::CLightingManager::insertStaticLightedModel (  CTransform *  model  )

insert a lighted object to the _StaticLightedModelQuadGrid. must not be inserted before must do it only for static objects, ie when freeHRC state is validated (see CTransform::update()) NB: only lightable models with no AncestorSkeletonModel should be inserted Definition at line 231 of file lighting_manager.cpp. References _StaticLightedModelQuadGrid, NLMISC::CMatrix::getPos(), NL3D::CTransform::getWorldMatrix(), NL3D::CQuadGrid< CTransform * >::insert(), NL3D_QUADGRID_LIGHT_NUM_LEVEL, NL3D::CLightingManager::CQGItLightedModel::QgItes, and uint. Referenced by NL3D::CTransform::update(). { CQGItLightedModel ite; const CVector &worldPos= model->getWorldMatrix().getPos(); // Insert the models in all levels, because addDynamicLight() may choose the best suited level to select for(uint i=0;i<NL3D_QUADGRID_LIGHT_NUM_LEVEL;i++) { ite.QgItes[i]= _StaticLightedModelQuadGrid[i].insert(worldPos, worldPos, model); } // return the iterator return ite; }

void NL3D::CLightingManager::setLightTransitionThreshold (  float  lightTransitionThreshold  )

Advanced. When a model is influenced by more light than allowed, or when it reach the limits of the light (attenuationEnd), the light can be darkened according to some threshold. The resultLightColor begin to fade when distModelToLight== attEnd- threshold*(attEnd-attBegin). when distModelToLight== 0, resultLightColor==Black. By default, this value is 0.1f. Setting higher values will smooth transition but will generally darken the global effects of lights. NB: clamp(value, 0, 1); Definition at line 128 of file lighting_manager.cpp. References _LightTransitionThreshold, and NLMISC::clamp(). Referenced by NL3D::CScene::setLightTransitionThreshold(). { clamp(lightTransitionThreshold, 0.f, 1.f); _LightTransitionThreshold= lightTransitionThreshold; }

void NL3D::CLightingManager::setMaxLightContribution (  uint  nlights  )

set the max number of point light that can influence a model. NB: clamped by NL3D_MAX_LIGHT_CONTRIBUTION Default is 3. NB: the sun contribution is not taken into account Definition at line 105 of file lighting_manager.cpp. References _MaxLightContribution, min, NL3D_MAX_LIGHT_CONTRIBUTION, and uint. Referenced by CLightingManager(), and NL3D::CScene::setMaxLightContribution(). { _MaxLightContribution= min(nlights, (uint)NL3D_MAX_LIGHT_CONTRIBUTION); }

void NL3D::CLightingManager::setNoAttLightRadius (  float  noAttLightRadius  )

Advanced. When a light has no attenuation, it's still inserted in a quadgrid with some radius and won't influence models beyond. You can setup this radius with this method. Default is 1000m. NB: nlassert(noAttLightRadius>0); Definition at line 112 of file lighting_manager.cpp. References _NoAttLightRadius, and nlassert. { nlassert(noAttLightRadius>0); _NoAttLightRadius= noAttLightRadius; }

void NL3D::CLightingManager::setOutOfAttLightInfFactor (  float  outOfAttLightInfFactor  )

Advanced. When a model is out of [AttBegin, AttEnd] of a light, the computed influence of the light used to choose "best lights" is not constant, and is a function of distance multiplied by a factor you can setup here. Default is 0.1f and is good for lights with att like (50, 100) (arbitrary). Definition at line 120 of file lighting_manager.cpp. References _OutOfAttLightInfFactor. { outOfAttLightInfFactor= max(0.f, outOfAttLightInfFactor); _OutOfAttLightInfFactor= outOfAttLightInfFactor; }

---

Field Documentation

std::vector<CPointLight*> NL3D::CLightingManager::_DynamicLightList [private]

Definition at line 181 of file lighting_manager.h.

CQuadGrid<CPointLightInfo> NL3D::CLightingManager::_LightQuadGrid[ 4 ] [private]

Definition at line 177 of file lighting_manager.h. Referenced by addDynamicLight(), clearDynamicLights(), CLightingManager(), and getDynamicPointLightList().

float NL3D::CLightingManager::_LightQuadGridRadiusLimit[ 4 ] [private]

Definition at line 179 of file lighting_manager.h. Referenced by addDynamicLight(), and CLightingManager().

float NL3D::CLightingManager::_LightTransitionThreshold [private]

Definition at line 188 of file lighting_manager.h. Referenced by CLightingManager(), computeModelLightContributions(), getLightTransitionThreshold(), and setLightTransitionThreshold().

uint NL3D::CLightingManager::_MaxLightContribution [private]

Definition at line 185 of file lighting_manager.h. Referenced by computeModelLightContributions(), getMaxLightContribution(), and setMaxLightContribution().

float NL3D::CLightingManager::_NoAttLightRadius [private]

Definition at line 186 of file lighting_manager.h. Referenced by addDynamicLight(), CLightingManager(), getNoAttLightRadius(), and setNoAttLightRadius().

float NL3D::CLightingManager::_OutOfAttLightInfFactor [private]

Definition at line 187 of file lighting_manager.h. Referenced by CLightingManager(), computeModelLightContributions(), getOutOfAttLightInfFactor(), and setOutOfAttLightInfFactor().

CQuadGrid<CTransform*> NL3D::CLightingManager::_StaticLightedModelQuadGrid[ 4 ] [private]

Definition at line 176 of file lighting_manager.h. Referenced by addDynamicLight(), CLightingManager(), eraseStaticLightedModel(), and insertStaticLightedModel().

---

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

• lighting_manager.h
• lighting_manager.cpp

---