Merge branch 'master' into DRTVWR-519

# Conflicts:
#	README.md

5 files changed, 111 insertions, 109 deletions

diff --git a/indra/llinventory/llsettingsbase.cpp b/indra/llinventory/llsettingsbase.cpp
index 61b59e35aa..8a8e2bb340 100644
--- a/indra/llinventory/llsettingsbase.cpp
+++ b/indra/llinventory/llsettingsbase.cpp
@@ -395,7 +395,7 @@ bool LLSettingsBase::validate()
 
 LLSD LLSettingsBase::settingValidation(LLSD &settings, validation_list_t &validations, bool partial)
 {
-    static Validator  validateName(SETTING_NAME, false, LLSD::TypeString, boost::bind(&Validator::verifyStringLength, _1, 63));
+    static Validator  validateName(SETTING_NAME, false, LLSD::TypeString, boost::bind(&Validator::verifyStringLength, _1, _2, 63));
     static Validator  validateId(SETTING_ID, false, LLSD::TypeUUID);
     static Validator  validateHash(SETTING_HASH, false, LLSD::TypeInteger);
     static Validator  validateType(SETTING_TYPE, false, LLSD::TypeString);
@@ -534,7 +534,7 @@ bool LLSettingsBase::Validator::verify(LLSD &data, U32 flags)
         return false;
     }
 
-    if (!mVerify.empty() && !mVerify(data[mName]))
+    if (!mVerify.empty() && !mVerify(data[mName], flags))
     {
         LL_WARNS("SETTINGS") << "Setting '" << mName << "' fails validation." << LL_ENDL;
         return false;
@@ -543,17 +543,17 @@ bool LLSettingsBase::Validator::verify(LLSD &data, U32 flags)
     return true;
 }
 
-bool LLSettingsBase::Validator::verifyColor(LLSD &value)
+bool LLSettingsBase::Validator::verifyColor(LLSD &value, U32)
 {
     return (value.size() == 3 || value.size() == 4);
 }
 
-bool LLSettingsBase::Validator::verifyVector(LLSD &value, S32 length)
+bool LLSettingsBase::Validator::verifyVector(LLSD &value, U32, S32 length)
 {
     return (value.size() == length);
 }
 
-bool LLSettingsBase::Validator::verifyVectorNormalized(LLSD &value, S32 length)
+bool LLSettingsBase::Validator::verifyVectorNormalized(LLSD &value, U32, S32 length)
 {
     if (value.size() != length)
         return false;
@@ -596,7 +596,7 @@ bool LLSettingsBase::Validator::verifyVectorNormalized(LLSD &value, S32 length)
     return true;
 }
 
-bool LLSettingsBase::Validator::verifyVectorMinMax(LLSD &value, LLSD minvals, LLSD maxvals)
+bool LLSettingsBase::Validator::verifyVectorMinMax(LLSD &value, U32, LLSD minvals, LLSD maxvals)
 {
     for (S32 index = 0; index < value.size(); ++index)
     {
@@ -619,12 +619,12 @@ bool LLSettingsBase::Validator::verifyVectorMinMax(LLSD &value, LLSD minvals, LL
     return true;
 }
 
-bool LLSettingsBase::Validator::verifyQuaternion(LLSD &value)
+bool LLSettingsBase::Validator::verifyQuaternion(LLSD &value, U32)
 {
     return (value.size() == 4);
 }
 
-bool LLSettingsBase::Validator::verifyQuaternionNormal(LLSD &value)
+bool LLSettingsBase::Validator::verifyQuaternionNormal(LLSD &value, U32)
 {
     if (value.size() != 4)
         return false;
@@ -642,7 +642,7 @@ bool LLSettingsBase::Validator::verifyQuaternionNormal(LLSD &value)
     return true;
 }
 
-bool LLSettingsBase::Validator::verifyFloatRange(LLSD &value, LLSD range)
+bool LLSettingsBase::Validator::verifyFloatRange(LLSD &value, U32, LLSD range)
 {
     F64 real = value.asReal();
 
@@ -655,7 +655,7 @@ bool LLSettingsBase::Validator::verifyFloatRange(LLSD &value, LLSD range)
     return true;
 }
 
-bool LLSettingsBase::Validator::verifyIntegerRange(LLSD &value, LLSD range)
+bool LLSettingsBase::Validator::verifyIntegerRange(LLSD &value, U32, LLSD range)
 {
     S32 ival = value.asInteger();
 
@@ -668,7 +668,7 @@ bool LLSettingsBase::Validator::verifyIntegerRange(LLSD &value, LLSD range)
     return true;
 }
 
-bool LLSettingsBase::Validator::verifyStringLength(LLSD &value, S32 length)
+bool LLSettingsBase::Validator::verifyStringLength(LLSD &value, U32, S32 length)
 {
     std::string sval = value.asString();
 
diff --git a/indra/llinventory/llsettingsbase.h b/indra/llinventory/llsettingsbase.h
index f7a9d5b7cd..1f0589f571 100644
--- a/indra/llinventory/llsettingsbase.h
+++ b/indra/llinventory/llsettingsbase.h
@@ -270,7 +270,7 @@ public:
     public:
         static const U32 VALIDATION_PARTIAL;
         
-        typedef boost::function<bool(LLSD &)> verify_pr;
+        typedef boost::function<bool(LLSD &, U32)> verify_pr;
 
         Validator(std::string name, bool required, LLSD::Type type, verify_pr verify = verify_pr(), LLSD defval = LLSD())  :
             mName(name),
@@ -287,15 +287,15 @@ public:
         bool        verify(LLSD &data, U32 flags);
 
         // Some basic verifications
-        static bool verifyColor(LLSD &value);
-        static bool verifyVector(LLSD &value, S32 length);
-        static bool verifyVectorMinMax(LLSD &value, LLSD minvals, LLSD maxvals);
-        static bool verifyVectorNormalized(LLSD &value, S32 length);
-        static bool verifyQuaternion(LLSD &value);
-        static bool verifyQuaternionNormal(LLSD &value);
-        static bool verifyFloatRange(LLSD &value, LLSD range);
-        static bool verifyIntegerRange(LLSD &value, LLSD range);
-        static bool verifyStringLength(LLSD &value, S32 length);
+        static bool verifyColor(LLSD &value, U32 flags);
+        static bool verifyVector(LLSD &value, U32 flags, S32 length);
+        static bool verifyVectorMinMax(LLSD &value, U32 flags, LLSD minvals, LLSD maxvals);
+        static bool verifyVectorNormalized(LLSD &value, U32 flags, S32 length);
+        static bool verifyQuaternion(LLSD &value, U32 flags);
+        static bool verifyQuaternionNormal(LLSD &value, U32 flags);
+        static bool verifyFloatRange(LLSD &value, U32 flags, LLSD range);
+        static bool verifyIntegerRange(LLSD &value, U32 flags, LLSD range);
+        static bool verifyStringLength(LLSD &value, U32 flags, S32 length);
 
     private:
         std::string mName;
diff --git a/indra/llinventory/llsettingsdaycycle.cpp b/indra/llinventory/llsettingsdaycycle.cpp
index a687fd840d..2bb03e8391 100644
--- a/indra/llinventory/llsettingsdaycycle.cpp
+++ b/indra/llinventory/llsettingsdaycycle.cpp
@@ -460,7 +460,7 @@ void LLSettingsDay::blend(const LLSettingsBase::ptr_t &other, F64 mix)
 
 namespace
 {
-    bool validateDayCycleTrack(LLSD &value)
+    bool validateDayCycleTrack(LLSD &value, U32 flags)
     {
         // Trim extra tracks.
         while (value.size() > LLSettingsDay::TRACK_MAX)
@@ -531,7 +531,7 @@ namespace
         return true;
     }
 
-    bool validateDayCycleFrames(LLSD &value)
+    bool validateDayCycleFrames(LLSD &value, U32 flags)
     {
         bool hasSky(false);
         bool hasWater(false);
@@ -544,7 +544,7 @@ namespace
             if (ftype == "sky")
             {
                 LLSettingsSky::validation_list_t valid_sky = LLSettingsSky::validationList();
-                LLSD res_sky = LLSettingsBase::settingValidation(frame, valid_sky);
+                LLSD res_sky = LLSettingsBase::settingValidation(frame, valid_sky, flags);
                 
                 if (res_sky["success"].asInteger() == 0)
                 {
@@ -557,7 +557,7 @@ namespace
             else if (ftype == "water")
             {
                 LLSettingsWater::validation_list_t valid_h2o = LLSettingsWater::validationList();
-                LLSD res_h2o = LLSettingsBase::settingValidation(frame, valid_h2o);
+                LLSD res_h2o = LLSettingsBase::settingValidation(frame, valid_h2o, flags);
                 if (res_h2o["success"].asInteger() == 0)
                 {
                     LL_WARNS("SETTINGS") << "Water setting named '" << (*itf).first << "' validation failed!: " << res_h2o << LL_ENDL;
@@ -573,18 +573,20 @@ namespace
             }
         }
 
-        if (!hasSky)
+        if ((flags & LLSettingsBase::Validator::VALIDATION_PARTIAL) == 0)
         {
-            LL_WARNS("SETTINGS") << "No skies defined." << LL_ENDL;
-            return false;
-        }
+            if (!hasSky)
+            {
+                LL_WARNS("SETTINGS") << "No skies defined." << LL_ENDL;
+                return false;
+            }
 
-        if (!hasWater)
-        {
-            LL_WARNS("SETTINGS") << "No waters defined." << LL_ENDL;
-            return false;
+            if (!hasWater)
+            {
+                LL_WARNS("SETTINGS") << "No waters defined." << LL_ENDL;
+                return false;
+            }
         }
-
         return true;
     }
 }
diff --git a/indra/llinventory/llsettingssky.cpp b/indra/llinventory/llsettingssky.cpp
index 81937dbda5..1470edbf38 100644
--- a/indra/llinventory/llsettingssky.cpp
+++ b/indra/llinventory/llsettingssky.cpp
@@ -156,25 +156,25 @@ LLSettingsSky::validation_list_t legacyHazeValidationList()
     if (legacyHazeValidation.empty())
     {
         legacyHazeValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_AMBIENT,             false,  LLSD::TypeArray, 
-            boost::bind(&LLSettingsBase::Validator::verifyVectorMinMax, _1,
+            boost::bind(&LLSettingsBase::Validator::verifyVectorMinMax, _1, _2,
                 LLSD(LLSDArray(0.0f)(0.0f)(0.0f)("*")),
                 LLSD(LLSDArray(3.0f)(3.0f)(3.0f)("*")))));
         legacyHazeValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_BLUE_DENSITY,        false,  LLSD::TypeArray, 
-            boost::bind(&LLSettingsBase::Validator::verifyVectorMinMax, _1,
+            boost::bind(&LLSettingsBase::Validator::verifyVectorMinMax, _1, _2,
                 LLSD(LLSDArray(0.0f)(0.0f)(0.0f)("*")),
                 LLSD(LLSDArray(3.0f)(3.0f)(3.0f)("*")))));
         legacyHazeValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_BLUE_HORIZON,        false,  LLSD::TypeArray, 
-            boost::bind(&LLSettingsBase::Validator::verifyVectorMinMax, _1,
+            boost::bind(&LLSettingsBase::Validator::verifyVectorMinMax, _1, _2,
                 LLSD(LLSDArray(0.0f)(0.0f)(0.0f)("*")),
                 LLSD(LLSDArray(3.0f)(3.0f)(3.0f)("*")))));
         legacyHazeValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_HAZE_DENSITY,        false,  LLSD::TypeReal,  
-            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0f)(5.0f)))));
+            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(5.0f)))));
         legacyHazeValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_HAZE_HORIZON,        false,  LLSD::TypeReal,  
-            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0f)(5.0f)))));
+            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(5.0f)))));
         legacyHazeValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_MULTIPLIER,  false,  LLSD::TypeReal,  
-            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0001f)(2.0f)))));
+            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0001f)(2.0f)))));
         legacyHazeValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DISTANCE_MULTIPLIER, false,  LLSD::TypeReal,
-            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0001f)(1000.0f)))));
+            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0001f)(1000.0f)))));
     }
     return legacyHazeValidation;
 }
@@ -185,19 +185,19 @@ LLSettingsSky::validation_list_t rayleighValidationList()
     if (rayleighValidation.empty())
     {
         rayleighValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_PROFILE_WIDTH,      false,  LLSD::TypeReal,  
-            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0f)(32768.0f)))));
+            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(32768.0f)))));
 
         rayleighValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_PROFILE_EXP_TERM,   false,  LLSD::TypeReal,  
-            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0f)(2.0f)))));
+            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(2.0f)))));
         
         rayleighValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_PROFILE_EXP_SCALE_FACTOR, false,  LLSD::TypeReal,  
-            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, LLSD(LLSDArray(-1.0f)(1.0f)))));
+            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(-1.0f)(1.0f)))));
 
         rayleighValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_PROFILE_LINEAR_TERM, false,  LLSD::TypeReal,  
-            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0f)(2.0f)))));
+            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(2.0f)))));
 
         rayleighValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_PROFILE_CONSTANT_TERM, false,  LLSD::TypeReal,  
-            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0f)(1.0f)))));
+            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(1.0f)))));
     }
     return rayleighValidation;
 }
@@ -208,19 +208,19 @@ LLSettingsSky::validation_list_t absorptionValidationList()
     if (absorptionValidation.empty())
     {
         absorptionValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_PROFILE_WIDTH,      false,  LLSD::TypeReal,  
-            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0f)(32768.0f)))));
+            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(32768.0f)))));
 
         absorptionValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_PROFILE_EXP_TERM,   false,  LLSD::TypeReal,  
-            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0f)(2.0f)))));
+            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(2.0f)))));
         
         absorptionValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_PROFILE_EXP_SCALE_FACTOR, false,  LLSD::TypeReal,  
-            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, LLSD(LLSDArray(-1.0f)(1.0f)))));
+            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(-1.0f)(1.0f)))));
 
         absorptionValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_PROFILE_LINEAR_TERM, false,  LLSD::TypeReal,  
-            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0f)(2.0f)))));
+            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(2.0f)))));
 
         absorptionValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_PROFILE_CONSTANT_TERM, false,  LLSD::TypeReal,  
-            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0f)(1.0f)))));
+            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(1.0f)))));
     }
     return absorptionValidation;
 }
@@ -231,31 +231,31 @@ LLSettingsSky::validation_list_t mieValidationList()
     if (mieValidation.empty())
     {
         mieValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_PROFILE_WIDTH,      false,  LLSD::TypeReal,  
-            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0f)(32768.0f)))));
+            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(32768.0f)))));
 
         mieValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_PROFILE_EXP_TERM,   false,  LLSD::TypeReal,  
-            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0f)(2.0f)))));
+            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(2.0f)))));
         
         mieValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_PROFILE_EXP_SCALE_FACTOR, false,  LLSD::TypeReal,  
-            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, LLSD(LLSDArray(-1.0f)(1.0f)))));
+            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(-1.0f)(1.0f)))));
 
         mieValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_PROFILE_LINEAR_TERM, false,  LLSD::TypeReal,  
-            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0f)(2.0f)))));
+            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(2.0f)))));
 
         mieValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_DENSITY_PROFILE_CONSTANT_TERM, false,  LLSD::TypeReal,  
-            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0f)(1.0f)))));
+            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(1.0f)))));
 
         mieValidation.push_back(LLSettingsBase::Validator(LLSettingsSky::SETTING_MIE_ANISOTROPY_FACTOR, false,  LLSD::TypeReal,  
-            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0f)(1.0f)))));
+            boost::bind(&LLSettingsBase::Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(1.0f)))));
     }
     return mieValidation;
 }
 
-bool validateLegacyHaze(LLSD &value)
+bool validateLegacyHaze(LLSD &value, U32 flags)
 {
     LLSettingsSky::validation_list_t legacyHazeValidations = legacyHazeValidationList();
     llassert(value.type() == LLSD::TypeMap);
-    LLSD result = LLSettingsBase::settingValidation(value, legacyHazeValidations);
+    LLSD result = LLSettingsBase::settingValidation(value, legacyHazeValidations, flags);
     if (result["errors"].size() > 0)
     {
         LL_WARNS("SETTINGS") << "Legacy Haze Config Validation errors: " << result["errors"] << LL_ENDL;
@@ -269,7 +269,7 @@ bool validateLegacyHaze(LLSD &value)
     return true;
 }
 
-bool validateRayleighLayers(LLSD &value)
+bool validateRayleighLayers(LLSD &value, U32 flags)
 {
     LLSettingsSky::validation_list_t rayleighValidations = rayleighValidationList();
     if (value.isArray())
@@ -280,24 +280,24 @@ bool validateRayleighLayers(LLSD &value)
             LLSD& layerConfig = (*itf);
             if (layerConfig.type() == LLSD::TypeMap)
             {
-                if (!validateRayleighLayers(layerConfig))
+                if (!validateRayleighLayers(layerConfig, flags))
                 {
                     allGood = false;
                 }
             }
             else if (layerConfig.type() == LLSD::TypeArray)
             {
-                return validateRayleighLayers(layerConfig);
+                return validateRayleighLayers(layerConfig, flags);
             }
             else
             {
-                return LLSettingsBase::settingValidation(value, rayleighValidations);
+                return LLSettingsBase::settingValidation(value, rayleighValidations, flags);
             }
         }
         return allGood;
     }    
     llassert(value.type() == LLSD::TypeMap);
-    LLSD result = LLSettingsBase::settingValidation(value, rayleighValidations);
+    LLSD result = LLSettingsBase::settingValidation(value, rayleighValidations, flags);
     if (result["errors"].size() > 0)
     {
         LL_WARNS("SETTINGS") << "Rayleigh Config Validation errors: " << result["errors"] << LL_ENDL;
@@ -311,7 +311,7 @@ bool validateRayleighLayers(LLSD &value)
     return true;
 }
 
-bool validateAbsorptionLayers(LLSD &value)
+bool validateAbsorptionLayers(LLSD &value, U32 flags)
 {
     LLSettingsBase::validation_list_t absorptionValidations = absorptionValidationList();
     if (value.isArray())
@@ -322,24 +322,24 @@ bool validateAbsorptionLayers(LLSD &value)
             LLSD& layerConfig = (*itf);
             if (layerConfig.type() == LLSD::TypeMap)
             {
-                if (!validateAbsorptionLayers(layerConfig))
+                if (!validateAbsorptionLayers(layerConfig, flags))
                 {
                     allGood = false;
                 }
             }
             else if (layerConfig.type() == LLSD::TypeArray)
             {
-                return validateAbsorptionLayers(layerConfig);
+                return validateAbsorptionLayers(layerConfig, flags);
             }
             else
             {
-                return LLSettingsBase::settingValidation(value, absorptionValidations);
+                return LLSettingsBase::settingValidation(value, absorptionValidations, flags);
             }
         }
         return allGood;
     }
     llassert(value.type() == LLSD::TypeMap);
-    LLSD result = LLSettingsBase::settingValidation(value, absorptionValidations);
+    LLSD result = LLSettingsBase::settingValidation(value, absorptionValidations, flags);
     if (result["errors"].size() > 0)
     {
         LL_WARNS("SETTINGS") << "Absorption Config Validation errors: " << result["errors"] << LL_ENDL;
@@ -353,7 +353,7 @@ bool validateAbsorptionLayers(LLSD &value)
     return true;
 }
 
-bool validateMieLayers(LLSD &value)
+bool validateMieLayers(LLSD &value, U32 flags)
 {
     LLSettingsBase::validation_list_t mieValidations = mieValidationList();
     if (value.isArray())
@@ -364,23 +364,23 @@ bool validateMieLayers(LLSD &value)
             LLSD& layerConfig = (*itf);
             if (layerConfig.type() == LLSD::TypeMap)
             {
-                if (!validateMieLayers(layerConfig))
+                if (!validateMieLayers(layerConfig, flags))
                 {
                     allGood = false;
                 }
             }
             else if (layerConfig.type() == LLSD::TypeArray)
             {
-                return validateMieLayers(layerConfig);
+                return validateMieLayers(layerConfig, flags);
             }
             else
             {
-                return LLSettingsBase::settingValidation(value, mieValidations);
+                return LLSettingsBase::settingValidation(value, mieValidations, flags);
             }
         }
         return allGood;
     }
-    LLSD result = LLSettingsBase::settingValidation(value, mieValidations);
+    LLSD result = LLSettingsBase::settingValidation(value, mieValidations, flags);
     if (result["errors"].size() > 0)
     {
         LL_WARNS("SETTINGS") << "Mie Config Validation errors: " << result["errors"] << LL_ENDL;
@@ -559,80 +559,80 @@ LLSettingsSky::validation_list_t LLSettingsSky::validationList()
         validation.push_back(Validator(SETTING_HALO_TEXTUREID,      false,  LLSD::TypeUUID));
 
         validation.push_back(Validator(SETTING_CLOUD_COLOR,         true,  LLSD::TypeArray, 
-            boost::bind(&Validator::verifyVectorMinMax, _1,
+            boost::bind(&Validator::verifyVectorMinMax, _1, _2,
                 LLSD(LLSDArray(0.0f)(0.0f)(0.0f)("*")),
                 LLSD(LLSDArray(1.0f)(1.0f)(1.0f)("*")))));
         validation.push_back(Validator(SETTING_CLOUD_POS_DENSITY1,  true,  LLSD::TypeArray, 
-            boost::bind(&Validator::verifyVectorMinMax, _1,
+            boost::bind(&Validator::verifyVectorMinMax, _1, _2,
                 LLSD(LLSDArray(0.0f)(0.0f)(0.0f)("*")),
                 LLSD(LLSDArray(1.0f)(1.0f)(3.0f)("*")))));
         validation.push_back(Validator(SETTING_CLOUD_POS_DENSITY2,  true,  LLSD::TypeArray, 
-            boost::bind(&Validator::verifyVectorMinMax, _1,
+            boost::bind(&Validator::verifyVectorMinMax, _1, _2,
                 LLSD(LLSDArray(0.0f)(0.0f)(0.0f)("*")),
                 LLSD(LLSDArray(1.0f)(1.0f)(1.0f)("*")))));
         validation.push_back(Validator(SETTING_CLOUD_SCALE,         true,  LLSD::TypeReal,  
-            boost::bind(&Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.001f)(3.0f)))));
+            boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.001f)(3.0f)))));
         validation.push_back(Validator(SETTING_CLOUD_SCROLL_RATE,   true,  LLSD::TypeArray, 
-            boost::bind(&Validator::verifyVectorMinMax, _1,
+            boost::bind(&Validator::verifyVectorMinMax, _1, _2,
                 LLSD(LLSDArray(-50.0f)(-50.0f)),
                 LLSD(LLSDArray(50.0f)(50.0f)))));
         validation.push_back(Validator(SETTING_CLOUD_SHADOW,        true,  LLSD::TypeReal,  
-            boost::bind(&Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0f)(1.0f)))));
+            boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(1.0f)))));
         validation.push_back(Validator(SETTING_CLOUD_TEXTUREID,     false, LLSD::TypeUUID));
         validation.push_back(Validator(SETTING_CLOUD_VARIANCE,      false,  LLSD::TypeReal,  
-            boost::bind(&Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0f)(1.0f)))));
+            boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(1.0f)))));
 
         validation.push_back(Validator(SETTING_DOME_OFFSET,         false, LLSD::TypeReal,  
-            boost::bind(&Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0f)(1.0f)))));
+            boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(1.0f)))));
         validation.push_back(Validator(SETTING_DOME_RADIUS,         false, LLSD::TypeReal,  
-            boost::bind(&Validator::verifyFloatRange, _1, LLSD(LLSDArray(1000.0f)(2000.0f)))));
+            boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(1000.0f)(2000.0f)))));
         validation.push_back(Validator(SETTING_GAMMA,               true,  LLSD::TypeReal,  
-            boost::bind(&Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0f)(20.0f)))));
+            boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(20.0f)))));
         validation.push_back(Validator(SETTING_GLOW,                true,  LLSD::TypeArray, 
-            boost::bind(&Validator::verifyVectorMinMax, _1,
+            boost::bind(&Validator::verifyVectorMinMax, _1, _2,
                 LLSD(LLSDArray(0.2f)("*")(-10.0f)("*")),
                 LLSD(LLSDArray(40.0f)("*")(10.0f)("*")))));
         
         validation.push_back(Validator(SETTING_MAX_Y,               true,  LLSD::TypeReal,  
-            boost::bind(&Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0f)(10000.0f)))));
+            boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(10000.0f)))));
         validation.push_back(Validator(SETTING_MOON_ROTATION,       true,  LLSD::TypeArray, &Validator::verifyQuaternionNormal));
         validation.push_back(Validator(SETTING_MOON_SCALE,          false, LLSD::TypeReal,
-                boost::bind(&Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.25f)(20.0f))), LLSD::Real(1.0)));
+                boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.25f)(20.0f))), LLSD::Real(1.0)));
         validation.push_back(Validator(SETTING_MOON_TEXTUREID,      false, LLSD::TypeUUID));
         validation.push_back(Validator(SETTING_MOON_BRIGHTNESS,     false,  LLSD::TypeReal, 
-            boost::bind(&Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0f)(1.0f)))));
+            boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(1.0f)))));
 
         validation.push_back(Validator(SETTING_STAR_BRIGHTNESS,     true,  LLSD::TypeReal, 
-            boost::bind(&Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0f)(500.0f)))));
+            boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(500.0f)))));
         validation.push_back(Validator(SETTING_SUNLIGHT_COLOR,      true,  LLSD::TypeArray, 
-            boost::bind(&Validator::verifyVectorMinMax, _1,
+            boost::bind(&Validator::verifyVectorMinMax, _1, _2,
                 LLSD(LLSDArray(0.0f)(0.0f)(0.0f)("*")),
                 LLSD(LLSDArray(3.0f)(3.0f)(3.0f)("*")))));
         validation.push_back(Validator(SETTING_SUN_ROTATION,        true,  LLSD::TypeArray, &Validator::verifyQuaternionNormal));
         validation.push_back(Validator(SETTING_SUN_SCALE,           false, LLSD::TypeReal,
-            boost::bind(&Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.25f)(20.0f))), LLSD::Real(1.0)));
+            boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.25f)(20.0f))), LLSD::Real(1.0)));
         validation.push_back(Validator(SETTING_SUN_TEXTUREID, false, LLSD::TypeUUID));
 
         validation.push_back(Validator(SETTING_PLANET_RADIUS,       true,  LLSD::TypeReal,  
-            boost::bind(&Validator::verifyFloatRange, _1, LLSD(LLSDArray(1000.0f)(32768.0f)))));
+            boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(1000.0f)(32768.0f)))));
 
         validation.push_back(Validator(SETTING_SKY_BOTTOM_RADIUS,   true,  LLSD::TypeReal,  
-            boost::bind(&Validator::verifyFloatRange, _1, LLSD(LLSDArray(1000.0f)(32768.0f)))));
+            boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(1000.0f)(32768.0f)))));
 
         validation.push_back(Validator(SETTING_SKY_TOP_RADIUS,       true,  LLSD::TypeReal,  
-            boost::bind(&Validator::verifyFloatRange, _1, LLSD(LLSDArray(1000.0f)(32768.0f)))));
+            boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(1000.0f)(32768.0f)))));
 
         validation.push_back(Validator(SETTING_SUN_ARC_RADIANS,      true,  LLSD::TypeReal,  
-            boost::bind(&Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0f)(0.1f)))));
+            boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(0.1f)))));
 
         validation.push_back(Validator(SETTING_SKY_MOISTURE_LEVEL,      false,  LLSD::TypeReal,  
-            boost::bind(&Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0f)(1.0f)))));
+            boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(1.0f)))));
 
         validation.push_back(Validator(SETTING_SKY_DROPLET_RADIUS,      false,  LLSD::TypeReal,  
-            boost::bind(&Validator::verifyFloatRange, _1, LLSD(LLSDArray(5.0f)(1000.0f)))));
+            boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(5.0f)(1000.0f)))));
 
         validation.push_back(Validator(SETTING_SKY_ICE_LEVEL,      false,  LLSD::TypeReal,  
-            boost::bind(&Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0f)(1.0f)))));
+            boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(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));
diff --git a/indra/llinventory/llsettingswater.cpp b/indra/llinventory/llsettingswater.cpp
index 0eb95dcd89..1ae8d78b22 100644
--- a/indra/llinventory/llsettingswater.cpp
+++ b/indra/llinventory/llsettingswater.cpp
@@ -236,34 +236,34 @@ LLSettingsWater::validation_list_t LLSettingsWater::validationList()
         // in deeply nested arrays like this [[[[[[[[[[v1,v2,v3]]]]]]]]]]
 
         validation.push_back(Validator(SETTING_BLUR_MULTIPLIER, true, LLSD::TypeReal,
-            boost::bind(&Validator::verifyFloatRange, _1, LLSD(LLSDArray(-0.5f)(0.5f)))));
+            boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(-0.5f)(0.5f)))));
         validation.push_back(Validator(SETTING_FOG_COLOR, true, LLSD::TypeArray,
-            boost::bind(&Validator::verifyVectorMinMax, _1,
+            boost::bind(&Validator::verifyVectorMinMax, _1, _2,
                 LLSD(LLSDArray(0.0f)(0.0f)(0.0f)(1.0f)),
                 LLSD(LLSDArray(1.0f)(1.0f)(1.0f)(1.0f)))));
         validation.push_back(Validator(SETTING_FOG_DENSITY, true, LLSD::TypeReal,
-            boost::bind(&Validator::verifyFloatRange, _1, LLSD(LLSDArray(-10.0f)(10.0f)))));
+            boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(-10.0f)(10.0f)))));
         validation.push_back(Validator(SETTING_FOG_MOD, true, LLSD::TypeReal,
-            boost::bind(&Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0f)(20.0f)))));
+            boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(20.0f)))));
         validation.push_back(Validator(SETTING_FRESNEL_OFFSET, true, LLSD::TypeReal,
-            boost::bind(&Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0f)(1.0f)))));
+            boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(1.0f)))));
         validation.push_back(Validator(SETTING_FRESNEL_SCALE, true, LLSD::TypeReal,
-            boost::bind(&Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0f)(1.0f)))));
+            boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(1.0f)))));
         validation.push_back(Validator(SETTING_NORMAL_MAP, true, LLSD::TypeUUID));
         validation.push_back(Validator(SETTING_NORMAL_SCALE, true, LLSD::TypeArray,
-            boost::bind(&Validator::verifyVectorMinMax, _1,
+            boost::bind(&Validator::verifyVectorMinMax, _1, _2,
                 LLSD(LLSDArray(0.0f)(0.0f)(0.0f)),
                 LLSD(LLSDArray(10.0f)(10.0f)(10.0f)))));
         validation.push_back(Validator(SETTING_SCALE_ABOVE, true, LLSD::TypeReal,
-            boost::bind(&Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0f)(3.0f)))));
+            boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(3.0f)))));
         validation.push_back(Validator(SETTING_SCALE_BELOW, true, LLSD::TypeReal,
-            boost::bind(&Validator::verifyFloatRange, _1, LLSD(LLSDArray(0.0f)(3.0f)))));
+            boost::bind(&Validator::verifyFloatRange, _1, _2, LLSD(LLSDArray(0.0f)(3.0f)))));
         validation.push_back(Validator(SETTING_WAVE1_DIR, true, LLSD::TypeArray,
-            boost::bind(&Validator::verifyVectorMinMax, _1,
+            boost::bind(&Validator::verifyVectorMinMax, _1, _2,
                 LLSD(LLSDArray(-20.0f)(-20.0f)),
                 LLSD(LLSDArray(20.0f)(20.0f)))));
         validation.push_back(Validator(SETTING_WAVE2_DIR, true, LLSD::TypeArray,
-            boost::bind(&Validator::verifyVectorMinMax, _1,
+            boost::bind(&Validator::verifyVectorMinMax, _1, _2,
                 LLSD(LLSDArray(-20.0f)(-20.0f)),
                 LLSD(LLSDArray(20.0f)(20.0f)))));
     }