mirror of
https://port.numenaute.org/aleajactaest/khanat-code-old.git
synced 2024-12-15 13:38:42 +00:00
436 lines
12 KiB
C++
436 lines
12 KiB
C++
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
|
|
// Copyright (C) 2010 Winch Gate Property Limited
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as
|
|
// published by the Free Software Foundation, either version 3 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
#include "std3d.h"
|
|
|
|
#include "nel/3d/point_light.h"
|
|
#include "nel/3d/light.h"
|
|
#include "nel/3d/transform.h"
|
|
#include "nel/misc/common.h"
|
|
|
|
using namespace NLMISC;
|
|
using namespace std;
|
|
|
|
namespace NL3D
|
|
{
|
|
|
|
|
|
// ***************************************************************************
|
|
//NLMISC::CBlockMemory<CTransform*, false> CPointLight::_LightedModelListMemory(NL3D_LIGHTED_MODEL_ALLOC_BLOCKSIZE);
|
|
|
|
|
|
// ***************************************************************************
|
|
CPointLight::CPointLight() : _LightedModels(/*&_LightedModelListMemory*/)
|
|
{
|
|
_Position= CVector::Null;
|
|
_Ambient= CRGBA::Black;
|
|
_Diffuse= _Specular= CRGBA::White;
|
|
|
|
// Default setup. this is arbitrary
|
|
_Type= PointLight;
|
|
_AttenuationBegin= 10;
|
|
_AttenuationEnd= 30;
|
|
|
|
// Default spot setup. this is arbitrary
|
|
_SpotDirection.set(0,1,0);
|
|
_SpotAngleBegin= float(NLMISC::Pi/4);
|
|
_SpotAngleEnd= float(NLMISC::Pi/2);
|
|
|
|
// compute AttenuationFactors only one time.
|
|
static bool done= false;
|
|
static float cAtt, lAtt, qAtt;
|
|
static float spotCOOD, spotCAE, spotEXP;
|
|
if(!done)
|
|
{
|
|
done= true;
|
|
computeAttenuationFactors();
|
|
computeSpotAttenuationFactors();
|
|
// bkup setup.
|
|
cAtt= _ConstantAttenuation;
|
|
lAtt= _LinearAttenuation;
|
|
qAtt= _QuadraticAttenuation;
|
|
spotCAE= _CosSpotAngleEnd;
|
|
spotCOOD= _OOCosSpotAngleDelta;
|
|
spotEXP= _SpotExponent;
|
|
}
|
|
else
|
|
{
|
|
// just copy bkuped setup.
|
|
_ConstantAttenuation= cAtt;
|
|
_LinearAttenuation= lAtt;
|
|
_QuadraticAttenuation= qAtt;
|
|
_CosSpotAngleEnd= spotCAE;
|
|
_OOCosSpotAngleDelta= spotCOOD;
|
|
_SpotExponent= spotEXP;
|
|
}
|
|
|
|
_AddAmbientWithSun= false;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
CPointLight::CPointLight(const CPointLight &o) : _LightedModels(/*&_LightedModelListMemory*/)
|
|
{
|
|
// copy (no need to init)
|
|
operator=(o);
|
|
}
|
|
|
|
// ***************************************************************************
|
|
CPointLight &CPointLight::operator=(const CPointLight &o)
|
|
{
|
|
/// copy all but _LightedModels !!
|
|
_Type= o._Type;
|
|
_Position= o._Position;
|
|
_Ambient= o._Ambient;
|
|
_Diffuse= o._Diffuse;
|
|
_Specular= o._Specular;
|
|
|
|
_AttenuationBegin= o._AttenuationBegin;
|
|
_AttenuationEnd= o._AttenuationEnd;
|
|
_OODeltaAttenuation= o._OODeltaAttenuation;
|
|
_ConstantAttenuation= o._ConstantAttenuation;
|
|
_LinearAttenuation= o._LinearAttenuation;
|
|
_QuadraticAttenuation= o._QuadraticAttenuation;
|
|
|
|
_SpotDirection= o._SpotDirection;
|
|
_SpotAngleBegin= o._SpotAngleBegin;
|
|
_SpotAngleEnd= o._SpotAngleEnd;
|
|
_CosSpotAngleEnd= o._CosSpotAngleEnd;
|
|
_OOCosSpotAngleDelta= o._OOCosSpotAngleDelta;
|
|
_SpotExponent= o._SpotExponent;
|
|
|
|
_AddAmbientWithSun= o._AddAmbientWithSun;
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
CPointLight::~CPointLight()
|
|
{
|
|
resetLightedModels();
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CPointLight::setType(TType type)
|
|
{
|
|
_Type= type;
|
|
}
|
|
CPointLight::TType CPointLight::getType() const
|
|
{
|
|
return _Type;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
void CPointLight::setupAttenuation(float attenuationBegin, float attenuationEnd)
|
|
{
|
|
// set values.
|
|
attenuationBegin= max(attenuationBegin, 0.f);
|
|
attenuationEnd= max(attenuationEnd, attenuationBegin);
|
|
_AttenuationBegin= attenuationBegin;
|
|
_AttenuationEnd= attenuationEnd;
|
|
|
|
// update factors.
|
|
computeAttenuationFactors();
|
|
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CPointLight::setupSpotAngle(float spotAngleBegin, float spotAngleEnd)
|
|
{
|
|
clamp(spotAngleBegin, 0.f, float(Pi));
|
|
clamp(spotAngleEnd, spotAngleBegin, float(Pi));
|
|
_SpotAngleBegin= spotAngleBegin;
|
|
_SpotAngleEnd= spotAngleEnd;
|
|
|
|
// update factors.
|
|
computeSpotAttenuationFactors();
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CPointLight::setupSpotDirection(const CVector &dir)
|
|
{
|
|
_SpotDirection= dir;
|
|
_SpotDirection.normalize();
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CPointLight::computeAttenuationFactors()
|
|
{
|
|
// disable attenuation?
|
|
if(_AttenuationBegin==0 && _AttenuationEnd==0)
|
|
{
|
|
// setup for attenuation disabled.
|
|
_ConstantAttenuation= 1;
|
|
_LinearAttenuation= 0;
|
|
_QuadraticAttenuation= 0;
|
|
}
|
|
else
|
|
{
|
|
// precompute attenuation values, with help of CLight formula!!
|
|
CLight dummyLight;
|
|
dummyLight.setupAttenuation(_AttenuationBegin, _AttenuationEnd);
|
|
_ConstantAttenuation= dummyLight.getConstantAttenuation();
|
|
_LinearAttenuation= dummyLight.getLinearAttenuation();
|
|
_QuadraticAttenuation= dummyLight.getQuadraticAttenuation();
|
|
|
|
// setup _OODeltaAttenuation
|
|
_OODeltaAttenuation= _AttenuationEnd - _AttenuationBegin;
|
|
if(_OODeltaAttenuation <=0 )
|
|
_OODeltaAttenuation= 0;
|
|
else
|
|
_OODeltaAttenuation= 1.0f / _OODeltaAttenuation;
|
|
}
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CPointLight::computeSpotAttenuationFactors()
|
|
{
|
|
// Factors for linear Attenuation.
|
|
float cosSpotAngleBegin= (float)cosf(_SpotAngleBegin);
|
|
_CosSpotAngleEnd= (float)cos(_SpotAngleEnd);
|
|
if(cosSpotAngleBegin - _CosSpotAngleEnd > 0)
|
|
_OOCosSpotAngleDelta= 1.0f / (cosSpotAngleBegin - _CosSpotAngleEnd);
|
|
else
|
|
_OOCosSpotAngleDelta= 1e10f;
|
|
|
|
// compute an exponent such that at middleAngle, att is 0.5f.
|
|
float caMiddle= (cosSpotAngleBegin + _CosSpotAngleEnd) /2;
|
|
float divid=(float)log (caMiddle);
|
|
if (divid==0.f)
|
|
divid=0.0001f;
|
|
_SpotExponent= (float)(log (0.5)/divid);
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CPointLight::serial(NLMISC::IStream &f)
|
|
{
|
|
sint ver= f.serialVersion(2);
|
|
|
|
if(ver>=2)
|
|
f.serial(_AddAmbientWithSun);
|
|
else
|
|
_AddAmbientWithSun= false;
|
|
|
|
if(ver>=1)
|
|
{
|
|
f.serialEnum(_Type);
|
|
f.serial(_SpotDirection);
|
|
f.serial(_SpotAngleBegin);
|
|
f.serial(_SpotAngleEnd);
|
|
}
|
|
else if(f.isReading())
|
|
{
|
|
_Type= PointLight;
|
|
_SpotDirection.set(0,1,0);
|
|
_SpotAngleBegin= float(NLMISC::Pi/4);
|
|
_SpotAngleEnd= float(NLMISC::Pi/2);
|
|
}
|
|
|
|
f.serial(_Position);
|
|
f.serial(_Ambient);
|
|
f.serial(_Diffuse);
|
|
f.serial(_Specular);
|
|
f.serial(_AttenuationBegin);
|
|
f.serial(_AttenuationEnd);
|
|
|
|
// precompute.
|
|
if(f.isReading())
|
|
{
|
|
computeAttenuationFactors();
|
|
computeSpotAttenuationFactors();
|
|
}
|
|
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
float CPointLight::computeLinearAttenuation(const CVector &pos) const
|
|
{
|
|
return computeLinearAttenuation(pos, (pos - _Position).norm() );
|
|
}
|
|
|
|
// ***************************************************************************
|
|
float CPointLight::computeLinearAttenuation(const CVector &pos, float dist, float modelRadius) const
|
|
{
|
|
float gAtt;
|
|
|
|
// Attenuation Distance
|
|
if(_AttenuationEnd==0)
|
|
gAtt= 1;
|
|
else
|
|
{
|
|
float distMinusRadius= dist - modelRadius;
|
|
if(distMinusRadius<_AttenuationBegin)
|
|
gAtt= 1;
|
|
else if(distMinusRadius<_AttenuationEnd)
|
|
{
|
|
gAtt= (_AttenuationEnd - distMinusRadius) * _OODeltaAttenuation;
|
|
}
|
|
else
|
|
gAtt= 0;
|
|
}
|
|
|
|
// Spot Attenuation
|
|
if(_Type== SpotLight)
|
|
{
|
|
float spotAtt;
|
|
|
|
// Compute unnormalized direction
|
|
CVector dir= pos - _Position;
|
|
// get cosAngle(dir, SpotDirection):
|
|
float cosAngleDirSpot= (dir*_SpotDirection) / dist;
|
|
|
|
// Modify with modelRadius. NB: made Only for big models.
|
|
if(modelRadius>0)
|
|
{
|
|
// If the pointLight is in the model, consider no spotAtt
|
|
if(modelRadius > dist)
|
|
spotAtt= 1;
|
|
else
|
|
{
|
|
// compute the angle of the cone made by the model sphere and the pointLightCenter.
|
|
float cosAngleSphere= modelRadius / sqrtf( sqr(dist) + sqr(modelRadius) );
|
|
/* If this one is smaller than cosAngleDirSpot, it's mean that the angle of this cone is greater than the
|
|
angleDirSpot, hence a part of the sphere "ps" exist such that _SportDirection*(ps-_Position).normed() == 1
|
|
=> no spotAttenuation
|
|
*/
|
|
if(cosAngleSphere < cosAngleDirSpot)
|
|
spotAtt= 1;
|
|
else
|
|
{
|
|
// Must compute cos( AngleDirSpot-AngleSphere )
|
|
float sinAngleSphere= sqrtf(1 - sqr(cosAngleSphere));
|
|
float sinAngleDirSpot= sqrtf(1 - sqr(cosAngleDirSpot));
|
|
float cosDelta= cosAngleSphere * cosAngleDirSpot + sinAngleSphere * sinAngleDirSpot;
|
|
|
|
// spot attenuation on the exterior of the sphere
|
|
spotAtt= (cosDelta - _CosSpotAngleEnd) * _OOCosSpotAngleDelta;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// spot attenuation
|
|
spotAtt= (cosAngleDirSpot - _CosSpotAngleEnd) * _OOCosSpotAngleDelta;
|
|
}
|
|
|
|
// modulate
|
|
clamp(spotAtt, 0.f, 1.f);
|
|
gAtt*= spotAtt;
|
|
}
|
|
|
|
return gAtt;
|
|
}
|
|
|
|
// ***************************************************************************
|
|
void CPointLight::setupDriverLight(CLight &light, uint8 factor)
|
|
{
|
|
// expand 0..255 to 0..256, to avoid loss of precision.
|
|
uint ufactor= factor + (factor>>7); // add 0 or 1.
|
|
|
|
// modulate with factor
|
|
CRGBA ambient, diffuse, specular;
|
|
ambient.modulateFromuiRGBOnly(_Ambient, ufactor);
|
|
diffuse.modulateFromuiRGBOnly(_Diffuse, ufactor);
|
|
specular.modulateFromuiRGBOnly(_Specular, ufactor);
|
|
|
|
// setup the pointLight
|
|
if(_Type == SpotLight )
|
|
{
|
|
light.setupSpotLight(ambient, diffuse, specular, _Position, _SpotDirection,
|
|
_SpotExponent, float(NLMISC::Pi/2) ,
|
|
_ConstantAttenuation, _LinearAttenuation, _QuadraticAttenuation);
|
|
}
|
|
// PointLight or AmbientLight
|
|
else
|
|
{
|
|
light.setupPointLight(ambient, diffuse, specular, _Position, CVector::Null,
|
|
_ConstantAttenuation, _LinearAttenuation, _QuadraticAttenuation);
|
|
}
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CPointLight::setupDriverLightUserAttenuation(CLight &light, uint8 factor)
|
|
{
|
|
// expand 0..255 to 0..256, to avoid loss of precision.
|
|
uint ufactor= factor + (factor>>7); // add 0 or 1.
|
|
|
|
// modulate with factor
|
|
CRGBA ambient, diffuse, specular;
|
|
ambient.modulateFromuiRGBOnly(_Ambient, ufactor);
|
|
diffuse.modulateFromuiRGBOnly(_Diffuse, ufactor);
|
|
specular.modulateFromuiRGBOnly(_Specular, ufactor);
|
|
|
|
// setup the pointLight, disabling attenuation.
|
|
// NB: setup a pointLight even if it is a SpotLight because already attenuated
|
|
light.setupPointLight(ambient, diffuse, specular, _Position, CVector::Null,
|
|
1, 0, 0);
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
void CPointLight::resetLightedModels()
|
|
{
|
|
// For each transform, resetLighting him.
|
|
while(_LightedModels.begin() != _LightedModels.end() )
|
|
{
|
|
CTransform *model= *_LightedModels.begin();
|
|
// reset lighting
|
|
model->resetLighting();
|
|
|
|
// NB: the transform must erase him from this list.
|
|
nlassert( _LightedModels.begin() == _LightedModels.end() || *_LightedModels.begin() != model );
|
|
}
|
|
}
|
|
|
|
|
|
// ***************************************************************************
|
|
CPointLight::ItTransformList CPointLight::appendLightedModel(CTransform *model)
|
|
{
|
|
// append the entry in the list
|
|
_LightedModels.push_back(model);
|
|
ItTransformList it= _LightedModels.end();
|
|
it--;
|
|
return it;
|
|
}
|
|
// ***************************************************************************
|
|
void CPointLight::removeLightedModel(ItTransformList it)
|
|
{
|
|
// delete the entry in the list.
|
|
_LightedModels.erase(it);
|
|
}
|
|
// ***************************************************************************
|
|
void CPointLight::purge ()
|
|
{
|
|
//_LightedModelListMemory.purge();
|
|
}
|
|
|
|
// ***************************************************************************
|
|
void CPointLight::setAddAmbientWithSun(bool state)
|
|
{
|
|
_AddAmbientWithSun= state;
|
|
}
|
|
|
|
|
|
} // NL3D
|