path: root/indra/newview/lllegacyatmospherics.h

/** 
 * @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()
    {
    }

    LL_FORCE_INLINE friend bool operator==(const AtmosphericsVars& a, const AtmosphericsVars& b);

    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;
};

bool operator==(const AtmosphericsVars& a, const AtmosphericsVars& b)
{
    if (a.hazeColor != b.hazeColor)
    {
        return false;
    }

    if (a.hazeColorBelowCloud != b.hazeColorBelowCloud)
    {
        return false;
    }

    if (a.cloudColorSun != b.cloudColorSun)
    {
        return false;
    }

    if (a.cloudColorAmbient != b.cloudColorAmbient)
    {
        return false;
    }

    if (a.cloudDensity != b.cloudDensity)
    {
        return false;
    }

    if (a.density_multiplier != b.density_multiplier)
    {
        return false;
    }

    if (a.haze_horizon != b.haze_horizon)
    {
        return false;
    }

    if (a.haze_density != b.haze_density)
    {
        return false;
    }

    if (a.blue_horizon != b.blue_horizon)
    {
        return false;
    }

    if (a.blue_density != b.blue_density)
    {
        return false;
    }

    if (a.dome_offset != b.dome_offset)
    {
        return false;
    }

    if (a.dome_radius != b.dome_radius)
    {
        return false;
    }

    if (a.cloud_shadow != b.cloud_shadow)
    {
        return false;
    }

    if (a.glow != b.glow)
    {
        return false;
    }

    if (a.ambient != b.ambient)
    {
        return false;
    }

    if (a.sunlight != b.sunlight)
    {
        return false;
    }

    if (a.sun_norm != b.sun_norm)
    {
        return false;
    }

    if (a.gamma != b.gamma)
    {
        return false;
    }

    if (a.max_y != b.max_y)
    {
        return false;
    }

    if (a.distance_multiplier != b.distance_multiplier)
    {
        return false;
    }

    // light_atten, light_transmittance, total_density
    // are ignored as they always change when the values above do
    // they're just shared calc across the sky map generation to save cycles

    return true;
}

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);

protected:    

    void     calcSkyColorWLVert(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