NL3D::CLightInfluenceInterpolator Class Reference

#include <light_influence_interpolator.h>


Detailed Description

This class is used by CLandscape and IG/Pacs to compute interpolated influence of lights (biLinear-like) on a square. It works only with CPointLightNamed.
Author:
Lionel Berenguier

Nevrax France

Date:
2001

Definition at line 48 of file light_influence_interpolator.h.

Public Types

enum  { NumLightPerCorner = 2 }
 We support only 2 light per corner. More...


Public Member Functions

 CLightInfluenceInterpolator ()
 Constructor. No-op !!

void interpolate (std::vector< CPointLightInfluence > &pointLightList, float subX, float subY)

Data Fields

CCorner Corners [4]


Member Enumeration Documentation

anonymous enum
 

We support only 2 light per corner.

Enumeration values:
NumLightPerCorner 

Definition at line 53 of file light_influence_interpolator.h.

00053 {NumLightPerCorner= 2};


Constructor & Destructor Documentation

NL3D::CLightInfluenceInterpolator::CLightInfluenceInterpolator  )  [inline]
 

Constructor. No-op !!

Definition at line 77 of file light_influence_interpolator.h.

00077 {}


Member Function Documentation

void NL3D::CLightInfluenceInterpolator::interpolate std::vector< CPointLightInfluence > &  pointLightList,
float  subX,
float  subY
 

solve the biLinear (regrouping multiple influence of light at same id), and add CPointLightInfluence to the list.

Parameters:
subX E [0, 1] is the x coord for biLinear
subY E [0, 1] is the y coord for biLinear

Definition at line 38 of file light_influence_interpolator.cpp.

References NL3D::CPointLightNamed::_IdInInfluenceList, Corners, NL3D::CLightInfluenceInterpolator::CCorner::Influence, NL3D::CLightInfluenceInterpolator::CCorner::Lights, nlassert, NumLightPerCorner, sint, and uint.

Referenced by NL3D::CPatch::appendTileLightInfluences(), and NL3D::CSurfaceLightGrid::getStaticLightSetup().

00039 {
00040         uint    crn;
00041         // UnRolled loops.
00042         nlassert(NumLightPerCorner==2);
00043 
00044         // Reset index for each light.
00045         for(crn= 0; crn<4; crn++)
00046         {
00047                 CCorner         &corner= Corners[crn];
00048                 // UnRolled.
00049                 if(corner.Lights[0])
00050                         corner.Lights[0]->_IdInInfluenceList= -1;
00051                 if(corner.Lights[1])
00052                         corner.Lights[1]->_IdInInfluenceList= -1;
00053         }
00054 
00055         // Compute biLinear influence on each corner
00056         Corners[0].Influence= (1-subX) * (1-subY);
00057         Corners[1].Influence= subX * (1-subY);
00058         Corners[2].Influence= (1-subX) * subY;
00059         Corners[3].Influence= subX * subY;
00060 
00061         // For each light of each corner
00062         for(crn= 0; crn<4; crn++)
00063         {
00064                 CCorner         &corner= Corners[crn];
00065                 // UnRolled.
00066                 // light 0.
00067                 if(corner.Lights[0])
00068                 {
00069                         if(corner.Lights[0]->_IdInInfluenceList==-1)
00070                         {
00071                                 // append a PointLightInfluence
00072                                 pointLightList.push_back(CPointLightInfluence());
00073                                 sint    id= pointLightList.size()-1;
00074                                 // setup the PointLightInfluence
00075                                 corner.Lights[0]->_IdInInfluenceList= id;
00076                                 pointLightList[id].PointLight= corner.Lights[0];
00077                                 pointLightList[id].Influence= corner.Influence;
00078                         }
00079                         else
00080                         {
00081                                 // get the PointLightInfluence
00082                                 sint    id= corner.Lights[0]->_IdInInfluenceList;
00083                                 // increment the influence of the PointLightInfluence
00084                                 pointLightList[id].Influence+= corner.Influence;
00085                         }
00086                 }
00087                 // light 1.
00088                 if(corner.Lights[1])
00089                 {
00090                         if(corner.Lights[1]->_IdInInfluenceList==-1)
00091                         {
00092                                 // append a PointLightInfluence
00093                                 pointLightList.push_back(CPointLightInfluence());
00094                                 sint    id= pointLightList.size()-1;
00095                                 // setup the PointLightInfluence
00096                                 corner.Lights[1]->_IdInInfluenceList= id;
00097                                 pointLightList[id].PointLight= corner.Lights[1];
00098                                 pointLightList[id].Influence= corner.Influence;
00099                         }
00100                         else
00101                         {
00102                                 // get the PointLightInfluence
00103                                 sint    id= corner.Lights[1]->_IdInInfluenceList;
00104                                 // increment the influence of the PointLightInfluence
00105                                 pointLightList[id].Influence+= corner.Influence;
00106                         }
00107                 }
00108         }
00109 }


Field Documentation

CCorner NL3D::CLightInfluenceInterpolator::Corners[4]
 

The User must setup Lights correctly for each corner (ie set NULL for each light not here). Corner order is TL(0,0), TR(1,0), BL(0,1), BR(1,1).

Definition at line 71 of file light_influence_interpolator.h.

Referenced by NL3D::CPatch::appendTileLightInfluences(), NL3D::CSurfaceLightGrid::getStaticLightSetup(), and interpolate().


The documentation for this class was generated from the following files:
Generated on Tue Mar 16 06:49:26 2004 for NeL by doxygen 1.3.6