llwlparammanager.h

Go to the documentation of this file.

#ifndef LL_WLPARAMMANAGER_H
#define LL_WLPARAMMANAGER_H

#include <vector>
#include <map>
#include "llwlparamset.h"
#include "llwlanimator.h"
#include "llwldaycycle.h"
#include "llviewercamera.h"

class LLGLSLShader;
 
// color control
struct WLColorControl {
        
        F32 r, g, b, i;                         
        char const * name;                      
        std::string mSliderName;        
        bool hasSliderName;                     
        bool isSunOrAmbientColor;                       
        bool isBlueHorizonOrDensity;            

        inline WLColorControl(F32 red, F32 green, F32 blue, F32 intensity, char const * n,
                char const * sliderName = "")
                : r(red), g(green), b(blue), i(intensity), name(n), mSliderName(sliderName)
        {
                // if there's a slider name, say we have one
                hasSliderName = false;
                if (mSliderName != "") {
                        hasSliderName = true;
                }

                // if it's the sun controller
                isSunOrAmbientColor = false;
                if (mSliderName == "WLSunlight" || mSliderName == "WLAmbient") {
                        isSunOrAmbientColor = true;
                }

                isBlueHorizonOrDensity = false;
                if (mSliderName == "WLBlueHorizon" || mSliderName == "WLBlueDensity") {
                        isBlueHorizonOrDensity = true;
                }
        }

        inline WLColorControl & operator = (LLVector4 const & val) {
                r = val.mV[0];
                g = val.mV[1];
                b = val.mV[2];
                i = val.mV[3];          
                return *this;
        }

        inline operator LLVector4 (void) const {
                return LLVector4(r, g, b, i);
        }

        inline operator LLVector3 (void) const {
                return LLVector3(r, g, b);
        }

        inline void update(LLWLParamSet & params) const {
                params.set(name, r, g, b, i);
        }
};

// float slider control
struct WLFloatControl {
        F32 x;
        char const * name;
        F32 mult;

        inline WLFloatControl(F32 val, char const * n, F32 m=1.0f)
                : x(val), name(n), mult(m)
        {
        }

        inline WLFloatControl & operator = (LLVector4 const & val) {
                x = val.mV[0];

                return *this;
        }

        inline operator F32 (void) const {
                return x;
        }

        inline void update(LLWLParamSet & params) const {
                params.set(name, x);
        }
};

class LLWLParamManager
{
public:

        LLWLParamManager();
        ~LLWLParamManager();

        void loadPresets(const LLString & fileName);

        void savePresets(const LLString & fileName);

        void loadPreset(const LLString & name);

        void savePreset(const LLString & name);

        void propagateParameters(void);
        
        void updateShaderUniforms(LLGLSLShader * shader);

        void resetAnimator(F32 curTime, bool run);

        void update(LLViewerCamera * cam);

        // get where the light is pointing
        inline LLVector4 getLightDir(void) const;

        // get where the light is pointing
        inline LLVector4 getClampedLightDir(void) const;

        // get where the light is pointing
        inline LLVector4 getRotatedLightDir(void) const;
        
        inline F32 getDomeOffset(void) const;

        inline F32 getDomeRadius(void) const;

        static void initClass(void);

        // Cleanup of global data that's only inited once per class.
        static void cleanupClass();
        
        bool addParamSet(const std::string& name, LLWLParamSet& param);

        BOOL addParamSet(const std::string& name, LLSD const & param);

        bool getParamSet(const std::string& name, LLWLParamSet& param);

        bool setParamSet(const std::string& name, LLWLParamSet& param);
        
        bool setParamSet(const std::string& name, LLSD const & param);  

        bool removeParamSet(const std::string& name, bool delete_from_disk);

        // singleton pattern implementation
        static LLWLParamManager * instance();


public:

        // helper variables
        LLWLAnimator mAnimator;

        LLVector4 mLightDir;

        LLVector4 mRotatedLightDir;

        LLVector4 mClampedLightDir;

        // list of params and how they're cycled for days
        LLWLDayCycle mDay;

        LLWLParamSet mCurParams;

        F32 mSunDeltaYaw;
        WLFloatControl mWLGamma;

        F32 mSceneLightStrength;
        
        WLColorControl mBlueHorizon;
        WLColorControl mHazeDensity;
        WLColorControl mBlueDensity;
        WLFloatControl mDensityMult;
        WLColorControl mHazeHorizon;
        WLFloatControl mMaxAlt;

        WLColorControl mLightnorm;
        WLColorControl mSunlight;
        WLColorControl mAmbient;
        WLColorControl mGlow;

        WLColorControl mCloudColor;
        WLColorControl mCloudMain;
        WLFloatControl mCloudCoverage;
        WLColorControl mCloudDetail;
        WLFloatControl mDistanceMult;
        WLFloatControl mCloudScale;

        F32 mDomeOffset;
        F32 mDomeRadius;
        
        // list of all the parameters, listed by name
        std::map<std::string, LLWLParamSet> mParamList;
        
        
private:
        // our parameter manager singleton instance
        static LLWLParamManager * sInstance;

};

inline F32 LLWLParamManager::getDomeOffset(void) const
{
        return mDomeOffset;
}

inline F32 LLWLParamManager::getDomeRadius(void) const
{
        return mDomeRadius;
}

inline LLVector4 LLWLParamManager::getLightDir(void) const
{
        return mLightDir;
}

inline LLVector4 LLWLParamManager::getClampedLightDir(void) const
{
        return mClampedLightDir;
}

inline LLVector4 LLWLParamManager::getRotatedLightDir(void) const
{
        return mRotatedLightDir;
}

#endif

---