Visual Polish Alpha

indra/cmake/CMakeLists.txt

@@ -56,7 +56,6 @@ set(cmake_SOURCE_FILES
         SSE2NEON.cmake
         TemplateCheck.cmake
         TinyEXR.cmake
-        TinyGLTF.cmake
         Tracy.cmake
         Tut.cmake
         UI.cmake

indra/llinventory/llsettingssky.cpp

@@ -134,6 +134,16 @@ const std::string LLSettingsSky::SETTING_SKY_DROPLET_RADIUS("droplet_radius");
 const std::string LLSettingsSky::SETTING_SKY_ICE_LEVEL("ice_level");
 
 const std::string LLSettingsSky::SETTING_REFLECTION_PROBE_AMBIANCE("reflection_probe_ambiance");
+const std::string LLSettingsSky::SETTING_AMBIENT_SKY_SATURATION("ambient_sky_saturation");
+
+const std::string LLSettingsSky::SETTING_SKY_VERSION("sky_version");
+const std::string LLSettingsSky::SETTING_SUN_BRIGHTNESS("sun_brightness");
+
+const std::string LLSettingsSky::SETTING_HDR_OFFSET("hdr_offset");
+const std::string LLSettingsSky::SETTING_HDR_MAX("hdr_max");
+const std::string LLSettingsSky::SETTING_HDR_MIN("hdr_min");
+const std::string LLSettingsSky::SETTING_HDR_TONEMAPPER("hdr_tonemapper");
+const std::string LLSettingsSky::SETTING_HDR_TONEMAPPER_AMOUNT("hdr_tonemapper_amount");
 
 const LLUUID LLSettingsSky::DEFAULT_ASSET_ID("651510b8-5f4d-8991-1592-e7eeab2a5a06");
 
@@ -442,12 +452,15 @@ void LLSettingsSky::replaceSettings(const LLSettingsBase::ptr_t& other_sky)
 
     LLSettingsSky::ptr_t other = PTR_NAMESPACE::dynamic_pointer_cast<LLSettingsSky>(other_sky);
 
+    mSkySettingVersion = other->mSkySettingVersion;
+
     mCanAutoAdjust = other->mCanAutoAdjust;
     mReflectionProbeAmbiance = other->mReflectionProbeAmbiance;
 
     mSunScale = other->mSunScale;
     mSunRotation = other->mSunRotation;
     mSunlightColor = other->mSunlightColor;
+    mSunBrightness = other->mSunBrightness;
     mStarBrightness = other->mStarBrightness;
     mMoonBrightness = other->mMoonBrightness;
     mMoonScale = other->mMoonScale;
@@ -499,6 +512,12 @@ void LLSettingsSky::replaceSettings(const LLSettingsBase::ptr_t& other_sky)
     mRainbowTextureId = other->mRainbowTextureId;
     mBloomTextureId = other->mBloomTextureId;
 
+    mHDRMin = other->mHDRMin;
+    mHDRMax = other->mHDRMax;
+    mHDROffset = other->mHDROffset;
+    mTonemapper = other->mTonemapper;
+    mTonemapMix = other->mTonemapMix;
+
     mNextSunTextureId.setNull();
     mNextMoonTextureId.setNull();
     mNextCloudTextureId.setNull();
@@ -605,6 +624,7 @@ void LLSettingsSky::blend(LLSettingsBase::ptr_t &end, F64 blendf)
         mCanAutoAdjust = other->mCanAutoAdjust;
 
         mSunRotation = slerp((F32)blendf, mSunRotation, other->mSunRotation);
+        mSunBrightness = lerp(mSunBrightness, other->mSunBrightness, (F32)blendf);
         mMoonRotation = slerp((F32)blendf, mMoonRotation, other->mMoonRotation);
         lerpColor(mSunlightColor, other->mSunlightColor, (F32)blendf);
         lerpColor(mGlow, other->mGlow, (F32)blendf);
@@ -631,6 +651,14 @@ void LLSettingsSky::blend(LLSettingsBase::ptr_t &end, F64 blendf)
         mSkyIceLevel = lerp(mSkyIceLevel, other->mSkyIceLevel, (F32)blendf);
         mPlanetRadius = lerp(mPlanetRadius, other->mPlanetRadius, (F32)blendf);
 
+        mTonemapMix = lerp(mTonemapMix, other->mTonemapMix, (F32)blendf);
+        mHDRMax = lerp(mHDRMax, other->mHDRMax, (F32)blendf);
+        mHDRMin = lerp(mHDRMin, other->mHDRMin, (F32)blendf);
+        mHDROffset = lerp(mHDROffset, other->mHDROffset, (F32)blendf);
+        mAmbientSkySaturation = lerp(mAmbientSkySaturation, other->mAmbientSkySaturation, (F32)blendf);
+
+        mTonemapper = other->mTonemapper;
+
         // Legacy settings
 
         if (other->mHasLegacyHaze)
@@ -835,6 +863,9 @@ LLSettingsSky::validation_list_t LLSettingsSky::validationList()
         validation.push_back(Validator(SETTING_REFLECTION_PROBE_AMBIANCE, false, LLSD::TypeReal,
             boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(llsd::array(0.0f, 10.0f)))));
 
+        validation.push_back(Validator(SETTING_AMBIENT_SKY_SATURATION, false, LLSD::TypeReal,
+            boost::bind(&Validator::verifyFloatRange, _1, _2, llsd::array(0.0f, 1.0f))));
+
         validation.push_back(Validator(SETTING_RAYLEIGH_CONFIG, true, LLSD::TypeArray, &validateRayleighLayers));
         validation.push_back(Validator(SETTING_ABSORPTION_CONFIG, true, LLSD::TypeArray, &validateAbsorptionLayers));
         validation.push_back(Validator(SETTING_MIE_CONFIG, true, LLSD::TypeArray, &validateMieLayers));
@@ -1204,10 +1235,43 @@ void LLSettingsSky::loadValuesFromLLSD()
         mReflectionProbeAmbiance = (F32)settings[SETTING_REFLECTION_PROBE_AMBIANCE].asReal();
     }
 
-    mHDRMax = 2.0f;
-    mHDRMin = 0.5f;
-    mHDROffset = 1.0f;
-    mTonemapMix = 1.0f;
+
+    // Legacy (pre-Visual Polish) skies are version 1.
+    // Post-VP skies are are 2 and higher.
+    // Note: version increments should be saved for behavioral changes, not necessarily param additions.
+    // The version should be set server-side, not viewer-side.
+    // - Geenz, Feb 21, 2026
+    if (settings.has(SETTING_SKY_VERSION))
+    {
+        mSkySettingVersion = (U8)settings[SETTING_SKY_VERSION].asReal();
+    }
+    else
+    {
+        mSkySettingVersion = 1;
+    }
+
+    if (mSkySettingVersion > 1)
+    {
+        mHDRMax = (F32)settings[SETTING_HDR_MAX].asReal();
+        mHDRMin = (F32)settings[SETTING_HDR_MIN].asReal();
+        mHDROffset = (F32)settings[SETTING_HDR_OFFSET].asReal();
+        mTonemapMix = (F32)settings[SETTING_HDR_TONEMAPPER_AMOUNT].asReal();
+        mTonemapper = (U8)settings[SETTING_HDR_TONEMAPPER].asInteger();
+        mSunBrightness = (F32)settings[SETTING_SUN_BRIGHTNESS].asReal();
+        mAmbientSkySaturation = settings.has(SETTING_AMBIENT_SKY_SATURATION)
+            ? (F32)settings[SETTING_AMBIENT_SKY_SATURATION].asReal()
+            : 0.0f;
+    }
+    else
+    {
+        mHDRMax = 2.0f;
+        mHDRMin = 0.5f;
+        mHDROffset = 1.0f;
+        mTonemapMix = 1.0f;
+        mTonemapper = 0;
+        mSunBrightness = 130000.f; // Brightness roughly around high noon in lux.
+        mAmbientSkySaturation = 0.0f;
+    }
 
     mSunTextureId = settings[SETTING_SUN_TEXTUREID].asUUID();
     mMoonTextureId = settings[SETTING_MOON_TEXTUREID].asUUID();
@@ -1326,6 +1390,17 @@ void LLSettingsSky::saveValuesToLLSD()
     settings[SETTING_SKY_DROPLET_RADIUS] = mSkyDropletRadius;
     settings[SETTING_SKY_ICE_LEVEL] = mSkyIceLevel;
     settings[SETTING_PLANET_RADIUS] = mPlanetRadius;
+    if (mSkySettingVersion > 1)
+    {
+        settings[SETTING_HDR_MAX] = mHDRMax;
+        settings[SETTING_HDR_MIN] = mHDRMin;
+        settings[SETTING_HDR_OFFSET] = mHDROffset;
+        settings[SETTING_HDR_TONEMAPPER] = mTonemapper;
+        settings[SETTING_HDR_TONEMAPPER_AMOUNT] = mTonemapMix;
+        settings[SETTING_SKY_VERSION] = mSkySettingVersion;
+        settings[SETTING_SUN_BRIGHTNESS] = mSunBrightness;
+        settings[SETTING_AMBIENT_SKY_SATURATION] = mAmbientSkySaturation;
+    }
 
     LLSD& legacy = settings[SETTING_LEGACY_HAZE];
     set_legacy(settings, legacy, SETTING_DISTANCE_MULTIPLIER, mLegacyDistanceMultiplier, LLSD::Real(mDistanceMultiplier));
@@ -1540,6 +1615,18 @@ void LLSettingsSky::setReflectionProbeAmbiance(F32 ambiance)
     setLLSDDirty();
 }
 
+F32 LLSettingsSky::getAmbientSkySaturation() const
+{
+    return mAmbientSkySaturation;
+}
+
+void LLSettingsSky::setAmbientSkySaturation(F32 val)
+{
+    mAmbientSkySaturation = val;
+    setDirtyFlag(true);
+    setLLSDDirty();
+}
+
 void LLSettingsSky::setAmbientColor(const LLColor3 &val)
 {
     mAmbientColor = val;
@@ -2063,31 +2150,52 @@ F32 LLSettingsSky::getGamma() const
 
 F32 LLSettingsSky::getHDRMin(bool auto_adjust) const
 {
-    if (mCanAutoAdjust && !auto_adjust)
+    if ((mCanAutoAdjust || mSkySettingVersion < 2) && !auto_adjust)
         return 0.f;
 
     return mHDRMin;
 }
 
 F32 LLSettingsSky::getHDRMax(bool auto_adjust) const
 {
-    if (mCanAutoAdjust && !auto_adjust)
+    if ((mCanAutoAdjust || mSkySettingVersion < 2) && !auto_adjust)
         return 0.f;
 
     return mHDRMax;
 }
 
 F32 LLSettingsSky::getHDROffset(bool auto_adjust) const
 {
-    if (mCanAutoAdjust && !auto_adjust)
+    if ((mCanAutoAdjust || mSkySettingVersion < 2) && !auto_adjust)
         return 1.0f;
 
     return mHDROffset;
 }
 
+void LLSettingsSky::setHDRMin(F32 val)
+{
+    mHDRMin = val;
+    setDirtyFlag(true);
+    setLLSDDirty();
+}
+
+void LLSettingsSky::setHDRMax(F32 val)
+{
+    mHDRMax = val;
+    setDirtyFlag(true);
+    setLLSDDirty();
+}
+
+void LLSettingsSky::setHDROffset(F32 val)
+{
+    mHDROffset = val;
+    setDirtyFlag(true);
+    setLLSDDirty();
+}
+
 F32 LLSettingsSky::getTonemapMix(bool auto_adjust) const
 {
-    if (mCanAutoAdjust && !auto_adjust)
+    if ((mCanAutoAdjust || mSkySettingVersion < 2) && !auto_adjust)
     {
         // legacy settings do not support tonemaping
         return 0.0f;
@@ -2099,6 +2207,32 @@ F32 LLSettingsSky::getTonemapMix(bool auto_adjust) const
 void LLSettingsSky::setTonemapMix(F32 mix)
 {
     mTonemapMix = mix;
+    setDirtyFlag(true);
+    setLLSDDirty();
+}
+
+U8 LLSettingsSky::getTonemapper() const
+{
+    return mTonemapper;
+}
+
+void LLSettingsSky::setTonemapper(U8 tonemapper)
+{
+    mTonemapper = tonemapper;
+    setDirtyFlag(true);
+    setLLSDDirty();
+}
+
+U8 LLSettingsSky::getSkySettingVersion() const
+{
+    return mSkySettingVersion;
+}
+
+void LLSettingsSky::setSkySettingVersion(U8 version)
+{
+    mSkySettingVersion = version;
+    setDirtyFlag(true);
+    setLLSDDirty();
 }
 
 void LLSettingsSky::setGamma(F32 val)
@@ -2189,6 +2323,24 @@ void LLSettingsSky::setStarBrightness(F32 val)
     setLLSDDirty();
 }
 
+F32 LLSettingsSky::getSunBrightness() const
+{
+    if (mSkySettingVersion < 2)
+    {
+        // V1 skies used a ~1.0 light scale.
+        // Return the lux equivalent for a PBR pipeline (shader normalizes by dividing by 100000).
+        return 130000.f;
+    }
+    return mSunBrightness;
+}
+
+void LLSettingsSky::setSunBrightness(F32 val)
+{
+    mSunBrightness = val;
+    setDirtyFlag(true);
+    setLLSDDirty();
+}
+
 LLColor3 LLSettingsSky::getSunlightColor() const
 {
     return mSunlightColor;

indra/llinventory/llsettingssky.h

@@ -40,6 +40,8 @@ const F32 MOON_DIST     =    384.400e6f;
 class LLSettingsSky: public LLSettingsBase
 {
 public:
+    static const std::string SETTING_SKY_VERSION;
+    static const U8 MAX_SKY_SETTINGS_VERSION = 2;
     static const std::string SETTING_AMBIENT;
     static const std::string SETTING_BLOOM_TEXTUREID;
     static const std::string SETTING_RAINBOW_TEXTUREID;
@@ -75,6 +77,7 @@ class LLSettingsSky: public LLSettingsBase
     static const std::string SETTING_SUN_ROTATION;
     static const std::string SETTING_SUN_SCALE;
     static const std::string SETTING_SUN_TEXTUREID;
+    static const std::string SETTING_SUN_BRIGHTNESS;
 
     static const std::string SETTING_PLANET_RADIUS;
     static const std::string SETTING_SKY_BOTTOM_RADIUS;
@@ -98,6 +101,7 @@ class LLSettingsSky: public LLSettingsBase
     static const std::string SETTING_SKY_ICE_LEVEL;
 
     static const std::string SETTING_REFLECTION_PROBE_AMBIANCE;
+    static const std::string SETTING_AMBIENT_SKY_SATURATION;
 
     static const std::string SETTING_LEGACY_HAZE;
 
@@ -106,6 +110,13 @@ class LLSettingsSky: public LLSettingsBase
     static const F32 DEFAULT_AUTO_ADJUST_PROBE_AMBIANCE;
     static F32 sAutoAdjustProbeAmbiance;
 
+    static const std::string SETTING_HDR_OFFSET;
+    static const std::string SETTING_HDR_MAX;
+    static const std::string SETTING_HDR_MIN;
+
+    static const std::string SETTING_HDR_TONEMAPPER;
+    static const std::string SETTING_HDR_TONEMAPPER_AMOUNT;
+
     typedef PTR_NAMESPACE::shared_ptr<LLSettingsSky> ptr_t;
 
     //---------------------------------------------------------------------
@@ -174,6 +185,9 @@ class LLSettingsSky: public LLSettingsBase
 
     void setReflectionProbeAmbiance(F32 ambiance);
 
+    F32 getAmbientSkySaturation() const;
+    void setAmbientSkySaturation(F32 val);
+
     //---------------------------------------------------------------------
     LLColor3 getAmbientColor() const;
     void setAmbientColor(const LLColor3 &val);
@@ -213,8 +227,17 @@ class LLSettingsSky: public LLSettingsBase
     F32 getHDRMin(bool auto_adjust = false) const;
     F32 getHDRMax(bool auto_adjust = false) const;
     F32 getHDROffset(bool auto_adjust = false) const;
+    void setHDRMin(F32 val);
+    void setHDRMax(F32 val);
+    void setHDROffset(F32 val);
+
     F32 getTonemapMix(bool auto_adjust = false) const;
     void setTonemapMix(F32 mix);
+    U8 getTonemapper() const;
+    void setTonemapper(U8 tonemapper);
+
+    U8 getSkySettingVersion() const;
+    void setSkySettingVersion(U8 version);
 
     void setGamma(F32 val);
 
@@ -240,6 +263,9 @@ class LLSettingsSky: public LLSettingsBase
     F32 getStarBrightness() const;
     void setStarBrightness(F32 val);
 
+    F32 getSunBrightness() const;
+    void setSunBrightness(F32 val);
+
     LLColor3 getSunlightColor() const;
     void setSunlightColor(const LLColor3 &val);
 
@@ -373,11 +399,14 @@ class LLSettingsSky: public LLSettingsBase
     LLUUID      mNextHaloTextureId;
 
     bool mCanAutoAdjust;
+    U8 mSkySettingVersion;
     LLQuaternion mSunRotation;
     LLQuaternion mMoonRotation;
     LLColor3 mSunlightColor;
+    F32 mSunBrightness;
     LLColor3 mGlow;
     F32 mReflectionProbeAmbiance;
+    F32 mAmbientSkySaturation;
     F32 mSunScale;
     F32 mStarBrightness;
     F32 mMoonBrightness;
@@ -387,6 +416,7 @@ class LLSettingsSky: public LLSettingsBase
     F32 mCloudVariance;
     F32 mCloudShadow;
     F32 mCloudScale;
+    U8  mTonemapper;
     F32 mTonemapMix;
     F32 mHDROffset;
     F32 mHDRMax;