460 lines
9.7 KiB
C++
460 lines
9.7 KiB
C++
/**
|
|
* @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
|