nel/src/3d/point_light.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2012  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   6 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 #include "std3d.h"
  21
  22 #include "nel/3d/point_light.h"
  23 #include "nel/3d/light.h"
  24 #include "nel/3d/transform.h"
  25 #include "nel/misc/common.h"
  26
  27 using namespace NLMISC;
  28 using namespace std;
  29
  30 #ifdef DEBUG_NEW
  31 #define new DEBUG_NEW
  32 #endif
  33
  34 namespace NL3D
  35 {
  36
  37
  38 // ***************************************************************************
  39 //NLMISC::CBlockMemory<CTransform*, false>              CPointLight::_LightedModelListMemory(NL3D_LIGHTED_MODEL_ALLOC_BLOCKSIZE);
  40
  41
  42 // ***************************************************************************
  43 CPointLight::CPointLight() : _LightedModels(/*&_LightedModelListMemory*/)
  44 {
  45         _Position= CVector::Null;
  46         _Ambient= CRGBA::Black;
  47         _Diffuse= _Specular= CRGBA::White;
  48
  49         // Default setup. this is arbitrary
  50         _Type= PointLight;
  51         _AttenuationBegin= 10;
  52         _AttenuationEnd= 30;
  53
  54         // Default spot setup. this is arbitrary
  55         _SpotDirection.set(0,1,0);
  56         _SpotAngleBegin= float(NLMISC::Pi/4);
  57         _SpotAngleEnd= float(NLMISC::Pi/2);
  58
  59         // compute AttenuationFactors only one time.
  60         static  bool    done= false;
  61         static  float   cAtt, lAtt, qAtt;
  62         static  float   spotCOOD, spotCAE, spotEXP;
  63         if(!done)
  64         {
  65                 done= true;
  66                 computeAttenuationFactors();
  67                 computeSpotAttenuationFactors();
  68                 // bkup setup.
  69                 cAtt= _ConstantAttenuation;
  70                 lAtt= _LinearAttenuation;
  71                 qAtt= _QuadraticAttenuation;
  72                 spotCAE= _CosSpotAngleEnd;
  73                 spotCOOD= _OOCosSpotAngleDelta;
  74                 spotEXP= _SpotExponent;
  75         }
  76         else
  77         {
  78                 // just copy bkuped setup.
  79                 _ConstantAttenuation= cAtt;
  80                 _LinearAttenuation= lAtt;
  81                 _QuadraticAttenuation= qAtt;
  82                 _CosSpotAngleEnd= spotCAE;
  83                 _OOCosSpotAngleDelta= spotCOOD;
  84                 _SpotExponent= spotEXP;
  85         }
  86
  87         _AddAmbientWithSun= false;
  88 }
  89
  90
  91 // ***************************************************************************
  92 CPointLight::CPointLight(const CPointLight &o) : _LightedModels(/*&_LightedModelListMemory*/)
  93 {
  94         // copy (no need to init)
  95         operator=(o);
  96 }
  97
  98 // ***************************************************************************
  99 CPointLight &CPointLight::operator=(const CPointLight &o)
 100 {
 101         /// copy all but _LightedModels !!
 102         _Type= o._Type;
 103         _Position= o._Position;
 104         _Ambient= o._Ambient;
 105         _Diffuse= o._Diffuse;
 106         _Specular= o._Specular;
 107
 108         _AttenuationBegin= o._AttenuationBegin;
 109         _AttenuationEnd= o._AttenuationEnd;
 110         _OODeltaAttenuation= o._OODeltaAttenuation;
 111         _ConstantAttenuation= o._ConstantAttenuation;
 112         _LinearAttenuation= o._LinearAttenuation;
 113         _QuadraticAttenuation= o._QuadraticAttenuation;
 114
 115         _SpotDirection= o._SpotDirection;
 116         _SpotAngleBegin= o._SpotAngleBegin;
 117         _SpotAngleEnd= o._SpotAngleEnd;
 118         _CosSpotAngleEnd= o._CosSpotAngleEnd;
 119         _OOCosSpotAngleDelta= o._OOCosSpotAngleDelta;
 120         _SpotExponent= o._SpotExponent;
 121
 122         _AddAmbientWithSun= o._AddAmbientWithSun;
 123
 124         return *this;
 125 }
 126
 127
 128 // ***************************************************************************
 129 CPointLight::~CPointLight()
 130 {
 131         resetLightedModels();
 132 }
 133
 134
 135 // ***************************************************************************
 136 void                    CPointLight::setType(TType type)
 137 {
 138         _Type= type;
 139 }
 140 CPointLight::TType              CPointLight::getType() const
 141 {
 142         return _Type;
 143 }
 144
 145 // ***************************************************************************
 146 void                    CPointLight::setupAttenuation(float attenuationBegin, float attenuationEnd)
 147 {
 148         // set values.
 149         attenuationBegin= max(attenuationBegin, 0.f);
 150         attenuationEnd= max(attenuationEnd, attenuationBegin);
 151         _AttenuationBegin= attenuationBegin;
 152         _AttenuationEnd= attenuationEnd;
 153
 154         // update factors.
 155         computeAttenuationFactors();
 156
 157 }
 158
 159
 160 // ***************************************************************************
 161 void                    CPointLight::setupSpotAngle(float spotAngleBegin, float spotAngleEnd)
 162 {
 163         clamp(spotAngleBegin, 0.f, float(Pi));
 164         clamp(spotAngleEnd, spotAngleBegin, float(Pi));
 165         _SpotAngleBegin= spotAngleBegin;
 166         _SpotAngleEnd= spotAngleEnd;
 167
 168         // update factors.
 169         computeSpotAttenuationFactors();
 170 }
 171
 172
 173 // ***************************************************************************
 174 void                    CPointLight::setupSpotDirection(const CVector &dir)
 175 {
 176         _SpotDirection= dir;
 177         _SpotDirection.normalize();
 178 }
 179
 180
 181 // ***************************************************************************
 182 void                    CPointLight::computeAttenuationFactors()
 183 {
 184         // disable attenuation?
 185         if(_AttenuationBegin==0 && _AttenuationEnd==0)
 186         {
 187                 // setup for attenuation disabled.
 188                 _ConstantAttenuation= 1;
 189                 _LinearAttenuation= 0;
 190                 _QuadraticAttenuation= 0;
 191         }
 192         else
 193         {
 194                 // precompute attenuation values, with help of CLight formula!!
 195                 CLight  dummyLight;
 196                 dummyLight.setupAttenuation(_AttenuationBegin, _AttenuationEnd);
 197                 _ConstantAttenuation= dummyLight.getConstantAttenuation();
 198                 _LinearAttenuation= dummyLight.getLinearAttenuation();
 199                 _QuadraticAttenuation= dummyLight.getQuadraticAttenuation();
 200
 201                 // setup _OODeltaAttenuation
 202                 _OODeltaAttenuation= _AttenuationEnd - _AttenuationBegin;
 203                 if(_OODeltaAttenuation <=0 )
 204                         _OODeltaAttenuation= 0;
 205                 else
 206                         _OODeltaAttenuation= 1.0f / _OODeltaAttenuation;
 207         }
 208 }
 209
 210
 211 // ***************************************************************************
 212 void                    CPointLight::computeSpotAttenuationFactors()
 213 {
 214         // Factors for linear Attenuation.
 215         float   cosSpotAngleBegin= (float)cosf(_SpotAngleBegin);
 216         _CosSpotAngleEnd= (float)cos(_SpotAngleEnd);
 217         if(cosSpotAngleBegin - _CosSpotAngleEnd > 0)
 218                 _OOCosSpotAngleDelta= 1.0f / (cosSpotAngleBegin - _CosSpotAngleEnd);
 219         else
 220                 _OOCosSpotAngleDelta= 1e10f;
 221
 222         // compute an exponent such that at middleAngle, att is 0.5f.
 223         float   caMiddle= (cosSpotAngleBegin + _CosSpotAngleEnd) /2;
 224         float divid=(float)log (caMiddle);
 225         if (divid==0.f)
 226                 divid=0.0001f;
 227         _SpotExponent= (float)(log (0.5)/divid);
 228 }
 229
 230
 231 // ***************************************************************************
 232 void                    CPointLight::serial(NLMISC::IStream &f)
 233 {
 234         sint    ver= f.serialVersion(2);
 235
 236         if(ver>=2)
 237                 f.serial(_AddAmbientWithSun);
 238         else
 239                 _AddAmbientWithSun= false;
 240
 241         if(ver>=1)
 242         {
 243                 f.serialEnum(_Type);
 244                 f.serial(_SpotDirection);
 245                 f.serial(_SpotAngleBegin);
 246                 f.serial(_SpotAngleEnd);
 247         }
 248         else if(f.isReading())
 249         {
 250                 _Type= PointLight;
 251                 _SpotDirection.set(0,1,0);
 252                 _SpotAngleBegin= float(NLMISC::Pi/4);
 253                 _SpotAngleEnd= float(NLMISC::Pi/2);
 254         }
 255
 256         f.serial(_Position);
 257         f.serial(_Ambient);
 258         f.serial(_Diffuse);
 259         f.serial(_Specular);
 260         f.serial(_AttenuationBegin);
 261         f.serial(_AttenuationEnd);
 262
 263         // precompute.
 264         if(f.isReading())
 265         {
 266                 computeAttenuationFactors();
 267                 computeSpotAttenuationFactors();
 268         }
 269
 270 }
 271
 272
 273 // ***************************************************************************
 274 float                   CPointLight::computeLinearAttenuation(const CVector &pos) const
 275 {
 276         return computeLinearAttenuation(pos, (pos - _Position).norm() );
 277 }
 278
 279 // ***************************************************************************
 280 float                   CPointLight::computeLinearAttenuation(const CVector &pos, float dist, float modelRadius) const
 281 {
 282         float   gAtt;
 283
 284         // Attenuation Distance
 285         if(_AttenuationEnd==0)
 286                 gAtt= 1;
 287         else
 288         {
 289                 float   distMinusRadius= dist - modelRadius;
 290                 if(distMinusRadius<_AttenuationBegin)
 291                         gAtt= 1;
 292                 else if(distMinusRadius<_AttenuationEnd)
 293                 {
 294                         gAtt= (_AttenuationEnd - distMinusRadius) * _OODeltaAttenuation;
 295                 }
 296                 else
 297                         gAtt= 0;
 298         }
 299
 300         // Spot Attenuation
 301         if(_Type== SpotLight)
 302         {
 303                 float   spotAtt;
 304
 305                 // Compute unnormalized direction
 306                 CVector dir= pos - _Position;
 307                 // get cosAngle(dir, SpotDirection):
 308                 float   cosAngleDirSpot= (dir*_SpotDirection) / dist;
 309
 310                 // Modify with modelRadius. NB: made Only for big models.
 311                 if(modelRadius>0)
 312                 {
 313                         // If the pointLight is in the model, consider no spotAtt
 314                         if(modelRadius > dist)
 315                                 spotAtt= 1;
 316                         else
 317                         {
 318                                 // compute the angle of the cone made by the model sphere and the pointLightCenter.
 319                                 float   cosAngleSphere= modelRadius / sqrtf( sqr(dist) + sqr(modelRadius) );
 320                                 /* If this one is smaller than cosAngleDirSpot, it's mean that the angle of this cone is greater than the
 321                                         angleDirSpot, hence a part of the sphere "ps" exist such that _SportDirection*(ps-_Position).normed() == 1
 322                                         => no spotAttenuation
 323                                 */
 324                                 if(cosAngleSphere < cosAngleDirSpot)
 325                                         spotAtt= 1;
 326                                 else
 327                                 {
 328                                         // Must compute cos( AngleDirSpot-AngleSphere )
 329                                         float   sinAngleSphere= sqrtf(1 - sqr(cosAngleSphere));
 330                                         float   sinAngleDirSpot= sqrtf(1 - sqr(cosAngleDirSpot));
 331                                         float   cosDelta= cosAngleSphere * cosAngleDirSpot + sinAngleSphere * sinAngleDirSpot;
 332
 333                                         // spot attenuation on the exterior of the sphere
 334                                         spotAtt= (cosDelta - _CosSpotAngleEnd) * _OOCosSpotAngleDelta;
 335                                 }
 336                         }
 337                 }
 338                 else
 339                 {
 340                         // spot attenuation
 341                         spotAtt= (cosAngleDirSpot - _CosSpotAngleEnd) * _OOCosSpotAngleDelta;
 342                 }
 343
 344                 // modulate
 345                 clamp(spotAtt, 0.f, 1.f);
 346                 gAtt*= spotAtt;
 347         }
 348
 349         return gAtt;
 350 }
 351
 352 // ***************************************************************************
 353 void                    CPointLight::setupDriverLight(CLight &light, uint8 factor)
 354 {
 355         // expand 0..255 to 0..256, to avoid loss of precision.
 356         uint    ufactor= factor + (factor>>7);  // add 0 or 1.
 357
 358         // modulate with factor
 359         CRGBA   ambient, diffuse, specular;
 360         ambient.modulateFromuiRGBOnly(_Ambient, ufactor);
 361         diffuse.modulateFromuiRGBOnly(_Diffuse, ufactor);
 362         specular.modulateFromuiRGBOnly(_Specular, ufactor);
 363
 364         // setup the pointLight
 365         if(_Type == SpotLight )
 366         {
 367                 light.setupSpotLight(ambient, diffuse, specular, _Position, _SpotDirection,
 368                         _SpotExponent, float(NLMISC::Pi/2) ,
 369                         _ConstantAttenuation, _LinearAttenuation, _QuadraticAttenuation);
 370         }
 371         // PointLight or AmbientLight
 372         else
 373         {
 374                 light.setupPointLight(ambient, diffuse, specular, _Position, CVector::Null,
 375                         _ConstantAttenuation, _LinearAttenuation, _QuadraticAttenuation);
 376         }
 377 }
 378
 379
 380 // ***************************************************************************
 381 void                    CPointLight::setupDriverLightUserAttenuation(CLight &light, uint8 factor)
 382 {
 383         // expand 0..255 to 0..256, to avoid loss of precision.
 384         uint    ufactor= factor + (factor>>7);  // add 0 or 1.
 385
 386         // modulate with factor
 387         CRGBA   ambient, diffuse, specular;
 388         ambient.modulateFromuiRGBOnly(_Ambient, ufactor);
 389         diffuse.modulateFromuiRGBOnly(_Diffuse, ufactor);
 390         specular.modulateFromuiRGBOnly(_Specular, ufactor);
 391
 392         // setup the pointLight, disabling attenuation.
 393         // NB: setup a pointLight even if it is a SpotLight because already attenuated
 394         light.setupPointLight(ambient, diffuse, specular, _Position, CVector::Null,
 395                 1, 0, 0);
 396 }
 397
 398
 399 // ***************************************************************************
 400 void                    CPointLight::resetLightedModels()
 401 {
 402         // For each transform, resetLighting him.
 403         while(_LightedModels.begin() != _LightedModels.end() )
 404         {
 405                 CTransform      *model= *_LightedModels.begin();
 406                 // reset lighting
 407                 model->resetLighting();
 408
 409                 // NB: the transform must erase him from this list.
 410                 nlassert( _LightedModels.begin() == _LightedModels.end() || *_LightedModels.begin() != model );
 411         }
 412 }
 413
 414
 415 // ***************************************************************************
 416 CPointLight::ItTransformList    CPointLight::appendLightedModel(CTransform *model)
 417 {
 418         // append the entry in the list
 419         _LightedModels.push_back(model);
 420         ItTransformList it= _LightedModels.end();
 421         it--;
 422         return it;
 423 }
 424 // ***************************************************************************
 425 void                    CPointLight::removeLightedModel(ItTransformList it)
 426 {
 427         // delete the entry in the list.
 428         _LightedModels.erase(it);
 429 }
 430 // ***************************************************************************
 431 void                    CPointLight::purge ()
 432 {
 433         //_LightedModelListMemory.purge();
 434 }
 435
 436 // ***************************************************************************
 437 void                    CPointLight::setAddAmbientWithSun(bool state)
 438 {
 439         _AddAmbientWithSun= state;
 440 }
 441
 442
 443 } // NL3D