Merge branch 'master' into DRTVWR-482

# Conflicts:
#	indra/newview/app_settings/shaders/class1/objects/previewV.glsl
#	indra/newview/lldynamictexture.cpp
#	indra/newview/llfloatermodelpreview.cpp

1 files changed, 459 insertions, 0 deletions

diff --git a/indra/newview/llenvadapters.h b/indra/newview/llenvadapters.h
new file mode 100644
index 0000000000..bd58db0589
--- /dev/null
+++ b/indra/newview/llenvadapters.h
@@ -0,0 +1,459 @@
+/**
+ * @file llenvadapters.h
+ * @brief Declaration of classes managing WindLight and water settings.
+ *
+ * $LicenseInfo:firstyear=2009&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2011, Linden Research, Inc.
+ * 
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ * 
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * 
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_ENVADAPTERS_H
+#define LL_ENVADAPTERS_H
+
+#include "v3math.h"
+#include "v3color.h"
+#include "v4math.h"
+#include "llsettingsbase.h"
+#include "llsettingssky.h"
+
+class WLColorControl 
+{
+public:
+    inline WLColorControl(LLColor4 color, const std::string& n, const std::string& slider_name = std::string()):
+        mColor(color), 
+        mName(n), 
+        mSliderName(slider_name),
+        mHasSliderName(false),
+        mIsSunOrAmbientColor(false),
+        mIsBlueHorizonOrDensity(false)
+    {
+        // if there's a slider name, say we have one
+        mHasSliderName = !mSliderName.empty();
+
+        // if it's the sun controller
+        mIsSunOrAmbientColor = (mSliderName == "WLSunlight" || mSliderName == "WLAmbient");
+        mIsBlueHorizonOrDensity = (mSliderName == "WLBlueHorizon" || mSliderName == "WLBlueDensity");
+    }
+
+    inline void setColor4(const LLColor4 & val)
+    {
+        mColor = val;
+    }
+
+    inline void setColor3(const LLColor3 & val)
+    {
+        mColor = val;
+    }
+
+    inline LLColor4 getColor4() const
+    {
+        return mColor;
+    }
+
+    inline LLColor3 getColor3(void) const 
+    {
+        return vec4to3(mColor);
+    }
+
+    inline void update(const LLSettingsBase::ptr_t &psetting) const 
+    {
+        psetting->setValue(mName, mColor);
+    }
+
+    inline bool getHasSliderName() const
+    {
+        return mHasSliderName;
+    }
+
+    inline std::string getSliderName() const
+    {
+        return mSliderName;
+    }
+
+    inline bool getIsSunOrAmbientColor() const
+    {
+        return mIsSunOrAmbientColor;
+    }
+
+    inline bool getIsBlueHorizonOrDensity() const
+    {
+        return mIsBlueHorizonOrDensity;
+    }
+
+    inline F32 getRed() const
+    {
+        return mColor[0];
+    }
+
+    inline F32 getGreen() const
+    {
+        return mColor[1];
+    }
+
+    inline F32 getBlue() const
+    {
+        return mColor[2];
+    }
+
+    inline F32 getIntensity() const
+    {
+        return mColor[3];
+    }
+
+    inline void setRed(F32 red)
+    {
+        mColor[0] = red;
+    }
+
+    inline void setGreen(F32 green)
+    {
+        mColor[1] = green;
+    }
+
+    inline void setBlue(F32 blue)
+    {
+        mColor[2] = blue;
+    }
+
+    inline void setIntensity(F32 intensity)
+    {
+        mColor[3] = intensity;
+    }
+
+private:
+    LLColor4    mColor;         /// [3] is intensity, not alpha
+    std::string mName;			/// name to use to dereference params
+    std::string mSliderName;	/// name of the slider in menu
+    bool        mHasSliderName;			/// only set slider name for true color types
+    bool        mIsSunOrAmbientColor;			/// flag for if it's the sun or ambient color controller
+    bool        mIsBlueHorizonOrDensity;		/// flag for if it's the Blue Horizon or Density color controller
+
+};
+
+// float slider control
+class WLFloatControl 
+{
+public:
+    inline WLFloatControl(F32 val, const std::string& n, F32 m = 1.0f):
+        x(val), 
+        mName(n), 
+        mult(m)
+    {
+    }
+
+    inline WLFloatControl &operator = (F32 val) 
+    {
+        x = val;
+        return *this;
+    }
+
+    inline operator F32 (void) const 
+    {
+        return x;
+    }
+
+    inline void update(const LLSettingsBase::ptr_t &psetting) const 
+    {
+        psetting->setValue(mName, x);
+    }
+
+    inline F32 getMult() const
+    {
+        return mult;
+    }
+
+    inline void setValue(F32 val)
+    {
+        x = val;
+    }
+
+private:
+    F32 x;
+    std::string mName;
+    F32 mult;
+};
+
+class WLXFloatControl
+{
+public:
+    inline WLXFloatControl(F32 val, const std::string& n, F32 b): 
+        mExp(val),
+        mBase(b),
+        mName(n)
+    {
+    }
+
+    inline WLXFloatControl & operator = (F32 val)
+    {
+        mExp = log(val) / log(mBase);
+
+        return *this;
+    }
+
+    inline operator F32 (void) const
+    {
+        return pow(mBase, mExp);
+    }
+
+    inline void update(const LLSettingsBase::ptr_t &psetting) const
+    {
+        psetting->setValue(mName, pow(mBase, mExp));
+    }
+
+    inline F32 getExp() const
+    {
+        return mExp;
+    }
+
+    inline void setExp(F32 val)
+    {
+        mExp = val;
+    }
+
+    inline F32 getBase() const
+    {
+        return mBase;
+    }
+
+    inline void setBase(F32 val)
+    {
+        mBase = val;
+    }
+
+private:
+    F32 mExp;
+    F32 mBase;
+    std::string mName;
+};
+
+class WLVect2Control
+{
+public:
+    inline WLVect2Control(LLVector2 val, const std::string& n): 
+        mU(val.mV[0]), 
+        mV(val.mV[1]), 
+        mName(n)
+    {
+    }
+
+    inline WLVect2Control & operator = (const LLVector2 & val)
+    {
+        mU = val.mV[0];
+        mV = val.mV[1];
+
+        return *this;
+    }
+
+    inline void update(const LLSettingsBase::ptr_t &psetting) const
+    {
+        psetting->setValue(mName, LLVector2(mU, mV));
+    }
+
+    inline F32 getU() const
+    {
+        return mU;
+    }
+
+    inline void setU(F32 val)
+    {
+        mU = val;
+    }
+
+    inline F32 getV() const
+    {
+        return mV;
+    }
+
+    inline void setV(F32 val)
+    {
+        mV = val;
+    }
+
+private:
+    F32 mU;
+    F32 mV;
+    std::string mName;
+};
+
+class WLVect3Control
+{
+public:
+    inline WLVect3Control(LLVector3 val, const std::string& n):
+        mX(val.mV[0]),
+        mY(val.mV[1]),
+        mZ(val.mV[2]),
+        mName(n)
+    {
+    }
+
+    inline WLVect3Control & operator = (const LLVector3 & val)
+    {
+        mX = val.mV[0];
+        mY = val.mV[1];
+        mZ = val.mV[2];
+
+        return *this;
+    }
+
+    inline void update(const LLSettingsBase::ptr_t &psetting) const
+    {
+        psetting->setValue(mName, LLVector3(mX, mY, mZ));
+    }
+
+    inline F32 getX() const
+    {
+        return mX;
+    }
+
+    inline void setX(F32 val)
+    {
+        mX = val;
+    }
+
+    inline F32 getY() const
+    {
+        return mY;
+    }
+
+    inline void setY(F32 val)
+    {
+        mY = val;
+    }
+
+    inline F32 getZ() const
+    {
+        return mZ;
+    }
+
+    inline void setZ(F32 val)
+    {
+        mZ = val;
+    }
+
+private:
+    F32 mX;
+    F32 mY;
+    F32 mZ;
+    std::string mName;
+};
+
+class LLDensityProfileSettingsAdapter
+{
+public:
+    LLDensityProfileSettingsAdapter(const std::string& config, int layerIndex = 0)
+    : mConfig(config)
+    , mLayerIndex(layerIndex)
+    , mLayerWidth(1.0f, LLSettingsSky::SETTING_DENSITY_PROFILE_WIDTH)
+    , mExpTerm(1.0f, LLSettingsSky::SETTING_DENSITY_PROFILE_EXP_TERM)
+    , mExpScale(1.0f, LLSettingsSky::SETTING_DENSITY_PROFILE_EXP_SCALE_FACTOR)
+    , mLinTerm(1.0f, LLSettingsSky::SETTING_DENSITY_PROFILE_LINEAR_TERM)
+    , mConstantTerm(1.0f, LLSettingsSky::SETTING_DENSITY_PROFILE_CONSTANT_TERM)
+    {}
+
+protected:
+    std::string     mConfig;
+    int             mLayerIndex;
+    WLFloatControl  mLayerWidth; // 0.0 -> to top of atmosphere, however big that may be.
+    WLFloatControl  mExpTerm;
+    WLFloatControl  mExpScale;
+    WLFloatControl  mLinTerm;
+    WLFloatControl  mConstantTerm;
+};
+
+class LLRayleighDensityProfileSettingsAdapter : public LLDensityProfileSettingsAdapter
+{
+public:
+    LLRayleighDensityProfileSettingsAdapter(int layerIndex = 0)
+    : LLDensityProfileSettingsAdapter(LLSettingsSky::SETTING_RAYLEIGH_CONFIG, layerIndex)
+    {
+    }
+};
+
+class LLMieDensityProfileSettingsAdapter : public LLDensityProfileSettingsAdapter
+{
+public:
+    LLMieDensityProfileSettingsAdapter(int layerIndex = 0)
+    : LLDensityProfileSettingsAdapter(LLSettingsSky::SETTING_MIE_CONFIG, layerIndex)
+    , mAnisotropy(0.8f, LLSettingsSky::SETTING_MIE_ANISOTROPY_FACTOR)
+    {
+    }
+
+protected:
+    WLFloatControl  mAnisotropy;
+};
+
+class LLAbsorptionDensityProfileSettingsAdapter : public LLDensityProfileSettingsAdapter
+{
+public:
+    LLAbsorptionDensityProfileSettingsAdapter(int layerIndex = 0)
+    : LLDensityProfileSettingsAdapter(LLSettingsSky::SETTING_ABSORPTION_CONFIG, layerIndex)
+    {
+    }
+};
+
+//-------------------------------------------------------------------------
+class LLSkySettingsAdapter
+{
+public:
+    typedef std::shared_ptr<LLSkySettingsAdapter> ptr_t;
+    
+    LLSkySettingsAdapter();
+
+    WLFloatControl  mWLGamma;
+
+    /// Lighting
+    WLColorControl  mLightnorm;
+    WLColorControl  mSunlight;    
+    WLColorControl  mGlow;
+
+    /// Clouds
+    WLColorControl  mCloudColor;
+    WLColorControl  mCloudMain;
+    WLFloatControl  mCloudCoverage;
+    WLColorControl  mCloudDetail;    
+    WLFloatControl  mCloudScale;
+};
+
+class LLWatterSettingsAdapter
+{
+public:
+    typedef std::shared_ptr<LLWatterSettingsAdapter> ptr_t;
+
+    LLWatterSettingsAdapter();
+
+    WLColorControl  mFogColor;
+    WLXFloatControl mFogDensity;
+    WLFloatControl  mUnderWaterFogMod;
+
+    /// wavelet scales and directions
+    WLVect3Control  mNormalScale;
+    WLVect2Control  mWave1Dir;
+    WLVect2Control  mWave2Dir;
+
+    // controls how water is reflected and refracted
+    WLFloatControl  mFresnelScale;
+    WLFloatControl  mFresnelOffset;
+    WLFloatControl  mScaleAbove;
+    WLFloatControl  mScaleBelow;
+    WLFloatControl  mBlurMultiplier;
+
+};
+
+#endif // LL_ENVIRONMENT_H