Merge branch 'master' into DRTVWR-483

# Conflicts:
#	indra/newview/CMakeLists.txt
#	indra/newview/llviewerfloaterreg.cpp
#	indra/newview/skins/default/xui/de/floater_preview_texture.xml
#	indra/newview/skins/default/xui/es/floater_preview_texture.xml
#	indra/newview/skins/default/xui/fr/floater_preview_texture.xml
#	indra/newview/skins/default/xui/it/floater_preview_texture.xml
#	indra/newview/skins/default/xui/ja/panel_edit_classified.xml
#	indra/newview/skins/default/xui/ja/panel_me.xml
#	indra/newview/skins/default/xui/ru/floater_preview_texture.xml
#	indra/newview/skins/default/xui/tr/floater_picks.xml
#	indra/newview/skins/default/xui/tr/floater_preview_texture.xml
#	indra/newview/skins/default/xui/tr/panel_edit_classified.xml
#	indra/newview/skins/default/xui/tr/panel_me.xml
#	indra/newview/skins/default/xui/zh/floater_preview_texture.xml

1 files changed, 284 insertions, 0 deletions

diff --git a/indra/newview/lllegacyatmospherics.h b/indra/newview/lllegacyatmospherics.h
new file mode 100644
index 0000000000..03c8efb91a
--- /dev/null
+++ b/indra/newview/lllegacyatmospherics.h
@@ -0,0 +1,284 @@
+/** 
+ * @file lllegacyatmospherics.h
+ * @brief LLVOSky class header file
+ *
+ * $LicenseInfo:firstyear=2001&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, 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_LLLEGACYATMOSPHERICS_H
+#define LL_LLLEGACYATMOSPHERICS_H
+
+#include "stdtypes.h"
+#include "v3color.h"
+#include "v4coloru.h"
+#include "llviewertexture.h"
+#include "llviewerobject.h"
+#include "llframetimer.h"
+#include "v3colorutil.h"
+#include "llsettingssky.h"
+
+//////////////////////////////////
+//
+// Lots of constants
+//
+// Will clean these up at some point...
+//
+
+const F32 HORIZON_DIST          = 1024.0f;
+const F32 ATM_EXP_FALLOFF       = 0.000126f;
+const F32 ATM_SEA_LEVEL_NDENS   = 2.55e25f;
+const F32 ATM_HEIGHT            = 100000.f;
+
+// constants used in calculation of scattering coeff of clear air
+const F32 sigma     = 0.035f;
+const F32 fsigma    = (6.f + 3.f * sigma) / (6.f-7.f*sigma);
+const F64 Ndens     = 2.55e25;
+const F64 Ndens2    = Ndens*Ndens;
+
+class LLFace;
+class LLHaze;
+
+LL_FORCE_INLINE LLColor3 refr_ind_calc(const LLColor3 &wave_length)
+{
+    LLColor3 refr_ind;
+    for (S32 i = 0; i < 3; ++i)
+    {
+        const F32 wl2 = wave_length.mV[i] * wave_length.mV[i] * 1e-6f;
+        refr_ind.mV[i] = 6.43e3f + ( 2.95e6f / ( 146.0f - 1.f/wl2 ) ) + ( 2.55e4f / ( 41.0f - 1.f/wl2 ) );
+        refr_ind.mV[i] *= 1.0e-8f;
+        refr_ind.mV[i] += 1.f;
+    }
+    return refr_ind;
+}
+
+
+class LLHaze
+{
+public:
+    LLHaze() : mG(0), mFalloff(1), mAbsCoef(0.f) {mSigSca.setToBlack();}
+    LLHaze(const F32 g, const LLColor3& sca, const F32 fo = 2.f) : 
+            mG(g), mSigSca(0.25f/F_PI * sca), mFalloff(fo), mAbsCoef(0.f)
+    {
+        mAbsCoef = color_intens(mSigSca) / sAirScaIntense;
+    }
+
+    LLHaze(const F32 g, const F32 sca, const F32 fo = 2.f) : mG(g),
+            mSigSca(0.25f/F_PI * LLColor3(sca, sca, sca)), mFalloff(fo)
+    {
+        mAbsCoef = 0.01f * sca / sAirScaAvg;
+    }
+
+/* Proportion of light that is scattered into 'path' from 'in' over distance dt. */
+/* assumes that vectors 'path' and 'in' are normalized. Scattering coef / 2pi */
+
+    LL_FORCE_INLINE LLColor3 calcAirSca(const F32 h)
+    {
+       return calcFalloff(h) * sAirScaSeaLevel;
+    }
+
+    LL_FORCE_INLINE void calcAirSca(const F32 h, LLColor3 &result)
+    {
+        result = sAirScaSeaLevel;
+        result *= calcFalloff(h);
+    }
+
+    F32 getG() const                { return mG; }
+
+    void setG(const F32 g)
+    {
+        mG = g;
+    }
+
+    const LLColor3& getSigSca() const // sea level
+    {
+        return mSigSca;
+    } 
+
+    void setSigSca(const LLColor3& s)
+    {
+        mSigSca = s;
+        mAbsCoef = 0.01f * color_intens(mSigSca) / sAirScaIntense;
+    }
+
+    void setSigSca(const F32 s0, const F32 s1, const F32 s2)
+    {
+        mSigSca = sAirScaAvg * LLColor3 (s0, s1, s2);
+        mAbsCoef = 0.01f * (s0 + s1 + s2) / 3;
+    }
+
+    F32 getFalloff() const
+    {
+        return mFalloff;
+    }
+
+    void setFalloff(const F32 fo)
+    {
+        mFalloff = fo;
+    }
+
+    F32 getAbsCoef() const
+    {
+        return mAbsCoef;
+    }
+
+    inline static F32 calcFalloff(const F32 h)
+    {
+        return (h <= 0) ? 1.0f : (F32)LL_FAST_EXP(-ATM_EXP_FALLOFF * h);
+    }
+
+    inline LLColor3 calcSigSca(const F32 h) const
+    {
+        return calcFalloff(h * mFalloff) * mSigSca;
+    }
+
+    inline void calcSigSca(const F32 h, LLColor3 &result) const
+    {
+        result = mSigSca;
+        result *= calcFalloff(h * mFalloff);
+    }
+
+    LLColor3 calcSigExt(const F32 h) const
+    {
+        return calcFalloff(h * mFalloff) * (1 + mAbsCoef) * mSigSca;
+    }
+
+    F32 calcPhase(const F32 cos_theta) const;
+
+private:
+    static LLColor3 const sAirScaSeaLevel;
+    static F32 const sAirScaIntense;
+    static F32 const sAirScaAvg;
+
+protected:
+    F32         mG;
+    LLColor3    mSigSca;
+    F32         mFalloff;   // 1 - slow, >1 - faster
+    F32         mAbsCoef;
+};
+
+
+class LLCubeMap;
+
+class AtmosphericsVars
+{
+public:
+    AtmosphericsVars()
+    : hazeColor(0,0,0)
+    , hazeColorBelowCloud(0,0,0)
+    , cloudColorSun(0,0,0)
+    , cloudColorAmbient(0,0,0)
+    , cloudDensity(0.0f)
+    , blue_density()
+    , blue_horizon()
+    , haze_density(0.0f)
+    , haze_horizon(0.0f)
+    , density_multiplier(0.0f)
+    , max_y(0.0f)
+    , gamma(1.0f)
+    , sun_norm(0.0f, 1.0f, 0.0f, 1.0f)
+    , sunlight()
+    , ambient()
+    , glow()
+    , cloud_shadow(1.0f)
+    , dome_radius(1.0f)
+    , dome_offset(1.0f)
+    , light_atten()
+    , light_transmittance()
+    {
+    }
+
+    friend bool operator==(const AtmosphericsVars& a, const AtmosphericsVars& b);
+    // returns true if values are within treshold of each other.
+    friend bool approximatelyEqual(const AtmosphericsVars& a, const AtmosphericsVars& b, const F32 fraction_treshold);
+
+    LLColor3  hazeColor;
+    LLColor3  hazeColorBelowCloud;
+	LLColor3  cloudColorSun;
+	LLColor3  cloudColorAmbient;
+	F32       cloudDensity;
+    LLColor3  blue_density;
+    LLColor3  blue_horizon;
+    F32       haze_density;
+    F32       haze_horizon;
+    F32       density_multiplier;
+    F32       distance_multiplier;
+    F32       max_y;
+    F32       gamma;
+    LLVector4 sun_norm;
+    LLColor3  sunlight;
+    LLColor3  ambient;
+    LLColor3  glow;
+    F32       cloud_shadow;
+    F32       dome_radius;
+    F32       dome_offset;
+    LLColor3 light_atten;
+    LLColor3 light_transmittance;
+    LLColor3 total_density;
+};
+
+class LLAtmospherics
+{
+public:    
+    LLAtmospherics();
+    ~LLAtmospherics();
+
+    void init();
+    void updateFog(const F32 distance, const LLVector3& tosun);
+
+    const LLHaze& getHaze() const                    { return mHaze; }
+    LLHaze& getHaze()                                { return mHaze; }
+    F32 getHazeConcentration() const                 { return mHazeConcentration; }
+    void setHaze(const LLHaze& h)                    { mHaze = h; }
+    void setFogRatio(const F32 fog_ratio)            { mFogRatio = fog_ratio; }
+
+    F32      getFogRatio() const                     { return mFogRatio; }
+    LLColor4 getFogColor() const                     { return mFogColor; }
+    LLColor4 getGLFogColor() const                   { return mGLFogCol; }
+
+    void setCloudDensity(F32 cloud_density)          { mCloudDensity = cloud_density; }
+    void setWind ( const LLVector3& wind )           { mWind = wind.length(); }
+
+    LLColor4 calcSkyColorInDir(AtmosphericsVars& vars, const LLVector3& dir, bool isShiny = false);
+    LLColor4 calcSkyColorInDir(const LLSettingsSky::ptr_t &psky, AtmosphericsVars& vars, const LLVector3& dir, bool isShiny = false);
+
+protected:    
+
+    void     calcSkyColorWLVert(const LLSettingsSky::ptr_t &psky, LLVector3 & Pn, AtmosphericsVars& vars);
+    LLColor3 getHazeColor(LLSettingsSky::ptr_t psky, AtmosphericsVars& vars, F32 costheta, F32 cloud_shadow);
+
+    LLHaze              mHaze;
+    F32                 mHazeConcentration;
+    F32                 mCloudDensity;
+    F32                 mWind;
+    BOOL                mInitialized;
+    LLVector3           mLastLightingDirection;
+    LLColor3            mLastTotalAmbient;
+    F32                 mAmbientScale;
+    LLColor3            mNightColorShift;
+    F32                 mInterpVal;
+    LLColor4            mFogColor;
+    LLColor4            mGLFogCol;
+    F32                 mFogRatio;
+    F32                 mWorldScale;
+};
+
+#endif