NL3D::CZoneLighter Class Reference

#include <zone_lighter.h>

Static PointLights mgt.
void	compilePointLightRT (uint gridSize, float gridCellSize, std::vector< CTriangle > &obstacles, bool doShadow)
	Fill CubeGrid, and set PointLightRT in _StaticPointLightQuadGrid.
void	processZonePointLightRT (std::vector< CPointLightNamed > &listPointLight)
CQuadGrid< CPointLightRT * >	_StaticPointLightQuadGrid
	QuadGrid of PointLights. Builded from _StaticPointLights.
std::vector< CPointLightRT >	_StaticPointLights
	List of PointLights.
Public Member Functions
void	addLightableShape (IShape *shape, const NLMISC::CMatrix &modelMT)
void	addTriangles (const IShape &shape, const NLMISC::CMatrix &modelMT, std::vector< CTriangle > &triangleArray)
void	addTriangles (CLandscape &landscape, std::vector< uint > &listZone, uint order, std::vector< CTriangle > &triangleArray)
void	addWaterShape (CWaterShape *shape, const NLMISC::CMatrix &MT)
	Add a water shape. This is needed to decide wether tiles are above / below water.
float	attenuation (const CVector &pos, const CZoneLighter::CLightDesc &description)
	CZoneLighter ()
void	init ()
void	light (CLandscape &landscape, CZone &output, uint zoneToLight, const CLightDesc &description, std::vector< CTriangle > &obstacles, std::vector< uint > &listZone)
virtual void	progress (const char *message, float progress)
virtual	~CZoneLighter ()
Static PointLights mgt.
void	addStaticPointLight (const CPointLightNamed &pln)
	Append a static point light to compute. call at setup stage (before light() ).
Static Public Member Functions
bool	isLightableShape (IShape &shape)
	check wether a shape is lightable.
Data Fields
std::vector< CZBuffer >	_ZBufferLandscape
CZBuffer	_ZBufferObject
Private Types
typedef std::vector< CShapeInfo >	TShapeVect
	A vector of lightable shapes.
typedef CQuadGrid< CWaterShape * >	TWaterShapeQuadGrid
Private Member Functions
void	addTriangles (const CMeshBase &meshBase, const CMeshMRMGeom &meshGeom, const CMatrix &modelMT, std::vector< CTriangle > &triangleArray)
void	addTriangles (const CMeshBase &meshBase, const CMeshGeom &meshGeom, const NLMISC::CMatrix &modelMT, std::vector< CTriangle > &triangleArray)
void	buildZoneInformation (CLandscape &landscape, const std::vector< uint > &listZone, const CLightDesc &lightDesc)
float	calcSkyContribution (sint s, sint t, float height, float skyIntensity, const CVector &normal) const
void	computeTileFlagsForPositionTowardWater (const CLightDesc &lightDesc, std::vector< const CTessFace * > &tessFaces)
void	excludeAllPatchFromRefineAll (CLandscape &landscape, std::vector< uint > &listZone, bool exclude)
uint	getAPatch (uint process)
uint8	getMaxPhi (sint s, sint t, sint deltaS, sint deltaT, float heightPos) const
void	getNormal (const NL3D::CPatch *pPatch, sint16 lumelS, sint16 lumelT, std::vector< NL3D::CPatchUVLocator > &locator, const std::vector< NL3D::CPatch::CBindInfo > &bindInfo, const std::vector< bool > &binded, std::set< uint64 > &visited, float deltaS, float deltaT, uint rotation, const NL3D::CBezierPatch &bezierPatch, uint lastEdge=5)
void	getPatchNormalAndPositions (std::vector< CLumelDescriptor > &lumels, CLandscape &landscape, uint zoneToLight, uint patch, CPatchUVLocator *locator, bool *binded)
float	getSkyContribution (const CVector &pos, const CVector &normal, float SkyIntensity) const
	compute the sky contribution at the given position
bool	getTexture (const CMaterial &material, NLMISC::CBitmap *&result, bool &clampU, bool &clampV, uint8 &alphaTestThreshold, bool &doubleSided)
bool	isLumelOnEdgeMustBeOversample (uint patch, uint edge, sint s, sint t, const std::vector< bool > &binded, const std::vector< bool > &oversampleEdges, std::vector< CPatchUVLocator > &locator, uint8 shadowed, std::vector< std::vector< uint8 > > &shadowBuffer)
void	lightShapes (uint zoneID, const CLightDesc &description)
	Launch a set of threads to perform lighting of lightable shapes.
void	lightSingleShape (CShapeInfo &lsi, const CLightDesc &description, uint cpu)
	Compute the lighting for a single lightable shape.
void	lightWater (CWaterShape &ws, const CMatrix &MT, const CLightDesc &description, uint cpu)
	Compute the lighting for a water shape.
void	makeQuadGridFromWaterShapes (NLMISC::CAABBox zoneBBox)
void	processCalc (uint process, const CLightDesc &description)
void	processLightableShapeCalc (uint process, TShapeVect *shapeToLit, uint firstShape, uint lastShape, const CLightDesc &description)
	Process lighting for a set of lightable shapes. This is called by the threads created by lightShapes().
void	setTileFlagsToDefault (std::vector< const CTessFace * > &tessFaces)
Static Private Member Functions
void	copyTileFlags (CZone &destZone, const CZone &srcZone)
Private Attributes
std::vector< std::vector< CBezierPatch > >	_BezierPatch
std::vector< std::vector< std::vector< bool > > >	_Binded
std::vector< std::vector< std::vector< CPatch::CBindInfo > > >	_BindInfo
std::map< std::string, NLMISC::CBitmap >	_Bitmaps
std::vector< CBorderVertex >	_BorderVertices
uint64	_CPUMask
NLMISC::CVector	_GetNormalNormal
const NL3D::CPatch *	_GetNormalPatch
uint	_GetNormalRadius
uint	_GetNormalSqRadius
std::vector< float >	_HeightField
sint	_HeightFieldCellCount
float	_HeightfieldCellSize
NLMISC::CVector	_K [256][8]
NL3D::CLandscape *	_Landscape
std::vector< uint >	_LastPatchComputed
TShapeVect	_LightableShapes
	lightable shapes
std::vector< std::vector< std::vector< CPatchUVLocator > > >	_Locator
std::vector< std::vector< CLumelDescriptor > >	_Lumels
NLMISC::CFastMutex	_Mutex
uint	_NumberOfPatchComputed
uint	_NumLightableShapesProcessed
NLMISC::CVector	_OrigineHeightField
std::vector< std::vector< bool > >	_OversampleEdges
NLMISC::CSynchronized< std::vector< bool > >	_PatchComputed
std::vector< CPatchInfo >	_PatchInfo
uint	_ProcessCount
volatile uint	_ProcessExited
CQuadGrid< const CTriangle * >	_QuadGrid [10]
NLMISC::CRandom	_Random
NLMISC::CMatrix	_RayBasis
std::vector< std::vector< uint8 > >	_ShadowArray
float	_ShadowBias
bool	_Softshadow
NLMISC::CVector	_SunDirection
TWaterShapeQuadGrid	_WaterShapeQuadGrid
TShapeVect	_WaterShapes
bool	_ZBufferOverflow
std::map< uint, uint >	_ZoneId
uint	_ZoneToLight
Static Private Attributes
sint16	_GetNormalDeltaS [4] = { -1, 0, 1, 0 }
sint16	_GetNormalDeltaT [4] = { 0, 1, 0, -1 }
Friends
class	CCalcLightableShapeRunnable
class	NL3D::CLightRunnable
class	NL3D::CRenderZBuffer

---

Member Typedef Documentation

typedef std::vector<CShapeInfo> NL3D::CZoneLighter::TShapeVect [private]

A vector of lightable shapes. Definition at line 403 of file zone_lighter.h. Referenced by NL3D::CCalcLightableShapeRunnable::CCalcLightableShapeRunnable(), and processLightableShapeCalc().

typedef CQuadGrid<CWaterShape *> NL3D::CZoneLighter::TWaterShapeQuadGrid [private]

Definition at line 605 of file zone_lighter.h.

---

Constructor & Destructor Documentation

CZoneLighter::CZoneLighter (   )

Definition at line 245 of file zone_lighter.cpp. : _PatchComputed ("PatchComputed") { }

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

Definition at line 70 of file zone_lighter.h. {}

---

Member Function Documentation

void CZoneLighter::addLightableShape (  IShape *  shape, const NLMISC::CMatrix &  modelMT )

Some shape (water shapes for now) can be lit. This add such a shape to the process of lighting. See also: isLightableShape() Definition at line 2773 of file zone_lighter.cpp. References _LightableShapes, NL3D::CZoneLighter::CShapeInfo::MT, and NL3D::CZoneLighter::CShapeInfo::Shape. { CShapeInfo lsi; lsi.MT = MT; lsi.Shape = shape; _LightableShapes.push_back(lsi); }

void CZoneLighter::addStaticPointLight (  const CPointLightNamed &  pln  )

Append a static point light to compute. call at setup stage (before light() ). Definition at line 3179 of file zone_lighter.cpp. References NL3D::CZoneLighter::CPointLightRT::BSphere, NLMISC::CBSphere::Center, NL3D::CPointLight::getAttenuationBegin(), NL3D::CPointLight::getAttenuationEnd(), NL3D::CPointLight::getPosition(), NL3D::CZoneLighter::CPointLightRT::OODeltaAttenuation, NL3D::CZoneLighter::CPointLightRT::PointLight, and NLMISC::CBSphere::Radius. { // build the plRT. CPointLightRT plRT; plRT.PointLight= pln; // compute plRT.OODeltaAttenuation plRT.OODeltaAttenuation= pln.getAttenuationEnd() - pln.getAttenuationBegin(); if(plRT.OODeltaAttenuation <=0 ) plRT.OODeltaAttenuation= 0; 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 CZoneLighter::addTriangles (  const CMeshBase &  meshBase, const CMeshMRMGeom &  meshGeom, const CMatrix &  modelMT, std::vector< CTriangle > &  triangleArray )  [private]

Definition at line 1887 of file zone_lighter.cpp. References NL3D::CMeshBase::getMaterial(), NL3D::CMeshMRMGeom::getNbRdrPass(), NL3D::CPrimitiveBlock::getNumQuad(), NL3D::CPrimitiveBlock::getNumTri(), NL3D::CPrimitiveBlock::getQuadPointer(), NL3D::CMeshMRMGeom::getRdrPassMaterial(), NL3D::CMeshMRMGeom::getRdrPassPrimitiveBlock(), NL3D::CVertexBuffer::getTexCoordPointer(), getTexture(), NL3D::CPrimitiveBlock::getTriPointer(), NL3D::CMeshMRMGeom::getVertexBuffer(), NL3D::CVertexBuffer::getVertexCoordPointer(), uint, uint32, uint8, and v. { // 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); // Get the material const CMaterial &material = meshBase.getMaterial (meshGeom.getRdrPassMaterial (0, pass)); // ** Get the bitmap // Texture informations, not NULL only if texture is used for alpha test CBitmap *texture; bool clampU; bool clampV; uint8 alphaTestThreshold; bool doubleSided; if (getTexture (material, texture, clampU, clampV, alphaTestThreshold, doubleSided)) { // 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])); // UV float u[3]; float v[3]; for (uint i=0; i<3; i++) { // Get UV coordinates float *uv = (float*)vb.getTexCoordPointer (triIndex[tri*3+i], 0); if (uv) { // Copy it u[i] = uv[0]; v[i] = uv[1]; } } // Make a triangle triangleArray.push_back (CTriangle (NLMISC::CTriangle (v0, v1, v2), doubleSided, texture, clampU, clampV, u, v, alphaTestThreshold)); } // 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])); // UV float u[4]; float v[4]; for (uint i=0; i<4; i++) { // Get UV coordinates float *uv = (float*)vb.getTexCoordPointer (triIndex[tri*4+i], 0); if (uv) { // Copy it u[i] = uv[0]; v[i] = uv[1]; } } // Make 2 triangles triangleArray.push_back (CTriangle (NLMISC::CTriangle (v0, v1, v2), doubleSided, texture, clampU, clampV, u, v, alphaTestThreshold)); u[1] = u[2]; u[2] = u[3]; v[1] = v[2]; v[2] = v[3]; triangleArray.push_back (CTriangle (NLMISC::CTriangle (v0, v2, v3), doubleSided, texture, clampU, clampV, u, v, alphaTestThreshold)); } } } }

void CZoneLighter::addTriangles (  const CMeshBase &  meshBase, const CMeshGeom &  meshGeom, const NLMISC::CMatrix &  modelMT, std::vector< CTriangle > &  triangleArray )  [private]

Definition at line 1717 of file zone_lighter.cpp. References NL3D::CMeshBase::getMaterial(), NL3D::CMeshGeom::getNbMatrixBlock(), NL3D::CMeshGeom::getNbRdrPass(), NL3D::CPrimitiveBlock::getNumQuad(), NL3D::CPrimitiveBlock::getNumTri(), NL3D::CPrimitiveBlock::getQuadPointer(), NL3D::CMeshGeom::getRdrPassMaterial(), NL3D::CMeshGeom::getRdrPassPrimitiveBlock(), NL3D::CVertexBuffer::getTexCoordPointer(), getTexture(), NL3D::CPrimitiveBlock::getTriPointer(), NL3D::CMeshGeom::getVertexBuffer(), NL3D::CVertexBuffer::getVertexCoordPointer(), uint, uint32, uint8, and v. { // 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); // Get the material const CMaterial &material = meshBase.getMaterial (meshGeom.getRdrPassMaterial ( block, pass)); // ** Get the bitmap // Texture informations, not NULL only if texture is used for alpha test CBitmap *texture; bool clampU; bool clampV; uint8 alphaTestThreshold; bool doubleSided; if (getTexture (material, texture, clampU, clampV, alphaTestThreshold, doubleSided)) { // 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])); // UV float u[3]; float v[3]; for (uint i=0; i<3; i++) { // Get UV coordinates float *uv = (float*)vb.getTexCoordPointer (triIndex[tri*3+i], 0); if (uv) { // Copy it u[i] = uv[0]; v[i] = uv[1]; } } // Make a triangle triangleArray.push_back (CTriangle (NLMISC::CTriangle (v0, v1, v2), doubleSided, texture, clampU, clampV, u, v, alphaTestThreshold)); } // 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])); // UV float u[4]; float v[4]; for (uint i=0; i<4; i++) { // Get UV coordinates float *uv = (float*)vb.getTexCoordPointer (triIndex[tri*4+i], 0); if (uv) { // Copy it u[i] = uv[0]; v[i] = uv[1]; } } // Make 2 triangles triangleArray.push_back (CTriangle (NLMISC::CTriangle (v0, v1, v2), doubleSided, texture, clampU, clampV, u, v, alphaTestThreshold)); u[1] = u[2]; u[2] = u[3]; v[1] = v[2]; v[2] = v[3]; triangleArray.push_back (CTriangle (NLMISC::CTriangle (v0, v2, v3), doubleSided, texture, clampU, clampV, u, v, alphaTestThreshold)); } } } } }

void CZoneLighter::addTriangles (  const IShape &  shape, const NLMISC::CMatrix &  modelMT, std::vector< CTriangle > &  triangleArray )

Definition at line 1670 of file zone_lighter.cpp. References addTriangles(), NL3D::CMeshMRM::getMeshGeom(), NL3D::CMeshMultiLod::getMeshGeom(), and NL3D::CMesh::getMeshGeom(). { // 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, mesh->getMeshGeom (), modelMT, triangleArray); } // 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 (*meshMulti, *geomMesh, modelMT, triangleArray); } // Dynamic cast const CMeshMRMGeom *mrmGeomMesh=dynamic_cast<const CMeshMRMGeom*>(meshGeom); if (mrmGeomMesh) { addTriangles (*meshMulti, *mrmGeomMesh, modelMT, triangleArray); } } // It is a CMeshMultiLod ? else if (meshMRM) { // Get the first lod mesh geom addTriangles (*meshMRM, meshMRM->getMeshGeom (), modelMT, triangleArray); } }

void CZoneLighter::addTriangles (  CLandscape &  landscape, std::vector< uint > &  listZone, uint  order, std::vector< CTriangle > &  triangleArray )

Definition at line 1613 of file zone_lighter.cpp. References NL3D::CTessVertex::EndPos, excludeAllPatchFromRefineAll(), NL3D::CParamCoord::getS(), NL3D::CParamCoord::getT(), NL3D::CLandscape::getTessellationLeaves(), min, NL3D::CTessFace::PVBase, NL3D::CTessFace::PVLeft, NL3D::CTessFace::PVRight, NL3D::CLandscape::refineAll(), NL3D::CLandscape::setThreshold(), NL3D::CLandscape::setTileMaxSubdivision(), uint, NL3D::CTessFace::VBase, NL3D::CTessFace::VLeft, and NL3D::CTessFace::VRight. Referenced by addTriangles(). { // 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]; // Start and end coordinate float startS=min (min (face->PVBase.getS(), face->PVLeft.getS()), face->PVRight.getS()); float endS=max (max (face->PVBase.getS(), face->PVLeft.getS()), face->PVRight.getS()); float startT=min (min (face->PVBase.getT(), face->PVLeft.getT()), face->PVRight.getT()); float endT=max (max (face->PVBase.getT(), face->PVLeft.getT()), face->PVRight.getT()); // Add a triangle triangleArray.push_back (CTriangle (NLMISC::CTriangle (face->VBase->EndPos, face->VLeft->EndPos, face->VRight->EndPos))); } // 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 CZoneLighter::addWaterShape (  CWaterShape *  shape, const NLMISC::CMatrix &  MT )

Add a water shape. This is needed to decide wether tiles are above / below water. make sure it hasn't been inserted twice Definition at line 3057 of file zone_lighter.cpp. References NL3D::CZoneLighter::CShapeInfo::MT, and NL3D::CZoneLighter::CShapeInfo::Shape. { CShapeInfo ci; ci.Shape = shape; ci.MT = MT; _WaterShapes.push_back(ci); }

float CZoneLighter::attenuation (  const CVector &  pos, const CZoneLighter::CLightDesc &  description )

Definition at line 3767 of file zone_lighter.cpp. References _Random, _ZBufferLandscape, _ZBufferObject, _ZBufferOverflow, NL3D::CZoneLighter::CZBuffer::LocalZBufferXMin, NL3D::CZoneLighter::CZBuffer::LocalZBufferYMin, min, NLMISC::CRandom::rand(), NLMISC::CRandom::RandMax, sint, NL3D::CZoneLighter::CLightDesc::SoftShadowJitter, NL3D::CZoneLighter::CLightDesc::SoftShadowSamplesSqrt, testZPercentageCloserFilter(), transformVectorToZBuffer(), uint, NLMISC::CVector::x, x, NLMISC::CVector::y, y, and NLMISC::CVector::z. Referenced by lightWater(), and processCalc(). { // Clipped ? // *** Landscape attenuation // Current value float averageAttenuation = 0; float randomSum = 0; // For each sample uint sample; const uint samples = description.SoftShadowSamplesSqrt*description.SoftShadowSamplesSqrt; for (sample=0; sample<samples; sample++) { // The zbuffer CZBuffer &zbuffer = _ZBufferLandscape[sample]; // Get position in z buffer CVector zPos; transformVectorToZBuffer (zbuffer, pos, zPos); sint x = (sint)floor (zPos.x); sint y = (sint)floor (zPos.y); // Get the z float random = (float)_Random.rand () * description.SoftShadowJitter + _Random.RandMax * (1.f - description.SoftShadowJitter); averageAttenuation += random * testZPercentageCloserFilter (zPos.x-(float)zbuffer.LocalZBufferXMin, zPos.y-(float)zbuffer.LocalZBufferYMin, zPos.z, zbuffer, description, _ZBufferOverflow); randomSum += random; } // Average landscape attenuation averageAttenuation /= randomSum; // *** Attenuation in the object zbuffer // Get position in z buffer CVector zPos; transformVectorToZBuffer (_ZBufferObject, pos, zPos); const sint x = (sint)floor (zPos.x); const sint y = (sint)floor (zPos.y); const float objectAttenuation = testZPercentageCloserFilter (zPos.x-(float)_ZBufferObject.LocalZBufferXMin, zPos.y-(float)_ZBufferObject.LocalZBufferYMin, zPos.z, _ZBufferObject, description, _ZBufferOverflow); // *** Return the min of the both return std::min (objectAttenuation, averageAttenuation); }

void CZoneLighter::buildZoneInformation (  CLandscape &  landscape, const std::vector< uint > &  listZone, const CLightDesc &  lightDesc )  [private]

make a quad grid of each water shape check for each tile if it is above / below water Definition at line 2045 of file zone_lighter.cpp. References _BezierPatch, _Binded, _BindInfo, _GetNormalNormal, _Locator, _Lumels, _OversampleEdges, _ZoneId, _ZoneToLight, BLUR_SIZE, computeTileFlagsForPositionTowardWater(), count, easineasout(), NL3D::CTessVertex::EndPos, NL3D::CBezierPatch::evalNormal(), NL3D::CLandscape::excludePatchFromRefineAll(), NLMISC::CAABBoxExt::getAABBox(), NL3D::CPatch::getBindNeighbor(), getNormal(), NLMISC::CPlane::getNormal(), NL3D::CZone::getNumPatchs(), NL3D::CPatch::getOrderS(), NL3D::CPatch::getOrderT(), NL3D::CPatch::getPatchId(), NLMISC::getPowerOf2(), NL3D::CParamCoord::getS(), NL3D::CParamCoord::getT(), NL3D::CLandscape::getTessellationLeaves(), NL3D::CPatch::getZone(), NL3D::CLandscape::getZone(), NL3D::CZone::getZoneBB(), NL3D::CZone::getZoneId(), index, NLMISC::isPowerOf2(), NLMISC::CPlane::make(), makeQuadGridFromWaterShapes(), NL_LUMEL_BY_TILE, NL_MAX_TILES_BY_PATCH_EDGE, nlassert, NL3D::CZoneLighter::CLumelDescriptor::Normal, NLMISC::CVector::normalize(), NL3D::CTessFace::Patch, NL3D::CZoneLighter::CLumelDescriptor::Position, progress(), NL3D::CTessFace::PVBase, NL3D::CTessFace::PVLeft, NL3D::CTessFace::PVRight, NL3D::CLandscape::refineAll(), s, NL3D::CZoneLighter::CLumelDescriptor::S, NLMISC::CVector::set(), NL3D::CLandscape::setThreshold(), setTileFlagsToDefault(), NL3D::CLandscape::setTileMaxSubdivision(), sint, t, NL3D::CZoneLighter::CLumelDescriptor::T, uint, NL3D::CPatch::unpackIntoCache(), value, NL3D::CTessFace::VBase, NL3D::CTessFace::VLeft, and NL3D::CTessFace::VRight. Referenced by light(). { // Bool visit vector<vector<uint> > visited; // Zone count uint zoneCount=listZone.size(); // Resize arries _Locator.resize (zoneCount); _Binded.resize (zoneCount); _BindInfo.resize (zoneCount); _BezierPatch.resize (zoneCount); // For each zone for (uint zone=0; zone<zoneCount; zone++) { // Get num patches uint patchCount=landscape.getZone(listZone[zone])->getNumPatchs(); // Insert zone id _ZoneId.insert (map<uint, uint>::value_type (listZone[zone], zone)); // This is the zone to light ? if (listZone[zone]==_ZoneToLight) { // Resize the arraies _Lumels.resize(patchCount); // _LumelCorners.resize(patchCount); // _BezierPatch.resize(patchCount); _OversampleEdges.resize(patchCount); visited.resize(patchCount); } // Common arries _Locator[zone].resize(patchCount); _Binded[zone].resize(patchCount); _BindInfo[zone].resize(patchCount); _BezierPatch[zone].resize(patchCount); // For each patch uint patch; for (patch=0; patch<patchCount; patch++) { // Get a patch pointer const CPatch* pPatch=(const_cast<const CZone*>(landscape.getZone(listZone[zone])))->getPatch (patch); // Progress bar progress ("Scan all patches", (float)patch/(float)patchCount); // Get pointer on arries vector<bool> &binded=_Binded[zone][patch]; vector<CPatch::CBindInfo> &bindInfo=_BindInfo[zone][patch]; vector<CPatchUVLocator> &locator=_Locator[zone][patch]; CBezierPatch &bezierPatch=_BezierPatch[zone][patch]; binded.resize (4, false); bindInfo.resize (4); locator.resize (4); // Contruct the patch bezierPatch=*pPatch->unpackIntoCache(); // Same zone ? if (listZone[zone]==_ZoneToLight) { // oversample this edge _OversampleEdges[patch].resize (4, false); } // *** Build bind info // *** Build neighboorhood information uint edge; for (edge=0; edge<4; edge++) { // Bond neighbor pPatch->getBindNeighbor (edge, bindInfo[edge]); // Patch binded if (bindInfo[edge].NPatchs>0) { // This edeg is binded binded[edge]=true; // Same zone ? if ((listZone[zone]==_ZoneToLight)&&(bindInfo[edge].Zone->getZoneId()!=_ZoneToLight)) { // oversample this edge _OversampleEdges[patch][edge]=true; } locator[edge].build (pPatch, edge, bindInfo[edge]); } else { if (listZone[zone]==_ZoneToLight) { // oversample this edge _OversampleEdges[patch][edge]=true; } } } // This is the zone to light ? if (listZone[zone]==_ZoneToLight) { // *** Resize lumel array for this patch // Get patch order uint orderS=pPatch->getOrderS(); uint orderT=pPatch->getOrderT(); // Number of lumels uint lumelCount = orderS*orderT*16; uint lumelCornerCount = (orderS*4+1)*(orderT*4+1); // Resize the lumel descriptor CLumelDescriptor descriptor; descriptor.Normal.set (0,0,0); descriptor.Position.set (0,0,0); descriptor.S=0; descriptor.T=0; _Lumels[patch].resize (lumelCount, descriptor); visited[patch].resize (lumelCount, 0); // _LumelCorners[patch].resize (lumelCornerCount); // *** Unexclude this patch // Exclude all the patches from refine all landscape.excludePatchFromRefineAll (listZone[zone], patch, false); } else { // Exclude all the patches from refine all landscape.excludePatchFromRefineAll (listZone[zone], patch, true); } } } // *** Now tesselate this zone to shadow casters accuracy // Setup the landscape landscape.setThreshold (0); landscape.setTileMaxSubdivision (0); // Refine all progress ("Refine landscape to shadow accuracy", 0.5f); landscape.refineAll (CVector (0, 0, 0)); // Get tesselated faces std::vector<const CTessFace*> leaves; landscape.getTessellationLeaves(leaves); if (_WaterShapes.size() != 0) // any water shape in this zone ? { makeQuadGridFromWaterShapes(landscape.getZone(_ZoneToLight)->getZoneBB().getAABBox()); computeTileFlagsForPositionTowardWater(lightDesc, leaves); } else { setTileFlagsToDefault(leaves); } // Id of this zone in the array uint zoneNumber=_ZoneId[_ZoneToLight]; // Scan each leaves uint leavesCount=leaves.size(); uint leave; for (leave=0; leave<leavesCount; leave++) { // Progress bar if ( (leave&0xff) == 0) progress ("Precompute lumel position", (float)leave/(float)leavesCount); // Leave const CTessFace *face=leaves[leave]; // Get zone id if (face->Patch->getZone()->getZoneId()==_ZoneToLight) { // Get a patch pointer const CPatch* pPatch=face->Patch; // Get order uint orderS=pPatch->getOrderS(); uint orderT=pPatch->getOrderT(); // *** Base Coordinates CVector pos[15]; pos[0]=face->VBase->EndPos; // p0 pos[1]=face->VRight->EndPos; pos[2]=face->VLeft->EndPos; // p2 pos[3]=(pos[1]+pos[2])/2; pos[4]=(pos[0]+pos[1])/2; // p4 pos[5]=(pos[0]+pos[2])/2; pos[6]=(pos[0]+pos[3])/2; // p6 pos[7]=(pos[2]+pos[3])/2; pos[8]=(pos[1]+pos[3])/2; // p8 pos[9]=(pos[0]+pos[4])/2; pos[10]=(pos[1]+pos[4])/2; // p10 pos[11]=(pos[0]+pos[5])/2; pos[12]=(pos[2]+pos[5])/2; // p12 pos[13]=(pos[3]+pos[5])/2; pos[14]=(pos[3]+pos[4])/2; // p14 float s0=face->PVBase.getS(); float s1=face->PVRight.getS(); float s2=face->PVLeft.getS(); float s3=(s1+s2)/2; float s4=(s0+s1)/2; float s5=(s0+s2)/2; float s6=(s4+s5)/2; float s7=(s2+s3)/2; float s8=(s1+s3)/2; float t0=face->PVBase.getT(); float t1=face->PVRight.getT(); float t2=face->PVLeft.getT(); float t3=(t1+t2)/2; float t4=(t0+t1)/2; float t5=(t0+t2)/2; float t6=(t4+t5)/2; float t7=(t2+t3)/2; float t8=(t1+t3)/2; // *** Interpolated value CVector interpolatedP[10]= { (pos[0]+pos[6])/2, (pos[4]+pos[6])/2, (pos[4]+pos[8])/2, (pos[1]+pos[8])/2, (pos[5]+pos[6])/2, (pos[3]+pos[6])/2, (pos[3]+pos[8])/2, (pos[5]+pos[7])/2, (pos[3]+pos[7])/2, (pos[2]+pos[7])/2, }; // Does the border are snapped ? uint sBase = (uint)floor ((float)orderS * face->PVBase.getS() + 0.5); uint tBase = (uint)floor ((float)orderT * face->PVBase.getT() + 0.5); uint sLeft = (uint)floor ((float)orderS * face->PVLeft.getS() + 0.5); uint tLeft = (uint)floor ((float)orderT * face->PVLeft.getT() + 0.5); uint sRight = (uint)floor ((float)orderS * face->PVRight.getS() + 0.5); uint tRight = (uint)floor ((float)orderT * face->PVRight.getT() + 0.5); bool snapedLeft[2]= { (sBase == 0) && (sRight == 0), (sBase == 0) && (sLeft == 0), }; bool snapedRight[2]= { (sBase == orderS) && (sRight == orderS), (sBase == orderS) && (sLeft == orderS), }; bool snapedTop[2]= { (tBase == 0) && (tRight == 0), (tBase == 0) && (tLeft == 0), }; bool snapedBottom[2]= { (tBase == orderT) && (tRight == orderT), (tBase == orderT) && (tLeft == orderT), }; bool snapedBorder[2]= { snapedLeft[0]||snapedRight[0]||snapedTop[0]||snapedBottom[0], snapedLeft[1]||snapedRight[1]||snapedTop[1]||snapedBottom[1], }; bool snapedCorner[3]= { ((sBase == 0) && ((tBase == 0) || (tBase == orderT))) || ((sBase == orderS) && ((tBase == 0) || (tBase == orderT))), ((sRight == 0) && ((tRight == 0) || (tRight == orderT))) || ((sRight == orderS) && ((tRight == 0) || (tRight == orderT))), ((sLeft == 0) && ((tLeft == 0) || (tLeft == orderT))) || ((sLeft == orderS) && ((tLeft == 0) || (tLeft == orderT))), }; // Snap on the border uint i; for (i=0; i<8; i++) { // Snaped on left ? if (snapedBorder[VertexThanCanBeSnappedOnABorder[i][1]]) { // Compute the border vertex interpolatedP[VertexThanCanBeSnappedOnABorder[i][0]] = (pos[VertexThanCanBeSnappedOnABorder[i][2]] + pos[VertexThanCanBeSnappedOnABorder[i][3]])/2; } } // Snap on the corner for (i=0; i<3; i++) { // Snaped on a corner ? uint tesselCornerIndex = VertexThanCanBeSnappedOnACorner[i][1]; if ( snapedCorner[tesselCornerIndex] ) { // Compute the border vertex interpolatedP[VertexThanCanBeSnappedOnACorner[i][0]] = pos[tesselCornerIndex]; } } float interpolatedS[10]= { (s0+s6)/2, (s4+s6)/2, (s4+s8)/2, (s1+s8)/2, (s5+s6)/2, (s3+s6)/2, (s3+s8)/2, (s5+s7)/2, (s3+s7)/2, (s2+s7)/2, }; float interpolatedT[10]= { (t0+t6)/2, (t4+t6)/2, (t4+t8)/2, (t1+t8)/2, (t5+t6)/2, (t3+t6)/2, (t3+t8)/2, (t5+t7)/2, (t3+t7)/2, (t2+t7)/2, }; for (i=0; i<10; i++) { sint s=(sint)((float)orderS*4*interpolatedS[i]); sint t=(sint)((float)orderT*4*interpolatedT[i]); if ((s>=0)&&(s<(sint)orderS*4)&&(t>=0)&&(t<(sint)orderT*4)) { // Triangle index uint index=s+t*orderS*4; // Ge tthe patch id uint patchId=pPatch->getPatchId(); // Get lumel array vector<CLumelDescriptor> &lumels=_Lumels[patchId]; // Visited visited[patchId][index]++; // Position lumels[index].Position+=interpolatedP[i]; } } } } // *** Now, finalise patch informations for shadow source positions // For each patches uint patchCount=landscape.getZone(_ZoneToLight)->getNumPatchs(); uint patch; for (patch=0; patch<patchCount; patch++) { // Info progress ("Finalize lumel positions", (float)patch/(float)patchCount); // *** Resize lumel array for this patch // Get a patch pointer const CPatch* pPatch=(const_cast<const CZone*>(landscape.getZone(_ZoneToLight)))->getPatch (patch); uint orderS=pPatch->getOrderS(); uint orderT=pPatch->getOrderT(); // Get lumel array vector<CLumelDescriptor> &lumels=_Lumels[patch]; // *** Average position // Renormalize nlassert (isPowerOf2 (orderS)); nlassert (isPowerOf2 (orderT)); uint lumelS=4<<getPowerOf2 (orderS); uint lumelT=4<<getPowerOf2 (orderT); for (uint t=0; t<lumelT; t++) for (uint s=0; s<lumelS; s++) { // Lumel index uint lumelIndex=s+t*lumelS; // *** Number of visit uint visitedCount=visited[patch][lumelIndex]; // If visited, renormalise other values if (visitedCount) { // Normalise position lumels[lumelIndex].Position/=(float)visitedCount; } // Not visited for next pass visited[patch][lumelIndex]=false; } } // *** Now tesselate this zone to shadow receivers accuracy // Setup the landscape landscape.setThreshold (0); landscape.setTileMaxSubdivision (4); // Refine all progress ("Refine landscape to lumels", 0.5f); landscape.refineAll (CVector (0, 0, 0)); // Get tesselated faces leaves.clear (); landscape.getTessellationLeaves(leaves); // Scan each leaves leavesCount=leaves.size(); for (leave=0; leave<leavesCount; leave++) { // Progress bar if ( (leave&0xff) == 0) progress ("Precompute tesselation", (float)leave/(float)leavesCount); // Leave const CTessFace *face=leaves[leave]; // Get zone id if (face->Patch->getZone()->getZoneId()==_ZoneToLight) { // Get a patch pointer const CPatch* pPatch=face->Patch; // Get order uint orderS=pPatch->getOrderS(); uint orderT=pPatch->getOrderT(); // Coordinates float fS=(face->PVBase.getS()+face->PVLeft.getS()+face->PVRight.getS())/3.f; float fT=(face->PVBase.getT()+face->PVLeft.getT()+face->PVRight.getT())/3.f; uint s=(uint)((float)orderS*4*fS); uint t=(uint)((float)orderT*4*fT); nlassert (s>=0); nlassert (s<orderS*4); nlassert (t>=0); nlassert (t<orderT*4); // Triangle index uint index=s+t*orderS*4; // Ge tthe patch id uint patchId=pPatch->getPatchId(); // Get lumel array vector<CLumelDescriptor> &lumels=_Lumels[patchId]; // Visited visited[patchId][index]++; // Lumel s and t lumels[index].S+=fS; lumels[index].T+=fT; // Normal CPlane plane; plane.make (face->VBase->EndPos, face->VLeft->EndPos, face->VRight->EndPos); lumels[index].Normal+=plane.getNormal(); } } // *** Now, finalise patch informations // For each patches patchCount=landscape.getZone(_ZoneToLight)->getNumPatchs(); for (patch=0; patch<patchCount; patch++) { // Info progress ("Finalize patches", (float)patch/(float)patchCount); // *** Resize lumel array for this patch // Get a patch pointer const CPatch* pPatch=(const_cast<const CZone*>(landscape.getZone(_ZoneToLight)))->getPatch (patch); uint orderS=pPatch->getOrderS(); uint orderT=pPatch->getOrderT(); // Get lumel array vector<CLumelDescriptor> &lumels=_Lumels[patch]; // *** Compute an interpolated normal // Get pointer on arries vector<bool> &binded=_Binded[zoneNumber][patch]; vector<CPatchUVLocator> &locator=_Locator[zoneNumber][patch]; vector<CPatch::CBindInfo> &bindInfo=_BindInfo[zoneNumber][patch]; CBezierPatch &bezierPatch=_BezierPatch[zoneNumber][patch]; // Renormalize nlassert (isPowerOf2 (orderS)); nlassert (isPowerOf2 (orderT)); uint powerS=getPowerOf2 (orderS); uint powerT=getPowerOf2 (orderT); uint lumelS=4<<powerS; uint lumelT=4<<powerT; // Sample edge normal CVector normals[NL_MAX_TILES_BY_PATCH_EDGE*NL_LUMEL_BY_TILE+1][4]; uint sFixed[4] = { 0, 0xffffffff, lumelS-1, 0xffffffff }; uint tFixed[4] = { 0xffffffff, lumelT-1, 0xffffffff, 0 }; float sOri[4] = { 0, -1, (float)lumelS, -1 }; float tOri[4] = { -1, (float)lumelT, -1, 0 }; for (uint edge=0; edge<4; edge++) { // s and t uint count=(edge&1)?lumelS:lumelT; for (uint lumel=0; lumel<=count; lumel++) { // Start coordinates float origineS; float origineT; uint startS; uint startT; if (edge&1) { if (lumel==count) startS=count-1; else startS=lumel; startT=tFixed[edge]; origineS=(float)lumel; origineT=tOri[edge]; } else { if (lumel==count) startT=count-1; else startT=lumel; startS=sFixed[edge]; origineT=(float)lumel; origineS=sOri[edge]; } _GetNormalNormal=CVector::Null; set<uint64> visitedLumels; getNormal (pPatch, startS, startT, locator, bindInfo, binded, visitedLumels, startS+0.5f-origineS, startT+0.5f-origineT, 0, bezierPatch); _GetNormalNormal.normalize (); normals[lumel][edge]=_GetNormalNormal; } // Smooth the corners #define BLUR_SIZE 4 for (uint i=1; i<BLUR_SIZE; i++) { float value=(float)i/BLUR_SIZE; value=easineasout(value); normals[i][edge]=normals[0][edge]*(1-value)+normals[i][edge]*value; normals[i][edge].normalize(); normals[count-i][edge]=normals[count][edge]*(1-value)+normals[count-i][edge]*value; normals[count-i][edge].normalize(); } } for (uint t=0; t<lumelT; t++) for (uint s=0; s<lumelS; s++) { // Lumel index uint lumelIndex=s+t*lumelS; // *** Calc the smoothed normal // For each edge CVector normalS=bezierPatch.evalNormal (((float)s+0.5f)/(float)lumelS, ((float)t+0.5f)/(float)lumelT); float sFactor=0; CVector normalT=normalS; float tFactor=0; bool sGood=false, tGood=false; if (s<BLUR_SIZE) { sGood=true; // Average the two normals CVector average=normals[t][0]; average+=normals[t+1][0]; average/=2; // Blend float value=s+0.5f; sFactor=BLUR_SIZE-value; value/=BLUR_SIZE; value=easineasout(value); normalS=(normalS*value+average*(1-value)); normalS.normalize(); } if (s>=lumelS-BLUR_SIZE) { sGood=true; // Average the two normals CVector average=normals[t][2]; average+=normals[t+1][2]; average/=2; // Blend float value=s+0.5f; sFactor=BLUR_SIZE-(lumelS-value); value=(lumelS-value)/BLUR_SIZE; value=easineasout(value); normalS=(normalS*value+average*(1-value)); normalS.normalize(); } if (t<BLUR_SIZE) { tGood=true; // Average the two normals CVector average=normals[s][3]; average+=normals[s+1][3]; average/=2; // Blend float value=t+0.5f; tFactor=BLUR_SIZE-value; value/=BLUR_SIZE; value=easineasout(value); normalT=(normalT*value+average*(1-value)); normalT.normalize(); } if (t>=lumelT-BLUR_SIZE) { tGood=true; // Average the two normals CVector average=normals[s][1]; average+=normals[s+1][1]; average/=2; // Blend float value=t+0.5f; tFactor=BLUR_SIZE-(lumelT-value); value=((lumelT)-value)/BLUR_SIZE; value=easineasout(value); normalT=(normalT*value+average*(1-value)); normalT.normalize(); } // The smooth normal CVector smoothNormal; if ((sGood)&&(tGood)) { if ((sFactor!=BLUR_SIZE)||(tFactor!=BLUR_SIZE)) smoothNormal=normalS*(BLUR_SIZE-tFactor)+normalT*(BLUR_SIZE-sFactor); else smoothNormal=normalS+normalT; } else if (sGood) smoothNormal=normalS; else smoothNormal=normalT; // Normalize it smoothNormal.normalize(); // The pure normal CVector purNormal=bezierPatch.evalNormal (((float)s+0.5f)/(float)lumelS, ((float)t+0.5f)/(float)lumelT); // Normalize the noisy normal lumels[lumelIndex].Normal.normalize(); // Final normal lumels[lumelIndex].Normal=lumels[lumelIndex].Normal-purNormal+smoothNormal; lumels[lumelIndex].Normal.normalize (); // *** Number of visit uint visitedCount=visited[patch][lumelIndex]; // Some lumel have not been found in tesselation //nlassert (visitedCount==2); // If visited, renormalise other values if (visitedCount) { // Normalise position lumels[lumelIndex].S/=(float)visitedCount; lumels[lumelIndex].T/=(float)visitedCount; } } } }

float CZoneLighter::calcSkyContribution (  sint  s, sint  t, float  height, float  skyIntensity, const CVector &  normal )  const [private]

Definition at line 296 of file zone_lighter.cpp. References NLMISC::clamp(), deltaDirection, getMaxPhi(), height, NLMISC::Pi, s, sint, t, uint, and uint8. Referenced by getSkyContribution(). { // Sky contribution float skyContribution; // Calc k CVector k (0, 0, 0); // For the height direction for (uint i=0; i<8; i++) { // Get phi for this point uint8 phi=getMaxPhi (s, t, deltaDirection[i][0], deltaDirection[i][1], height); // Add to k k+=_K[phi][i]; } // Finalize sky contribution skyContribution=(float)(skyIntensity*(normal*k)/(2*Pi)); skyContribution=(float)(skyIntensity*(normal*k)/(2*Pi)); clamp (skyContribution, 0.f, 1.f); return skyContribution; }

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

Fill CubeGrid, and set PointLightRT in _StaticPointLightQuadGrid. Definition at line 3202 of file zone_lighter.cpp. References NL3D::CQuadGrid< T >::begin(), NL3D::CZoneLighter::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::CZoneLighter::CPointLightRT::FaceCubeGrid, NL3D::CPointLight::getAttenuationEnd(), NLMISC::CAABBox::getMax(), NLMISC::CAABBox::getMin(), NL3D::CZoneLighter::CTriangle::getPlane(), NL3D::CPointLight::getPosition(), NL3D::CPointLight::getType(), NL3D::CCubeGrid< const CTriangle * >::insert(), NL3D::CQuadGrid< T >::insert(), NL3D::CQuadGrid< CPointLightRT * >::insert(), NLMISC::CAABBox::intersect(), NL3D_ZONE_LIGHTER_CUBE_GRID_SIZE, NL3D::CZoneLighter::CPointLightRT::PointLight, progress(), NLMISC::CBSphere::Radius, NL3D::CZoneLighter::CPointLightRT::RefCount, NL3D::CQuadGrid< T >::select(), NLMISC::CAABBox::setCenter(), NLMISC::CAABBox::setHalfSize(), size, NL3D::CZoneLighter::CTriangle::Triangle, uint, NLMISC::CTriangle::V0, NLMISC::CTriangle::V1, and NLMISC::CTriangle::V2. 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) { // Point lights ? if (!_StaticPointLights.empty ()) { // 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", 0.5f*i / (float)(_StaticPointLights.size()-1)); CPointLightRT &plRT= _StaticPointLights[i]; // Create the cubeGrid plRT.FaceCubeGrid.create(plRT.PointLight.getPosition(), NL3D_ZONE_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); // Triangle bounding box CAABBox triBbox; triBbox.setCenter (tri.Triangle.V0); triBbox.extend (tri.Triangle.V1); triBbox.extend (tri.Triangle.V2); // Triangle in the light if (triBbox.intersect (bbox)) { // Test BackFace culling. Only faces which are BackFace the point light are inserted. // This is to avoid AutoOccluding problems if( tri.getPlane() * plRT.BSphere.Center < 0) { // 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", 0.5f*i / (float)(_StaticPointLights.size()-1)); 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 CZoneLighter::computeTileFlagsForPositionTowardWater (  const CLightDesc &  lightDesc, std::vector< const CTessFace * > &  tessFaces )  [private]

For each tile of the current zone, check wether it below or above water. The result is stored in the flags of the tile. The quadtree is removed then. Definition at line 3563 of file zone_lighter.cpp. References _WaterShapeQuadGrid, _ZoneToLight, NL3D::CQuadGrid< T >::begin(), NL3D::CQuadGrid< T >::clearSelection(), NLMISC::contReset(), NL3D::CQuadGrid< T >::end(), NLMISC::CAABBox::extend(), NLMISC::CAABBox::getMax(), NLMISC::CPolygon2D::intersect(), nlinfo, progress(), NL3D::CQuadGrid< T >::select(), NLMISC::CAABBox::setMinMax(), NL3D::CTileElement::setVegetableState(), TTileOfPatchMap, uint, NL3D::CZoneLighter::CLightDesc::VegetableHeight, NLMISC::CPolygon::Vertices, NLMISC::CPolygon2D::Vertices, NLMISC::CVector::x, NLMISC::CVector::y, z, and NLMISC::CVector::z. Referenced by buildZoneInformation(). { uint numTileAbove = 0; uint numTileBelow = 0; uint numTileIntersect = 0; TTileOfPatchMap tiles; // First, build the bbox for all tiles // uint triCount = 0, totalTriCount = tessFaces.size(); nlinfo("Dealing with %d tessFaces", tessFaces.size()); for (std::vector<const CTessFace*>::iterator it = tessFaces.begin(); it != tessFaces.end(); ++it, ++triCount) { if ((*it)->Patch->getZone()->getZoneId() != _ZoneToLight) continue; if ((*it)->Patch->Tiles[(*it)->TileId].getVegetableState() == CTileElement::VegetableDisabled) continue; CTileOfPatch top((*it)->TileId, (*it)->Patch); TTileOfPatchMap::iterator tileIt = tiles.find(top); if (tileIt == tiles.end()) // first time ? { NLMISC::CAABBox b; b.setMinMax((*it)->VBase->EndPos, (*it)->VLeft->EndPos); b.extend((*it)->VRight->EndPos); b.extend(b.getMax() + lightDesc.VegetableHeight * NLMISC::CVector::K); // adds vegetable height tiles[top] = b; } else // extends the bbox with the given face { NLMISC::CAABBox &b = tileIt->second; b.extend((*it)->VBase->EndPos); b.extend((*it)->VRight->EndPos); b.extend((*it)->VLeft->EndPos); } if ((triCount % 100) == 0) { progress("Building bbox from tiles", (float) triCount / totalTriCount); } } progress("Building bbox from tiles", 1.f); // Now, check each tile bbox against water shapes // NLMISC::CPolygon waterPoly; NLMISC::CPolygon2D tilePoly; tilePoly.Vertices.resize(4); uint tileCount = 0, totalTileCount = tiles.size(); for (TTileOfPatchMap::iterator tileIt = tiles.begin(); tileIt != tiles.end(); ++tileIt, ++tileCount) { const NLMISC::CVector v0 = tileIt->second.getMin(); const NLMISC::CVector v1 = tileIt->second.getMax(); tilePoly.Vertices[0].set(v0.x, v0.y); tilePoly.Vertices[1].set(v1.x, v0.y); tilePoly.Vertices[2].set(v1.x, v1.y); tilePoly.Vertices[3].set(v0.x, v1.y); _WaterShapeQuadGrid.clearSelection(); _WaterShapeQuadGrid.select(tileIt->second.getMin(), tileIt->second.getMax()); CTileElement &te = tileIt->first.Patch->Tiles[tileIt->first.TileId]; // alias to the current tile element TWaterShapeQuadGrid::CIterator qgIt; for (qgIt = _WaterShapeQuadGrid.begin(); qgIt != _WaterShapeQuadGrid.end(); ++qgIt) { (*qgIt)->getShapeInWorldSpace(waterPoly); NLMISC::CPolygon2D poly(waterPoly); if (poly.intersect(tilePoly)) // above or below a water surface ? { float waterHeight = waterPoly.Vertices[0].z; if (v1.z < waterHeight) { // below te.setVegetableState(CTileElement::UnderWater); //nlassert(te.getVegetableState() == CTileElement::UnderWater); ++ numTileBelow; } else if (v0. z > waterHeight) { // above te.setVegetableState(CTileElement::AboveWater); //nlassert(te.getVegetableState() == CTileElement::AboveWater); ++ numTileAbove; } else { // intersect water te.setVegetableState(CTileElement::IntersectWater); //nlassert(te.getVegetableState() == CTileElement::IntersectWater); ++ numTileIntersect; } break; } } if (qgIt == _WaterShapeQuadGrid.end()) // no intersection found ? if yes it's above water { te.setVegetableState(CTileElement::AboveWater); //nlassert(te.getVegetableState() == CTileElement::AboveWater); ++ numTileAbove; } if ((tileCount % 50) == 0) { progress("Computing tile position towards water", (float) tileCount / totalTileCount); } } progress("Computing tile position towards water", 1.f); nlinfo(" %d tiles are above water.", numTileAbove); nlinfo(" %d tiles are below water.", numTileBelow); nlinfo(" %d tiles intersect water.", numTileIntersect); NLMISC::contReset(_WaterShapeQuadGrid); }

void CZoneLighter::copyTileFlags (  CZone &  destZone, const CZone &  srcZone )  [static, private]

This copy the flags of the tiles from the source zone to a dest zone (result of the lighting). This is needed beacuse these flags are updated to say wether a given tile is above / below water IMPORTANT : the source and destination zones must match of course... Definition at line 1261 of file zone_lighter.cpp. References NL3D::CZone::copyTilesFlags(), NL3D::CZone::getNumPatchs(), NL3D::CZone::getPatch(), NL3D::CZone::getZoneId(), nlassert, and sint. Referenced by light(). { nlassert(destZone.getZoneId() == srcZone.getZoneId()); for (sint k = 0; k < srcZone.getNumPatchs(); ++k) { destZone.copyTilesFlags(k, srcZone.getPatch(k)); } }

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

Definition at line 1985 of file zone_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); } } }

uint CZoneLighter::getAPatch (  uint  process  )  [private]

Definition at line 3726 of file zone_lighter.cpp. References _LastPatchComputed, _NumberOfPatchComputed, _PatchComputed, _PatchInfo, index, and uint. Referenced by processCalc(). { // Accessor CSynchronized<std::vector<bool> >::CAccessor access (&_PatchComputed); // Current index uint index = _LastPatchComputed[process]; uint firstIndex = index; if (access.value().size() == 0) // no more patches return 0xffffffff; while (access.value()[index]) { // Next patch index++; // Last patch ? if (index == _PatchInfo.size()) index = 0; // First ? if (firstIndex == index) // no more patches return 0xffffffff; } // Visited access.value()[index] = true; // Last index _LastPatchComputed[process] = index; _NumberOfPatchComputed++; // Return the index return index; }

uint8 CZoneLighter::getMaxPhi (  sint  s, sint  t, sint  deltaS, sint  deltaT, float  heightPos )  const [private]

Definition at line 1390 of file zone_lighter.cpp. References _HeightFieldCellCount, _HeightfieldCellSize, NLMISC::clamp(), height, nlassert, NLMISC::Pi, res, s, sint, t, and uint8. Referenced by calcSkyContribution(). { // Start position s+=deltaS; t+=deltaT; // Distance increment float stepDistance=CVector (deltaS*_HeightfieldCellSize, deltaT*_HeightfieldCellSize,0).norm (); // Current distance float distance=stepDistance; // Max height float maxHeight=0; float maxTanTeta=0; // For all the line while ((s<_HeightFieldCellCount)&&(t<_HeightFieldCellCount)&&(s>=0)&&(t>=0)) { // Get height float height=_HeightField[s+t*_HeightFieldCellCount]; height-=heightPos; // Better ? if (height>maxHeight) { // Calc sin teta float tanTeta=height/distance; nlassert (tanTeta>=0); // Better ? if (tanTeta>maxTanTeta) { // New max height maxHeight=height; maxTanTeta=tanTeta; } } s+=deltaS; t+=deltaT; distance+=stepDistance; } // return phi float teta=(float)atan (maxTanTeta); nlassert (teta>=0); nlassert (teta<=Pi/2); clamp (teta, 0.f, (float)Pi/2); sint res=(sint)((Pi/2-teta)*256/(Pi/2)); clamp (res, 0, 255); return (uint8)res; }

void CZoneLighter::getNormal (  const NL3D::CPatch *  pPatch, sint16  lumelS, sint16  lumelT, std::vector< NL3D::CPatchUVLocator > &  locator, const std::vector< NL3D::CPatch::CBindInfo > &  bindInfo, const std::vector< bool > &  binded, std::set< uint64 > &  visited, float  deltaS, float  deltaT, uint  rotation, const NL3D::CBezierPatch &  bezierPatch, uint  lastEdge = 5 )  [private]

Definition at line 1506 of file zone_lighter.cpp. References _BezierPatch, _Binded, _BindInfo, _GetNormalDeltaS, _GetNormalDeltaT, _GetNormalNormal, _Locator, _ZoneId, NL3D::CBezierPatch::evalNormal(), NL3D::CPatch::getOrderS(), NL3D::CPatch::getOrderT(), NL3D::CPatch::getPatchId(), NL3D::CPatch::getSmoothFlag(), NL3D::CPatch::getZone(), NL3D::CZone::getZoneId(), nlassert, sint, sint16, uint, uint16, uint64, NLMISC::CVector2f::x, and NLMISC::CVector2f::y. Referenced by buildZoneInformation(). { // Build a desc srructure uint64 id=(uint64)lumelS|(((uint64)lumelT)<<16)|(((uint64)pPatch->getPatchId())<<32)|(((uint64)pPatch->getZone()->getZoneId())<<48); // Insert it if (visited.insert (id).second) { // Clip float sqDist=deltaS*deltaS+deltaT*deltaT; if ( sqDist < 1 ) { // Continue... sint orderSx4=pPatch->getOrderS()<<2; sint orderTx4=pPatch->getOrderT()<<2; sint16 _GetNormalBorderS[4]={ 0, -10, 1, -10 }; sint16 _GetNormalBorderT[4]={ -10, 1, -10, 0 }; _GetNormalBorderS[2]=orderSx4-1; _GetNormalBorderT[1]=orderTx4-1; // Add normal _GetNormalNormal+=bezierPatch.evalNormal ( ((float)lumelS+0.5f)/(float)orderSx4, ((float)lumelT+0.5f)/(float)orderTx4 ); // For the four neighbors for (uint edge=0; edge<4; edge++) { // Not last edge ? if (edge!=lastEdge) { // Direction uint globalDirection=(edge+(4-rotation))&0x3; // Neighbor if ( (lumelS==_GetNormalBorderS[edge]) || (lumelT==_GetNormalBorderT[edge]) ) { // Binded ? bool bind=binded[edge]; bool smooth=pPatch->getSmoothFlag (edge); if (bind&&smooth) { // Lumel coord CVector2f lumelCoord ( ((float)(lumelS+_GetNormalDeltaS[edge])+0.5f)/4, ((float)(lumelT+_GetNormalDeltaT[edge])+0.5f)/4 ); // Get neighbor pixel uint otherPatch=locator[edge].selectPatch(lumelCoord); // Get uv CVector2f neighborUV; CPatch *patchOut; locator[edge].locateUV (lumelCoord, otherPatch, patchOut, neighborUV); // New coordinates sint16 newLumelS=(sint16)(4.f*neighborUV.x); sint16 newLumelT=(sint16)(4.f*neighborUV.y); // Zone id uint16 patchId=patchOut->getPatchId(); uint16 zoneId=_ZoneId[patchOut->getZone()->getZoneId ()]; // Get edge uint newEdge=0; uint i; for (i=0; i<=(uint)bindInfo[edge].NPatchs; i++) { // Good patch ? if (bindInfo[edge].Next[i]==patchOut) { // Get its edge newEdge=bindInfo[edge].Edge[i]; break; } } // Rotation uint newRotation=(2-edge+rotation+newEdge)&0x3; // Must found it nlassert (i!=(uint)bindInfo[edge].NPatchs); // Get the bezier patch CBezierPatch &NewBezierPatch=_BezierPatch[zoneId][patchId]; // Next lumel getNormal (patchOut, newLumelS, newLumelT, _Locator[zoneId][patchId], _BindInfo[zoneId][patchId], _Binded[zoneId][patchId], visited, deltaS+_GetNormalDeltaS[globalDirection], deltaT+_GetNormalDeltaT[globalDirection], newRotation, NewBezierPatch, newEdge); } } else { // Left internal getNormal (pPatch, lumelS+_GetNormalDeltaS[edge], lumelT+_GetNormalDeltaT[edge], locator, bindInfo, binded, visited, deltaS+_GetNormalDeltaS[globalDirection], deltaT+_GetNormalDeltaT[globalDirection], rotation, bezierPatch, (edge+2)&0x3); } } } } } }

void NL3D::CZoneLighter::getPatchNormalAndPositions (  std::vector< CLumelDescriptor > &  lumels, CLandscape &  landscape, uint  zoneToLight, uint  patch, CPatchUVLocator *  locator, bool *  binded )  [private]

float CZoneLighter::getSkyContribution (  const CVector &  pos, const CVector &  normal, float  SkyIntensity )  const [private]

compute the sky contribution at the given position Definition at line 1271 of file zone_lighter.cpp. References _HeightfieldCellSize, _OrigineHeightField, calcSkyContribution(), s, sint, t, NLMISC::CVector::x, NLMISC::CVector::y, and NLMISC::CVector::z. Referenced by lightWater(), and processCalc(). { float s=(pos.x-_OrigineHeightField.x)/_HeightfieldCellSize; float t=(pos.y-_OrigineHeightField.y)/_HeightfieldCellSize; sint sInt=(sint)(floor (s+0.5f)); sint tInt=(sint)(floor (t+0.5f)); // Bilinear float skyContributionTab[2][2]; skyContributionTab[0][0] = calcSkyContribution (sInt-1, tInt-1, pos.z, skyIntensity, normal); skyContributionTab[1][0] = calcSkyContribution (sInt, tInt-1, pos.z, skyIntensity, normal); skyContributionTab[1][1] = calcSkyContribution (sInt, tInt, pos.z, skyIntensity, normal); skyContributionTab[0][1] = calcSkyContribution (sInt-1, tInt, pos.z, skyIntensity, normal); float sFact=s+0.5f-sInt; float tFact=t+0.5f-tInt; return (skyContributionTab[0][0]*(1.f-sFact) + skyContributionTab[1][0]*sFact)*(1.f-tFact) + (skyContributionTab[0][1]*(1.f-sFact) + skyContributionTab[1][1]*sFact)*tFact; }

bool CZoneLighter::getTexture (  const CMaterial &  material, NLMISC::CBitmap *&  result, bool &  clampU, bool &  clampV, uint8 &  alphaTestThreshold, bool &  doubleSided )  [private]

Definition at line 1820 of file zone_lighter.cpp. References _Bitmaps, NLMISC::clamp(), NLMISC::CBitmap::convertToType(), NL3D::ITexture::generate(), NL3D::CMaterial::getAlphaTest(), NL3D::CMaterial::getAlphaTestThreshold(), NL3D::CMaterial::getBlend(), NL3D::CMaterial::getDoubleSided(), NL3D::ITexture::getShareName(), NL3D::CMaterial::getTexture(), NL3D::ITexture::getWrapS(), NL3D::ITexture::getWrapT(), NL3D::ITexture::release(), NL3D::ITexture::supportSharing(), and uint8. Referenced by addTriangles(). { // Texture informations, not NULL only if texture is used for alpha test result = NULL; clampU = false; clampV = false; // Alpha test threashold float alphaTestThresholdF = material.getAlphaTestThreshold () * 255; clamp (alphaTestThresholdF, 0.f, 255.f); alphaTestThreshold = (uint8)alphaTestThresholdF; // Drawable material ? if (material.getBlend ()) return false; // Use alpha test ? if (material.getAlphaTest ()) { // Get the texture ITexture *texture = material.getTexture (0); // Is texture shared ? if (texture && texture->supportSharing ()) { // Share name string name = texture->getShareName(); // Texture exist ? std::map<string, NLMISC::CBitmap>::iterator ite = _Bitmaps.find (name); if (ite != _Bitmaps.end ()) { // Yes result = &(ite->second); } else { // No, add it ite = _Bitmaps.insert (std::map<string, NLMISC::CBitmap>::value_type (name, CBitmap())).first; result = &(ite->second); // Generate the texture texture->generate (); // Convert to RGBA texture->convertToType (CBitmap::RGBA); // Copy it *result = *texture; // Release the texture texture->release (); } // Wrap flags clampU = texture->getWrapS () == ITexture::Clamp; clampV = texture->getWrapT () == ITexture::Clamp; } } // Get double sided flag doubleSided = material.getDoubleSided (); return true; }

void CZoneLighter::init (   )

Definition at line 251 of file zone_lighter.cpp. References _Bitmaps, _ZBufferOverflow, NLMISC::Pi, NLMISC::CVector::set(), and uint. { // Precalc some values for (uint i=0; i<8; i++) { // Precalc sinP and cosP float sinP=(float)(sin((Pi/4)*(i+0.5))-sin((Pi/4)*(i-0.5))); float cosP=(float)(cos((Pi/4)*(i-0.5))-cos((Pi/4)*(i+0.5))); for (uint phi=0; phi<256; phi++) { // Real phi float fPhi=(float)((Pi/2)*phi/256.0); // Tmp result float tmp0=(float)(fPhi-sin(2*fPhi)/2); float tmp1=(float)sin(fPhi); // Calc K _K[phi][i].set (tmp0*sinP, tmp0*cosP, (float)((Pi/4)*tmp1*tmp1)); } } // Init some containers _ZBufferOverflow = false; _Bitmaps.clear (); }

bool CZoneLighter::isLightableShape (  IShape &  shape  )  [static]

check wether a shape is lightable. for now, the only shape that we lit are water shapes Definition at line 2783 of file zone_lighter.cpp. References NL3D::CWaterShape::getColorMap(), and NL3D::CWaterShape::isLightMappingEnabled(). Referenced by processLightableShapeCalc(). { if (dynamic_cast<CWaterShape *>(&shape) != NULL) { // check that this water surface has a diffuse map that is a CTextureFile (we must be able to save it !) CWaterShape *ws = static_cast<CWaterShape *>(&shape); const ITexture *tex = ws->getColorMap(); if (dynamic_cast<const CTextureFile *>(tex) != NULL) { return ws->isLightMappingEnabled(); } } return false; }

bool CZoneLighter::isLumelOnEdgeMustBeOversample (  uint  patch, uint  edge, sint  s, sint  t, const std::vector< bool > &  binded, const std::vector< bool > &  oversampleEdges, std::vector< CPatchUVLocator > &  locator, uint8  shadowed, std::vector< std::vector< uint8 > > &  shadowBuffer )  [private]

Definition at line 1451 of file zone_lighter.cpp. References _GetNormalDeltaS, _GetNormalDeltaT, NL3D::CPatch::getOrderS(), NL3D::CPatch::getPatchId(), s, sint, t, uint, uint8, NLMISC::CVector2f::x, and NLMISC::CVector2f::y. { // Must force oversampling of this edge ? if (oversampleEdges[edge]) return true; else { // binded ? if (binded[edge]) { // Lumel coord CVector2f lumelCoord (((float)(s+_GetNormalDeltaS[edge])+0.5f)/4.f, ((float)(t+_GetNormalDeltaT[edge])+0.5f)/4.f); uint otherPatch=locator[edge].selectPatch(lumelCoord); // Get uv CVector2f neighborUV; CPatch *patchOut; locator[edge].locateUV (lumelCoord, otherPatch, patchOut, neighborUV); // Is the same shadowed flag ? sint ss=(sint)(neighborUV.x*4.f); sint tt=(sint)(neighborUV.y*4.f); return (shadowBuffer[patchOut->getPatchId()][ss+(patchOut->getOrderS()<<2)*tt]!=shadowed); } else { // Not oversample if not binded return false; } } }

void CZoneLighter::light (  CLandscape &  landscape, CZone &  output, uint  zoneToLight, const CLightDesc &  description, std::vector< CTriangle > &  obstacles, std::vector< uint > &  listZone )

copy the tiles flags from the zone to light to the output zone Perform lightning of some ig's of the current zone (if any) Definition at line 920 of file zone_lighter.cpp. References _BorderVertices, _CPUMask, _HeightFieldCellCount, _HeightfieldCellSize, _LastPatchComputed, _NumberOfPatchComputed, _OrigineHeightField, _PatchComputed, _PatchInfo, NL3D::CZoneLighter::CTriangle::_Plane, _ProcessCount, _ProcessExited, _RayBasis, _ShadowArray, _ZBufferLandscape, _ZBufferObject, _ZBufferOverflow, _ZoneToLight, NL3D::CZoneInfo::BorderVertices, NL3D::CZone::build(), buildZoneInformation(), compilePointLightRT(), copyTileFlags(), FilterZBuffer(), NL3D::CZoneLighter::CTriangle::Flags, NLMISC::CAABBoxExt::getCenter(), NLMISC::IProcess::getCPUMask(), NLMISC::IThread::getCPUMask(), NLMISC::CMatrix::getI(), NLMISC::CMatrix::getJ(), NL3D::CZone::getZoneBB(), NL3D::CZoneLighter::CLightDesc::GridCellSize, NL3D::CZoneLighter::CLightDesc::GridSize, NL3D::CZoneLighter::CLightDesc::HeightfieldCellSize, NL3D::CZoneLighter::CLightDesc::HeightfieldSize, InitZBuffer(), NLMISC::CMatrix::invert(), lightShapes(), NL3D::CZoneLighter::CZBuffer::LocalZBufferHeight, NL3D::CZoneLighter::CZBuffer::LocalZBufferWidth, NLMISC::CPlane::make(), MAX_CPU_PROCESS, NLMISC::CVector::maxof(), min, NLMISC::CVector::minof(), NL3D::NEL3DCalcBase(), nlassert, NLMISC::nlSleep(), nlwarning, NL3D::CZoneLighter::CLightDesc::NumCPU, NL3D::CZoneInfo::Patchs, NL3D::CZoneInfo::PointLights, processZonePointLightRT(), progress(), NL3D::CZone::retrieve(), NLMISC::IThread::setCPUMask(), NL3D::CZoneLighter::CLightDesc::Shadow, sint, size, NL3D::CZoneLighter::CLightDesc::SoftShadowSamplesSqrt, NLMISC::IThread::start(), NL3D::CZoneLighter::CLightDesc::SunCenter, NL3D::CZoneLighter::CLightDesc::SunDirection, NL3D::CZoneLighter::CLightDesc::SunDistance, NL3D::CZoneLighter::CLightDesc::SunRadius, NL3D::CLightRunnable::Thread, NL3D::CRenderZBuffer::Thread, NLMISC::toString(), NL3D::CZoneLighter::CTriangle::Triangle, uint, uint64, NLMISC::CTriangle::V0, NLMISC::CTriangle::V1, NLMISC::CTriangle::V2, x, NLMISC::CVector::x, y, NLMISC::CVector::y, NLMISC::CVector::z, NL3D::CZoneLighter::CLightDesc::ZBufferLandscapeSize, NL3D::CZoneLighter::CLightDesc::ZBufferObjectSize, and NL3D::CZoneInfo::ZoneId. { /* * Lighting algorithm * ------------------ * * - Create a quad grid to store shadow casting triangles * - Create a heightfield used for global illumination. Cells are initialized with -FLT_MAX * - Insert each shadow casting triangles in the quad grid and fill the heightfield's cells overlapped by the bounding box of the triangle with * the max height of the triangle if its height is > than the current height in the heightfield's cell. * - */ // Backup thread mask IThread *currentThread = IThread::getCurrentThread (); uint64 threadMask = currentThread->getCPUMask(); currentThread->setCPUMask (1); // Calc the ray basis _SunDirection=description.SunDirection; NEL3DCalcBase (_SunDirection, _RayBasis); // Zone to light _ZoneToLight=zoneToLight; // Landscape _Landscape=&landscape; // Process count _ProcessCount=description.NumCPU; if (_ProcessCount==0) { // Create a doomy thread IProcess *pProcess=IProcess::getCurrentProcess (); _CPUMask = pProcess->getCPUMask(); _ProcessCount = 0; uint64 i; for (i=0; i<64; i++) { if (_CPUMask&((uint64)1<<i)) _ProcessCount++; } } if (_ProcessCount>MAX_CPU_PROCESS) _ProcessCount=MAX_CPU_PROCESS; // Number of obstacle polygones printf ("Obstacle polygones : %d\n", obstacles.size ()); // Number of CPUS used printf ("Number of CPU used: %d\n", _ProcessCount); // Zone pointer CZone *pZone=landscape.getZone (_ZoneToLight); if (pZone) { // *** Compute center of the object // Get the zone bounding box const CAABBoxExt &zoneBB=pZone->getZoneBB(); // Get the center CVector center = zoneBB.getCenter (); // *** Compute planes const uint size=obstacles.size(); uint triangleId; for (triangleId=0; triangleId<size; triangleId++) { // Triangle ref CZoneLighter::CTriangle& triangle=obstacles[triangleId]; // Calc the plane triangle._Plane.make (triangle.Triangle.V0, triangle.Triangle.V1, triangle.Triangle.V2); } // Create landscape zbuffers _ZBufferLandscape.resize (description.SoftShadowSamplesSqrt*description.SoftShadowSamplesSqrt); uint sampleX; uint sampleY; for (sampleY=0; sampleY<description.SoftShadowSamplesSqrt; sampleY++) for (sampleX=0; sampleX<description.SoftShadowSamplesSqrt; sampleX++) { // *** Render the light zbuffer CZBuffer &zbuffer = _ZBufferLandscape[sampleX + sampleY*description.SoftShadowSamplesSqrt]; // Delta pos for area light float deltaX = ( (float)sampleX + 0.5f - (float)description.SoftShadowSamplesSqrt / 2.f) / (float)description.SoftShadowSamplesSqrt; float deltaY = ( (float)sampleY + 0.5f - (float)description.SoftShadowSamplesSqrt / 2.f) / (float)description.SoftShadowSamplesSqrt; CVector lightPos = _RayBasis.getI () * ((float)description.SunRadius * deltaX) + _RayBasis.getJ () * ((float)description.SunRadius * deltaY); lightPos = description.SunCenter - (description.SunDirection * description.SunDistance) + lightPos; InitZBuffer (zbuffer, lightPos, _RayBasis, zoneBB, description.ZBufferLandscapeSize, description); printf ("Zbuffer %d size : %d x %d\n", sampleX+sampleY*description.SoftShadowSamplesSqrt, zbuffer.LocalZBufferWidth, zbuffer.LocalZBufferHeight); } // *** Init the zbuffer for the vegetation CVector lightPos = description.SunCenter - (description.SunDirection * description.SunDistance); InitZBuffer (_ZBufferObject, lightPos, _RayBasis, zoneBB, description.ZBufferObjectSize, description); printf ("Zbuffer object size : %d x %d\n", _ZBufferObject.LocalZBufferWidth, _ZBufferObject.LocalZBufferHeight); // Compute the zbuffer in multi thread _ProcessExited = 0; // Number of triangle to render per thread uint numTriangle = (obstacles.size () / _ProcessCount) + 1; // First triangle for the thread uint firstTriangle = 0; // Count _NumberOfPatchComputed = 0; for (uint process=0; process<_ProcessCount; process++) { // Get list of triangles to render uint lastTriangle=firstTriangle+numTriangle; if (lastTriangle>obstacles.size ()) lastTriangle=obstacles.size (); // Create a thread CRenderZBuffer *runnable = new CRenderZBuffer (process, this, &description, firstTriangle, lastTriangle - firstTriangle, &obstacles); IThread *pThread=IThread::create (runnable); runnable->Thread = pThread; // New first patch firstTriangle = lastTriangle; // Launch pThread->start(); } // Wait for others processes while (_ProcessExited!=_ProcessCount) { nlSleep (1000); // Call the progress callback progress ("Render triangles", (float)_NumberOfPatchComputed/(float)obstacles.size()); } // * Save the zbuffer uint sample; const uint samples = description.SoftShadowSamplesSqrt*description.SoftShadowSamplesSqrt; #ifdef SAVE_ZBUFFER for (sample=0; sample<samples; sample++) { // *** The zbuffer CZBuffer &zbuffer = _ZBufferLandscape[sample]; string zbufferFilename = SAVE_ZBUFFER"/zbuffer_landscape_" + toString (sample) + ".jpg"; SaveZBuffer (zbuffer, zbufferFilename.c_str ()); } // Save the object zbuffer SaveZBuffer (_ZBufferObject, SAVE_ZBUFFER"/zbuffer_object.jpg"); #endif // SAVE_ZBUFFER // *** Filter the zbuffer for (sample=0; sample<samples; sample++) { // For landscape zbuffer, expand the z to neighbor FilterZBuffer (_ZBufferLandscape[sample], 5); } // Change the quadGrid basis CMatrix invRayBasis=_RayBasis; invRayBasis.invert (); // Init the heightfield _HeightfieldCellSize=description.HeightfieldCellSize; _HeightFieldCellCount=(sint)(description.HeightfieldSize/_HeightfieldCellSize); nlassert (_HeightFieldCellCount!=0); _OrigineHeightField=zoneBB.getCenter ()-CVector (description.HeightfieldSize/2, description.HeightfieldSize/2, 0); _HeightField.resize (_HeightFieldCellCount*_HeightFieldCellCount, -FLT_MAX); // Fill the quadGrid and the heightField for (triangleId=0; triangleId<size; triangleId++) { // Progress bar if ( (triangleId&0xff) == 0) progress ("Build quadtree and heightfield", (float)triangleId/(float)size); // Triangle ref CZoneLighter::CTriangle& triangle=obstacles[triangleId]; // Look for the min coordinate, in World Basis CVector minv; minv.minof (triangle.Triangle.V0, triangle.Triangle.V1); minv.minof (minv, triangle.Triangle.V2); // Look for the max coordinate, in World Basis CVector maxv; maxv.maxof (triangle.Triangle.V0, triangle.Triangle.V1); maxv.maxof (maxv, triangle.Triangle.V2); // Lanscape tri ? if (triangle.Flags & CTriangle::Landscape) { // Fill the heightfield sint minX=std::max (0, (sint)floor (0.5f+(minv.x-_OrigineHeightField.x)/_HeightfieldCellSize)); sint maxX=std::min (_HeightFieldCellCount, (sint)floor (0.5f+(maxv.x-_OrigineHeightField.x)/_HeightfieldCellSize)); sint minY=std::max (0, (sint)floor (0.5f+(minv.y-_OrigineHeightField.y)/_HeightfieldCellSize)); sint maxY=std::min (_HeightFieldCellCount, (sint)floor (0.5f+(maxv.y-_OrigineHeightField.y)/_HeightfieldCellSize)); // Calc position in the heightfield for (sint y=minY; y<maxY; y++) for (sint x=minX; x<maxX; x++) { // Valid position, try to insert it if (maxv.z>_HeightField[x+y*_HeightFieldCellCount]) { // New height in this cell _HeightField[x+y*_HeightFieldCellCount]=maxv.z; } } } } // Retrieve the zone to fill its shaded value pZone->retrieve (_PatchInfo, _BorderVertices); // Number of patch uint patchCount=_PatchInfo.size(); // Bit array to know if the lumel is shadowed if (description.Shadow) _ShadowArray.resize (patchCount); // A lumel vector by patch vector<vector<CLumelDescriptor> > lumels; lumels.resize (patchCount); // Build zone informations buildZoneInformation (landscape, listZone, description); } // Number of patch uint patchCount=_PatchInfo.size(); // Reset patch count { CSynchronized<std::vector<bool> >::CAccessor access (&_PatchComputed); access.value().resize (0); access.value().resize (patchCount, false); } // Patch by thread uint patchCountByThread = patchCount/_ProcessCount; patchCountByThread++; // Patch to allocate uint firstPatch=0; _NumberOfPatchComputed = 0; // Reset exited process _ProcessExited=0; // Set the thread state _LastPatchComputed.resize (_ProcessCount); // Launch threads uint process; for (process=0; process<_ProcessCount; process++) { // Last patch uint lastPatch=firstPatch+patchCountByThread; if (lastPatch>patchCount) lastPatch=patchCount; // Last patch computed _LastPatchComputed[process] = firstPatch; // Create a thread CLightRunnable *runnable = new CLightRunnable (process, this, &description); IThread *pThread=IThread::create (runnable); runnable->Thread = pThread; // New first patch firstPatch=lastPatch; // Launch pThread->start(); } // Wait for others processes while (_ProcessExited!=_ProcessCount) { nlSleep (1000); // Call the progress callback progress ("Lighting patches", (float)_NumberOfPatchComputed/(float)_PatchInfo.size()); } // Reset old thread mask currentThread->setCPUMask (threadMask); // overflow ? if (_ZBufferOverflow) nlwarning ("Error : zbuffer overflow"); // Progress bar progress ("Compute Influences of PointLights", 0.f); // Compute PointLight influences on zone. // Some precalc. compilePointLightRT(description.GridSize, description.GridCellSize, obstacles, description.Shadow); // Influence patchs and get light list of interest std::vector<CPointLightNamed> listPointLight; processZonePointLightRT(listPointLight); // Rebuild the zone // Progress bar progress ("Compress the lightmap", 0.6f); // Build, with list of lights. CZoneInfo zinfo; zinfo.ZoneId= _ZoneToLight; zinfo.Patchs= _PatchInfo; zinfo.BorderVertices= _BorderVertices; zinfo.PointLights= listPointLight; output.build (zinfo); copyTileFlags(output, *(landscape.getZone(zoneToLight))); lightShapes(zoneToLight, description); }

void CZoneLighter::lightShapes (  uint  zoneID, const CLightDesc &  description )  [private]

Launch a set of threads to perform lighting of lightable shapes. compute light for the lightable shapes in the given zone wait for other process Definition at line 2800 of file zone_lighter.cpp. References _LightableShapes, _NumLightableShapesProcessed, _ProcessCount, _ProcessExited, CCalcLightableShapeRunnable, min, NLMISC::nlSleep(), progress(), NLMISC::IThread::start(), and uint. Referenced by light(). { if (_LightableShapes.size() == 0) return; uint numShapePerThread = 1 + (_LightableShapes.size() / _ProcessCount); uint currShapeIndex = 0; uint process = 0; _ProcessExited = 0; _NumLightableShapesProcessed = 0; progress("Processing lightable shapes", 0); for (uint k = 0; k < _LightableShapes.size(); ++k, ++process) { uint lastShapeIndex = currShapeIndex + numShapePerThread; lastShapeIndex = std::min((uint)_LightableShapes.size(), lastShapeIndex); IThread *pThread = IThread::create (new CCalcLightableShapeRunnable(process, this, &description, &_LightableShapes, currShapeIndex, lastShapeIndex)); pThread->start(); currShapeIndex = lastShapeIndex; } while (_ProcessExited != _ProcessCount) { nlSleep (10); } }

void CZoneLighter::lightSingleShape (  CShapeInfo &  si, const CLightDesc &  description, uint  cpu )  [private]

Compute the lighting for a single lightable shape. we compute the lighting for one single shape Definition at line 2852 of file zone_lighter.cpp. References _LightableShapes, _NumLightableShapesProcessed, lightWater(), NL3D::CZoneLighter::CShapeInfo::MT, progress(), NL3D::CZoneLighter::CShapeInfo::Shape, and uint. Referenced by processLightableShapeCalc(). { if (dynamic_cast<CWaterShape *>(si.Shape)) { lightWater(* static_cast<CWaterShape *>(si.Shape), si.MT, description, cpu); } ++_NumLightableShapesProcessed; progress("Processing lightable shapes", (float) _NumLightableShapesProcessed / _LightableShapes.size()); return; }

void CZoneLighter::lightWater (  CWaterShape &  ws, const CMatrix &  MT, const CLightDesc &  description, uint  cpu )  [private]

Compute the lighting for a water shape. get the diffuse map build a matrix to convert from water space to uv space get min and max uvs raytrace each texel now, save the result Definition at line 2927 of file zone_lighter.cpp. References attenuation(), NLMISC::clamp(), NLMISC::COFile::close(), NL3D::ITexture::generate(), NL3D::CWaterShape::getColorMap(), NL3D::CWaterShape::getColorMapMat(), getExt(), NL3D::CTextureFile::getFileName(), NLMISC::CBitmap::getHeight(), NLMISC::CPolygon::getNumVertices(), NLMISC::CBitmap::getPixels(), NL3D::CWaterShape::getShapeInWorldSpace(), getSkyContribution(), NLMISC::CBitmap::getWidth(), height, NLMISC::CMatrix::inverted(), min, NLMISC::CRGBA::modulateFromColor(), NL3D::CZoneLighter::CLightDesc::ModulateWaterColor, nlwarning, NLMISC::COFile::open(), NLMISC::CMatrix::setPos(), NLMISC::CMatrix::setRot(), NL3D::CZoneLighter::CLightDesc::Shadow, sint, NL3D::CZoneLighter::CLightDesc::SkyContributionForWater, NL3D::CZoneLighter::CLightDesc::SkyIntensity, NL3D::CZoneLighter::CLightDesc::SunDirection, uint, uint8, NLMISC::CPolygon::Vertices, NL3D::CZoneLighter::CLightDesc::WaterAmbient, NL3D::CZoneLighter::CLightDesc::WaterDiffuse, NL3D::CZoneLighter::CLightDesc::WaterShadowBias, width, NLMISC::CBitmap::writeTGA(), x, NLMISC::CVector::x, NLMISC::CVector2f::x, y, NLMISC::CVector::y, and NLMISC::CVector2f::y. Referenced by lightSingleShape(). { try { CTextureFile *diffuseTex = NLMISC::safe_cast<CTextureFile *>(ws.getColorMap()); std::string texFileName = CPath::lookup(diffuseTex->getFileName()); diffuseTex->generate(); const uint width = diffuseTex->getWidth(); const uint height = diffuseTex->getHeight(); NLMISC::CMatrix worldSpaceToUVs; NLMISC::CVector2f col0, col1, pos; ws.getColorMapMat(col0, col1, pos); worldSpaceToUVs.setRot(NLMISC::CVector(col0.x * width, col0.y * height, 0), NLMISC::CVector(col1.x * width, col1.y * height, 0), NLMISC::CVector::K); worldSpaceToUVs.setPos(NLMISC::CVector(pos.x * width, pos.y * height, 0)); NLMISC::CPolygon p; ws.getShapeInWorldSpace(p); float minU, maxU; float minV, maxV; NLMISC::CVector uvs = worldSpaceToUVs * p.Vertices[0]; minU = maxU = uvs.x; minV = maxV = uvs.y; for (uint k = 1; k < (uint) p.getNumVertices(); ++k) { uvs = worldSpaceToUVs * p.Vertices[k]; minU = std::min(uvs.x, minU); minV = std::min(uvs.y, minV); maxU = std::max(uvs.x, maxU); maxV = std::max(uvs.y, maxV); } sint iMinU = (sint) minU; sint iMaxU = (sint) maxU; sint iMinV = (sint) minV; sint iMaxV = (sint) maxV; NLMISC::clamp(iMinU, 0, (sint) width); NLMISC::clamp(iMaxU, 0, (sint) width); NLMISC::clamp(iMinV, 0, (sint) height); NLMISC::clamp(iMaxV, 0, (sint) height); // matrix to go from uv space to worldspace NLMISC::CMatrix UVSpaceToWorldSpace = worldSpaceToUVs.inverted(); CObjectVector<uint8> &pixs8 = diffuseTex->getPixels(); NLMISC::CRGBA *rgbPixs = (NLMISC::CRGBA *) &pixs8[0]; for (sint x = iMinU; x < iMaxU; ++x) { for (sint y = iMinV; y < iMaxV; ++y) { float factor; NLMISC::CVector pos = UVSpaceToWorldSpace * NLMISC::CVector( x + 0.5f, y + 0.5f, 0 ) + description.WaterShadowBias * NLMISC::CVector::K; if (description.Shadow) { factor = attenuation (pos, description); } else { factor = - NLMISC::CVector::K * description.SunDirection; } clamp(factor, 0.f, 1.f); factor = factor * description.WaterDiffuse + description.WaterAmbient; if (description.SkyContributionForWater) { factor += getSkyContribution(pos, NLMISC::CVector::K, description.SkyIntensity); } clamp(factor, 0.f, 1.f); uint intensity = (uint8) (255 * factor); NLMISC::CRGBA srcCol(intensity, intensity, intensity, 255); if (!description.ModulateWaterColor) { rgbPixs[x + y * width] = srcCol; } else { NLMISC::CRGBA &col = rgbPixs[x + y * width]; col.modulateFromColor(col, srcCol); } } } if (getExt(texFileName) != ".tga") { nlwarning("Zone lighter : error when lighting a water surface : input bitmap is not a tga file"); } else { try { COFile of; of.open(texFileName); diffuseTex->writeTGA(of, 24); of.close(); } catch (NLMISC::Exception &) { nlwarning("Zone lighter : while lighting a water shape, writing %s failed! ", texFileName.c_str()); } } } catch(NLMISC::Exception &e) { nlwarning("Water shape lighting failed !"); nlwarning(e.what()); } }

void CZoneLighter::makeQuadGridFromWaterShapes (  NLMISC::CAABBox  zoneBBox  )  [private]

Make a quad grid of all the water shapes that where registered by calling addWaterShape() The vector of water shapes is released then Parameters: bbox  the bbox of the zone containing the water shapes Definition at line 3067 of file zone_lighter.cpp. References _WaterShapeQuadGrid, NLMISC::contReset(), count, NL3D::CQuadGrid< T >::create(), NLMISC::CAABBox::getMax(), NLMISC::CAABBox::getMin(), height, NL3D::CQuadGrid< T >::insert(), NLMISC::CAABBox::intersect(), progress(), NLMISC::CAABBox::transformAABBox(), uint, width, NLMISC::CVector::x, and NLMISC::CVector::y. Referenced by buildZoneInformation(). { if (!_WaterShapes.size()) return; NLMISC::CAABBox tmpBox; const uint numCells = 16; float width = zoneBBox.getMax().x - zoneBBox.getMin().x; float height = zoneBBox.getMax().y - zoneBBox.getMin().y; float dim = std::max(width, height); _WaterShapeQuadGrid.create(numCells, dim / numCells); uint count = 0, totalCount = _WaterShapes.size(); for (TShapeVect::iterator it = _WaterShapes.begin(); it != _WaterShapes.end(); ++it, ++count) { it->Shape->getAABBox(tmpBox); NLMISC::CAABBox currBB = NLMISC::CAABBox::transformAABBox(it->MT, tmpBox); if (zoneBBox.intersect(currBB)) { _WaterShapeQuadGrid.insert(currBB.getMin(), currBB.getMax(), NLMISC::safe_cast<CWaterShape *>(it->Shape)); } progress("Building quadtree from water surfaces", (float) count / totalCount); } NLMISC::contReset(_WaterShapes); }

void CZoneLighter::processCalc (  uint  process, const CLightDesc &  description )  [private]

Definition at line 1293 of file zone_lighter.cpp. References _Lumels, _PatchInfo, _ShadowArray, _ZoneToLight, attenuation(), NLMISC::clamp(), getAPatch(), getSkyContribution(), NL3D::CLandscape::getZone(), NL3D::CPatchInfo::Lumels, nlassert, NL3D::CZoneLighter::CLightDesc::Shadow, sint, NL3D::CZoneLighter::CLightDesc::SkyContribution, NL3D::CZoneLighter::CLightDesc::SkyIntensity, NL3D::CZoneLighter::CLightDesc::SunContribution, and uint. { // *** Raytrace each patches // Pointer on the zone CZone *pZone=_Landscape->getZone (_ZoneToLight); // Get a patch uint patch = getAPatch (process); while (patch != 0xffffffff) { // For each patch if (description.Shadow) { // Lumels std::vector<CLumelDescriptor> &lumels=_Lumels[patch]; // Lumel count uint lumelCount=lumels.size(); CPatchInfo &patchInfo=_PatchInfo[patch]; nlassert (patchInfo.Lumels.size()==lumelCount); // Resize shadow array _ShadowArray[patch].resize (lumelCount); // For each lumel for (uint lumel=0; lumel<lumelCount; lumel++) { float factor=0; factor = attenuation (lumels[lumel].Position, description); patchInfo.Lumels[lumel]=(uint)(factor*255); } } else { // Lumels std::vector<CLumelDescriptor> &lumels=_Lumels[patch]; // Lumel count uint lumelCount=lumels.size(); CPatchInfo &patchInfo=_PatchInfo[patch]; nlassert (patchInfo.Lumels.size()==lumelCount); // For each lumel for (uint lumel=0; lumel<lumelCount; lumel++) { // Not shadowed patchInfo.Lumels[lumel]=255; } } // *** Lighting // Get the patch info CPatchInfo &patchInfo=_PatchInfo[patch]; // ** Pointer on arries std::vector<CLumelDescriptor> &lumels=_Lumels[patch]; // Go for light each lumel for (uint lumel=0; lumel<lumels.size(); lumel++) { // Sky contribution float skyContribution; if (description.SkyContribution) { skyContribution = getSkyContribution(lumels[lumel].Position, lumels[lumel].Normal, description.SkyIntensity); } else { skyContribution = 0.f; } // Sun contribution float sunContribution; if (description.SunContribution) { sunContribution=(-lumels[lumel].Normal*_SunDirection)-skyContribution; clamp (sunContribution, 0.f, 1.f); } else sunContribution=0; // Final lighting sint finalLighting=(sint)(255.f*(((float)patchInfo.Lumels[lumel])*sunContribution/255.f+skyContribution)); clamp (finalLighting, 0, 255); patchInfo.Lumels[lumel]=finalLighting; } // Next patch patch = getAPatch (process); } }

void CZoneLighter::processLightableShapeCalc (  uint  process, TShapeVect *  shapeToLit, uint  firstShape, uint  lastShape, const CLightDesc &  description )  [private]

Process lighting for a set of lightable shapes. This is called by the threads created by lightShapes(). Definition at line 2836 of file zone_lighter.cpp. References isLightableShape(), lightSingleShape(), nlassert, TShapeVect, and uint. { // for each lightable shape for (uint k = firstShape; k < lastShape; ++k) { nlassert(isLightableShape(* (*shapesToLit)[k].Shape)); // make sure it is a lightable shape lightSingleShape((*shapesToLit)[k], description, process); } }

void CZoneLighter::processZonePointLightRT (  std::vector< CPointLightNamed > &  listPointLight  )  [private]

Process the zone, ie process _PatchInfo. MultiCPU: not done for now. Be aware of CPointLightRT::RefCount!!!! Definition at line 3346 of file zone_lighter.cpp. References _PatchInfo, _ZoneToLight, NL3D::CQuadGrid< CPointLightRT * >::begin(), NL3D::CZoneLighter::CPointLightRT::BSphere, NLMISC::CBSphere::Center, NLMISC::clamp(), NL3D::CPointLight::computeLinearAttenuation(), NL3D::CPatch::computeVertex(), NL3D::CZoneLighter::CPointLightRT::DstId, NL3D::CQuadGrid< CPointLightRT * >::end(), NL3D::CBezierPatch::evalNormal(), NL3D::CLandscape::getZone(), NL3D::CZoneLighter::CPatchForPL::HeightTLI, NL3D::CTileLightInfluence::Light, NL3D::CZoneLighter::CTileLightInfUnpack::Light, NL3D::CZoneLighter::CTileLightInfUnpack::LightFactor, min, NLMISC::CVector::normalize(), NL3D::CZoneLighter::CPredPointLightToPoint::Point, NL3D::CZoneLighter::CPointLightRT::PointLight, progress(), NL3D::CZoneLighter::CPointLightRT::RefCount, s, NL3D::CQuadGrid< CPointLightRT * >::select(), NL3D::CTileLightInfluence::setDiffuseLightFactor(), t, NL3D::CZoneLighter::CPointLightRT::testRaytrace(), NL3D::CPatchInfo::TileLightInfluences, NL3D::CZoneLighter::CPatchForPL::TileLightInfluences, uint, uint8, NL3D::CPatch::unpackIntoCache(), w, NL3D::CZoneLighter::CPatchForPL::WidthTLI, x, and y. Referenced by light(). { uint i; vector<CPointLightRT*> lightInfs; lightInfs.reserve(1024); // clear result list listPointLight.clear(); // zoneToLight CZone *zoneToLight= _Landscape->getZone(_ZoneToLight); if(!zoneToLight) return; // Build patchForPLs //=========== vector<CPatchForPL> patchForPLs; patchForPLs.resize(_PatchInfo.size()); for(i=0; i<patchForPLs.size(); i++) { // Get OrderS/OrderT patchForPLs[i].OrderS= _PatchInfo[i].OrderS; patchForPLs[i].OrderT= _PatchInfo[i].OrderT; // resize TileLightInfluences uint w= patchForPLs[i].WidthTLI= patchForPLs[i].OrderS/2 +1 ; uint h= patchForPLs[i].HeightTLI= patchForPLs[i].OrderT/2 +1; patchForPLs[i].TileLightInfluences.resize(w*h); } // compute each TileLightInfluence //=========== for(i=0; i<patchForPLs.size(); i++) { // progress progress ("Compute Influences of PointLights", 0.5f + 0.5f*i / (float)patchForPLs.size()); CPatchForPL &pfpl= patchForPLs[i]; const CPatch *patch= const_cast<const CZone*>(zoneToLight)->getPatch(i); uint x, y; for(y= 0; y<pfpl.HeightTLI; y++) { for(x= 0; x<pfpl.WidthTLI; x++) { // compute the point and normal (normalized) where the TLI lies. //--------- CVector pos, normal; float s, t; s= (float)x / (pfpl.WidthTLI-1); t= (float)y / (pfpl.HeightTLI-1); // Compute the Vertex, with Noise information (important for accurate raytracing). pos= patch->computeVertex(s, t); // Use UnNoised normal from BezierPatch, because the lighting does not need to be so precise. CBezierPatch *bp= patch->unpackIntoCache(); normal= bp->evalNormal(s, t); // 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; // a light influence a TLI only if this one is FrontFaced to the light !! if( ( pl->BSphere.Center - pos ) * normal > 0) { // Add 5cm else it fails in some case where ( pl->BSphere.Center - pos ) * normal is // nearly 0 and the point should be occluded. const float deltaY= 0.05f; CVector posToRT= pos + normal * deltaY; // Test if really in the radius of the light, if no occlusion, and if in SpotAngle if( pl->testRaytrace(posToRT) ) { // Ok, add the light to the lights which influence the TLI lightInfs.push_back(pl); } } // next it++; } // Choose the Best ones. //--------- CPredPointLightToPoint predPLTP; predPLTP.Point= pos; // sort. sort(lightInfs.begin(), lightInfs.end(), predPLTP); // truncate. lightInfs.resize( min((uint)lightInfs.size(), (uint)CTileLightInfluence::NumLightPerCorner) ); // For each of them, fill TLI //--------- CTileLightInfUnpack tli; uint lightInfId; for(lightInfId=0; lightInfId<lightInfs.size(); lightInfId++) { CPointLightRT *pl= lightInfs[lightInfId]; // copy light. tli.Light[lightInfId]= pl; // Compute light Diffuse factor. CVector dir= pl->BSphere.Center - pos; dir.normalize(); tli.LightFactor[lightInfId]= dir * normal; clamp(tli.LightFactor[lightInfId], 0.f, 1.f); // modulate by light attenuation. tli.LightFactor[lightInfId]*= pl->PointLight.computeLinearAttenuation(pos); // Inc RefCount of the light. pl->RefCount++; } // Reset any empty slot to NULL. for(; lightInfId<CTileLightInfluence::NumLightPerCorner; lightInfId++) { tli.Light[lightInfId]= NULL; } // Set TLI in patch. //--------- pfpl.TileLightInfluences[y*pfpl.WidthTLI + x]= tli; } } } // compress and setup _PatchInfo 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) { // Must Copy it into Zone. listPointLight.push_back(plRT.PointLight); plRT.DstId= plId++; // If index >= 255, too many lights (NB: => because 255 is a NULL code). if(plId>=0xFF) { throw Exception("Too many Static Point Lights influence the zone!!"); } } } // For each patch, compress TLI in PatchInfo. for(i=0; i<patchForPLs.size(); i++) { CPatchForPL &pfpl= patchForPLs[i]; CPatchInfo &pInfo= _PatchInfo[i]; uint w= pfpl.WidthTLI; uint h= pfpl.HeightTLI; // Fill pInfo.TileLightInfluences pInfo.TileLightInfluences.resize(w*h); uint x, y; for(y= 0; y<h; y++) { for(x= 0; x<w; x++) { uint tliId= y*w + x; // For all light slot for(uint lightId= 0; lightId<CTileLightInfluence::NumLightPerCorner; lightId++) { CTileLightInfUnpack &tliSrc= pfpl.TileLightInfluences[tliId]; CTileLightInfluence &tliDst= pInfo.TileLightInfluences[tliId]; if(tliSrc.Light[lightId] == NULL) { // Mark as unused. tliDst.Light[lightId]= 0xFF; } else { // Get index. tliDst.Light[lightId]= tliSrc.Light[lightId]->DstId; // Get Diffuse Factor. tliDst.setDiffuseLightFactor(lightId, (uint8)(tliSrc.LightFactor[lightId]*255)); } } } } } }

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

Definition at line 342 of file zone_lighter.h. Referenced by buildZoneInformation(), compilePointLightRT(), computeTileFlagsForPositionTowardWater(), light(), lightShapes(), lightSingleShape(), makeQuadGridFromWaterShapes(), and processZonePointLightRT(). {};

void CZoneLighter::setTileFlagsToDefault (  std::vector< const CTessFace * > &  tessFaces  )  [private]

If no water surface overlap the zone, so we set all the flags to 'AboveWater", or don't change them if they were set to 'DisableVegetable' Definition at line 3710 of file zone_lighter.cpp. References _ZoneToLight, NL3D::CTileElement::getVegetableState(), and NL3D::CTileElement::setVegetableState(). Referenced by buildZoneInformation(). { for (std::vector<const CTessFace*>::iterator it = tessFaces.begin(); it != tessFaces.end(); ++it) { if ((*it)->Patch->getZone()->getZoneId() != _ZoneToLight) continue; CTileElement &te = (*it)->Patch->Tiles[(*it)->TileId]; if (te.getVegetableState() != CTileElement::VegetableDisabled) { te.setVegetableState(CTileElement::AboveWater); } } }

---

Friends And Related Function Documentation

friend class CCalcLightableShapeRunnable [friend]

Definition at line 356 of file zone_lighter.h. Referenced by lightShapes().

friend class NL3D::CLightRunnable [friend]

Definition at line 66 of file zone_lighter.h.

friend class NL3D::CRenderZBuffer [friend]

Definition at line 67 of file zone_lighter.h.

---

Field Documentation

std::vector<std::vector<CBezierPatch> > NL3D::CZoneLighter::_BezierPatch [private]

Definition at line 508 of file zone_lighter.h. Referenced by buildZoneInformation(), and getNormal().

std::vector<std::vector<std::vector<bool> > > NL3D::CZoneLighter::_Binded [private]

Definition at line 511 of file zone_lighter.h. Referenced by buildZoneInformation(), and getNormal().

std::vector<std::vector<std::vector<CPatch::CBindInfo> > > NL3D::CZoneLighter::_BindInfo [private]

Definition at line 510 of file zone_lighter.h. Referenced by buildZoneInformation(), and getNormal().

std::map<std::string, NLMISC::CBitmap> NL3D::CZoneLighter::_Bitmaps [private]

Definition at line 474 of file zone_lighter.h. Referenced by getTexture(), and init().

std::vector<CBorderVertex> NL3D::CZoneLighter::_BorderVertices [private]

Definition at line 505 of file zone_lighter.h. Referenced by light().

uint64 NL3D::CZoneLighter::_CPUMask [private]

Definition at line 470 of file zone_lighter.h. Referenced by light().

sint16 CZoneLighter::_GetNormalDeltaS = { -1, 0, 1, 0 } [static, private]

Definition at line 1501 of file zone_lighter.cpp. Referenced by getNormal(), and isLumelOnEdgeMustBeOversample().

sint16 CZoneLighter::_GetNormalDeltaT = { 0, 1, 0, -1 } [static, private]

Definition at line 1502 of file zone_lighter.cpp. Referenced by getNormal(), and isLumelOnEdgeMustBeOversample().

NLMISC::CVector NL3D::CZoneLighter::_GetNormalNormal [private]

Definition at line 517 of file zone_lighter.h. Referenced by buildZoneInformation(), and getNormal().

const NL3D::CPatch* NL3D::CZoneLighter::_GetNormalPatch [private]

Definition at line 516 of file zone_lighter.h.

uint NL3D::CZoneLighter::_GetNormalRadius [private]

Definition at line 518 of file zone_lighter.h.

uint NL3D::CZoneLighter::_GetNormalSqRadius [private]

Definition at line 519 of file zone_lighter.h.

std::vector<float> NL3D::CZoneLighter::_HeightField [private]

Definition at line 494 of file zone_lighter.h.

sint NL3D::CZoneLighter::_HeightFieldCellCount [private]

Definition at line 495 of file zone_lighter.h. Referenced by getMaxPhi(), and light().

float NL3D::CZoneLighter::_HeightfieldCellSize [private]

Definition at line 497 of file zone_lighter.h. Referenced by getMaxPhi(), getSkyContribution(), and light().

NLMISC::CVector NL3D::CZoneLighter::_K[256][8] [private]

Definition at line 524 of file zone_lighter.h.

NL3D::CLandscape* NL3D::CZoneLighter::_Landscape [private]

Definition at line 460 of file zone_lighter.h.

std::vector<uint> NL3D::CZoneLighter::_LastPatchComputed [private]

Definition at line 467 of file zone_lighter.h. Referenced by getAPatch(), and light().

TShapeVect NL3D::CZoneLighter::_LightableShapes [private]

lightable shapes Definition at line 598 of file zone_lighter.h. Referenced by addLightableShape(), lightShapes(), and lightSingleShape().

std::vector<std::vector<std::vector<CPatchUVLocator> > > NL3D::CZoneLighter::_Locator [private]

Definition at line 509 of file zone_lighter.h. Referenced by buildZoneInformation(), and getNormal().

std::vector<std::vector<CLumelDescriptor> > NL3D::CZoneLighter::_Lumels [private]

Definition at line 506 of file zone_lighter.h. Referenced by buildZoneInformation(), and processCalc().

NLMISC::CFastMutex NL3D::CZoneLighter::_Mutex [private]

Definition at line 479 of file zone_lighter.h. Referenced by NL3D::CRenderZBuffer::run().

uint NL3D::CZoneLighter::_NumberOfPatchComputed [private]

Definition at line 468 of file zone_lighter.h. Referenced by getAPatch(), light(), and NL3D::CRenderZBuffer::run().

uint NL3D::CZoneLighter::_NumLightableShapesProcessed [private]

Definition at line 599 of file zone_lighter.h. Referenced by lightShapes(), and lightSingleShape().

NLMISC::CVector NL3D::CZoneLighter::_OrigineHeightField [private]

Definition at line 496 of file zone_lighter.h. Referenced by getSkyContribution(), and light().

std::vector<std::vector<bool> > NL3D::CZoneLighter::_OversampleEdges [private]

Definition at line 512 of file zone_lighter.h. Referenced by buildZoneInformation().

NLMISC::CSynchronized<std::vector<bool> > NL3D::CZoneLighter::_PatchComputed [private]

Definition at line 466 of file zone_lighter.h. Referenced by getAPatch(), and light().

std::vector<CPatchInfo> NL3D::CZoneLighter::_PatchInfo [private]

Definition at line 504 of file zone_lighter.h. Referenced by getAPatch(), light(), processCalc(), and processZonePointLightRT().

uint NL3D::CZoneLighter::_ProcessCount [private]

Definition at line 469 of file zone_lighter.h. Referenced by light(), and lightShapes().

volatile uint NL3D::CZoneLighter::_ProcessExited [private]

Definition at line 471 of file zone_lighter.h. Referenced by light(), lightShapes(), and NL3D::CRenderZBuffer::run().

CQuadGrid<const CTriangle*> NL3D::CZoneLighter::_QuadGrid[ 10 ] [private]

Definition at line 456 of file zone_lighter.h.

NLMISC::CRandom NL3D::CZoneLighter::_Random [private]

Definition at line 491 of file zone_lighter.h. Referenced by attenuation().

NLMISC::CMatrix NL3D::CZoneLighter::_RayBasis [private]

Definition at line 457 of file zone_lighter.h. Referenced by light().

std::vector<std::vector<uint8> > NL3D::CZoneLighter::_ShadowArray [private]

Definition at line 463 of file zone_lighter.h. Referenced by light(), and processCalc().

float NL3D::CZoneLighter::_ShadowBias [private]

Definition at line 461 of file zone_lighter.h.

bool NL3D::CZoneLighter::_Softshadow [private]

Definition at line 462 of file zone_lighter.h.

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

QuadGrid of PointLights. Builded from _StaticPointLights. Definition at line 582 of file zone_lighter.h.

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

List of PointLights. Definition at line 580 of file zone_lighter.h.

NLMISC::CVector NL3D::CZoneLighter::_SunDirection [private]

Definition at line 458 of file zone_lighter.h. Referenced by NL3D::CRenderZBuffer::run().

TWaterShapeQuadGrid NL3D::CZoneLighter::_WaterShapeQuadGrid [private]

Definition at line 607 of file zone_lighter.h. Referenced by computeTileFlagsForPositionTowardWater(), and makeQuadGridFromWaterShapes().

TShapeVect NL3D::CZoneLighter::_WaterShapes [private]

List of all the water shapes in the zone. We need them to check wether the tiles are above / below water, or if theyr intersect water Definition at line 603 of file zone_lighter.h.

std::vector<CZBuffer> NL3D::CZoneLighter::_ZBufferLandscape

Definition at line 483 of file zone_lighter.h. Referenced by attenuation(), light(), and NL3D::CRenderZBuffer::run().

CZBuffer NL3D::CZoneLighter::_ZBufferObject

Definition at line 484 of file zone_lighter.h. Referenced by attenuation(), light(), and NL3D::CRenderZBuffer::run().

bool NL3D::CZoneLighter::_ZBufferOverflow [private]

Definition at line 488 of file zone_lighter.h. Referenced by attenuation(), init(), and light().

std::map<uint, uint> NL3D::CZoneLighter::_ZoneId [private]

Definition at line 513 of file zone_lighter.h. Referenced by buildZoneInformation(), and getNormal().

uint NL3D::CZoneLighter::_ZoneToLight [private]

Definition at line 459 of file zone_lighter.h. Referenced by buildZoneInformation(), computeTileFlagsForPositionTowardWater(), light(), processCalc(), processZonePointLightRT(), and setTileFlagsToDefault().

---

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

• zone_lighter.h
• zone_lighter.cpp

---