mirror of
https://port.numenaute.org/aleajactaest/khanat-opennel-code.git
synced 2024-09-24 13:40:34 +00:00
582 lines
18 KiB
C++
582 lines
18 KiB
C++
// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
|
|
// 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 "stdpch.h"
|
|
|
|
|
|
/////////////
|
|
// INCLUDE //
|
|
/////////////
|
|
// 3D Interface
|
|
#include "nel/3d/u_instance.h"
|
|
#include "nel/3d/u_scene.h"
|
|
#include "nel/3d/u_water.h"
|
|
#include "nel/3d/u_landscape.h"
|
|
|
|
// Client.
|
|
#include "light_cycle_manager.h"
|
|
#include "client_cfg.h"
|
|
#include "ig_client.h"
|
|
#include "user_entity.h"
|
|
#include "pacs_client.h"
|
|
#include "world_database_manager.h"
|
|
#include "continent_manager.h"
|
|
#include "continent.h"
|
|
#include "ig_enum.h"
|
|
#include "ig_callback.h"
|
|
#include "pacs_client.h"
|
|
#include "sound_manager.h"
|
|
#include "weather_manager_client.h"
|
|
#include "misc.h"
|
|
#include "interface_v3/interface_manager.h"
|
|
|
|
//#include "sound_manager.h" // \todo GUIGUI : uncomment after new FE done and class modified
|
|
|
|
|
|
H_AUTO_DECL(RZ_LightCycleManager)
|
|
|
|
///////////
|
|
// USING //
|
|
///////////
|
|
using namespace NLMISC;
|
|
using namespace NL3D;
|
|
using namespace NLPACS;
|
|
using namespace std;
|
|
|
|
|
|
////////////
|
|
// EXTERN //
|
|
////////////
|
|
extern UDriver *Driver;
|
|
extern UScene *Scene;
|
|
extern UScene *SceneRoot;
|
|
|
|
extern EGSPD::CSeason::TSeason CurrSeason;
|
|
|
|
|
|
////////////
|
|
// EXTERN //
|
|
////////////
|
|
extern ULandscape *Landscape;
|
|
|
|
static uint diffColors(CRGBA c1, CRGBA c2)
|
|
{
|
|
return (uint) maxof(abs((sint) c1.R - c2.R), abs((sint) c1.G - c2.G), abs((sint) c1.B - c2.B));
|
|
}
|
|
|
|
//-----------------------------------------------
|
|
float CLightCycleDesc::getNightTransitionLength() const
|
|
{
|
|
H_AUTO_USE(RZ_LightCycleManager)
|
|
return NightTransitionEndHour >= NightTransitionStartHour ? NightTransitionEndHour - NightTransitionStartHour
|
|
: NightTransitionEndHour + NumHours - NightTransitionStartHour;
|
|
}
|
|
|
|
//-----------------------------------------------
|
|
float CLightCycleDesc::getDawnTransitionLength() const
|
|
{
|
|
H_AUTO_USE(RZ_LightCycleManager)
|
|
return DawnTransitionEndHour >= DawnTransitionStartHour ? DawnTransitionEndHour - DawnTransitionStartHour
|
|
: DawnTransitionEndHour + NumHours - DawnTransitionStartHour;
|
|
}
|
|
|
|
//-----------------------------------------------
|
|
CLightCycleManager::CLightCycleManager() : _Touched(true),
|
|
_ValidDesc(false),
|
|
_LightLevel(0),
|
|
_WeatherLighting(0),
|
|
_LastWeatherLighting(0),
|
|
_Hour(0),
|
|
_UpdateFreq(0),
|
|
_State(StateUnknown),
|
|
_PrevState(StateUnknown)
|
|
{
|
|
H_AUTO_USE(RZ_LightCycleManager)
|
|
}
|
|
|
|
|
|
//-----------------------------------------------
|
|
void CLightCycleManager::getLandscapeLightColor(NLMISC::CRGBA &diffuse, NLMISC::CRGBA &ambiant)
|
|
{
|
|
H_AUTO_USE(RZ_LightCycleManager)
|
|
nlassert(_LightLevel >= 0 && _LightLevel <= 1.f);
|
|
|
|
if(ContinentMngr.cur())
|
|
{
|
|
switch(_State)
|
|
{
|
|
case DayToNight:
|
|
if (_LightLevel <= _Desc.DuskRatio)
|
|
{
|
|
// day->dusk
|
|
uint level = (uint) (256.f * (_Desc.DuskRatio != 0.f ? _LightLevel / _Desc.DuskRatio : 0.f));
|
|
diffuse.blendFromui(ContinentMngr.cur()->LandscapeLightDay.Diffuse, ContinentMngr.cur()->LandscapeLightDusk.Diffuse, level);
|
|
ambiant.blendFromui(ContinentMngr.cur()->LandscapeLightDay.Ambiant, ContinentMngr.cur()->LandscapeLightDusk.Ambiant, level);
|
|
}
|
|
else
|
|
{
|
|
// dusk->night
|
|
uint level = (uint) (256.f * (_Desc.DuskRatio != 1.f ? (_LightLevel - _Desc.DuskRatio) / (1.f - _Desc.DuskRatio) : 0.f));
|
|
diffuse.blendFromui(ContinentMngr.cur()->LandscapeLightDusk.Diffuse, ContinentMngr.cur()->LandscapeLightNight.Diffuse, level);
|
|
ambiant.blendFromui(ContinentMngr.cur()->LandscapeLightDusk.Ambiant, ContinentMngr.cur()->LandscapeLightNight.Ambiant, level);
|
|
}
|
|
break;
|
|
default:
|
|
uint level = (uint) (256.f * _LightLevel);
|
|
diffuse.blendFromui(ContinentMngr.cur()->LandscapeLightDay.Diffuse, ContinentMngr.cur()->LandscapeLightNight.Diffuse, level);
|
|
ambiant.blendFromui(ContinentMngr.cur()->LandscapeLightDay.Ambiant, ContinentMngr.cur()->LandscapeLightNight.Ambiant, level);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------
|
|
bool CLightCycleManager::setLightDesc(const CLightCycleDesc &desc)
|
|
{
|
|
H_AUTO_USE(RZ_LightCycleManager)
|
|
if (desc.NightTransitionStartHour > desc.NumHours)
|
|
{
|
|
nlwarning ("NightTransitionStartHour (%d) > NumHours (%d)", desc.NightTransitionStartHour, desc.NumHours);
|
|
_State = StateUnknown;
|
|
return false;
|
|
}
|
|
|
|
if (desc.NightTransitionEndHour > desc.NumHours)
|
|
{
|
|
nlwarning ("NightTransitionEndHour (%d) > NumHours (%d)", desc.NightTransitionEndHour, desc.NumHours);
|
|
_State = StateUnknown;
|
|
return false;
|
|
}
|
|
//
|
|
if (desc.DawnTransitionStartHour > desc.NumHours)
|
|
{
|
|
nlwarning ("DawnTransitionStartHour (%d) > NumHours (%d)", desc.DawnTransitionStartHour, desc.NumHours);
|
|
_State = StateUnknown;
|
|
return false;
|
|
}
|
|
if (desc.DawnTransitionEndHour > desc.NumHours)
|
|
{
|
|
nlwarning ("DawnTransitionEndHour (%d) > NumHours (%d)", desc.DawnTransitionEndHour, desc.NumHours);
|
|
_State = StateUnknown;
|
|
return false;
|
|
}
|
|
//
|
|
// test if intervals are not overlapping
|
|
if (!(desc.DawnTransitionStartHour >= desc.NightTransitionEndHour
|
|
|| desc.DawnTransitionEndHour <= desc.NightTransitionStartHour
|
|
)
|
|
)
|
|
{
|
|
nlwarning("!(DawnTransitionStartHour (%d) >= NightTransitionEndHour (%d) || DawnTransitionEndHour (%d) <= NightTransitionStartHour (%d))",
|
|
desc.DawnTransitionStartHour, desc.NightTransitionEndHour, desc.DawnTransitionEndHour, desc.NightTransitionStartHour);
|
|
_State = StateUnknown;
|
|
return false;
|
|
}
|
|
//
|
|
|
|
//
|
|
_Desc = desc;
|
|
_ValidDesc = true;
|
|
_Hour = 0;
|
|
updateState();
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------
|
|
float CLightCycleManager::getUpdateDuration() const
|
|
{
|
|
H_AUTO_USE(RZ_LightCycleManager)
|
|
if (!_ValidDesc || _UpdateFreq == 0.f) return 0.f;
|
|
return (1.f / _UpdateFreq) / _Desc.RealDayLength * _Desc.NumHours;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------
|
|
std::string CLightCycleManager::getStateString() const
|
|
{
|
|
H_AUTO_USE(RZ_LightCycleManager)
|
|
switch(_State)
|
|
{
|
|
case NightToDay: return "night->day";
|
|
case DayToNight: return "day->night";
|
|
case Day: return "day";
|
|
case Night: return "night";
|
|
default:
|
|
return "???";
|
|
}
|
|
return "???";
|
|
}
|
|
|
|
//-----------------------------------------------
|
|
void CLightCycleManager::updateState()
|
|
{
|
|
H_AUTO_USE(RZ_LightCycleManager)
|
|
_PrevState = _State;
|
|
if(isInInterval(_Desc.DawnTransitionStartHour, _Desc.DawnTransitionEndHour, _Hour))
|
|
{
|
|
// night->day
|
|
_State = NightToDay;
|
|
return;
|
|
}
|
|
else if(isInInterval(_Desc.DawnTransitionEndHour, _Desc.NightTransitionStartHour, _Hour))
|
|
{
|
|
// day
|
|
_State = Day;
|
|
return;
|
|
}
|
|
else if(isInInterval(_Desc.NightTransitionStartHour, _Desc.NightTransitionEndHour, _Hour))
|
|
{
|
|
// day->night
|
|
_State = DayToNight;
|
|
return;
|
|
}
|
|
else if(isInInterval(_Desc.NightTransitionEndHour, _Desc.DawnTransitionStartHour, _Hour))
|
|
{
|
|
// night
|
|
if( _PrevState != Night && _PrevState != StateUnknown)
|
|
{
|
|
CInterfaceManager * pIM = CInterfaceManager::getInstance();
|
|
if( pIM )
|
|
{
|
|
pIM->runActionHandler("set",NULL,"dblink=UI:VARIABLES:NIGHT_WARNING_WANTED|value=1");
|
|
}
|
|
}
|
|
_State = Night;
|
|
return;
|
|
}
|
|
_State = StateUnknown;
|
|
return;
|
|
}
|
|
//
|
|
|
|
//-----------------------------------------------
|
|
bool CLightCycleManager::isInTransition() const
|
|
{
|
|
H_AUTO_USE(RZ_LightCycleManager)
|
|
return isInInterval(_Desc.DawnTransitionStartHour, _Desc.DawnTransitionEndHour, _Hour)
|
|
|| isInInterval(_Desc.NightTransitionStartHour, _Desc.DawnTransitionEndHour, _Hour);
|
|
}
|
|
|
|
//-----------------------------------------------
|
|
void CLightCycleManager::setHour(float hour, const CWeatherManagerClient &wm, NLMISC::CRGBA lightningColor)
|
|
{
|
|
H_AUTO_USE(RZ_LightCycleManager)
|
|
if (!_ValidDesc) return;
|
|
if (hour < 0) hour = 0;
|
|
if (hour > _Desc.NumHours)
|
|
{
|
|
hour -= ::floorf(hour / _Desc.NumHours) * _Desc.NumHours;
|
|
}
|
|
float updateDuration = getUpdateDuration();
|
|
if (fabs(_Hour - hour) >= (4.f * updateDuration))
|
|
{
|
|
touch();
|
|
}
|
|
_Hour = hour;
|
|
_LightLevel = getLightLevel(hour);
|
|
clamp(_LightLevel, 0.f, 1.f); // should not be necessary, but we avoid imprecisions
|
|
updateState();
|
|
|
|
_WeatherLighting = wm.getCurrWeatherState().Lighting;
|
|
|
|
// Change water lighting
|
|
NL3D::UWaterHeightMapManager::setBlendFactor(Driver, _LightLevel);
|
|
|
|
if (_PrevState != _State)
|
|
{
|
|
if (_State == Night || _State == Day)
|
|
{
|
|
// a transiation has ended, so release textures used for the blend
|
|
NL3D::UWaterHeightMapManager::releaseBlendTextures();
|
|
}
|
|
}
|
|
|
|
// directionnal lights
|
|
// (override the global light by the light in the weather manager : during bad weather, the scene can be darker)
|
|
setupCanopyLight(_WeatherLighting);
|
|
setupMainLight(_WeatherLighting);
|
|
|
|
// landscape lighting
|
|
CRGBA diffuse, ambiant;
|
|
getLandscapeLightColor(diffuse, ambiant);
|
|
|
|
bool colorTouched = diffuse != _LastDiffuse || ambiant != _LastAmbient;
|
|
if (colorTouched)
|
|
{
|
|
_LastDiffuse = diffuse;
|
|
_LastAmbient = ambiant;
|
|
|
|
// change landscape
|
|
if (Landscape)
|
|
{
|
|
if(ContinentMngr.cur())
|
|
Landscape->setupStaticLight(diffuse, ambiant, ContinentMngr.cur()->StaticLightingFactor[CurrSeason]);
|
|
else
|
|
Landscape->setupStaticLight(diffuse, ambiant, 1.f);
|
|
_UpdateFreq = getLandscapePatchUpdateFreq();
|
|
if (_Touched)
|
|
{
|
|
Landscape->updateLightingAll();
|
|
Landscape->setUpdateLightingFrequency(0);
|
|
}
|
|
else
|
|
{
|
|
Landscape->setUpdateLightingFrequency(_UpdateFreq);
|
|
}
|
|
}
|
|
}
|
|
_Touched = false;
|
|
|
|
// Set the Sun color
|
|
CRGBA color;
|
|
color.add(_LastDiffuse, lightningColor);
|
|
Scene->setLightGroupColor (LightGroupDay, color);
|
|
|
|
// Set the Night color
|
|
float nightLevel = _LightLevel*255.f;
|
|
clamp (nightLevel, 0, 255);
|
|
color.set ((uint8)nightLevel, (uint8)nightLevel, (uint8)nightLevel);
|
|
Scene->setLightGroupColor (LightGroupNight, color);
|
|
|
|
if (Landscape)
|
|
{
|
|
if (!isInInterval(_Desc.DawnTransitionStartHour, _Desc.DawnTransitionEndHour + 4.f * updateDuration, hour)
|
|
&& !isInInterval(_Desc.NightTransitionStartHour, _Desc.NightTransitionEndHour + 4.f * updateDuration, hour)
|
|
)
|
|
{
|
|
Landscape->setUpdateLightingFrequency(0);
|
|
}
|
|
}
|
|
|
|
/* if (SoundMngr)
|
|
{
|
|
float ratio;
|
|
if(isInDayInterval(_Desc.DawnTransitionStartHour, _Desc.DawnTransitionEndHour, _Desc.NumHours, hour, ratio))
|
|
{
|
|
// night->day
|
|
SoundMngr->setDayNightRatio (1.0f-ratio);
|
|
}
|
|
else if(isInDayInterval(_Desc.DawnTransitionEndHour, _Desc.NightTransitionStartHour, _Desc.NumHours, hour, ratio))
|
|
{
|
|
// day
|
|
SoundMngr->setDayNightRatio (0.0f);
|
|
}
|
|
else if(isInDayInterval(_Desc.NightTransitionStartHour, _Desc.NightTransitionEndHour, _Desc.NumHours, hour, ratio))
|
|
{
|
|
// day->night
|
|
SoundMngr->setDayNightRatio (ratio);
|
|
}
|
|
else if(isInDayInterval(_Desc.NightTransitionEndHour, _Desc.DawnTransitionStartHour, _Desc.NumHours, hour, ratio))
|
|
{
|
|
// night
|
|
SoundMngr->setDayNightRatio (1.0f);
|
|
}
|
|
}
|
|
*/
|
|
}
|
|
|
|
|
|
//-----------------------------------------------
|
|
// NB : interval can be reversed
|
|
bool CLightCycleManager::isInInterval(float start, float end, float value)
|
|
{
|
|
H_AUTO_USE(RZ_LightCycleManager)
|
|
return start <= end ? value >= start && value < end
|
|
: value >= start || value < end;
|
|
|
|
}
|
|
|
|
//-----------------------------------------------
|
|
// NB : interval can be reversed
|
|
bool CLightCycleManager::isInDayInterval(float startHour, float endHour, float dayDuration, float hour, float &ratio)
|
|
{
|
|
H_AUTO_USE(RZ_LightCycleManager)
|
|
if (startHour <= endHour)
|
|
{
|
|
if (hour >= startHour && hour < endHour)
|
|
{
|
|
ratio = startHour != endHour ? (hour - startHour) / (endHour - startHour)
|
|
: 0;
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
if (hour >= startHour || hour < endHour)
|
|
{
|
|
ratio = hour >= startHour ? (hour - startHour) / (dayDuration - startHour + endHour)
|
|
: (hour + dayDuration - startHour) / (dayDuration - startHour + endHour);
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------
|
|
float CLightCycleManager::getLightLevel(float hour) const
|
|
{
|
|
H_AUTO_USE(RZ_LightCycleManager)
|
|
float lightValue;
|
|
if (isInDayInterval(_Desc.NightTransitionStartHour, _Desc.NightTransitionEndHour, _Desc.NumHours, hour, lightValue))
|
|
return lightValue;
|
|
if (isInDayInterval(_Desc.DawnTransitionStartHour, _Desc.DawnTransitionEndHour, _Desc.NumHours, hour, lightValue))
|
|
return 1.f - lightValue;
|
|
|
|
// No transition, it is night or day
|
|
if (_Desc.DawnTransitionEndHour <= _Desc.NightTransitionStartHour)
|
|
{
|
|
return hour >= _Desc.DawnTransitionEndHour && hour < _Desc.NightTransitionStartHour ? 0.f : 1.f;
|
|
}
|
|
else
|
|
{
|
|
return hour >= _Desc.DawnTransitionEndHour || hour < _Desc.NightTransitionStartHour ? 0.f : 1.f;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------
|
|
void CLightCycleManager::create()
|
|
{
|
|
H_AUTO_USE(RZ_LightCycleManager)
|
|
Driver->enableLight(0, true);
|
|
}
|
|
|
|
//-----------------------------------------------
|
|
void CLightCycleManager::setDirLight(const CDirLightSetup &setup0, const CDirLightSetup &setup1, float level, float intensity,NL3D::UScene &scene)
|
|
{
|
|
H_AUTO_USE(RZ_LightCycleManager)
|
|
CDirLightSetup resultSetup;
|
|
resultSetup.blend(setup0, setup1, level);
|
|
resultSetup.modulate(intensity);
|
|
//
|
|
scene.setSunAmbient (resultSetup.Ambiant);
|
|
scene.setSunDiffuse (resultSetup.Diffuse);
|
|
scene.setSunSpecular (resultSetup.Specular);
|
|
scene.setSunDirection(resultSetup.Direction);
|
|
}
|
|
|
|
//-----------------------------------------------
|
|
float CLightCycleManager::getLandscapePatchUpdateFreq() const
|
|
{
|
|
H_AUTO_USE(RZ_LightCycleManager)
|
|
if(!_ValidDesc)
|
|
return 0.f;
|
|
|
|
if(ContinentMngr.cur() == 0)
|
|
return 0.f;
|
|
|
|
// transition duration in seconds
|
|
float dt = std::min(_Desc.getDawnTransitionLength(), _Desc.getNightTransitionLength()) * _Desc.RealDayLength / _Desc.NumHours;
|
|
uint numStep = std::max(diffColors(ContinentMngr.cur()->LandscapeLightDay.Diffuse, ContinentMngr.cur()->LandscapeLightNight.Diffuse),
|
|
diffColors(ContinentMngr.cur()->LandscapeLightDay.Ambiant, ContinentMngr.cur()->LandscapeLightNight.Ambiant)
|
|
);
|
|
numStep = std::min(numStep, _Desc.MaxNumColorSteps);
|
|
return (float) numStep / dt;
|
|
}
|
|
|
|
//-----------------------------------------------
|
|
void CLightCycleManager::touch()
|
|
{
|
|
H_AUTO_USE(RZ_LightCycleManager)
|
|
_Touched = true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------
|
|
void CLightCycleManager::instanceGroupAdded(NL3D::UInstanceGroup * /* ig */)
|
|
{
|
|
H_AUTO_USE(RZ_LightCycleManager)
|
|
}
|
|
|
|
|
|
//-----------------------------------------------
|
|
// rootLight :
|
|
// Set the light to render the root.
|
|
//-----------------------------------------------
|
|
void CLightCycleManager::setupCanopyLight(float intensity)
|
|
{
|
|
H_AUTO_USE(RZ_LightCycleManager)
|
|
if(!SceneRoot)
|
|
return;
|
|
|
|
if(ContinentMngr.cur())
|
|
{
|
|
switch (_State)
|
|
{
|
|
case DayToNight: // blend form day to night with dusk transition
|
|
setupDayToNightLight(*SceneRoot, ContinentMngr.cur()->RootLightDay, ContinentMngr.cur()->RootLightDusk, ContinentMngr.cur()->RootLightNight, intensity);
|
|
break;
|
|
default: // blend from night to day with no other transition
|
|
setDirLight(ContinentMngr.cur()->RootLightDay, ContinentMngr.cur()->RootLightNight, _LightLevel, intensity, *SceneRoot);
|
|
break;
|
|
}
|
|
}
|
|
}// setupCanopyLight //
|
|
|
|
//-----------------------------------------------
|
|
// mainLight :
|
|
// Set the light to render the main scene
|
|
//-----------------------------------------------
|
|
void CLightCycleManager::setupMainLight(float intensity)
|
|
{
|
|
H_AUTO_USE(RZ_LightCycleManager)
|
|
if(!Scene)
|
|
return;
|
|
if(ContinentMngr.cur())
|
|
{
|
|
switch (_State)
|
|
{
|
|
case DayToNight: // blend form day to night with dusk transition
|
|
setupDayToNightLight(*Scene, ContinentMngr.cur()->EntityLightDay, ContinentMngr.cur()->EntityLightDusk, ContinentMngr.cur()->EntityLightNight, intensity);
|
|
break;
|
|
default: // blend from night to day with no other transition
|
|
setDirLight(ContinentMngr.cur()->EntityLightDay, ContinentMngr.cur()->EntityLightNight, _LightLevel, intensity, *Scene);
|
|
break;
|
|
}
|
|
}
|
|
}// setupMainLight //
|
|
|
|
//-----------------------------------------------
|
|
void CLightCycleManager::setupDayToNightLight(NL3D::UScene &scene, const CDirLightSetup &dayLight, const CDirLightSetup &duskLight, const CDirLightSetup &nightLight, float lightIntensity)
|
|
{
|
|
H_AUTO_USE(RZ_LightCycleManager)
|
|
float blendFactor;
|
|
if (_LightLevel <= _Desc.DuskRatio)
|
|
{
|
|
blendFactor = _Desc.DuskRatio != 0 ? _LightLevel / _Desc.DuskRatio : 0.f;
|
|
setDirLight(dayLight,
|
|
duskLight,
|
|
blendFactor,
|
|
lightIntensity,
|
|
scene
|
|
);
|
|
}
|
|
else
|
|
{
|
|
blendFactor = _Desc.DuskRatio != 1.f ? (_LightLevel - _Desc.DuskRatio) / (1.f - _Desc.DuskRatio) : 0.f;
|
|
setDirLight(duskLight,
|
|
nightLight,
|
|
blendFactor,
|
|
lightIntensity,
|
|
scene
|
|
);
|
|
}
|
|
}
|