731 lines
40 KiB
C++
731 lines
40 KiB
C++
/**
|
|
*
|
|
* Copyright (c) 2009-2020, Kitty Barnett
|
|
*
|
|
* The source code in this file is provided to you under the terms of the
|
|
* GNU Lesser General Public License, version 2.1, but WITHOUT ANY WARRANTY;
|
|
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
|
|
* PARTICULAR PURPOSE. Terms of the LGPL can be found in doc/LGPL-licence.txt
|
|
* in this distribution, or online at http://www.gnu.org/licenses/lgpl-2.1.txt
|
|
*
|
|
* By copying, modifying or distributing this software, you acknowledge that
|
|
* you have read and understood your obligations described above, and agree to
|
|
* abide by those obligations.
|
|
*
|
|
*/
|
|
|
|
#include "llviewerprecompiledheaders.h"
|
|
|
|
#include "llinventoryfunctions.h"
|
|
#include "llsettingsvo.h"
|
|
#include <boost/algorithm/string.hpp>
|
|
|
|
#include "rlvactions.h"
|
|
#include "rlvenvironment.h"
|
|
#include "rlvhelper.h"
|
|
|
|
// ================================================================================================
|
|
// Constants and helper functions
|
|
//
|
|
|
|
namespace
|
|
{
|
|
const F32 SLIDER_SCALE_BLUE_HORIZON_DENSITY(2.0f);
|
|
const F32 SLIDER_SCALE_DENSITY_MULTIPLIER(0.001f);
|
|
const F32 SLIDER_SCALE_GLOW_R(20.0f);
|
|
const F32 SLIDER_SCALE_GLOW_B(-5.0f);
|
|
const F32 SLIDER_SCALE_SUN_AMBIENT(3.0f);
|
|
|
|
const std::string RLV_GETENV_PREFIX = "getenv_";
|
|
const std::string RLV_SETENV_PREFIX = "setenv_";
|
|
|
|
U32 rlvGetColorComponentFromCharacter(char ch)
|
|
{
|
|
if ( ('r' == ch) || ('x' == ch) ) return VRED;
|
|
else if ( ('g' == ch) || ('y' == ch )) return VGREEN;
|
|
else if ( ('b' == ch) || ('d' == ch) ) return VBLUE;
|
|
else if ('i' == ch) return VALPHA;
|
|
return U32_MAX;
|
|
}
|
|
|
|
const LLUUID& rlvGetLibraryEnvironmentsFolder()
|
|
{
|
|
LLInventoryModel::cat_array_t cats;
|
|
LLInventoryModel::item_array_t items;
|
|
LLNameCategoryCollector f("Environments");
|
|
gInventory.collectDescendentsIf(gInventory.getLibraryRootFolderID(), cats, items, LLInventoryModel::EXCLUDE_TRASH, f);
|
|
return (!cats.empty()) ? cats.front()->getUUID() : LLUUID::null;
|
|
}
|
|
|
|
// Legacy WindLight values we need tend to be expressed as a fraction of the [0, 2PI[ domain
|
|
F32 normalize_angle_domain(F32 angle)
|
|
{
|
|
while (angle < 0)
|
|
angle += F_TWO_PI;
|
|
while (angle > F_TWO_PI)
|
|
angle -= F_TWO_PI;
|
|
return angle;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Reasoning (Reference - https://upload.wikimedia.org/wikipedia/commons/thumb/f/f7/Azimuth-Altitude_schematic.svg/1024px-Azimuth-Altitude_schematic.svg.png)
|
|
*
|
|
* Given a(zimuth angle) and e(levation angle) - in the SL axis - we know that it calculates the quaternion as follows:
|
|
*
|
|
* | cos a sin a 0 | | cos e | | cos a x cos e | = | x |
|
|
* | sin a cos a 0 | x | 0 | = | sin a x cos e | = | y | (normalized direction vector identifying the sun position on a unit sphere)
|
|
* | 0 0 1 | | sin e | | sin e | = | z |
|
|
*
|
|
* As a result we can reverse the above by: quaternion -> rotate it around X-axis
|
|
* x = cos a x cos e <=> cos a = x / cos e \
|
|
* | (if we divide them we can get rid of cos e)
|
|
* | <=> sin a / cos a = y / x <=> tan a = y / x <=> a = atan2(y, x)
|
|
* y = sin a x cos e <=> sin a = y / cos e /
|
|
* z = sin e <=> e = asin z
|
|
*
|
|
* If we look at the resulting domain azimuth lies in ]-PI, PI] and elevation lies in [-PI/2, PI/2] which I actually prefer most. Going forward people should get the sun in a wind
|
|
* direction by manipulating the azimuth and then deal with the elevation (which ends up mimicking how a camera or an observer behave in real life).
|
|
*
|
|
* Special cases:
|
|
* x = 0 => (1) cos e = 0 -> sin e = 1 so y = 0 and z = 1 => in (0, 0, 1) we loose all information about the azimuth since cos e = 0
|
|
* OR (2) cos a = 0 -> sin a = 1 so y = cos e and z = sin e => tan e = z/y (with y != 0) => in (0, Y, Z) azimuth is PI/2 (or 3PI/2) and elevation can have an extended domain of ]-PI, PI]
|
|
* => When x = 0 (and y != 0) return PI/2 for azimuth and atan2(z, y) for elevation
|
|
* y = 0 => (1) sin a = 0 -> cos a = 1 so x = cos e and z = sin e => tan e = z/x (with x != 0) => in (X, 0, Z) azimuth is 0 (or PI) and elevation can have an extended domain of ]-PI, PI]
|
|
* OR (2) cos e = 0 -> see above
|
|
=> When y = 0 (and x != 0) return 0 for azimuth and atan2(z, x) for elevation
|
|
* z = 0 => sin e = 0 -> cos e = 1 so x = cos a and y = sin a => tan a = y / x => in (X, Y, 0) elevation is 0 (or PI) and azimuth has its normal domain of ]-PI, PI]
|
|
* => When z = 0 return 0 for elevation and a = atan2(y, x) for azimuth
|
|
*
|
|
* We still need to convert all that back/forth between legacy WindLight's odd choices:
|
|
* east angle = SL's azimuth rotates from E (1, 0, 0) to N (0, 1, 0) to W (-1, 0, 0) to S (0, -1, O) but the legacy east angle rotates the opposite way from E to S to W to N so invert the angle
|
|
* (the resulting number then needs to be positive and reported as a fraction of 2PI)
|
|
* sunposition = sun elevation reported as a fraction of 2PI
|
|
* moonposition = the moon always has sun's azimuth but its negative elevation
|
|
*
|
|
* Pre-EEP both azimuth and elevation have a 2PI range which means that two different a and e value combinations could yield the same sun direction which causes us problems now since we
|
|
* can't differentiate between the two. Pre-EEP likely favoured elevation over azimuth since people might naturally get the time of day they're thinking of and then try to adjust the
|
|
* azimuth to get the sun in the correct wind direction; however I've already decided that we'll favour azimuth going forward (see above).
|
|
*
|
|
* Comparison of pre-EEP and post-EEP legacy values:
|
|
* east angle = 0 (aka azimuth = 0) -> y = 0 so e = atan2(z, x) -> elevation has a range of 2PI so we correctly report pre-EEP values
|
|
* sunmoonpos = 0 (aka elevation = 0) -> z = 0 so a = atan2(y, x) -> azimuth has a range of 2PI so we correctly report pre-EEP values
|
|
* -PI/2 < sunmoonpos < PI/2 -> general case -> post-EEP ranges match pre-EEP ranges so we correctly report pre-EEP values
|
|
* sunmoonpos > PI/2 -> elevation went beyond our new maxium so the post-EEP sunmoonpos will actually be off by PI/2 (or 0.25)
|
|
* (and the resulting east angle is off by PI or 0.5 - for example smp 0.375 and ea 0.875 are equivalent with smp 0.125 and ea 0.375)
|
|
*
|
|
* In reverse this means that when setting values through RLVa:
|
|
* sunmoonpos without eastangle (=0) => always correct
|
|
* eastangle without sunmoonpos (=0) => always correct
|
|
* eastangle before sunmoonpos => always correct
|
|
* sunmoonpos before eastangle => correct for -0.25 <= sunmoonpos <= 0.25
|
|
* incorrect for 0.75 > sunmoonpos > 0.25
|
|
*/
|
|
F32 rlvGetAzimuthFromDirectionVector(const LLVector3& vecDir)
|
|
{
|
|
if (is_zero(vecDir.mV[VY]))
|
|
return 0.f;
|
|
else if (is_zero(vecDir.mV[VX]))
|
|
return F_PI_BY_TWO;
|
|
|
|
F32 radAzimuth = atan2f(vecDir.mV[VY], vecDir.mV[VX]);
|
|
return (radAzimuth >= 0.f) ? radAzimuth : radAzimuth + F_TWO_PI;
|
|
}
|
|
|
|
F32 rlvGetElevationFromDirectionVector(const LLVector3& vecDir)
|
|
{
|
|
if (is_zero(vecDir.mV[VZ]))
|
|
return 0.f;
|
|
|
|
F32 radElevation;
|
|
if ( (is_zero(vecDir.mV[VX])) && (!is_zero(vecDir.mV[VY])) )
|
|
radElevation = atan2f(vecDir.mV[VZ], vecDir.mV[VY]);
|
|
else if ( (!is_zero(vecDir.mV[VX])) && (is_zero(vecDir.mV[VY])) )
|
|
radElevation = atan2f(vecDir.mV[VZ], vecDir.mV[VX]);
|
|
else
|
|
radElevation = asinf(vecDir.mV[VZ]);
|
|
return (radElevation >= 0.f) ? radElevation : radElevation + F_TWO_PI;
|
|
}
|
|
|
|
// Defined in llsettingssky.cpp
|
|
LLQuaternion convert_azimuth_and_altitude_to_quat(F32 azimuth, F32 altitude);
|
|
|
|
// ================================================================================================
|
|
// RlvIsOfSettingsType - Inventory collector for settings of a specific subtype
|
|
//
|
|
|
|
class RlvIsOfSettingsType : public LLInventoryCollectFunctor
|
|
{
|
|
public:
|
|
RlvIsOfSettingsType(LLSettingsType::type_e eSettingsType, const std::string& strNameMatch = LLStringUtil::null)
|
|
: m_eSettingsType(eSettingsType)
|
|
, m_strNameMatch(strNameMatch)
|
|
{
|
|
}
|
|
|
|
~RlvIsOfSettingsType() override
|
|
{
|
|
}
|
|
|
|
bool operator()(LLInventoryCategory*, LLInventoryItem* pItem) override
|
|
{
|
|
if ( (pItem) && (LLAssetType::AT_SETTINGS == pItem->getActualType()) )
|
|
{
|
|
return
|
|
(m_eSettingsType == LLSettingsType::fromInventoryFlags(pItem->getFlags())) &&
|
|
( (m_strNameMatch.empty()) || (boost::iequals(pItem->getName(), m_strNameMatch)) );
|
|
}
|
|
return false;
|
|
}
|
|
|
|
protected:
|
|
LLSettingsType::type_e m_eSettingsType;
|
|
std::string m_strNameMatch;
|
|
};
|
|
|
|
// ================================================================================================
|
|
// RlvEnvironment
|
|
//
|
|
|
|
RlvEnvironment::RlvEnvironment()
|
|
{
|
|
//
|
|
// Presets
|
|
//
|
|
registerSetEnvFn<LLUUID>("asset", [](LLEnvironment::EnvSelection_t env, const LLUUID& idAsset)
|
|
{
|
|
if (idAsset.isNull())
|
|
return RLV_RET_FAILED_OPTION;
|
|
|
|
LLEnvironment::instance().setEnvironment(env, idAsset);
|
|
return RLV_RET_SUCCESS;
|
|
});
|
|
// Deprecated
|
|
auto fnApplyLibraryPreset = [](LLEnvironment::EnvSelection_t env, const std::string& strPreset, LLSettingsType::type_e eSettingsType)
|
|
{
|
|
LLUUID idAsset(strPreset);
|
|
if (idAsset.isNull())
|
|
{
|
|
const LLUUID& idLibraryEnv = rlvGetLibraryEnvironmentsFolder();
|
|
LLInventoryModel::cat_array_t cats;
|
|
LLInventoryModel::item_array_t items;
|
|
RlvIsOfSettingsType f(eSettingsType, strPreset);
|
|
gInventory.collectDescendentsIf(idLibraryEnv, cats, items, LLInventoryModel::EXCLUDE_TRASH, f);
|
|
if (!items.empty())
|
|
idAsset = items.front()->getAssetUUID();
|
|
}
|
|
|
|
if (idAsset.isNull())
|
|
return RLV_RET_FAILED_OPTION;
|
|
|
|
LLEnvironment::instance().setEnvironment(env, idAsset);
|
|
return RLV_RET_SUCCESS;
|
|
};
|
|
registerSetEnvFn<std::string>("preset", [&fnApplyLibraryPreset](LLEnvironment::EnvSelection_t env, const std::string& strPreset) { return fnApplyLibraryPreset(env, strPreset, LLSettingsType::ST_SKY); });
|
|
registerSetEnvFn<std::string>("daycycle", [&fnApplyLibraryPreset](LLEnvironment::EnvSelection_t env, const std::string& strPreset) { return fnApplyLibraryPreset(env, strPreset, LLSettingsType::ST_DAYCYCLE); });
|
|
|
|
//
|
|
// Atmosphere & Lighting tab
|
|
//
|
|
|
|
// SETTING_AMBIENT
|
|
registerSkyFn<LLColor3>("ambient", [](LLSettingsSky::ptr_t pSky) { return pSky->getAmbientColor() * (1.f / SLIDER_SCALE_SUN_AMBIENT); },
|
|
[](LLSettingsSky::ptr_t pSky, const LLColor3& clrValue) { pSky->setAmbientColor(clrValue * SLIDER_SCALE_SUN_AMBIENT); });
|
|
registerLegacySkyFn<LLColor3>("ambient",[](LLSettingsSky::ptr_t pSky) { return pSky->getAmbientColor() * (1.f / SLIDER_SCALE_SUN_AMBIENT); },
|
|
[](LLSettingsSky::ptr_t pSky, const LLColor3& clrValue) { pSky->setAmbientColor(clrValue * SLIDER_SCALE_SUN_AMBIENT); });
|
|
|
|
// SETTING_BLUE_DENSITY
|
|
registerSkyFn<LLColor3>("bluedensity", [](LLSettingsSky::ptr_t pSky) { return pSky->getBlueDensity() * (1.f / SLIDER_SCALE_BLUE_HORIZON_DENSITY); },
|
|
[](LLSettingsSky::ptr_t pSky, const LLColor3& clrValue) { pSky->setBlueDensity(clrValue * SLIDER_SCALE_BLUE_HORIZON_DENSITY); });
|
|
registerLegacySkyFn<LLColor3>("bluedensity",[](LLSettingsSky::ptr_t pSky) { return pSky->getBlueDensity() * (1.f / SLIDER_SCALE_BLUE_HORIZON_DENSITY); },
|
|
[](LLSettingsSky::ptr_t pSky, const LLColor3& clrValue) { pSky->setBlueDensity(clrValue * SLIDER_SCALE_BLUE_HORIZON_DENSITY); });
|
|
|
|
// SETTING_BLUE_HORIZON
|
|
registerSkyFn<LLColor3>("bluehorizon", [](LLSettingsSky::ptr_t pSky) { return pSky->getBlueHorizon() * (1.f / SLIDER_SCALE_BLUE_HORIZON_DENSITY); },
|
|
[](LLSettingsSky::ptr_t pSky, const LLColor3& clrValue) { pSky->setBlueHorizon(clrValue * SLIDER_SCALE_BLUE_HORIZON_DENSITY); });
|
|
registerLegacySkyFn<LLColor3>("bluehorizon",[](LLSettingsSky::ptr_t pSky) { return pSky->getBlueHorizon() * (1.f / SLIDER_SCALE_BLUE_HORIZON_DENSITY); },
|
|
[](LLSettingsSky::ptr_t pSky, const LLColor3& clrValue) { pSky->setBlueHorizon(clrValue * SLIDER_SCALE_BLUE_HORIZON_DENSITY); });
|
|
|
|
// SETTING_DENSITY_MULTIPLIER
|
|
registerSkyFn<F32>("densitymultiplier", [](LLSettingsSky::ptr_t pSky) { return pSky->getDensityMultiplier() / SLIDER_SCALE_DENSITY_MULTIPLIER; },
|
|
[](LLSettingsSky::ptr_t pSky, const F32& nValue) { pSky->setDensityMultiplier(nValue * SLIDER_SCALE_DENSITY_MULTIPLIER); });
|
|
|
|
// SETTING_DISTANCE_MULTIPLIER
|
|
registerSkyFn<F32>("distancemultiplier",[](LLSettingsSky::ptr_t pSky) { return pSky->getDistanceMultiplier(); },
|
|
[](LLSettingsSky::ptr_t pSky, const F32& nValue) { pSky->setDistanceMultiplier(nValue); });
|
|
|
|
|
|
// SETTING_SKY_DROPLET_RADIUS
|
|
registerSkyFn<F32>("dropletradius", [](LLSettingsSky::ptr_t pSky) { return pSky->getSkyDropletRadius(); },
|
|
[](LLSettingsSky::ptr_t pSky, const F32& nValue) { pSky->setSkyDropletRadius(nValue); });
|
|
|
|
// SETTING_HAZE_DENSITY
|
|
registerSkyFn<F32>("hazedensity", [](LLSettingsSky::ptr_t pSky) { return pSky->getHazeDensity(); },
|
|
[](LLSettingsSky::ptr_t pSky, const F32& nValue) { pSky->setHazeDensity(nValue); });
|
|
|
|
// SETTING_HAZE_HORIZON
|
|
registerSkyFn<F32>("hazehorizon", [](LLSettingsSky::ptr_t pSky) { return pSky->getHazeHorizon(); },
|
|
[](LLSettingsSky::ptr_t pSky, const F32& nValue) { pSky->setHazeHorizon(nValue); });
|
|
|
|
// SETTING_SKY_ICE_LEVEL
|
|
registerSkyFn<F32>("icelevel", [](LLSettingsSky::ptr_t pSky) { return pSky->getSkyIceLevel(); },
|
|
[](LLSettingsSky::ptr_t pSky, const F32& nValue) { pSky->setSkyIceLevel(nValue); });
|
|
|
|
// SETTING_MAX_Y
|
|
registerSkyFn<F32>("maxaltitude", [](LLSettingsSky::ptr_t pSky) { return pSky->getMaxY(); },
|
|
[](LLSettingsSky::ptr_t pSky, const F32& nValue) { pSky->setMaxY(nValue); });
|
|
|
|
// SETTING_SKY_MOISTURE_LEVEL
|
|
registerSkyFn<F32>("moisturelevel", [](LLSettingsSky::ptr_t pSky) { return pSky->getSkyMoistureLevel(); },
|
|
[](LLSettingsSky::ptr_t pSky, const F32& nValue) { pSky->setSkyMoistureLevel(nValue); });
|
|
|
|
// SETTING_GAMMA
|
|
registerSkyFn<F32>("scenegamma", [](LLSettingsSky::ptr_t pSky) { return pSky->getGamma(); },
|
|
[](LLSettingsSky::ptr_t pSky, const F32& nValue) { pSky->setGamma(nValue); });
|
|
|
|
//
|
|
// Clouds tab
|
|
//
|
|
|
|
// SETTING_CLOUD_COLOR
|
|
registerSkyFn<LLColor3>("cloudcolor", [](LLSettingsSky::ptr_t pSky) { return pSky->getCloudColor(); },
|
|
[](LLSettingsSky::ptr_t pSky, const LLColor3& clrValue) { pSky->setCloudColor(clrValue); });
|
|
registerLegacySkyFn<LLColor3>("cloudcolor", [](LLSettingsSky::ptr_t pSky) { return pSky->getCloudColor(); },
|
|
[](LLSettingsSky::ptr_t pSky, const LLColor3& clrValue) { pSky->setCloudColor(clrValue); });
|
|
|
|
// SETTING_CLOUD_SHADOW
|
|
registerSkyFn<F32>("cloudcoverage", [](LLSettingsSky::ptr_t pSky) { return pSky->getCloudShadow(); },
|
|
[](LLSettingsSky::ptr_t pSky, const F32& nValue) { pSky->setCloudShadow(nValue); });
|
|
|
|
// SETTING_CLOUD_POS_DENSITY1
|
|
registerSkyFn<LLColor3>("clouddensity", [](LLSettingsSky::ptr_t pSky) { return pSky->getCloudPosDensity1(); },
|
|
[](LLSettingsSky::ptr_t pSky, const LLColor3& clrValue) { pSky->setCloudPosDensity1(clrValue); });
|
|
registerLegacySkyFn<LLColor3>("cloud", [](LLSettingsSky::ptr_t pSky) { return pSky->getCloudPosDensity1(); },
|
|
[](LLSettingsSky::ptr_t pSky, const LLColor3& clrValue) { pSky->setCloudPosDensity1(clrValue); });
|
|
|
|
// SETTING_CLOUD_POS_DENSITY2
|
|
registerSkyFn<LLColor3>("clouddetail", [](LLSettingsSky::ptr_t pSky) { return pSky->getCloudPosDensity2(); },
|
|
[](LLSettingsSky::ptr_t pSky, const LLColor3& clrValue) { pSky->setCloudPosDensity2(clrValue); });
|
|
registerLegacySkyFn<LLColor3>("clouddetail",[](LLSettingsSky::ptr_t pSky) { return pSky->getCloudPosDensity2(); },
|
|
[](LLSettingsSky::ptr_t pSky, const LLColor3& clrValue) { pSky->setCloudPosDensity2(clrValue); });
|
|
|
|
// SETTING_CLOUD_SCALE
|
|
registerSkyFn<F32>("cloudscale", [](LLSettingsSky::ptr_t pSky) { return pSky->getCloudScale(); },
|
|
[](LLSettingsSky::ptr_t pSky, const F32& nValue) { pSky->setCloudScale(nValue); });
|
|
|
|
// SETTING_CLOUD_SCROLL_RATE
|
|
registerSkyFn<LLVector2>("cloudscroll", [](LLSettingsSky::ptr_t pSky) { return pSky->getCloudScrollRate(); },
|
|
[](LLSettingsSky::ptr_t pSky, const LLVector2& vecValue) { pSky->setCloudScrollRate(vecValue); });
|
|
registerLegacySkyFn<LLVector2>("cloudscroll", [](LLSettingsSky::ptr_t pSky) { return pSky->getCloudScrollRate(); },
|
|
[](LLSettingsSky::ptr_t pSky, const LLVector2& vecValue) { pSky->setCloudScrollRate(vecValue); });
|
|
|
|
// SETTING_CLOUD_TEXTUREID
|
|
registerSkyFn<LLUUID>("cloudtexture", [](LLSettingsSky::ptr_t pSky) { return pSky->getCloudNoiseTextureId(); },
|
|
[](LLSettingsSky::ptr_t pSky, const LLUUID& idTexture) { pSky->setCloudNoiseTextureId(idTexture); });
|
|
|
|
// SETTING_CLOUD_VARIANCE
|
|
registerSkyFn<F32>("cloudvariance", [](LLSettingsSky::ptr_t pSky) { return pSky->getCloudVariance(); },
|
|
[](LLSettingsSky::ptr_t pSky, const F32& nValue) { pSky->setCloudVariance(nValue); });
|
|
|
|
//
|
|
// Sun & Moon
|
|
//
|
|
|
|
// SETTING_MOON_BRIGHTNESS
|
|
registerSkyFn<F32>("moonbrightness", [](LLSettingsSky::ptr_t pSky) { return pSky->getMoonBrightness(); },
|
|
[](LLSettingsSky::ptr_t pSky, const F32& nValue) { pSky->setMoonBrightness(nValue); });
|
|
|
|
// SETTING_MOON_SCALE
|
|
registerSkyFn<F32>("moonscale", [](LLSettingsSky::ptr_t pSky) { return pSky->getMoonScale(); },
|
|
[](LLSettingsSky::ptr_t pSky, const F32& nValue) { pSky->setMoonScale(nValue); });
|
|
|
|
// SETTING_MOON_TEXTUREID
|
|
registerSkyFn<LLUUID>("moontexture", [](LLSettingsSky::ptr_t pSky) { return pSky->getMoonTextureId(); },
|
|
[](LLSettingsSky::ptr_t pSky, const LLUUID& idTexture) { pSky->setMoonTextureId(idTexture); });
|
|
|
|
// SETTING_GLOW
|
|
registerSkyFn<float>("sunglowsize", [](LLSettingsSky::ptr_t pSky) { return 2.0f - (pSky->getGlow().mV[VRED] / SLIDER_SCALE_GLOW_R); },
|
|
[](LLSettingsSky::ptr_t pSky, const F32& nValue) { pSky->setGlow(LLColor3((2.0f - nValue) * SLIDER_SCALE_GLOW_R, .0f, pSky->getGlow().mV[VBLUE])); });
|
|
registerSkyFn<float>("sunglowfocus", [](LLSettingsSky::ptr_t pSky) { return pSky->getGlow().mV[VBLUE] / SLIDER_SCALE_GLOW_B; },
|
|
[](LLSettingsSky::ptr_t pSky, const F32& nValue) { pSky->setGlow(LLColor3(pSky->getGlow().mV[VRED], .0f, nValue * SLIDER_SCALE_GLOW_B)); });
|
|
|
|
// SETTING_SUNLIGHT_COLOR
|
|
registerSkyFn<LLColor3>("sunlightcolor",[](LLSettingsSky::ptr_t pSky) { return pSky->getSunlightColor() * (1.f / SLIDER_SCALE_SUN_AMBIENT); },
|
|
[](LLSettingsSky::ptr_t pSky, const LLColor3& clrValue) { pSky->setSunlightColor(clrValue * SLIDER_SCALE_SUN_AMBIENT); });
|
|
registerLegacySkyFn<LLColor3>("sunmooncolor", [](LLSettingsSky::ptr_t pSky) { return pSky->getSunlightColor() * (1.f / SLIDER_SCALE_SUN_AMBIENT); },
|
|
[](LLSettingsSky::ptr_t pSky, const LLColor3& clrValue) { pSky->setSunlightColor(clrValue * SLIDER_SCALE_SUN_AMBIENT); });
|
|
|
|
// SETTING_SUN_SCALE
|
|
registerSkyFn<float>("sunscale", [](LLSettingsSky::ptr_t pSky) { return pSky->getSunScale(); },
|
|
[](LLSettingsSky::ptr_t pSky, F32 nValue) { pSky->setSunScale(nValue); });
|
|
|
|
// SETTING_SUN_TEXTUREID
|
|
registerSkyFn<LLUUID>("suntexture", [](LLSettingsSky::ptr_t pSky) { return pSky->getSunTextureId(); },
|
|
[](LLSettingsSky::ptr_t pSky, const LLUUID& idTexture) { pSky->setSunTextureId(idTexture); });
|
|
|
|
// SETTING_STAR_BRIGHTNESS
|
|
registerSkyFn<F32>("starbrightness", [](LLSettingsSky::ptr_t pSky) { return pSky->getStarBrightness(); },
|
|
[](LLSettingsSky::ptr_t pSky, const F32& nValue) { pSky->setStarBrightness(nValue); });
|
|
|
|
// SETTING_SUN_ROTATION
|
|
registerSkyFn<F32>("sunazimuth", [](LLSettingsSky::ptr_t pSky) { return rlvGetAzimuthFromDirectionVector(LLVector3::x_axis * pSky->getSunRotation()); },
|
|
[](LLSettingsSky::ptr_t pSky, const F32& radAzimuth) {
|
|
pSky->setSunRotation(convert_azimuth_and_altitude_to_quat(radAzimuth, rlvGetElevationFromDirectionVector(LLVector3::x_axis* pSky->getSunRotation())));
|
|
});
|
|
registerSkyFn<F32>("sunelevation", [](LLSettingsSky::ptr_t pSky) { return rlvGetElevationFromDirectionVector(LLVector3::x_axis * pSky->getSunRotation()); },
|
|
[](LLSettingsSky::ptr_t pSky, F32 radElevation) {
|
|
radElevation = llclamp(radElevation, -F_PI_BY_TWO, F_PI_BY_TWO);
|
|
pSky->setSunRotation(convert_azimuth_and_altitude_to_quat(rlvGetAzimuthFromDirectionVector(LLVector3::x_axis* pSky->getSunRotation()), radElevation));
|
|
});
|
|
|
|
// SETTING_MOON_ROTATION
|
|
registerSkyFn<F32>("moonazimuth", [](LLSettingsSky::ptr_t pSky) { return rlvGetAzimuthFromDirectionVector(LLVector3::x_axis * pSky->getMoonRotation()); },
|
|
[](LLSettingsSky::ptr_t pSky, const F32& radAzimuth) {
|
|
pSky->setMoonRotation(convert_azimuth_and_altitude_to_quat(radAzimuth, rlvGetElevationFromDirectionVector(LLVector3::x_axis* pSky->getMoonRotation())));
|
|
});
|
|
registerSkyFn<F32>("moonelevation", [](LLSettingsSky::ptr_t pSky) { return rlvGetElevationFromDirectionVector(LLVector3::x_axis * pSky->getMoonRotation()); },
|
|
[](LLSettingsSky::ptr_t pSky, F32 radElevation) {
|
|
radElevation = llclamp(radElevation, -F_PI_BY_TWO, F_PI_BY_TWO);
|
|
pSky->setMoonRotation(convert_azimuth_and_altitude_to_quat(rlvGetAzimuthFromDirectionVector(LLVector3::x_axis* pSky->getMoonRotation()), radElevation));
|
|
});
|
|
|
|
// Legacy WindLight support (see remarks at the top of this file)
|
|
registerSkyFn<F32>("eastangle", [](LLSettingsSky::ptr_t pSky) { return normalize_angle_domain(-rlvGetAzimuthFromDirectionVector(LLVector3::x_axis * pSky->getSunRotation())) / F_TWO_PI; },
|
|
[](LLSettingsSky::ptr_t pSky, const F32& radEastAngle)
|
|
{
|
|
const F32 radAzimuth = -radEastAngle * F_TWO_PI;
|
|
const F32 radElevation = rlvGetElevationFromDirectionVector(LLVector3::x_axis * pSky->getSunRotation());
|
|
pSky->setSunRotation(convert_azimuth_and_altitude_to_quat(radAzimuth, radElevation));
|
|
pSky->setMoonRotation(convert_azimuth_and_altitude_to_quat(radAzimuth + F_PI, -radElevation));
|
|
});
|
|
|
|
registerSkyFn<F32>("sunmoonposition", [](LLSettingsSky::ptr_t pSky) { return rlvGetElevationFromDirectionVector(LLVector3::x_axis * pSky->getSunRotation()) / F_TWO_PI; },
|
|
[](LLSettingsSky::ptr_t pSky, const F32& nValue)
|
|
{
|
|
const F32 radAzimuth = rlvGetAzimuthFromDirectionVector(LLVector3::x_axis * pSky->getSunRotation());
|
|
const F32 radElevation = nValue * F_TWO_PI;
|
|
pSky->setSunRotation(convert_azimuth_and_altitude_to_quat(radAzimuth, radElevation));
|
|
pSky->setMoonRotation(convert_azimuth_and_altitude_to_quat(radAzimuth + F_PI, -radElevation));
|
|
});
|
|
|
|
// Create a fixed sky from the nearest daycycle (local > experience > parcel > region)
|
|
registerSetEnvFn<F32>("daytime", [](LLEnvironment::EnvSelection_t env, const F32& nValue)
|
|
{
|
|
if ((nValue >= 0.f) && (nValue <= 1.0f))
|
|
{
|
|
LLSettingsDay::ptr_t pDay;
|
|
if (LLEnvironment::ENV_EDIT != env)
|
|
{
|
|
LLEnvironment::EnvSelection_t envs[] = { LLEnvironment::ENV_LOCAL, LLEnvironment::ENV_PUSH, LLEnvironment::ENV_PARCEL, LLEnvironment::ENV_REGION };
|
|
for (size_t idxEnv = 0, cntEnv = sizeof(envs) / sizeof(LLEnvironment::EnvSelection_t); idxEnv < cntEnv && !pDay; idxEnv++)
|
|
pDay = LLEnvironment::instance().getEnvironmentDay(envs[idxEnv]);
|
|
}
|
|
else
|
|
{
|
|
pDay = LLEnvironment::instance().getEnvironmentDay(LLEnvironment::ENV_EDIT);
|
|
}
|
|
|
|
if (pDay)
|
|
{
|
|
auto pNewSky = LLSettingsVOSky::buildDefaultSky();
|
|
auto pSkyBlender = std::make_shared<LLTrackBlenderLoopingManual>(pNewSky, pDay, 1);
|
|
pSkyBlender->setPosition(nValue);
|
|
|
|
LLEnvironment::instance().setEnvironment(env, pNewSky);
|
|
LLEnvironment::instance().updateEnvironment(LLEnvironment::TRANSITION_INSTANT);
|
|
}
|
|
}
|
|
else if (nValue == -1)
|
|
{
|
|
LLEnvironment::instance().clearEnvironment(env);
|
|
LLEnvironment::instance().setSelectedEnvironment(env);
|
|
LLEnvironment::instance().updateEnvironment();
|
|
// defocusEnvFloaters();
|
|
}
|
|
else
|
|
{
|
|
return RLV_RET_FAILED_OPTION;
|
|
}
|
|
|
|
return RLV_RET_SUCCESS;
|
|
});
|
|
registerGetEnvFn("daytime", [](LLEnvironment::EnvSelection_t env)
|
|
{
|
|
// I forgot how much I hate this command... it literally makes no sense since time of day only has any meaning in an
|
|
// actively animating day cycle (but in that case we have to return -1).
|
|
if (!LLEnvironment::instance().getEnvironmentFixedSky(env)) {
|
|
return std::to_string(-1.f);
|
|
}
|
|
|
|
// It's invalid input for @setenv_daytime (see above) so it can be fed in without changing the current environment
|
|
return std::to_string(2.f);
|
|
});
|
|
}
|
|
|
|
RlvEnvironment::~RlvEnvironment()
|
|
{
|
|
}
|
|
|
|
// static
|
|
LLEnvironment::EnvSelection_t RlvEnvironment::getTargetEnvironment()
|
|
{
|
|
return RlvActions::canChangeEnvironment() ? LLEnvironment::ENV_LOCAL : LLEnvironment::ENV_EDIT;
|
|
}
|
|
|
|
// static
|
|
LLSettingsSky::ptr_t RlvEnvironment::getTargetSky(bool forSetCmd)
|
|
{
|
|
LLEnvironment* pEnv = LLEnvironment::getInstance();
|
|
|
|
if (forSetCmd)
|
|
{
|
|
LLEnvironment::EnvSelection_t targetEnv = getTargetEnvironment();
|
|
bool isSharedEnv = !pEnv->getEnvironmentFixedSky(targetEnv),
|
|
hasLocalDayCycle = !isSharedEnv && pEnv->getEnvironmentDay(targetEnv),
|
|
isLocalTransition = !hasLocalDayCycle && pEnv->getCurrentEnvironmentInstance()->isTransition();
|
|
if ( (isSharedEnv) || (hasLocalDayCycle) || (isLocalTransition) )
|
|
{
|
|
LLSettingsSky::ptr_t pSky = (isSharedEnv) ? pEnv->getEnvironmentFixedSky(LLEnvironment::ENV_PARCEL, true)->buildClone()
|
|
: (hasLocalDayCycle) ? pEnv->getEnvironmentFixedSky(targetEnv)->buildClone()
|
|
: pEnv->getEnvironmentFixedSky(targetEnv);
|
|
pEnv->setEnvironment(targetEnv, pSky);
|
|
pEnv->setSelectedEnvironment(targetEnv, LLEnvironment::TRANSITION_INSTANT);
|
|
pEnv->updateEnvironment(LLEnvironment::TRANSITION_INSTANT);
|
|
}
|
|
}
|
|
|
|
return pEnv->getCurrentSky();
|
|
}
|
|
|
|
|
|
// static
|
|
bool RlvEnvironment::onHandleCommand(const RlvCommand& rlvCmd, ERlvCmdRet& cmdRet, const std::string& strCmdPrefix, const handler_map_t& fnLookup, const legacy_handler_map_t& legacyFnLookup)
|
|
{
|
|
if ( (rlvCmd.getBehaviour().length() > strCmdPrefix.length() + 2) && (boost::starts_with(rlvCmd.getBehaviour(), strCmdPrefix)) )
|
|
{
|
|
if ( (RLV_TYPE_FORCE == rlvCmd.getParamType()) && (!RlvActions::canChangeEnvironment(rlvCmd.getObjectID())) )
|
|
{
|
|
cmdRet = RLV_RET_FAILED_LOCK;
|
|
return true;
|
|
}
|
|
|
|
std::string strEnvCommand = rlvCmd.getBehaviour().substr(strCmdPrefix.length());
|
|
|
|
handler_map_t::const_iterator itFnEntry = fnLookup.find(strEnvCommand);
|
|
if (fnLookup.end() != itFnEntry)
|
|
{
|
|
cmdRet = itFnEntry->second((RLV_TYPE_FORCE == rlvCmd.getParamType()) ? rlvCmd.getOption() : rlvCmd.getParam());
|
|
return true;
|
|
}
|
|
|
|
// Legacy handling (blargh)
|
|
U32 idxComponent = rlvGetColorComponentFromCharacter(strEnvCommand.back());
|
|
if (idxComponent <= VALPHA)
|
|
{
|
|
strEnvCommand.pop_back();
|
|
|
|
legacy_handler_map_t::const_iterator itLegacyFnEntry = legacyFnLookup.find(strEnvCommand);
|
|
if (legacyFnLookup.end() != itLegacyFnEntry)
|
|
{
|
|
cmdRet = itLegacyFnEntry->second((RLV_TYPE_FORCE == rlvCmd.getParamType()) ? rlvCmd.getOption() : rlvCmd.getParam(), idxComponent);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool RlvEnvironment::onReplyCommand(const RlvCommand& rlvCmd, ERlvCmdRet& cmdRet)
|
|
{
|
|
return onHandleCommand(rlvCmd, cmdRet, RLV_GETENV_PREFIX, m_GetFnLookup, m_LegacyGetFnLookup);
|
|
}
|
|
|
|
bool RlvEnvironment::onForceCommand(const RlvCommand& rlvCmd, ERlvCmdRet& cmdRet)
|
|
{
|
|
return onHandleCommand(rlvCmd, cmdRet, RLV_SETENV_PREFIX, m_SetFnLookup, m_LegacySetFnLookup);
|
|
}
|
|
|
|
template<>
|
|
std::string RlvEnvironment::handleGetFn<float>(const std::function<float(LLSettingsSky::ptr_t)>& fn)
|
|
{
|
|
LLSettingsSky::ptr_t pSky = getTargetSky();
|
|
return std::to_string(fn(pSky));
|
|
}
|
|
|
|
template<>
|
|
std::string RlvEnvironment::handleGetFn<LLUUID>(const std::function<LLUUID(LLSettingsSky::ptr_t)>& fn)
|
|
{
|
|
LLSettingsSky::ptr_t pSky = getTargetSky();
|
|
return fn(pSky).asString();
|
|
}
|
|
|
|
template<>
|
|
std::string RlvEnvironment::handleGetFn<LLVector2>(const std::function<LLVector2(LLSettingsSky::ptr_t)>& fn)
|
|
{
|
|
LLSettingsSky::ptr_t pSky = getTargetSky();
|
|
LLVector2 replyVec = fn(pSky);
|
|
return llformat("%f/%f", replyVec.mV[VX], replyVec.mV[VY]);
|
|
}
|
|
|
|
template<>
|
|
std::string RlvEnvironment::handleGetFn<LLColor3>(const std::function<LLColor3(LLSettingsSky::ptr_t)>& fn)
|
|
{
|
|
LLSettingsSky::ptr_t pSky = getTargetSky();
|
|
LLColor3 replyColor = fn(pSky);
|
|
return llformat("%f/%f/%f", replyColor.mV[VX], replyColor.mV[VY], replyColor.mV[VZ]);
|
|
}
|
|
|
|
template<typename T>
|
|
ERlvCmdRet RlvEnvironment::handleSetFn(const std::string& strRlvOption, const std::function<void(LLSettingsSky::ptr_t, const T&)>& fn)
|
|
{
|
|
T optionValue;
|
|
if (!RlvCommandOptionHelper::parseOption<T>(strRlvOption, optionValue))
|
|
return RLV_RET_FAILED_PARAM;
|
|
|
|
LLSettingsSky::ptr_t pSky = getTargetSky(true);
|
|
fn(pSky, optionValue);
|
|
pSky->update();
|
|
return RLV_RET_SUCCESS;
|
|
}
|
|
|
|
template<>
|
|
std::string RlvEnvironment::handleLegacyGetFn<LLVector2>(const std::function<const LLVector2 (LLSettingsSkyPtr_t)>& getFn, U32 idxComponent)
|
|
{
|
|
if (idxComponent >= 2)
|
|
return LLStringUtil::null;
|
|
return std::to_string(getFn(getTargetSky()).mV[idxComponent]);
|
|
}
|
|
|
|
template<>
|
|
std::string RlvEnvironment::handleLegacyGetFn<LLColor3>(const std::function<const LLColor3 (LLSettingsSkyPtr_t)>& getFn, U32 idxComponent)
|
|
{
|
|
if ( (idxComponent >= VRED) && (idxComponent <= VBLUE) )
|
|
{
|
|
return std::to_string(getFn(getTargetSky()).mV[idxComponent]);
|
|
}
|
|
else if (idxComponent == VALPHA)
|
|
{
|
|
const LLColor3& clr = getFn(getTargetSky());
|
|
return std::to_string(llmax(clr.mV[VRED], clr.mV[VGREEN], clr.mV[VBLUE]));
|
|
}
|
|
return LLStringUtil::null;
|
|
}
|
|
|
|
template<>
|
|
ERlvCmdRet RlvEnvironment::handleLegacySetFn<LLVector2>(float optionValue, LLVector2 curValue, const std::function<void(LLSettingsSkyPtr_t, const LLVector2&)>& setFn, U32 idxComponent)
|
|
{
|
|
if (idxComponent >= 2)
|
|
return RLV_RET_FAILED_UNKNOWN;
|
|
|
|
LLSettingsSky::ptr_t pSky = getTargetSky(true);
|
|
curValue.mV[idxComponent] = optionValue;
|
|
setFn(pSky, curValue);
|
|
pSky->update();
|
|
|
|
return RLV_RET_SUCCESS;
|
|
}
|
|
|
|
template<>
|
|
ERlvCmdRet RlvEnvironment::handleLegacySetFn<LLColor3>(float optionValue, LLColor3 curValue, const std::function<void(LLSettingsSkyPtr_t, const LLColor3&)>& setFn, U32 idxComponent)
|
|
{
|
|
LLSettingsSky::ptr_t pSky = getTargetSky(true);
|
|
if ( (idxComponent >= VRED) && (idxComponent <= VBLUE) )
|
|
{
|
|
curValue.mV[idxComponent] = optionValue;
|
|
}
|
|
else if (idxComponent == VALPHA)
|
|
{
|
|
const F32 curMax = llmax(curValue.mV[VRED], curValue.mV[VGREEN], curValue.mV[VBLUE]);
|
|
if ( (0.0f == optionValue) || (0.0f == curMax) )
|
|
{
|
|
curValue.mV[VRED] = curValue.mV[VGREEN] = curValue.mV[VBLUE] = optionValue;
|
|
}
|
|
else
|
|
{
|
|
const F32 nDelta = (optionValue - curMax) / curMax;
|
|
curValue.mV[VRED] *= (1.0f + nDelta);
|
|
curValue.mV[VGREEN] *= (1.0f + nDelta);
|
|
curValue.mV[VBLUE] *= (1.0f + nDelta);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return RLV_RET_FAILED_UNKNOWN;
|
|
}
|
|
|
|
setFn(pSky, curValue);
|
|
pSky->update();
|
|
|
|
return RLV_RET_SUCCESS;
|
|
}
|
|
|
|
|
|
template<typename T>
|
|
void RlvEnvironment::registerSkyFn(const std::string& strFnName, const std::function<T(LLSettingsSkyPtr_t)>& getFn, const std::function<void(LLSettingsSkyPtr_t, const T&)>& setFn)
|
|
{
|
|
RLV_ASSERT(m_GetFnLookup.end() == m_GetFnLookup.find(strFnName));
|
|
m_GetFnLookup.insert(std::make_pair(strFnName, [this, getFn](const std::string& strRlvParam)
|
|
{
|
|
if (RlvUtil::sendChatReply(strRlvParam, handleGetFn<T>(getFn)))
|
|
return RLV_RET_SUCCESS;
|
|
return RLV_RET_FAILED_PARAM;
|
|
}));
|
|
|
|
RLV_ASSERT(m_SetFnLookup.end() == m_SetFnLookup.find(strFnName));
|
|
m_SetFnLookup.insert(std::make_pair(strFnName, [this, setFn](const std::string& strRlvOption)
|
|
{
|
|
return handleSetFn<T>(strRlvOption, setFn);
|
|
}));
|
|
}
|
|
|
|
void RlvEnvironment::registerGetEnvFn(const std::string& strFnName, const std::function<std::string(LLEnvironment::EnvSelection_t env)>& getFn)
|
|
{
|
|
RLV_ASSERT(m_GetFnLookup.end() == m_GetFnLookup.find(strFnName));
|
|
m_GetFnLookup.insert(std::make_pair(strFnName, [getFn](const std::string& strRlvParam)
|
|
{
|
|
if (RlvUtil::sendChatReply(strRlvParam, getFn(getTargetEnvironment())))
|
|
return RLV_RET_SUCCESS;
|
|
return RLV_RET_FAILED_PARAM;
|
|
}));
|
|
}
|
|
|
|
template<typename T>
|
|
void RlvEnvironment::registerSetEnvFn(const std::string& strFnName, const std::function<ERlvCmdRet(LLEnvironment::EnvSelection_t env, const T& strRlvOption)>& setFn)
|
|
{
|
|
RLV_ASSERT(m_SetFnLookup.end() == m_SetFnLookup.find(strFnName));
|
|
m_SetFnLookup.insert(std::make_pair(strFnName, [setFn](const std::string& strRlvOption)
|
|
{
|
|
T optionValue;
|
|
if (!RlvCommandOptionHelper::parseOption<T>(strRlvOption, optionValue))
|
|
return RLV_RET_FAILED_PARAM;
|
|
return setFn(getTargetEnvironment(), optionValue);
|
|
}));
|
|
}
|
|
|
|
template<typename T>
|
|
void RlvEnvironment::registerLegacySkyFn(const std::string& strFnName, const std::function<const T (LLSettingsSkyPtr_t)>& getFn, const std::function<void(LLSettingsSkyPtr_t, const T&)>& setFn)
|
|
{
|
|
RLV_ASSERT(m_LegacyGetFnLookup.end() == m_LegacyGetFnLookup.find(strFnName));
|
|
m_LegacyGetFnLookup.insert(std::make_pair(strFnName, [this, getFn](const std::string& strRlvParam, U32 idxComponent)
|
|
{
|
|
const std::string strReply = handleLegacyGetFn<T>(getFn, idxComponent);
|
|
if (strReply.empty())
|
|
return RLV_RET_FAILED_UNKNOWN;
|
|
else if (RlvUtil::sendChatReply(strRlvParam, strReply))
|
|
return RLV_RET_SUCCESS;
|
|
return RLV_RET_FAILED_PARAM;
|
|
}));
|
|
|
|
RLV_ASSERT(m_LegacySetFnLookup.end() == m_LegacySetFnLookup.find(strFnName));
|
|
m_LegacySetFnLookup.insert(std::make_pair(strFnName, [this, getFn, setFn](const std::string& strRlvOption, U32 idxComponent)
|
|
{
|
|
float optionValue;
|
|
if (!RlvCommandOptionHelper::parseOption(strRlvOption, optionValue))
|
|
return RLV_RET_FAILED_PARAM;
|
|
return handleLegacySetFn<T>(optionValue, getFn(getTargetSky(true)), setFn, idxComponent);;
|
|
}));
|
|
}
|
|
|
|
// ================================================================================================
|