summaryrefslogtreecommitdiff
path: root/indra/llinventory
diff options
context:
space:
mode:
authornat-goodspeed <nat@lindenlab.com>2024-09-23 18:23:56 -0400
committerGitHub <noreply@github.com>2024-09-23 18:23:56 -0400
commit9036e4582cec1893016bd692293ec1c0135f7112 (patch)
treef1dabff03453d87a78257d872acddb8f86f4da9c /indra/llinventory
parent9289b96de48e0a3f57819ca173c5d5d51ad25c56 (diff)
parent74badfcfb07733214cbe5aa5ae02bd413f8465a2 (diff)
Merge pull request #2652 from secondlife/lua-merge-dev2
Merge develop into release/luau-scripting
Diffstat (limited to 'indra/llinventory')
-rw-r--r--indra/llinventory/llsettingsbase.cpp113
-rw-r--r--indra/llinventory/llsettingsbase.h128
-rw-r--r--indra/llinventory/llsettingsdaycycle.cpp47
-rw-r--r--indra/llinventory/llsettingsdaycycle.h12
-rw-r--r--indra/llinventory/llsettingssky.cpp654
-rw-r--r--indra/llinventory/llsettingssky.h71
-rw-r--r--indra/llinventory/llsettingswater.cpp107
-rw-r--r--indra/llinventory/llsettingswater.h103
8 files changed, 977 insertions, 258 deletions
diff --git a/indra/llinventory/llsettingsbase.cpp b/indra/llinventory/llsettingsbase.cpp
index 4aab3dee3b..0ee71de3a1 100644
--- a/indra/llinventory/llsettingsbase.cpp
+++ b/indra/llinventory/llsettingsbase.cpp
@@ -69,25 +69,99 @@ const U32 LLSettingsBase::Validator::VALIDATION_PARTIAL(0x01 << 0);
LLSettingsBase::LLSettingsBase():
mSettings(LLSD::emptyMap()),
mDirty(true),
- mBlendedFactor(0.0)
+ mLLSDDirty(true),
+ mReplaced(false),
+ mBlendedFactor(0.0),
+ mSettingFlags(0)
{
}
LLSettingsBase::LLSettingsBase(const LLSD setting) :
mSettings(setting),
+ mLLSDDirty(true),
mDirty(true),
- mBlendedFactor(0.0)
+ mReplaced(false),
+ mBlendedFactor(0.0),
+ mSettingFlags(0)
{
}
+//virtual
+void LLSettingsBase::loadValuesFromLLSD()
+{
+ mLLSDDirty = false;
+
+ mAssetId = mSettings[SETTING_ASSETID].asUUID();
+ mSettingId = getValue(SETTING_ID).asUUID();
+ mSettingName = getValue(SETTING_NAME).asString();
+ if (mSettings.has(SETTING_FLAGS))
+ {
+ mSettingFlags = (U32)mSettings[SETTING_FLAGS].asInteger();
+ }
+ else
+ {
+ mSettingFlags = 0;
+ }
+}
+
+//virtual
+void LLSettingsBase::saveValuesToLLSD()
+{
+ mLLSDDirty = false;
+
+ mSettings[SETTING_NAME] = mSettingName;
+ if (mAssetId.isNull())
+ {
+ mSettings.erase(SETTING_ASSETID);
+ }
+ else
+ {
+ mSettings[SETTING_ASSETID] = mAssetId;
+ }
+ mSettings[SETTING_FLAGS] = LLSD::Integer(mSettingFlags);
+}
+
+void LLSettingsBase::saveValuesIfNeeded()
+{
+ if (mLLSDDirty)
+ {
+ saveValuesToLLSD();
+ }
+}
+
//=========================================================================
-void LLSettingsBase::lerpSettings(const LLSettingsBase &other, F64 mix)
+void LLSettingsBase::lerpSettings(LLSettingsBase &other, F64 mix)
{
- mSettings = interpolateSDMap(mSettings, other.mSettings, other.getParameterMap(), mix);
+ LL_PROFILE_ZONE_SCOPED_CATEGORY_ENVIRONMENT;
+ saveValuesIfNeeded();
+ stringset_t skip = getSkipInterpolateKeys();
+ stringset_t slerps = getSlerpKeys();
+ mSettings = interpolateSDMap(mSettings, other.getSettings(), other.getParameterMap(), mix, skip, slerps);
setDirtyFlag(true);
+ loadValuesFromLLSD();
+}
+
+void LLSettingsBase::lerpVector2(LLVector2& a, const LLVector2& b, F32 mix)
+{
+ a.mV[0] = lerp(a.mV[0], b.mV[0], mix);
+ a.mV[1] = lerp(a.mV[1], b.mV[1], mix);
}
-LLSD LLSettingsBase::combineSDMaps(const LLSD &settings, const LLSD &other) const
+void LLSettingsBase::lerpVector3(LLVector3& a, const LLVector3& b, F32 mix)
+{
+ a.mV[0] = lerp(a.mV[0], b.mV[0], mix);
+ a.mV[1] = lerp(a.mV[1], b.mV[1], mix);
+ a.mV[2] = lerp(a.mV[2], b.mV[2], mix);
+}
+
+void LLSettingsBase::lerpColor(LLColor3& a, const LLColor3& b, F32 mix)
+{
+ a.mV[0] = lerp(a.mV[0], b.mV[0], mix);
+ a.mV[1] = lerp(a.mV[1], b.mV[1], mix);
+ a.mV[2] = lerp(a.mV[2], b.mV[2], mix);
+}
+
+LLSD LLSettingsBase::combineSDMaps(const LLSD &settings, const LLSD &other)
{
LLSD newSettings;
@@ -161,13 +235,10 @@ LLSD LLSettingsBase::combineSDMaps(const LLSD &settings, const LLSD &other) cons
return newSettings;
}
-LLSD LLSettingsBase::interpolateSDMap(const LLSD &settings, const LLSD &other, const parammapping_t& defaults, F64 mix) const
+LLSD LLSettingsBase::interpolateSDMap(const LLSD &settings, const LLSD &other, const parammapping_t& defaults, F64 mix, const stringset_t& skip, const stringset_t& slerps)
{
LLSD newSettings;
- stringset_t skip = getSkipInterpolateKeys();
- stringset_t slerps = getSlerpKeys();
-
llassert(mix >= 0.0f && mix <= 1.0f);
for (LLSD::map_const_iterator it = settings.beginMap(); it != settings.endMap(); ++it)
@@ -204,7 +275,7 @@ LLSD LLSettingsBase::interpolateSDMap(const LLSD &settings, const LLSD &other, c
}
}
- newSettings[key_name] = interpolateSDValue(key_name, value, other_value, defaults, mix, slerps);
+ newSettings[key_name] = interpolateSDValue(key_name, value, other_value, defaults, mix, skip, slerps);
}
// Special handling cases
@@ -233,12 +304,12 @@ LLSD LLSettingsBase::interpolateSDMap(const LLSD &settings, const LLSD &other, c
if (def_iter != defaults.end())
{
// Blend against default value
- newSettings[key_name] = interpolateSDValue(key_name, def_iter->second.getDefaultValue(), (*it).second, defaults, mix, slerps);
+ newSettings[key_name] = interpolateSDValue(key_name, def_iter->second.getDefaultValue(), (*it).second, defaults, mix, skip, slerps);
}
else if ((*it).second.type() == LLSD::TypeMap)
{
// interpolate in case there are defaults inside (part of legacy)
- newSettings[key_name] = interpolateSDValue(key_name, LLSDMap(), (*it).second, defaults, mix, slerps);
+ newSettings[key_name] = interpolateSDValue(key_name, LLSDMap(), (*it).second, defaults, mix, skip, slerps);
}
// else do nothing when no known defaults
// TODO: Should I blend this out instead?
@@ -260,7 +331,7 @@ LLSD LLSettingsBase::interpolateSDMap(const LLSD &settings, const LLSD &other, c
return newSettings;
}
-LLSD LLSettingsBase::interpolateSDValue(const std::string& key_name, const LLSD &value, const LLSD &other_value, const parammapping_t& defaults, BlendFactor mix, const stringset_t& slerps) const
+LLSD LLSettingsBase::interpolateSDValue(const std::string& key_name, const LLSD &value, const LLSD &other_value, const parammapping_t& defaults, BlendFactor mix, const stringset_t& skip, const stringset_t& slerps)
{
LLSD new_value;
@@ -286,7 +357,7 @@ LLSD LLSettingsBase::interpolateSDValue(const std::string& key_name, const LLSD
break;
case LLSD::TypeMap:
// deep copy.
- new_value = interpolateSDMap(value, other_value, defaults, mix);
+ new_value = interpolateSDMap(value, other_value, defaults, mix, skip, slerps);
break;
case LLSD::TypeArray:
@@ -348,13 +419,15 @@ LLSettingsBase::stringset_t LLSettingsBase::getSkipInterpolateKeys() const
return skipSet;
}
-LLSD LLSettingsBase::getSettings() const
+LLSD& LLSettingsBase::getSettings()
{
+ saveValuesIfNeeded();
return mSettings;
}
-LLSD LLSettingsBase::cloneSettings() const
+LLSD LLSettingsBase::cloneSettings()
{
+ saveValuesIfNeeded();
LLSD settings(combineSDMaps(getSettings(), LLSD()));
if (U32 flags = getFlags())
{
@@ -363,7 +436,7 @@ LLSD LLSettingsBase::cloneSettings() const
return settings;
}
-size_t LLSettingsBase::getHash() const
+size_t LLSettingsBase::getHash()
{ // get a shallow copy of the LLSD filtering out values to not include in the hash
LLSD hash_settings = llsd_shallow(getSettings(),
LLSDMap(SETTING_NAME, false)(SETTING_ID, false)(SETTING_HASH, false)("*", true));
@@ -381,7 +454,9 @@ bool LLSettingsBase::validate()
mSettings[SETTING_TYPE] = getSettingsType();
}
+ saveValuesIfNeeded();
LLSD result = LLSettingsBase::settingValidation(mSettings, validations);
+ loadValuesFromLLSD();
if (result["errors"].size() > 0)
{
@@ -704,7 +779,7 @@ F64 LLSettingsBlender::setBlendFactor(const LLSettingsBase::BlendFactor& blendf_
if (mTarget)
{
- mTarget->replaceSettings(mInitial->getSettings());
+ mTarget->replaceSettings(mInitial);
mTarget->blend(mFinal, blendf);
}
else
@@ -719,7 +794,7 @@ void LLSettingsBlender::triggerComplete()
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_ENVIRONMENT;
if (mTarget)
- mTarget->replaceSettings(mFinal->getSettings());
+ mTarget->replaceSettings(mFinal);
LLSettingsBlender::ptr_t hold = shared_from_this(); // prevents this from deleting too soon
mTarget->update();
mOnFinished(shared_from_this());
diff --git a/indra/llinventory/llsettingsbase.h b/indra/llinventory/llsettingsbase.h
index 9d8d746b7e..816ff3e111 100644
--- a/indra/llinventory/llsettingsbase.h
+++ b/indra/llinventory/llsettingsbase.h
@@ -109,72 +109,59 @@ public:
virtual bool isDirty() const { return mDirty; }
virtual bool isVeryDirty() const { return mReplaced; }
inline void setDirtyFlag(bool dirty) { mDirty = dirty; clearAssetId(); }
+ inline void setReplaced() { mReplaced = true; }
- size_t getHash() const; // Hash will not include Name, ID or a previously stored Hash
+ size_t getHash(); // Hash will not include Name, ID or a previously stored Hash
inline LLUUID getId() const
{
- return getValue(SETTING_ID).asUUID();
+ return mSettingId;
}
inline std::string getName() const
{
- return getValue(SETTING_NAME).asString();
+ return mSettingName;
}
inline void setName(std::string val)
{
- setValue(SETTING_NAME, val);
+ mSettingName = val;
+ setDirtyFlag(true);
+ setLLSDDirty();
}
inline LLUUID getAssetId() const
{
- if (mSettings.has(SETTING_ASSETID))
- return mSettings[SETTING_ASSETID].asUUID();
- return LLUUID();
+ return mAssetId;
}
inline U32 getFlags() const
{
- if (mSettings.has(SETTING_FLAGS))
- return static_cast<U32>(mSettings[SETTING_FLAGS].asInteger());
- return 0;
+ return mSettingFlags;
}
inline void setFlags(U32 value)
{
- setLLSD(SETTING_FLAGS, LLSD::Integer(value));
+ mSettingFlags = value;
+ setDirtyFlag(true);
+ setLLSDDirty();
}
inline bool getFlag(U32 flag) const
{
- if (mSettings.has(SETTING_FLAGS))
- return ((U32)mSettings[SETTING_FLAGS].asInteger() & flag) == flag;
- return false;
+ return (mSettingFlags & flag) == flag;
}
inline void setFlag(U32 flag)
{
- U32 flags((mSettings.has(SETTING_FLAGS)) ? (U32)mSettings[SETTING_FLAGS].asInteger() : 0);
-
- flags |= flag;
-
- if (flags)
- mSettings[SETTING_FLAGS] = LLSD::Integer(flags);
- else
- mSettings.erase(SETTING_FLAGS);
+ mSettingFlags |= flag;
+ setLLSDDirty();
}
inline void clearFlag(U32 flag)
{
- U32 flags((mSettings.has(SETTING_FLAGS)) ? (U32)mSettings[SETTING_FLAGS].asInteger() : 0);
-
- flags &= ~flag;
-
- if (flags)
- mSettings[SETTING_FLAGS] = LLSD::Integer(flags);
- else
- mSettings.erase(SETTING_FLAGS);
+ mSettingFlags &= ~flag;
+ setLLSDDirty();
}
virtual void replaceSettings(LLSD settings)
@@ -183,14 +170,41 @@ public:
setDirtyFlag(true);
mReplaced = true;
mSettings = settings;
+ loadValuesFromLLSD();
+ }
+
+ virtual void replaceSettings(const ptr_t& other)
+ {
+ mBlendedFactor = 0.0;
+ setDirtyFlag(true);
+ mReplaced = true;
+ mSettingFlags = other->getFlags();
+ mSettingName = other->getName();
+ mSettingId = other->getId();
+ mAssetId = other->getAssetId();
+ setLLSDDirty();
+ }
+
+ void setSettings(LLSD settings)
+ {
+ setDirtyFlag(true);
+ mSettings = settings;
+ loadValuesFromLLSD();
}
- virtual LLSD getSettings() const;
+ // if you are using getSettings to edit them, call setSettings(settings),
+ // replaceSettings(settings) or loadValuesFromLLSD() afterwards
+ virtual LLSD& getSettings();
+ virtual void setLLSDDirty()
+ {
+ mLLSDDirty = true;
+ }
//---------------------------------------------------------------------
//
inline void setLLSD(const std::string &name, const LLSD &value)
{
+ saveValuesIfNeeded();
mSettings[name] = value;
mDirty = true;
if (name != SETTING_ASSETID)
@@ -202,8 +216,9 @@ public:
setLLSD(name, value);
}
- inline LLSD getValue(const std::string &name, const LLSD &deflt = LLSD()) const
+ inline LLSD getValue(const std::string &name, const LLSD &deflt = LLSD())
{
+ saveValuesIfNeeded();
if (!mSettings.has(name))
return deflt;
return mSettings[name];
@@ -259,11 +274,11 @@ public:
(const_cast<LLSettingsBase *>(this))->updateSettings();
}
- virtual void blend(const ptr_t &end, BlendFactor blendf) = 0;
+ virtual void blend(ptr_t &end, BlendFactor blendf) = 0;
virtual bool validate();
- virtual ptr_t buildDerivedClone() const = 0;
+ virtual ptr_t buildDerivedClone() = 0;
class Validator
{
@@ -310,17 +325,24 @@ public:
inline void setAssetId(LLUUID value)
{ // note that this skips setLLSD
- mSettings[SETTING_ASSETID] = value;
+ mAssetId = value;
+ mLLSDDirty = true;
}
inline void clearAssetId()
{
- if (mSettings.has(SETTING_ASSETID))
- mSettings.erase(SETTING_ASSETID);
+ mAssetId.setNull();
+ mLLSDDirty = true;
}
// Calculate any custom settings that may need to be cached.
virtual void updateSettings() { mDirty = false; mReplaced = false; }
+ LLSD cloneSettings();
+
+ static void lerpVector2(LLVector2& a, const LLVector2& b, F32 mix);
+ static void lerpVector3(LLVector3& a, const LLVector3& b, F32 mix);
+ static void lerpColor(LLColor3& a, const LLColor3& b, F32 mix);
+
protected:
LLSettingsBase();
@@ -331,7 +353,7 @@ protected:
typedef std::set<std::string> stringset_t;
// combining settings objects. Customize for specific setting types
- virtual void lerpSettings(const LLSettingsBase &other, BlendFactor mix);
+ virtual void lerpSettings(LLSettingsBase &other, BlendFactor mix);
// combining settings maps where it can based on mix rate
// @settings initial value (mix==0)
@@ -339,8 +361,8 @@ protected:
// @defaults list of default values for legacy fields and (re)setting shaders
// @mix from 0 to 1, ratio or rate of transition from initial 'settings' to 'other'
// return interpolated and combined LLSD map
- LLSD interpolateSDMap(const LLSD &settings, const LLSD &other, const parammapping_t& defaults, BlendFactor mix) const;
- LLSD interpolateSDValue(const std::string& name, const LLSD &value, const LLSD &other, const parammapping_t& defaults, BlendFactor mix, const stringset_t& slerps) const;
+ static LLSD interpolateSDMap(const LLSD &settings, const LLSD &other, const parammapping_t& defaults, BlendFactor mix, const stringset_t& skip, const stringset_t& slerps);
+ static LLSD interpolateSDValue(const std::string& name, const LLSD &value, const LLSD &other, const parammapping_t& defaults, BlendFactor mix, const stringset_t& skip, const stringset_t& slerps);
/// when lerping between settings, some may require special handling.
/// Get a list of these key to be skipped by the default settings lerp.
@@ -353,32 +375,40 @@ protected:
virtual validation_list_t getValidationList() const = 0;
- // Apply any settings that need special handling.
- virtual void applySpecial(void *, bool force = false) { };
+ // Apply settings.
+ virtual void applyToUniforms(void *) { };
+ virtual void applySpecial(void*, bool force = false) { };
virtual parammapping_t getParameterMap() const { return parammapping_t(); }
- LLSD mSettings;
-
- LLSD cloneSettings() const;
-
inline void setBlendFactor(BlendFactor blendfactor)
{
mBlendedFactor = blendfactor;
}
- void replaceWith(LLSettingsBase::ptr_t other)
+ virtual void replaceWith(const LLSettingsBase::ptr_t other)
{
- replaceSettings(other->cloneSettings());
+ replaceSettings(other);
setBlendFactor(other->getBlendFactor());
}
+ virtual void loadValuesFromLLSD();
+ virtual void saveValuesToLLSD();
+ void saveValuesIfNeeded();
+
+ LLUUID mAssetId;
+ LLUUID mSettingId;
+ std::string mSettingName;
+ U32 mSettingFlags;
+
private:
+ bool mLLSDDirty;
bool mDirty;
bool mReplaced; // super dirty!
- LLSD combineSDMaps(const LLSD &first, const LLSD &other) const;
+ static LLSD combineSDMaps(const LLSD &first, const LLSD &other);
+ LLSD mSettings;
BlendFactor mBlendedFactor;
};
diff --git a/indra/llinventory/llsettingsdaycycle.cpp b/indra/llinventory/llsettingsdaycycle.cpp
index 1e7de94414..2b189e7cca 100644
--- a/indra/llinventory/llsettingsdaycycle.cpp
+++ b/indra/llinventory/llsettingsdaycycle.cpp
@@ -124,33 +124,42 @@ static const F32 DEFAULT_MULTISLIDER_INCREMENT(0.005f);
//=========================================================================
LLSettingsDay::LLSettingsDay(const LLSD &data) :
LLSettingsBase(data),
- mInitialized(false)
+ mInitialized(false),
+ mDaySettings(LLSD::emptyMap())
{
mDayTracks.resize(TRACK_MAX);
+ loadValuesFromLLSD();
}
LLSettingsDay::LLSettingsDay() :
LLSettingsBase(),
- mInitialized(false)
+ mInitialized(false),
+ mDaySettings(LLSD::emptyMap())
{
mDayTracks.resize(TRACK_MAX);
+ replaceSettings(defaults());
}
//=========================================================================
-LLSD LLSettingsDay::getSettings() const
+LLSD& LLSettingsDay::getSettings()
{
- LLSD settings(LLSD::emptyMap());
+ if (!mDaySettings.emptyMap())
+ {
+ return mDaySettings;
+ }
+ mDaySettings = LLSD::emptyMap();
+ LLSD& settings = LLSettingsBase::getSettings();
- if (mSettings.has(SETTING_NAME))
- settings[SETTING_NAME] = mSettings[SETTING_NAME];
+ if (settings.has(SETTING_NAME))
+ mDaySettings[SETTING_NAME] = settings[SETTING_NAME];
- if (mSettings.has(SETTING_ID))
- settings[SETTING_ID] = mSettings[SETTING_ID];
+ if (settings.has(SETTING_ID))
+ mDaySettings[SETTING_ID] = settings[SETTING_ID];
- if (mSettings.has(SETTING_ASSETID))
- settings[SETTING_ASSETID] = mSettings[SETTING_ASSETID];
+ if (settings.has(SETTING_ASSETID))
+ mDaySettings[SETTING_ASSETID] = settings[SETTING_ASSETID];
- settings[SETTING_TYPE] = getSettingsType();
+ mDaySettings[SETTING_TYPE] = getSettingsType();
std::map<std::string, LLSettingsBase::ptr_t> in_use;
@@ -174,7 +183,7 @@ LLSD LLSettingsDay::getSettings() const
}
tracks.append(trackout);
}
- settings[SETTING_TRACKS] = tracks;
+ mDaySettings[SETTING_TRACKS] = tracks;
LLSD frames(LLSD::emptyMap());
for (std::map<std::string, LLSettingsBase::ptr_t>::iterator itFrame = in_use.begin(); itFrame != in_use.end(); ++itFrame)
@@ -184,9 +193,15 @@ LLSD LLSettingsDay::getSettings() const
frames[(*itFrame).first] = framesettings;
}
- settings[SETTING_FRAMES] = frames;
+ mDaySettings[SETTING_FRAMES] = frames;
- return settings;
+ return mDaySettings;
+}
+
+void LLSettingsDay::setLLSDDirty()
+{
+ mDaySettings = LLSD::emptyMap();
+ LLSettingsBase::setLLSDDirty();
}
bool LLSettingsDay::initialize(bool validate_frames)
@@ -392,6 +407,8 @@ bool LLSettingsDay::initialize(bool validate_frames)
mSettings[SETTING_ASSETID] = assetid;
}
+ loadValuesFromLLSD();
+
mInitialized = true;
return true;
}
@@ -449,7 +466,7 @@ LLSD LLSettingsDay::defaults()
return dfltsetting;
}
-void LLSettingsDay::blend(const LLSettingsBase::ptr_t &other, F64 mix)
+void LLSettingsDay::blend(LLSettingsBase::ptr_t &other, F64 mix)
{
LL_ERRS("DAYCYCLE") << "Day cycles are not blendable!" << LL_ENDL;
}
diff --git a/indra/llinventory/llsettingsdaycycle.h b/indra/llinventory/llsettingsdaycycle.h
index 917b0870f2..d37423ea9a 100644
--- a/indra/llinventory/llsettingsdaycycle.h
+++ b/indra/llinventory/llsettingsdaycycle.h
@@ -81,9 +81,10 @@ public:
bool initialize(bool validate_frames = false);
- virtual ptr_t buildClone() const = 0;
- virtual ptr_t buildDeepCloneAndUncompress() const = 0;
- virtual LLSD getSettings() const SETTINGS_OVERRIDE;
+ virtual ptr_t buildClone() = 0;
+ virtual ptr_t buildDeepCloneAndUncompress() = 0;
+ virtual LLSD& getSettings() SETTINGS_OVERRIDE;
+ virtual void setLLSDDirty() override;
virtual LLSettingsType::type_e getSettingsTypeValue() const SETTINGS_OVERRIDE { return LLSettingsType::ST_DAYCYCLE; }
@@ -91,7 +92,7 @@ public:
virtual std::string getSettingsType() const SETTINGS_OVERRIDE { return std::string("daycycle"); }
// Settings status
- virtual void blend(const LLSettingsBase::ptr_t &other, F64 mix) SETTINGS_OVERRIDE;
+ virtual void blend(LLSettingsBase::ptr_t &other, F64 mix) SETTINGS_OVERRIDE;
static LLSD defaults();
@@ -127,7 +128,7 @@ public:
virtual validation_list_t getValidationList() const SETTINGS_OVERRIDE;
static validation_list_t validationList();
- virtual LLSettingsBase::ptr_t buildDerivedClone() const SETTINGS_OVERRIDE { return buildClone(); }
+ virtual LLSettingsBase::ptr_t buildDerivedClone() SETTINGS_OVERRIDE { return buildClone(); }
LLSettingsBase::TrackPosition getUpperBoundFrame(S32 track, const LLSettingsBase::TrackPosition& keyframe);
LLSettingsBase::TrackPosition getLowerBoundFrame(S32 track, const LLSettingsBase::TrackPosition& keyframe);
@@ -143,6 +144,7 @@ protected:
private:
CycleList_t mDayTracks;
+ LLSD mDaySettings;
LLSettingsBase::Seconds mLastUpdateTime;
diff --git a/indra/llinventory/llsettingssky.cpp b/indra/llinventory/llsettingssky.cpp
index cbec2f4906..3685915ffd 100644
--- a/indra/llinventory/llsettingssky.cpp
+++ b/indra/llinventory/llsettingssky.cpp
@@ -407,10 +407,11 @@ LLSettingsSky::LLSettingsSky(const LLSD &data) :
mNextRainbowTextureId(),
mNextHaloTextureId()
{
+ loadValuesFromLLSD();
}
LLSettingsSky::LLSettingsSky():
- LLSettingsBase(),
+ LLSettingsBase(LLSettingsSky::defaults()),
mNextSunTextureId(),
mNextMoonTextureId(),
mNextCloudTextureId(),
@@ -418,6 +419,7 @@ LLSettingsSky::LLSettingsSky():
mNextRainbowTextureId(),
mNextHaloTextureId()
{
+ replaceSettings(defaults());
}
void LLSettingsSky::replaceSettings(LLSD settings)
@@ -431,7 +433,80 @@ void LLSettingsSky::replaceSettings(LLSD settings)
mNextHaloTextureId.setNull();
}
-void LLSettingsSky::replaceWithSky(LLSettingsSky::ptr_t pother)
+void LLSettingsSky::replaceSettings(const LLSettingsBase::ptr_t& other_sky)
+{
+ LLSettingsBase::replaceSettings(other_sky);
+
+ llassert(getSettingsType() == other_sky->getSettingsType());
+
+ LLSettingsSky::ptr_t other = PTR_NAMESPACE::dynamic_pointer_cast<LLSettingsSky>(other_sky);
+
+ mCanAutoAdjust = other->mCanAutoAdjust;
+ mReflectionProbeAmbiance = other->mReflectionProbeAmbiance;
+
+ mSunScale = other->mSunScale;
+ mSunRotation = other->mSunRotation;
+ mSunlightColor = other->mSunlightColor;
+ mStarBrightness = other->mStarBrightness;
+ mMoonBrightness = other->mMoonBrightness;
+ mMoonScale = other->mMoonScale;
+ mMoonRotation = other->mMoonRotation;
+ mMaxY = other->mMaxY;
+ mGlow = other->mGlow;
+ mGamma = other->mGamma;
+ mCloudVariance = other->mCloudVariance;
+ mCloudShadow = other->mCloudShadow;
+ mScrollRate = other->mScrollRate;
+ mCloudScale = other->mCloudScale;
+ mCloudPosDensity1 = other->mCloudPosDensity1;
+ mCloudPosDensity2 = other->mCloudPosDensity2;
+ mCloudColor = other->mCloudColor;
+
+ mAbsorptionConfigs = other->mAbsorptionConfigs;
+ mMieConfigs = other->mMieConfigs;
+ mRayleighConfigs = other->mRayleighConfigs;
+
+ mSunArcRadians = other->mSunArcRadians;
+ mSkyTopRadius = other->mSkyTopRadius;
+ mSkyBottomRadius = other->mSkyBottomRadius;
+ mSkyMoistureLevel = other->mSkyMoistureLevel;
+ mSkyDropletRadius = other->mSkyDropletRadius;
+ mSkyIceLevel = other->mSkyIceLevel;
+ mPlanetRadius = other->mPlanetRadius;
+
+ mHasLegacyHaze = other->mHasLegacyHaze;
+ mDistanceMultiplier = other->mDistanceMultiplier;
+ mDensityMultiplier = other->mDensityMultiplier;
+ mHazeHorizon = other->mHazeHorizon;
+ mHazeDensity = other->mHazeDensity;
+ mBlueHorizon = other->mBlueHorizon;
+ mBlueDensity = other->mBlueDensity;
+ mAmbientColor = other->mAmbientColor;
+
+ mLegacyDistanceMultiplier = other->mLegacyDistanceMultiplier;
+ mLegacyDensityMultiplier = other->mLegacyDensityMultiplier;
+ mLegacyHazeHorizon = other->mLegacyHazeHorizon;
+ mLegacyHazeDensity = other->mLegacyHazeDensity;
+ mLegacyBlueHorizon = other->mLegacyBlueHorizon;
+ mLegacyBlueDensity = other->mLegacyBlueDensity;
+ mLegacyAmbientColor = other->mLegacyAmbientColor;
+
+ mSunTextureId = other->mSunTextureId;
+ mMoonTextureId = other->mMoonTextureId;
+ mCloudTextureId = other->mCloudTextureId;
+ mHaloTextureId = other->mHaloTextureId;
+ mRainbowTextureId = other->mRainbowTextureId;
+ mBloomTextureId = other->mBloomTextureId;
+
+ mNextSunTextureId.setNull();
+ mNextMoonTextureId.setNull();
+ mNextCloudTextureId.setNull();
+ mNextBloomTextureId.setNull();
+ mNextRainbowTextureId.setNull();
+ mNextHaloTextureId.setNull();
+}
+
+void LLSettingsSky::replaceWithSky(const LLSettingsSky::ptr_t& pother)
{
replaceWith(pother);
@@ -443,61 +518,158 @@ void LLSettingsSky::replaceWithSky(LLSettingsSky::ptr_t pother)
mNextHaloTextureId = pother->mNextHaloTextureId;
}
-void LLSettingsSky::blend(const LLSettingsBase::ptr_t &end, F64 blendf)
+bool lerp_legacy_color(LLColor3& a, bool& a_has_legacy, const LLColor3& b, bool b_has_legacy, const LLColor3& def, F32 mix)
{
- LL_PROFILE_ZONE_SCOPED_CATEGORY_ENVIRONMENT;
- llassert(getSettingsType() == end->getSettingsType());
+ if (b_has_legacy)
+ {
+ if (a_has_legacy)
+ {
+ LLSettingsBase::lerpColor(a, b, mix);
+ }
+ else
+ {
+ a = def;
+ LLSettingsBase::lerpColor(a, b, mix);
+ a_has_legacy = true;
+ }
+ }
+ else if (a_has_legacy)
+ {
+ LLSettingsBase::lerpColor(a, def, mix);
+ }
+ else
+ {
+ LLSettingsBase::lerpColor(a, b, mix);
+ }
+ return a_has_legacy;
+}
- LLSettingsSky::ptr_t other = PTR_NAMESPACE::dynamic_pointer_cast<LLSettingsSky>(end);
- if (other)
+bool lerp_legacy_float(F32& a, bool& a_has_legacy, F32 b, bool b_has_legacy, F32 def, F32 mix)
+{
+ if (b_has_legacy)
{
- if (other->mSettings.has(SETTING_LEGACY_HAZE))
+ if (a_has_legacy)
{
- if (!mSettings.has(SETTING_LEGACY_HAZE) || !mSettings[SETTING_LEGACY_HAZE].has(SETTING_AMBIENT))
- {
- // Special case since SETTING_AMBIENT is both in outer and legacy maps, we prioritize legacy one
- // see getAmbientColor(), we are about to replaceSettings(), so we are free to set it
- setAmbientColor(getAmbientColor());
- }
+ a = lerp(a, b, mix);
}
else
{
- if (mSettings.has(SETTING_LEGACY_HAZE) && mSettings[SETTING_LEGACY_HAZE].has(SETTING_AMBIENT))
- {
- // Special case due to ambient's duality
- // We need to match 'other's' structure for interpolation.
- // We are free to change mSettings, since we are about to reset it
- mSettings[SETTING_AMBIENT] = getAmbientColor().getValue();
- mSettings[SETTING_LEGACY_HAZE].erase(SETTING_AMBIENT);
- }
+ a = lerp(def, b, mix);
+ a_has_legacy = true;
}
+ }
+ else if (!a_has_legacy)
+ {
+ a = lerp(a, b, mix);
+ }
+ else
+ {
+ a = lerp(a, def, mix);
+ }
+ return a_has_legacy;
+}
+void LLSettingsSky::blend(LLSettingsBase::ptr_t &end, F64 blendf)
+{
+ LL_PROFILE_ZONE_SCOPED_CATEGORY_ENVIRONMENT;
+ llassert(getSettingsType() == end->getSettingsType());
+
+ LLSettingsSky::ptr_t other = PTR_NAMESPACE::dynamic_pointer_cast<LLSettingsSky>(end);
+ if (other)
+ {
LLUUID cloud_noise_id = getCloudNoiseTextureId();
LLUUID cloud_noise_id_next = other->getCloudNoiseTextureId();
- F64 cloud_shadow = 0;
if (!cloud_noise_id.isNull() && cloud_noise_id_next.isNull())
{
// If there is no cloud texture in destination, reduce coverage to imitate disappearance
// See LLDrawPoolWLSky::renderSkyClouds... we don't blend present texture with null
// Note: Probably can be done by shader
- cloud_shadow = lerp((F32)mSettings[SETTING_CLOUD_SHADOW].asReal(), 0.f, (F32)blendf);
+ mCloudShadow = lerp(mCloudShadow, 0.f, (F32)blendf);
cloud_noise_id_next = cloud_noise_id;
}
else if (cloud_noise_id.isNull() && !cloud_noise_id_next.isNull())
{
// Source has no cloud texture, reduce initial coverage to imitate appearance
// use same texture as destination
- cloud_shadow = lerp(0.f, (F32)other->mSettings[SETTING_CLOUD_SHADOW].asReal(), (F32)blendf);
+ mCloudShadow = lerp(0.f, mCloudShadow, (F32)blendf);
setCloudNoiseTextureId(cloud_noise_id_next);
}
else
{
- cloud_shadow = lerp((F32)mSettings[SETTING_CLOUD_SHADOW].asReal(), (F32)other->mSettings[SETTING_CLOUD_SHADOW].asReal(), (F32)blendf);
+ mCloudShadow = lerp(mCloudShadow, (F32)other->mCloudShadow, (F32)blendf);
+ }
+
+ mSettingFlags |= other->mSettingFlags;
+
+ mCanAutoAdjust = false; // no point?
+
+ mSunRotation = slerp((F32)blendf, mSunRotation, other->mSunRotation);
+ mMoonRotation = slerp((F32)blendf, mMoonRotation, other->mMoonRotation);
+ lerpColor(mSunlightColor, other->mSunlightColor, (F32)blendf);
+ lerpColor(mGlow, other->mGlow, (F32)blendf);
+ mReflectionProbeAmbiance = lerp(mReflectionProbeAmbiance, other->mReflectionProbeAmbiance, (F32)blendf);
+ mSunScale = lerp(mSunScale, other->mSunScale, (F32)blendf);
+ mStarBrightness = lerp(mStarBrightness, other->mStarBrightness, (F32)blendf);
+ mMoonBrightness = lerp(mMoonBrightness, other->mMoonBrightness, (F32)blendf);
+ mMoonScale = lerp(mMoonScale, other->mMoonScale, (F32)blendf);
+ mMaxY = lerp(mMaxY, other->mMaxY, (F32)blendf);
+ mGamma = lerp(mGamma, other->mGamma, (F32)blendf);
+ mCloudVariance = lerp(mCloudVariance, other->mCloudVariance, (F32)blendf);
+ mCloudShadow = lerp(mCloudShadow, other->mCloudShadow, (F32)blendf);
+ mCloudScale = lerp(mCloudScale, other->mCloudScale, (F32)blendf);
+ lerpVector2(mScrollRate, other->mScrollRate, (F32)blendf);
+ lerpColor(mCloudPosDensity1, other->mCloudPosDensity1, (F32)blendf);
+ lerpColor(mCloudPosDensity2, other->mCloudPosDensity2, (F32)blendf);
+ lerpColor(mCloudColor, other->mCloudColor, (F32)blendf);
+
+ mSunArcRadians = lerp(mSunArcRadians, other->mSunArcRadians, (F32)blendf);
+ mSkyTopRadius = lerp(mSkyTopRadius, other->mSkyTopRadius, (F32)blendf);
+ mSkyBottomRadius = lerp(mSkyBottomRadius, other->mSkyBottomRadius, (F32)blendf);
+ mSkyMoistureLevel = lerp(mSkyMoistureLevel, other->mSkyMoistureLevel, (F32)blendf);
+ mSkyDropletRadius = lerp(mSkyDropletRadius, other->mSkyDropletRadius, (F32)blendf);
+ mSkyIceLevel = lerp(mSkyIceLevel, other->mSkyIceLevel, (F32)blendf);
+ mPlanetRadius = lerp(mPlanetRadius, other->mPlanetRadius, (F32)blendf);
+
+ // Legacy settings
+
+ if (other->mHasLegacyHaze)
+ {
+ if (!mHasLegacyHaze || !mLegacyAmbientColor)
+ {
+ // Special case since SETTING_AMBIENT is both in outer and legacy maps,
+ // we prioritize legacy one
+ setAmbientColor(other->getAmbientColor());
+ mLegacyAmbientColor = true;
+ mHasLegacyHaze = true;
+ }
+ }
+ else
+ {
+ if (mLegacyAmbientColor)
+ {
+ // Special case due to ambient's duality
+ mLegacyAmbientColor = false;
+ }
}
- LLSD blenddata = interpolateSDMap(mSettings, other->mSettings, other->getParameterMap(), blendf);
- blenddata[SETTING_CLOUD_SHADOW] = LLSD::Real(cloud_shadow);
- replaceSettings(blenddata);
+ mHasLegacyHaze |= lerp_legacy_float(mHazeHorizon, mLegacyHazeHorizon, other->mHazeHorizon, other->mLegacyHazeHorizon, 0.19f, (F32)blendf);
+ mHasLegacyHaze |= lerp_legacy_float(mHazeDensity, mLegacyHazeDensity, other->mHazeDensity, other->mLegacyHazeDensity, 0.7f, (F32)blendf);
+ mHasLegacyHaze |= lerp_legacy_float(mDistanceMultiplier, mLegacyDistanceMultiplier, other->mDistanceMultiplier, other->mLegacyDistanceMultiplier, 0.8f, (F32)blendf);
+ mHasLegacyHaze |= lerp_legacy_float(mDensityMultiplier, mLegacyDensityMultiplier, other->mDensityMultiplier, other->mLegacyDensityMultiplier, 0.0001f, (F32)blendf);
+ mHasLegacyHaze |= lerp_legacy_color(mBlueHorizon, mLegacyBlueHorizon, other->mBlueHorizon, other->mLegacyBlueHorizon, LLColor3(0.4954f, 0.4954f, 0.6399f), (F32)blendf);
+ mHasLegacyHaze |= lerp_legacy_color(mBlueDensity, mLegacyBlueDensity, other->mBlueDensity, other->mLegacyBlueDensity, LLColor3(0.2447f, 0.4487f, 0.7599f), (F32)blendf);
+
+ parammapping_t defaults = other->getParameterMap();
+ stringset_t skip = getSkipInterpolateKeys();
+ stringset_t slerps = getSlerpKeys();
+ mAbsorptionConfigs = interpolateSDMap(mAbsorptionConfigs, other->mAbsorptionConfigs, defaults, blendf, skip, slerps);
+ mMieConfigs = interpolateSDMap(mMieConfigs, other->mMieConfigs, defaults, blendf, skip, slerps);
+ mRayleighConfigs = interpolateSDMap(mRayleighConfigs, other->mRayleighConfigs, defaults, blendf, skip, slerps);
+
+ setDirtyFlag(true);
+ setReplaced();
+ setLLSDDirty();
+
mNextSunTextureId = other->getSunTextureId();
mNextMoonTextureId = other->getMoonTextureId();
mNextCloudTextureId = cloud_noise_id_next;
@@ -955,6 +1127,184 @@ void LLSettingsSky::updateSettings()
calculateLightSettings();
}
+
+F32 get_float(bool &use_legacy, LLSD& settings, std::string key, F32 default_value)
+{
+ if (settings.has(LLSettingsSky::SETTING_LEGACY_HAZE) && settings[LLSettingsSky::SETTING_LEGACY_HAZE].has(key))
+ {
+ use_legacy = true;
+ return (F32)settings[LLSettingsSky::SETTING_LEGACY_HAZE][key].asReal();
+ }
+ if (settings.has(key))
+ {
+ return (F32)settings[key].asReal();
+ }
+ use_legacy = true;
+ return default_value;
+}
+
+LLColor3 get_color(bool& use_legacy, LLSD& settings, const std::string& key, const LLColor3& default_value)
+{
+ if (settings.has(LLSettingsSky::SETTING_LEGACY_HAZE) && settings[LLSettingsSky::SETTING_LEGACY_HAZE].has(key))
+ {
+ use_legacy = true;
+ return LLColor3(settings[LLSettingsSky::SETTING_LEGACY_HAZE][key]);
+ }
+ use_legacy = false;
+ if (settings.has(key))
+ {
+ return LLColor3(settings[key]);
+ }
+ use_legacy = true;
+ return default_value;
+}
+
+
+void LLSettingsSky::loadValuesFromLLSD()
+{
+ LL_PROFILE_ZONE_SCOPED_CATEGORY_ENVIRONMENT;
+
+ LLSettingsBase::loadValuesFromLLSD();
+
+ LLSD& settings = getSettings();
+ mCanAutoAdjust = !settings.has(SETTING_REFLECTION_PROBE_AMBIANCE);
+ if (mCanAutoAdjust)
+ {
+ mReflectionProbeAmbiance = 0;
+ }
+ else
+ {
+ mReflectionProbeAmbiance = (F32)settings[SETTING_REFLECTION_PROBE_AMBIANCE].asReal();
+ }
+
+ mSunTextureId = settings[SETTING_SUN_TEXTUREID].asUUID();
+ mMoonTextureId = settings[SETTING_MOON_TEXTUREID].asUUID();
+ mCloudTextureId = settings[SETTING_CLOUD_TEXTUREID].asUUID();
+ mHaloTextureId = settings[SETTING_HALO_TEXTUREID].asUUID();
+ mRainbowTextureId = settings[SETTING_RAINBOW_TEXTUREID].asUUID();
+ mBloomTextureId = settings[SETTING_BLOOM_TEXTUREID].asUUID();
+
+ mSunScale = (F32)settings[SETTING_SUN_SCALE].asReal();
+ mSunRotation = LLQuaternion(settings[SETTING_SUN_ROTATION]);
+ mSunlightColor = LLColor3(settings[SETTING_SUNLIGHT_COLOR]);
+ mStarBrightness = (F32)settings[SETTING_STAR_BRIGHTNESS].asReal();
+ mMoonBrightness = (F32)settings[SETTING_MOON_BRIGHTNESS].asReal();
+ mMoonScale = (F32)settings[SETTING_MOON_SCALE].asReal();
+ mMoonRotation = LLQuaternion(settings[SETTING_MOON_ROTATION]);
+ mMaxY = (F32)settings[SETTING_MAX_Y].asReal();
+ mGlow = LLColor3(settings[SETTING_GLOW]);
+ mGamma = (F32)settings[SETTING_GAMMA].asReal();
+ mCloudVariance = (F32)settings[SETTING_CLOUD_VARIANCE].asReal();
+ mCloudShadow = (F32)settings[SETTING_CLOUD_SHADOW].asReal();
+ mScrollRate = LLVector2(settings[SETTING_CLOUD_SCROLL_RATE]);
+ mCloudScale = (F32)settings[SETTING_CLOUD_SCALE].asReal();
+ mCloudPosDensity1 = LLColor3(settings[SETTING_CLOUD_POS_DENSITY1]);
+ mCloudPosDensity2 = LLColor3(settings[SETTING_CLOUD_POS_DENSITY2]);
+ mCloudColor = LLColor3(settings[SETTING_CLOUD_COLOR]);
+ mAbsorptionConfigs = settings[SETTING_ABSORPTION_CONFIG];
+ mMieConfigs = settings[SETTING_MIE_CONFIG];
+ mRayleighConfigs = settings[SETTING_RAYLEIGH_CONFIG];
+ mSunArcRadians = (F32)settings[SETTING_SUN_ARC_RADIANS].asReal();
+ mSkyTopRadius = (F32)settings[SETTING_SKY_TOP_RADIUS].asReal();
+ mSkyBottomRadius = (F32)settings[SETTING_SKY_BOTTOM_RADIUS].asReal();
+ mSkyMoistureLevel = (F32)settings[SETTING_SKY_MOISTURE_LEVEL].asReal();
+ mSkyDropletRadius = (F32)settings[SETTING_SKY_DROPLET_RADIUS].asReal();
+ mSkyIceLevel = (F32)settings[SETTING_SKY_ICE_LEVEL].asReal();
+ mPlanetRadius = (F32)settings[SETTING_PLANET_RADIUS].asReal();
+
+ // special case for legacy handling
+ mHasLegacyHaze = settings.has(LLSettingsSky::SETTING_LEGACY_HAZE);
+ mDistanceMultiplier = get_float(mLegacyDistanceMultiplier, settings, SETTING_DISTANCE_MULTIPLIER, 0.8f);
+ mDensityMultiplier = get_float(mLegacyDensityMultiplier, settings, SETTING_DENSITY_MULTIPLIER, 0.0001f);
+ mHazeHorizon = get_float(mLegacyHazeHorizon, settings, SETTING_HAZE_HORIZON, 0.19f);
+ mHazeDensity = get_float(mLegacyHazeDensity, settings, SETTING_HAZE_DENSITY, 0.7f);
+ mBlueHorizon = get_color(mLegacyBlueHorizon, settings, SETTING_BLUE_HORIZON, LLColor3(0.4954f, 0.4954f, 0.6399f));
+ mBlueDensity = get_color(mLegacyBlueDensity, settings, SETTING_BLUE_DENSITY, LLColor3(0.2447f, 0.4487f, 0.7599f));
+ mAmbientColor = get_color(mLegacyAmbientColor, settings, SETTING_AMBIENT, LLColor3(0.25f, 0.25f, 0.25f));
+ // one of these values might be true despite not having SETTING_LEGACY_HAZE if defaults were used
+ mHasLegacyHaze |= mLegacyDistanceMultiplier
+ || mLegacyDensityMultiplier
+ || mLegacyHazeHorizon
+ || mLegacyHazeDensity
+ || mLegacyBlueHorizon
+ || mLegacyBlueDensity
+ || mLegacyAmbientColor;
+}
+
+void set_legacy(LLSD &settings, LLSD &legacy, const std::string& key, bool has_value, const LLSD & value)
+{
+ if (has_value)
+ {
+ legacy[key] = value;
+ }
+ else
+ {
+ settings[key] = value;
+ legacy.erase(key);
+ }
+}
+
+void LLSettingsSky::saveValuesToLLSD()
+{
+ LL_PROFILE_ZONE_SCOPED_CATEGORY_ENVIRONMENT;
+
+ LLSettingsBase::saveValuesToLLSD();
+
+ LLSD& settings = getSettings();
+
+ if (mCanAutoAdjust)
+ {
+ settings.erase(SETTING_REFLECTION_PROBE_AMBIANCE);
+ }
+ else
+ {
+ settings[SETTING_REFLECTION_PROBE_AMBIANCE] = mReflectionProbeAmbiance;
+ }
+ settings[SETTING_SUN_TEXTUREID] = mSunTextureId;
+ settings[SETTING_MOON_TEXTUREID] = mMoonTextureId;
+ settings[SETTING_CLOUD_TEXTUREID] = mCloudTextureId;
+ settings[SETTING_HALO_TEXTUREID] = mHaloTextureId;
+ settings[SETTING_RAINBOW_TEXTUREID] = mRainbowTextureId;
+ settings[SETTING_BLOOM_TEXTUREID] = mBloomTextureId;
+
+ settings[SETTING_SUN_SCALE] = mSunScale;
+ settings[SETTING_SUN_ROTATION] = mSunRotation.getValue();
+ settings[SETTING_SUNLIGHT_COLOR] = mSunlightColor.getValue();
+ settings[SETTING_STAR_BRIGHTNESS] = mStarBrightness;
+ settings[SETTING_MOON_BRIGHTNESS] = mMoonBrightness;
+ settings[SETTING_MOON_SCALE] = mMoonScale;
+ settings[SETTING_MOON_ROTATION] = mMoonRotation.getValue();
+ settings[SETTING_MAX_Y] = mMaxY;
+ settings[SETTING_GLOW] = mGlow.getValue();
+ settings[SETTING_GAMMA] = mGamma;
+ settings[SETTING_CLOUD_VARIANCE] = mCloudVariance;
+ settings[SETTING_CLOUD_SHADOW] = mCloudShadow;
+ settings[SETTING_CLOUD_SCROLL_RATE] = mScrollRate.getValue();
+ settings[SETTING_CLOUD_SCALE] = mCloudScale;
+ settings[SETTING_CLOUD_POS_DENSITY1] = mCloudPosDensity1.getValue();
+ settings[SETTING_CLOUD_POS_DENSITY2] = mCloudPosDensity2.getValue();
+ settings[SETTING_CLOUD_COLOR] = mCloudColor.getValue();
+ settings[SETTING_ABSORPTION_CONFIG] = mAbsorptionConfigs;
+ settings[SETTING_MIE_CONFIG] = mMieConfigs;
+ settings[SETTING_RAYLEIGH_CONFIG] = mRayleighConfigs;
+ settings[SETTING_SUN_ARC_RADIANS] = mSunArcRadians;
+ settings[SETTING_SKY_TOP_RADIUS] = mSkyTopRadius;
+ settings[SETTING_SKY_BOTTOM_RADIUS] = mSkyBottomRadius;
+ settings[SETTING_SKY_MOISTURE_LEVEL] = mSkyMoistureLevel;
+ settings[SETTING_SKY_DROPLET_RADIUS] = mSkyDropletRadius;
+ settings[SETTING_SKY_ICE_LEVEL] = mSkyIceLevel;
+ settings[SETTING_PLANET_RADIUS] = mPlanetRadius;
+
+ LLSD& legacy = settings[SETTING_LEGACY_HAZE];
+ set_legacy(settings, legacy, SETTING_DISTANCE_MULTIPLIER, mLegacyDistanceMultiplier, LLSD::Real(mDistanceMultiplier));
+ set_legacy(settings, legacy, SETTING_DENSITY_MULTIPLIER, mLegacyDensityMultiplier, LLSD::Real(mDensityMultiplier));
+ set_legacy(settings, legacy, SETTING_HAZE_HORIZON, mLegacyHazeHorizon, LLSD::Real(mHazeHorizon));
+ set_legacy(settings, legacy, SETTING_HAZE_DENSITY, mLegacyHazeDensity, LLSD::Real(mHazeDensity));
+ set_legacy(settings, legacy, SETTING_BLUE_HORIZON, mLegacyBlueHorizon, mBlueHorizon.getValue());
+ set_legacy(settings, legacy, SETTING_BLUE_DENSITY, mLegacyBlueDensity, mBlueDensity.getValue());
+ set_legacy(settings, legacy, SETTING_AMBIENT, mLegacyAmbientColor, mAmbientColor.getValue());
+}
+
F32 LLSettingsSky::getSunMoonGlowFactor() const
{
return getIsSunUp() ? 1.0f :
@@ -1024,37 +1374,40 @@ LLColor3 LLSettingsSky::getLightDiffuse() const
return LLColor3::white;
}
-LLColor3 LLSettingsSky::getColor(const std::string& key, const LLColor3& default_value) const
+LLColor3 LLSettingsSky::getColor(const std::string& key, const LLColor3& default_value)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_ENVIRONMENT;
- if (mSettings.has(SETTING_LEGACY_HAZE) && mSettings[SETTING_LEGACY_HAZE].has(key))
+ LLSD& settings = getSettings();
+ if (settings.has(SETTING_LEGACY_HAZE) && settings[SETTING_LEGACY_HAZE].has(key))
{
- return LLColor3(mSettings[SETTING_LEGACY_HAZE][key]);
+ return LLColor3(settings[SETTING_LEGACY_HAZE][key]);
}
- if (mSettings.has(key))
+ if (settings.has(key))
{
- return LLColor3(mSettings[key]);
+ return LLColor3(settings[key]);
}
return default_value;
}
-F32 LLSettingsSky::getFloat(const std::string& key, F32 default_value) const
+F32 LLSettingsSky::getFloat(const std::string& key, F32 default_value)
{
LL_PROFILE_ZONE_SCOPED_CATEGORY_ENVIRONMENT;
- if (mSettings.has(SETTING_LEGACY_HAZE) && mSettings[SETTING_LEGACY_HAZE].has(key))
+
+ LLSD& settings = getSettings();
+ if (settings.has(SETTING_LEGACY_HAZE) && settings[SETTING_LEGACY_HAZE].has(key))
{
- return (F32)mSettings[SETTING_LEGACY_HAZE][key].asReal();
+ return (F32)settings[SETTING_LEGACY_HAZE][key].asReal();
}
- if (mSettings.has(key))
+ if (settings.has(key))
{
- return (F32)mSettings[key].asReal();
+ return (F32)settings[key].asReal();
}
return default_value;
}
LLColor3 LLSettingsSky::getAmbientColor() const
{
- return getColor(SETTING_AMBIENT, LLColor3(0.25f, 0.25f, 0.25f));
+ return mAmbientColor;
}
LLColor3 LLSettingsSky::getAmbientColorClamped() const
@@ -1072,119 +1425,143 @@ LLColor3 LLSettingsSky::getAmbientColorClamped() const
LLColor3 LLSettingsSky::getBlueDensity() const
{
- return getColor(SETTING_BLUE_DENSITY, LLColor3(0.2447f, 0.4487f, 0.7599f));
+ return mBlueDensity;
}
LLColor3 LLSettingsSky::getBlueHorizon() const
{
- return getColor(SETTING_BLUE_HORIZON, LLColor3(0.4954f, 0.4954f, 0.6399f));
+ return mBlueHorizon;
}
F32 LLSettingsSky::getHazeDensity() const
{
- return getFloat(SETTING_HAZE_DENSITY, 0.7f);
+ return mHazeDensity;
}
F32 LLSettingsSky::getHazeHorizon() const
{
- return getFloat(SETTING_HAZE_HORIZON, 0.19f);
+ return mHazeHorizon;
}
F32 LLSettingsSky::getDensityMultiplier() const
{
- return getFloat(SETTING_DENSITY_MULTIPLIER, 0.0001f);
+ return mDensityMultiplier;
}
F32 LLSettingsSky::getDistanceMultiplier() const
{
- return getFloat(SETTING_DISTANCE_MULTIPLIER, 0.8f);
+ return mDistanceMultiplier;
}
void LLSettingsSky::setPlanetRadius(F32 radius)
{
- mSettings[SETTING_PLANET_RADIUS] = radius;
+ mPlanetRadius = radius;
+ setDirtyFlag(true);
}
void LLSettingsSky::setSkyBottomRadius(F32 radius)
{
- mSettings[SETTING_SKY_BOTTOM_RADIUS] = radius;
+ mSkyBottomRadius = radius;
+ setDirtyFlag(true);
}
void LLSettingsSky::setSkyTopRadius(F32 radius)
{
- mSettings[SETTING_SKY_TOP_RADIUS] = radius;
+ mSkyTopRadius = radius;
+ setDirtyFlag(true);
}
void LLSettingsSky::setSunArcRadians(F32 radians)
{
- mSettings[SETTING_SUN_ARC_RADIANS] = radians;
+ mSunArcRadians = radians;
+ setDirtyFlag(true);
}
void LLSettingsSky::setMieAnisotropy(F32 aniso_factor)
{
getMieConfig()[SETTING_MIE_ANISOTROPY_FACTOR] = aniso_factor;
+ setDirtyFlag(true);
}
void LLSettingsSky::setSkyMoistureLevel(F32 moisture_level)
{
- setValue(SETTING_SKY_MOISTURE_LEVEL, moisture_level);
+ mSkyMoistureLevel = moisture_level;
+ setDirtyFlag(true);
}
void LLSettingsSky::setSkyDropletRadius(F32 radius)
{
- setValue(SETTING_SKY_DROPLET_RADIUS,radius);
+ mSkyDropletRadius = radius;
+ setDirtyFlag(true);
}
void LLSettingsSky::setSkyIceLevel(F32 ice_level)
{
- setValue(SETTING_SKY_ICE_LEVEL, ice_level);
+ mSkyIceLevel = ice_level;
+ setDirtyFlag(true);
}
void LLSettingsSky::setReflectionProbeAmbiance(F32 ambiance)
{
- setValue(SETTING_REFLECTION_PROBE_AMBIANCE, ambiance);
+ mReflectionProbeAmbiance = ambiance;
+ mCanAutoAdjust = false;
+ setLLSDDirty();
}
void LLSettingsSky::setAmbientColor(const LLColor3 &val)
{
- mSettings[SETTING_LEGACY_HAZE][SETTING_AMBIENT] = val.getValue();
+ mAmbientColor = val;
+ mLegacyAmbientColor = true;
setDirtyFlag(true);
+ setLLSDDirty();
}
void LLSettingsSky::setBlueDensity(const LLColor3 &val)
{
- mSettings[SETTING_LEGACY_HAZE][SETTING_BLUE_DENSITY] = val.getValue();
+ mBlueDensity = val;
+ mLegacyBlueDensity = true;
setDirtyFlag(true);
+ setLLSDDirty();
}
void LLSettingsSky::setBlueHorizon(const LLColor3 &val)
{
- mSettings[SETTING_LEGACY_HAZE][SETTING_BLUE_HORIZON] = val.getValue();
+ mBlueHorizon = val;
+ mLegacyBlueHorizon = true;
setDirtyFlag(true);
+ setLLSDDirty();
}
void LLSettingsSky::setDensityMultiplier(F32 val)
{
- mSettings[SETTING_LEGACY_HAZE][SETTING_DENSITY_MULTIPLIER] = val;
+ mDensityMultiplier = val;
+ mLegacyDensityMultiplier = true;
setDirtyFlag(true);
+ setLLSDDirty();
}
void LLSettingsSky::setDistanceMultiplier(F32 val)
{
- mSettings[SETTING_LEGACY_HAZE][SETTING_DISTANCE_MULTIPLIER] = val;
+ mDistanceMultiplier = val;
+ mLegacyDistanceMultiplier = true;
setDirtyFlag(true);
+ setLLSDDirty();
}
void LLSettingsSky::setHazeDensity(F32 val)
{
- mSettings[SETTING_LEGACY_HAZE][SETTING_HAZE_DENSITY] = val;
+ mHazeDensity = val;
+ mLegacyHazeDensity = true;
setDirtyFlag(true);
+ setLLSDDirty();
}
void LLSettingsSky::setHazeHorizon(F32 val)
{
- mSettings[SETTING_LEGACY_HAZE][SETTING_HAZE_HORIZON] = val;
+ mHazeHorizon = val;
+ mLegacyHazeHorizon = true;
setDirtyFlag(true);
+ setLLSDDirty();
}
// Get total from rayleigh and mie density values for normalization
@@ -1299,7 +1676,7 @@ LLColor3 LLSettingsSky::getMoonlightColor() const
return getSunlightColor(); //moon and sun share light color
}
-void LLSettingsSky::clampColor(LLColor3& color, F32 gamma, F32 scale) const
+void LLSettingsSky::clampColor(LLColor3& color, F32 gamma, F32 scale)
{
F32 max_color = llmax(color.mV[0], color.mV[1], color.mV[2]);
if (max_color > scale)
@@ -1415,22 +1792,22 @@ LLUUID LLSettingsSky::GetDefaultHaloTextureId()
F32 LLSettingsSky::getPlanetRadius() const
{
- return (F32)mSettings[SETTING_PLANET_RADIUS].asReal();
+ return mPlanetRadius;
}
F32 LLSettingsSky::getSkyMoistureLevel() const
{
- return (F32)mSettings[SETTING_SKY_MOISTURE_LEVEL].asReal();
+ return mSkyMoistureLevel;
}
F32 LLSettingsSky::getSkyDropletRadius() const
{
- return (F32)mSettings[SETTING_SKY_DROPLET_RADIUS].asReal();
+ return mSkyDropletRadius;
}
F32 LLSettingsSky::getSkyIceLevel() const
{
- return (F32)mSettings[SETTING_SKY_ICE_LEVEL].asReal();
+ return mSkyIceLevel;
}
F32 LLSettingsSky::getReflectionProbeAmbiance(bool auto_adjust) const
@@ -1440,22 +1817,22 @@ F32 LLSettingsSky::getReflectionProbeAmbiance(bool auto_adjust) const
return sAutoAdjustProbeAmbiance;
}
- return (F32)mSettings[SETTING_REFLECTION_PROBE_AMBIANCE].asReal();
+ return mReflectionProbeAmbiance;
}
F32 LLSettingsSky::getSkyBottomRadius() const
{
- return (F32)mSettings[SETTING_SKY_BOTTOM_RADIUS].asReal();
+ return mSkyBottomRadius;
}
F32 LLSettingsSky::getSkyTopRadius() const
{
- return (F32)mSettings[SETTING_SKY_TOP_RADIUS].asReal();
+ return mSkyTopRadius;
}
F32 LLSettingsSky::getSunArcRadians() const
{
- return (F32)mSettings[SETTING_SUN_ARC_RADIANS].asReal();
+ return mSunArcRadians;
}
F32 LLSettingsSky::getMieAnisotropy() const
@@ -1465,158 +1842,171 @@ F32 LLSettingsSky::getMieAnisotropy() const
LLSD LLSettingsSky::getRayleighConfig() const
{
- LLSD copy = *(mSettings[SETTING_RAYLEIGH_CONFIG].beginArray());
+ LLSD copy = *(mRayleighConfigs.beginArray());
return copy;
}
LLSD LLSettingsSky::getMieConfig() const
{
- LLSD copy = *(mSettings[SETTING_MIE_CONFIG].beginArray());
+ LLSD copy = *(mMieConfigs.beginArray());
return copy;
}
LLSD LLSettingsSky::getAbsorptionConfig() const
{
- LLSD copy = *(mSettings[SETTING_ABSORPTION_CONFIG].beginArray());
+ LLSD copy = *(mAbsorptionConfigs.beginArray());
return copy;
}
LLSD LLSettingsSky::getRayleighConfigs() const
{
- return mSettings[SETTING_RAYLEIGH_CONFIG];
+ return mRayleighConfigs;
}
LLSD LLSettingsSky::getMieConfigs() const
{
- return mSettings[SETTING_MIE_CONFIG];
+ return mMieConfigs;
}
LLSD LLSettingsSky::getAbsorptionConfigs() const
{
- return mSettings[SETTING_ABSORPTION_CONFIG];
+ return mAbsorptionConfigs;
}
void LLSettingsSky::setRayleighConfigs(const LLSD& rayleighConfig)
{
- mSettings[SETTING_RAYLEIGH_CONFIG] = rayleighConfig;
+ mRayleighConfigs = rayleighConfig;
+ setLLSDDirty();
}
void LLSettingsSky::setMieConfigs(const LLSD& mieConfig)
{
- mSettings[SETTING_MIE_CONFIG] = mieConfig;
+ mMieConfigs = mieConfig;
+ setLLSDDirty();
}
void LLSettingsSky::setAbsorptionConfigs(const LLSD& absorptionConfig)
{
- mSettings[SETTING_ABSORPTION_CONFIG] = absorptionConfig;
+ mAbsorptionConfigs = absorptionConfig;
+ setLLSDDirty();
}
LLUUID LLSettingsSky::getBloomTextureId() const
{
- return mSettings[SETTING_BLOOM_TEXTUREID].asUUID();
+ return mBloomTextureId;
}
LLUUID LLSettingsSky::getRainbowTextureId() const
{
- return mSettings[SETTING_RAINBOW_TEXTUREID].asUUID();
+ return mRainbowTextureId;
}
LLUUID LLSettingsSky::getHaloTextureId() const
{
- return mSettings[SETTING_HALO_TEXTUREID].asUUID();
+ return mHaloTextureId;
}
//---------------------------------------------------------------------
LLColor3 LLSettingsSky::getCloudColor() const
{
- return LLColor3(mSettings[SETTING_CLOUD_COLOR]);
+ return mCloudColor;
}
void LLSettingsSky::setCloudColor(const LLColor3 &val)
{
- setValue(SETTING_CLOUD_COLOR, val);
+ mCloudColor = val;
+ setLLSDDirty();
}
LLUUID LLSettingsSky::getCloudNoiseTextureId() const
{
- return mSettings[SETTING_CLOUD_TEXTUREID].asUUID();
+ return mCloudTextureId;
}
void LLSettingsSky::setCloudNoiseTextureId(const LLUUID &id)
{
- setValue(SETTING_CLOUD_TEXTUREID, id);
+ mCloudTextureId = id;
+ setLLSDDirty();
}
LLColor3 LLSettingsSky::getCloudPosDensity1() const
{
- return LLColor3(mSettings[SETTING_CLOUD_POS_DENSITY1]);
+ return mCloudPosDensity1;
}
void LLSettingsSky::setCloudPosDensity1(const LLColor3 &val)
{
- setValue(SETTING_CLOUD_POS_DENSITY1, val);
+ mCloudPosDensity1 = val;
+ setLLSDDirty();
}
LLColor3 LLSettingsSky::getCloudPosDensity2() const
{
- return LLColor3(mSettings[SETTING_CLOUD_POS_DENSITY2]);
+ return mCloudPosDensity2;
}
void LLSettingsSky::setCloudPosDensity2(const LLColor3 &val)
{
- setValue(SETTING_CLOUD_POS_DENSITY2, val);
+ mCloudPosDensity2 = val;
+ setLLSDDirty();
}
F32 LLSettingsSky::getCloudScale() const
{
- return (F32)mSettings[SETTING_CLOUD_SCALE].asReal();
+ return mCloudScale;
}
void LLSettingsSky::setCloudScale(F32 val)
{
- setValue(SETTING_CLOUD_SCALE, val);
+ mCloudScale = val;
+ setLLSDDirty();
}
LLVector2 LLSettingsSky::getCloudScrollRate() const
{
- return LLVector2(mSettings[SETTING_CLOUD_SCROLL_RATE]);
+ return mScrollRate;
}
void LLSettingsSky::setCloudScrollRate(const LLVector2 &val)
{
- setValue(SETTING_CLOUD_SCROLL_RATE, val);
+ mScrollRate = val;
+ setLLSDDirty();
}
void LLSettingsSky::setCloudScrollRateX(F32 val)
{
- mSettings[SETTING_CLOUD_SCROLL_RATE][0] = val;
+ mScrollRate.mV[0] = val;
setDirtyFlag(true);
+ setLLSDDirty();
}
void LLSettingsSky::setCloudScrollRateY(F32 val)
{
- mSettings[SETTING_CLOUD_SCROLL_RATE][1] = val;
+ mScrollRate.mV[1] = val;
setDirtyFlag(true);
+ setLLSDDirty();
}
F32 LLSettingsSky::getCloudShadow() const
{
- return (F32)mSettings[SETTING_CLOUD_SHADOW].asReal();
+ return mCloudShadow;
}
void LLSettingsSky::setCloudShadow(F32 val)
{
- setValue(SETTING_CLOUD_SHADOW, val);
+ mCloudShadow = val;
+ setLLSDDirty();
}
F32 LLSettingsSky::getCloudVariance() const
{
- return (F32)mSettings[SETTING_CLOUD_VARIANCE].asReal();
+ return mCloudVariance;
}
void LLSettingsSky::setCloudVariance(F32 val)
{
- setValue(SETTING_CLOUD_VARIANCE, val);
+ mCloudVariance = val;
+ setLLSDDirty();
}
F32 LLSettingsSky::getDomeOffset() const
@@ -1633,88 +2023,95 @@ F32 LLSettingsSky::getDomeRadius() const
F32 LLSettingsSky::getGamma() const
{
- return (F32)mSettings[SETTING_GAMMA].asReal();
+ return mGamma;
}
void LLSettingsSky::setGamma(F32 val)
{
- mSettings[SETTING_GAMMA] = LLSD::Real(val);
+ mGamma = val;
setDirtyFlag(true);
+ setLLSDDirty();
}
-
LLColor3 LLSettingsSky::getGlow() const
{
- return LLColor3(mSettings[SETTING_GLOW]);
+ return mGlow;
}
void LLSettingsSky::setGlow(const LLColor3 &val)
{
- setValue(SETTING_GLOW, val);
+ mGlow = val;
+ setLLSDDirty();
}
F32 LLSettingsSky::getMaxY() const
{
- return (F32)mSettings[SETTING_MAX_Y].asReal();
+ return mMaxY;
}
void LLSettingsSky::setMaxY(F32 val)
{
- setValue(SETTING_MAX_Y, val);
+ mMaxY = val;
+ setLLSDDirty();
}
LLQuaternion LLSettingsSky::getMoonRotation() const
{
- return LLQuaternion(mSettings[SETTING_MOON_ROTATION]);
+ return mMoonRotation;
}
void LLSettingsSky::setMoonRotation(const LLQuaternion &val)
{
- setValue(SETTING_MOON_ROTATION, val);
+ mMoonRotation = val;
+ setLLSDDirty();
}
F32 LLSettingsSky::getMoonScale() const
{
- return (F32)mSettings[SETTING_MOON_SCALE].asReal();
+ return mMoonScale;
}
void LLSettingsSky::setMoonScale(F32 val)
{
- setValue(SETTING_MOON_SCALE, val);
+ mMoonScale = val;
+ setLLSDDirty();
}
LLUUID LLSettingsSky::getMoonTextureId() const
{
- return mSettings[SETTING_MOON_TEXTUREID].asUUID();
+ return mMoonTextureId;
}
void LLSettingsSky::setMoonTextureId(LLUUID id)
{
- setValue(SETTING_MOON_TEXTUREID, id);
+ mMoonTextureId = id;
+ setLLSDDirty();
}
F32 LLSettingsSky::getMoonBrightness() const
{
- return (F32)mSettings[SETTING_MOON_BRIGHTNESS].asReal();
+ return mMoonBrightness;
}
void LLSettingsSky::setMoonBrightness(F32 brightness_factor)
{
- setValue(SETTING_MOON_BRIGHTNESS, brightness_factor);
+ mMoonBrightness = brightness_factor;
+ setLLSDDirty();
}
F32 LLSettingsSky::getStarBrightness() const
{
- return (F32)mSettings[SETTING_STAR_BRIGHTNESS].asReal();
+ return mStarBrightness;
}
void LLSettingsSky::setStarBrightness(F32 val)
{
- setValue(SETTING_STAR_BRIGHTNESS, val);
+ mStarBrightness = val;
+ setLLSDDirty();
}
LLColor3 LLSettingsSky::getSunlightColor() const
{
- return LLColor3(mSettings[SETTING_SUNLIGHT_COLOR]);
+ return mSunlightColor;
}
LLColor3 LLSettingsSky::getSunlightColorClamped() const
@@ -1733,38 +2130,41 @@ LLColor3 LLSettingsSky::getSunlightColorClamped() const
void LLSettingsSky::setSunlightColor(const LLColor3 &val)
{
- setValue(SETTING_SUNLIGHT_COLOR, val);
+ mSunlightColor = val;
+ setLLSDDirty();
}
LLQuaternion LLSettingsSky::getSunRotation() const
{
- return LLQuaternion(mSettings[SETTING_SUN_ROTATION]);
+ return mSunRotation;
}
void LLSettingsSky::setSunRotation(const LLQuaternion &val)
{
- setValue(SETTING_SUN_ROTATION, val);
+ mSunRotation = val;
+ setLLSDDirty();
}
-
F32 LLSettingsSky::getSunScale() const
{
- return (F32)mSettings[SETTING_SUN_SCALE].asReal();
+ return mSunScale;
}
void LLSettingsSky::setSunScale(F32 val)
{
- setValue(SETTING_SUN_SCALE, val);
+ mSunScale = val;
+ setLLSDDirty();
}
LLUUID LLSettingsSky::getSunTextureId() const
{
- return mSettings[SETTING_SUN_TEXTUREID].asUUID();
+ return mSunTextureId;
}
void LLSettingsSky::setSunTextureId(LLUUID id)
{
- setValue(SETTING_SUN_TEXTUREID, id);
+ mSunTextureId = id;
+ setLLSDDirty();
}
LLUUID LLSettingsSky::getNextSunTextureId() const
@@ -1790,5 +2190,5 @@ LLUUID LLSettingsSky::getNextBloomTextureId() const
// if true, this sky is a candidate for auto-adjustment
bool LLSettingsSky::canAutoAdjust() const
{
- return !mSettings.has(SETTING_REFLECTION_PROBE_AMBIANCE);
+ return mCanAutoAdjust;
}
diff --git a/indra/llinventory/llsettingssky.h b/indra/llinventory/llsettingssky.h
index 40bb337a48..38c0368423 100644
--- a/indra/llinventory/llsettingssky.h
+++ b/indra/llinventory/llsettingssky.h
@@ -111,20 +111,24 @@ public:
LLSettingsSky(const LLSD &data);
virtual ~LLSettingsSky() { };
- virtual ptr_t buildClone() const = 0;
+ virtual ptr_t buildClone() = 0;
//---------------------------------------------------------------------
virtual std::string getSettingsType() const SETTINGS_OVERRIDE { return std::string("sky"); }
virtual LLSettingsType::type_e getSettingsTypeValue() const SETTINGS_OVERRIDE { return LLSettingsType::ST_SKY; }
// Settings status
- virtual void blend(const LLSettingsBase::ptr_t &end, F64 blendf) SETTINGS_OVERRIDE;
+ virtual void blend(LLSettingsBase::ptr_t &end, F64 blendf) SETTINGS_OVERRIDE;
virtual void replaceSettings(LLSD settings) SETTINGS_OVERRIDE;
+ virtual void replaceSettings(const LLSettingsBase::ptr_t& other_sky) override;
- void replaceWithSky(LLSettingsSky::ptr_t pother);
+ void replaceWithSky(const LLSettingsSky::ptr_t& pother);
static LLSD defaults(const LLSettingsBase::TrackPosition& position = 0.0f);
+ void loadValuesFromLLSD() override;
+ void saveValuesToLLSD() override;
+
F32 getPlanetRadius() const;
F32 getSkyBottomRadius() const;
F32 getSkyTopRadius() const;
@@ -306,7 +310,7 @@ public:
LLColor3 getSunlightColorClamped() const;
LLColor3 getAmbientColorClamped() const;
- virtual LLSettingsBase::ptr_t buildDerivedClone() const SETTINGS_OVERRIDE { return buildClone(); }
+ virtual LLSettingsBase::ptr_t buildDerivedClone() SETTINGS_OVERRIDE { return buildClone(); }
static LLUUID GetDefaultAssetId();
static LLUUID GetDefaultSunTextureId();
@@ -348,6 +352,12 @@ protected:
virtual stringset_t getSlerpKeys() const SETTINGS_OVERRIDE;
virtual stringset_t getSkipInterpolateKeys() const SETTINGS_OVERRIDE;
+ LLUUID mSunTextureId;
+ LLUUID mMoonTextureId;
+ LLUUID mCloudTextureId;
+ LLUUID mBloomTextureId;
+ LLUUID mRainbowTextureId;
+ LLUUID mHaloTextureId;
LLUUID mNextSunTextureId;
LLUUID mNextMoonTextureId;
LLUUID mNextCloudTextureId;
@@ -355,17 +365,64 @@ protected:
LLUUID mNextRainbowTextureId;
LLUUID mNextHaloTextureId;
+ bool mCanAutoAdjust;
+ LLQuaternion mSunRotation;
+ LLQuaternion mMoonRotation;
+ LLColor3 mSunlightColor;
+ LLColor3 mGlow;
+ F32 mReflectionProbeAmbiance;
+ F32 mSunScale;
+ F32 mStarBrightness;
+ F32 mMoonBrightness;
+ F32 mMoonScale;
+ F32 mMaxY;
+ F32 mGamma;
+ F32 mCloudVariance;
+ F32 mCloudShadow;
+ F32 mCloudScale;
+ LLVector2 mScrollRate;
+ LLColor3 mCloudPosDensity1;
+ LLColor3 mCloudPosDensity2;
+ LLColor3 mCloudColor;
+ LLSD mAbsorptionConfigs;
+ LLSD mMieConfigs;
+ LLSD mRayleighConfigs;
+ F32 mSunArcRadians;
+ F32 mSkyTopRadius;
+ F32 mSkyBottomRadius;
+ F32 mSkyMoistureLevel;
+ F32 mSkyDropletRadius;
+ F32 mSkyIceLevel;
+ F32 mPlanetRadius;
+
+ F32 mHazeHorizon;
+ F32 mHazeDensity;
+ F32 mDistanceMultiplier;
+ F32 mDensityMultiplier;
+ LLColor3 mBlueHorizon;
+ LLColor3 mBlueDensity;
+ LLColor3 mAmbientColor;
+
+ bool mHasLegacyHaze;
+ bool mLegacyHazeHorizon;
+ bool mLegacyHazeDensity;
+ bool mLegacyDistanceMultiplier;
+ bool mLegacyDensityMultiplier;
+ bool mLegacyBlueHorizon;
+ bool mLegacyBlueDensity;
+ bool mLegacyAmbientColor;
+
private:
static LLSD rayleighConfigDefault();
static LLSD absorptionConfigDefault();
static LLSD mieConfigDefault();
- LLColor3 getColor(const std::string& key, const LLColor3& default_value) const;
- F32 getFloat(const std::string& key, F32 default_value) const;
+ LLColor3 getColor(const std::string& key, const LLColor3& default_value);
+ F32 getFloat(const std::string& key, F32 default_value);
void calculateHeavenlyBodyPositions() const;
void calculateLightSettings() const;
- void clampColor(LLColor3& color, F32 gamma, const F32 scale = 1.0f) const;
+ static void clampColor(LLColor3& color, F32 gamma, const F32 scale = 1.0f);
mutable LLVector3 mSunDirection;
mutable LLVector3 mMoonDirection;
diff --git a/indra/llinventory/llsettingswater.cpp b/indra/llinventory/llsettingswater.cpp
index 161b8cda25..08e18ea26e 100644
--- a/indra/llinventory/llsettingswater.cpp
+++ b/indra/llinventory/llsettingswater.cpp
@@ -68,14 +68,18 @@ static const LLUUID DEFAULT_OPAQUE_WATER_TEXTURE("43c32285-d658-1793-c123-bf8631
//=========================================================================
LLSettingsWater::LLSettingsWater(const LLSD &data) :
LLSettingsBase(data),
- mNextNormalMapID()
+ mNextNormalMapID(),
+ mNextTransparentTextureID()
{
+ loadValuesFromLLSD();
}
LLSettingsWater::LLSettingsWater() :
LLSettingsBase(),
- mNextNormalMapID()
+ mNextNormalMapID(),
+ mNextTransparentTextureID()
{
+ replaceSettings(defaults());
}
//=========================================================================
@@ -109,6 +113,53 @@ LLSD LLSettingsWater::defaults(const LLSettingsBase::TrackPosition& position)
return dfltsetting;
}
+void LLSettingsWater::loadValuesFromLLSD()
+{
+ LL_PROFILE_ZONE_SCOPED_CATEGORY_ENVIRONMENT;
+
+ LLSettingsBase::loadValuesFromLLSD();
+
+ LLSD& settings = getSettings();
+
+ mBlurMultiplier = (F32)settings[SETTING_BLUR_MULTIPLIER].asReal();
+ mWaterFogColor = LLColor3(settings[SETTING_FOG_COLOR]);
+ mWaterFogDensity = (F32)settings[SETTING_FOG_DENSITY].asReal();
+ mFogMod = (F32)settings[SETTING_FOG_MOD].asReal();
+ mFresnelOffset = (F32)settings[SETTING_FRESNEL_OFFSET].asReal();
+ mFresnelScale = (F32)settings[SETTING_FRESNEL_SCALE].asReal();
+ mNormalScale = LLVector3(settings[SETTING_NORMAL_SCALE]);
+ mScaleAbove = (F32)settings[SETTING_SCALE_ABOVE].asReal();
+ mScaleBelow = (F32)settings[SETTING_SCALE_BELOW].asReal();
+ mWave1Dir = LLVector2(settings[SETTING_WAVE1_DIR]);
+ mWave2Dir = LLVector2(settings[SETTING_WAVE2_DIR]);
+
+ mNormalMapID = getNormalMapID();
+ mTransparentTextureID = getTransparentTextureID();
+}
+
+void LLSettingsWater::saveValuesToLLSD()
+{
+ LL_PROFILE_ZONE_SCOPED_CATEGORY_ENVIRONMENT;
+
+ LLSettingsBase::saveValuesToLLSD();
+
+ LLSD & settings = getSettings();
+ settings[SETTING_BLUR_MULTIPLIER] = LLSD::Real(mBlurMultiplier);
+ settings[SETTING_FOG_COLOR] = mWaterFogColor.getValue();
+ settings[SETTING_FOG_DENSITY] = LLSD::Real(mWaterFogDensity);
+ settings[SETTING_FOG_MOD] = LLSD::Real(mFogMod);
+ settings[SETTING_FRESNEL_OFFSET] = LLSD::Real(mFresnelOffset);
+ settings[SETTING_FRESNEL_SCALE] = LLSD::Real(mFresnelScale);
+ settings[SETTING_NORMAL_SCALE] = mNormalScale.getValue();
+ settings[SETTING_SCALE_ABOVE] = LLSD::Real(mScaleAbove);
+ settings[SETTING_SCALE_BELOW] = LLSD::Real(mScaleBelow);
+ settings[SETTING_WAVE1_DIR] = mWave1Dir.getValue();
+ settings[SETTING_WAVE2_DIR] = mWave2Dir.getValue();
+
+ settings[SETTING_NORMAL_MAP] = mNormalMapID;
+ settings[SETTING_TRANSPARENT_TEXTURE] = mTransparentTextureID;
+}
+
LLSD LLSettingsWater::translateLegacySettings(LLSD legacy)
{
bool converted_something(false);
@@ -180,13 +231,30 @@ LLSD LLSettingsWater::translateLegacySettings(LLSD legacy)
return newsettings;
}
-void LLSettingsWater::blend(const LLSettingsBase::ptr_t &end, F64 blendf)
+void LLSettingsWater::blend(LLSettingsBase::ptr_t &end, F64 blendf)
{
+ LL_PROFILE_ZONE_SCOPED_CATEGORY_ENVIRONMENT;
LLSettingsWater::ptr_t other = PTR_NAMESPACE::static_pointer_cast<LLSettingsWater>(end);
if (other)
{
- LLSD blenddata = interpolateSDMap(mSettings, other->mSettings, other->getParameterMap(), blendf);
- replaceSettings(blenddata);
+ mSettingFlags |= other->mSettingFlags;
+
+ mBlurMultiplier = lerp((F32)blendf, mBlurMultiplier, other->mBlurMultiplier);
+ lerpColor(mWaterFogColor, other->mWaterFogColor, (F32)blendf);
+ mWaterFogDensity = lerp((F32)blendf, mWaterFogDensity, other->mWaterFogDensity);
+ mFogMod = lerp((F32)blendf, mFogMod, other->mFogMod);
+ mFresnelOffset = lerp((F32)blendf, mFresnelOffset, other->mFresnelOffset);
+ mFresnelScale = lerp((F32)blendf, mFresnelScale, other->mFresnelScale);
+ lerpVector3(mNormalScale, other->mNormalScale, (F32)blendf);
+ mScaleAbove = lerp((F32)blendf, mScaleAbove, other->mScaleAbove);
+ mScaleBelow = lerp((F32)blendf, mScaleBelow, other->mScaleBelow);
+ lerpVector2(mWave1Dir, other->mWave1Dir, (F32)blendf);
+ lerpVector2(mWave2Dir, other->mWave2Dir, (F32)blendf);
+
+ setDirtyFlag(true);
+ setReplaced();
+ setLLSDDirty();
+
mNextNormalMapID = other->getNormalMapID();
mNextTransparentTextureID = other->getTransparentTextureID();
}
@@ -204,7 +272,34 @@ void LLSettingsWater::replaceSettings(LLSD settings)
mNextTransparentTextureID.setNull();
}
-void LLSettingsWater::replaceWithWater(LLSettingsWater::ptr_t other)
+void LLSettingsWater::replaceSettings(const LLSettingsBase::ptr_t& other_water)
+{
+ LLSettingsBase::replaceSettings(other_water);
+
+ llassert(getSettingsType() == other_water->getSettingsType());
+
+ LLSettingsWater::ptr_t other = PTR_NAMESPACE::dynamic_pointer_cast<LLSettingsWater>(other_water);
+
+ mBlurMultiplier = other->mBlurMultiplier;
+ mWaterFogColor = other->mWaterFogColor;
+ mWaterFogDensity = other->mWaterFogDensity;
+ mFogMod = other->mFogMod;
+ mFresnelOffset = other->mFresnelOffset;
+ mFresnelScale = other->mFresnelScale;
+ mNormalScale = other->mNormalScale;
+ mScaleAbove = other->mScaleAbove;
+ mScaleBelow = other->mScaleBelow;
+ mWave1Dir = other->mWave1Dir;
+ mWave2Dir = other->mWave2Dir;
+
+ mNormalMapID = other->mNormalMapID;
+ mTransparentTextureID = other->mTransparentTextureID;
+
+ mNextNormalMapID.setNull();
+ mNextTransparentTextureID.setNull();
+}
+
+void LLSettingsWater::replaceWithWater(const LLSettingsWater::ptr_t& other)
{
replaceWith(other);
diff --git a/indra/llinventory/llsettingswater.h b/indra/llinventory/llsettingswater.h
index 9e7ff61272..82fc37cfb3 100644
--- a/indra/llinventory/llsettingswater.h
+++ b/indra/llinventory/llsettingswater.h
@@ -55,151 +55,181 @@ public:
LLSettingsWater(const LLSD &data);
virtual ~LLSettingsWater() { };
- virtual ptr_t buildClone() const = 0;
+ virtual ptr_t buildClone() = 0;
//---------------------------------------------------------------------
virtual std::string getSettingsType() const SETTINGS_OVERRIDE { return std::string("water"); }
virtual LLSettingsType::type_e getSettingsTypeValue() const SETTINGS_OVERRIDE { return LLSettingsType::ST_WATER; }
// Settings status
- virtual void blend(const LLSettingsBase::ptr_t &end, F64 blendf) SETTINGS_OVERRIDE;
+ virtual void blend(LLSettingsBase::ptr_t &end, F64 blendf) SETTINGS_OVERRIDE;
virtual void replaceSettings(LLSD settings) SETTINGS_OVERRIDE;
- void replaceWithWater(LLSettingsWater::ptr_t other);
+ virtual void replaceSettings(const LLSettingsBase::ptr_t& other_water) override;
+ void replaceWithWater(const LLSettingsWater::ptr_t& other);
static LLSD defaults(const LLSettingsBase::TrackPosition& position = 0.0f);
+ void loadValuesFromLLSD() override;
+ void saveValuesToLLSD() override;
+
//---------------------------------------------------------------------
F32 getBlurMultiplier() const
{
- return (F32)mSettings[SETTING_BLUR_MULTIPLIER].asReal();
+ return mBlurMultiplier;
}
void setBlurMultiplier(F32 val)
{
- setValue(SETTING_BLUR_MULTIPLIER, val);
+ mBlurMultiplier = val;
+ setDirtyFlag(true);
+ setLLSDDirty();
}
LLColor3 getWaterFogColor() const
{
- return LLColor3(mSettings[SETTING_FOG_COLOR]);
+ return mWaterFogColor;
}
void setWaterFogColor(LLColor3 val)
{
- setValue(SETTING_FOG_COLOR, val);
+ mWaterFogColor = val;
+ setDirtyFlag(true);
+ setLLSDDirty();
}
F32 getWaterFogDensity() const
{
- return (F32)mSettings[SETTING_FOG_DENSITY].asReal();
+ return mWaterFogDensity;
}
F32 getModifiedWaterFogDensity(bool underwater) const;
void setWaterFogDensity(F32 val)
{
- setValue(SETTING_FOG_DENSITY, val);
+ mWaterFogDensity = val;
+ setDirtyFlag(true);
+ setLLSDDirty();
}
F32 getFogMod() const
{
- return (F32)mSettings[SETTING_FOG_MOD].asReal();
+ return mFogMod;
}
void setFogMod(F32 val)
{
- setValue(SETTING_FOG_MOD, val);
+ mFogMod = val;
+ setDirtyFlag(true);
+ setLLSDDirty();
}
F32 getFresnelOffset() const
{
- return (F32)mSettings[SETTING_FRESNEL_OFFSET].asReal();
+ return mFresnelOffset;
}
void setFresnelOffset(F32 val)
{
- setValue(SETTING_FRESNEL_OFFSET, val);
+ mFresnelOffset = val;
+ setDirtyFlag(true);
+ setLLSDDirty();
}
F32 getFresnelScale() const
{
- return (F32)mSettings[SETTING_FRESNEL_SCALE].asReal();
+ return mFresnelScale;
}
void setFresnelScale(F32 val)
{
- setValue(SETTING_FRESNEL_SCALE, val);
+ mFresnelScale = val;
+ setDirtyFlag(true);
+ setLLSDDirty();
}
LLUUID getTransparentTextureID() const
{
- return mSettings[SETTING_TRANSPARENT_TEXTURE].asUUID();
+ return mTransparentTextureID;
}
void setTransparentTextureID(LLUUID val)
{
- setValue(SETTING_TRANSPARENT_TEXTURE, val);
+ mTransparentTextureID = val;
+ setDirtyFlag(true);
+ setLLSDDirty();
}
LLUUID getNormalMapID() const
{
- return mSettings[SETTING_NORMAL_MAP].asUUID();
+ return mNormalMapID;
}
void setNormalMapID(LLUUID val)
{
- setValue(SETTING_NORMAL_MAP, val);
+ mNormalMapID = val;
+ setDirtyFlag(true);
+ setLLSDDirty();
}
LLVector3 getNormalScale() const
{
- return LLVector3(mSettings[SETTING_NORMAL_SCALE]);
+ return mNormalScale;
}
void setNormalScale(LLVector3 val)
{
- setValue(SETTING_NORMAL_SCALE, val);
+ mNormalScale = val;
+ setDirtyFlag(true);
+ setLLSDDirty();
}
F32 getScaleAbove() const
{
- return (F32)mSettings[SETTING_SCALE_ABOVE].asReal();
+ return mScaleAbove;
}
void setScaleAbove(F32 val)
{
- setValue(SETTING_SCALE_ABOVE, val);
+ mScaleAbove = val;
+ setDirtyFlag(true);
+ setLLSDDirty();
}
F32 getScaleBelow() const
{
- return (F32)mSettings[SETTING_SCALE_BELOW].asReal();
+ return mScaleBelow;
}
void setScaleBelow(F32 val)
{
- setValue(SETTING_SCALE_BELOW, val);
+ mScaleBelow = val;
+ setDirtyFlag(true);
+ setLLSDDirty();
}
LLVector2 getWave1Dir() const
{
- return LLVector2(mSettings[SETTING_WAVE1_DIR]);
+ return mWave1Dir;
}
void setWave1Dir(LLVector2 val)
{
- setValue(SETTING_WAVE1_DIR, val);
+ mWave1Dir = val;
+ setDirtyFlag(true);
+ setLLSDDirty();
}
LLVector2 getWave2Dir() const
{
- return LLVector2(mSettings[SETTING_WAVE2_DIR]);
+ return mWave2Dir;
}
void setWave2Dir(LLVector2 val)
{
- setValue(SETTING_WAVE2_DIR, val);
+ mWave2Dir = val;
+ setDirtyFlag(true);
+ setLLSDDirty();
}
//-------------------------------------------
@@ -218,7 +248,7 @@ public:
static LLSD translateLegacySettings(LLSD legacy);
- virtual LLSettingsBase::ptr_t buildDerivedClone() const SETTINGS_OVERRIDE { return buildClone(); }
+ virtual LLSettingsBase::ptr_t buildDerivedClone() SETTINGS_OVERRIDE { return buildClone(); }
static LLUUID GetDefaultAssetId();
static LLUUID GetDefaultWaterNormalAssetId();
@@ -241,9 +271,22 @@ protected:
LLSettingsWater();
+ LLUUID mTransparentTextureID;
+ LLUUID mNormalMapID;
LLUUID mNextTransparentTextureID;
LLUUID mNextNormalMapID;
+ F32 mBlurMultiplier;
+ LLColor3 mWaterFogColor;
+ F32 mWaterFogDensity;
+ F32 mFogMod;
+ F32 mFresnelOffset;
+ F32 mFresnelScale;
+ LLVector3 mNormalScale;
+ F32 mScaleAbove;
+ F32 mScaleBelow;
+ LLVector2 mWave1Dir;
+ LLVector2 mWave2Dir;
};
#endif