llwaterparammanager.cpp

Go to the documentation of this file.

#include "llviewerprecompiledheaders.h"

#include "llwaterparammanager.h"

#include "pipeline.h"
#include "llsky.h"

#include "llsliderctrl.h"
#include "llspinctrl.h"
#include "llcheckboxctrl.h"
#include "lluictrlfactory.h"
#include "llviewercontrol.h"
#include "llviewercamera.h"
#include "llcombobox.h"
#include "lllineeditor.h"
#include "llsdserialize.h"

#include "v4math.h"
#include "llviewerdisplay.h"
#include "llviewercontrol.h"
#include "llviewerwindow.h"
#include "lldrawpoolwater.h"
#include "llagent.h"
#include "llviewerregion.h"

#include "llwlparammanager.h"
#include "llwaterparamset.h"
#include "llpostprocess.h"
#include "llfloaterwater.h"

#include "curl/curl.h"

LLWaterParamManager * LLWaterParamManager::sInstance = NULL;

LLWaterParamManager::LLWaterParamManager() :
        mFogColor(22.f/255.f, 43.f/255.f, 54.f/255.f, 0.0f, 0.0f, "waterFogColor", "WaterFogColor"),
        mFogDensity(4, "waterFogDensity", 2),
        mUnderWaterFogMod(0.25, "underWaterFogMod"),
        mNormalScale(2.f, 2.f, 2.f, "normScale"),
        mFresnelScale(0.5f, "fresnelScale"),
        mFresnelOffset(0.4f, "fresnelOffset"),
        mScaleAbove(0.025f, "scaleAbove"),
        mScaleBelow(0.2f, "scaleBelow"),
        mBlurMultiplier(0.1f, "blurMultiplier"),
        mWave1Dir(.5f, .5f, "wave1Dir"),
        mWave2Dir(.5f, .5f, "wave2Dir"),
        mDensitySliderValue(1.0f),
        mWaterFogKS(1.0f)
{
}

LLWaterParamManager::~LLWaterParamManager()
{
}

void LLWaterParamManager::loadAllPresets(const LLString& file_name)
{
        LLString path_name(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "windlight/water", ""));
        LL_INFOS2("AppInit", "Shaders") << "Loading water settings from " << path_name << LL_ENDL;

        //mParamList.clear();
        
        bool found = true;                      
        while(found) 
        {
                std::string name;
                found = gDirUtilp->getNextFileInDir(path_name, "*.xml", name, false);

                LL_DEBUGS2("AppInit", "Shaders") << "name: " << name << LL_ENDL;
                
                // if we have one
                if(found) 
                {
                        // bugfix for SL-46920: preventing filenames that break stuff.
                        char * curl_str = curl_unescape(name.c_str(), name.size());
                        std::string unescaped_name(curl_str);
                        curl_free(curl_str);
                        curl_str = NULL;

                        // not much error checking here since we're getting rid of this
                        std::string water_name = unescaped_name.substr(0, unescaped_name.size() - 4);
                
                        LLString cur_path(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "windlight/water", name));
                        LL_DEBUGS2("AppInit", "Shaders") << "Loading water from " << cur_path << LL_ENDL;
                        
                        std::ifstream water_xml(cur_path.c_str());
                        if (water_xml)
                        {
                                LLSD water_data(LLSD::emptyMap());
                                LLPointer<LLSDParser> parser = new LLSDXMLParser();
                                parser->parse(water_xml, water_data, LLSDSerialize::SIZE_UNLIMITED);

                                addParamSet(water_name, water_data);
                        }
                }
        }
}

void LLWaterParamManager::loadPreset(const LLString & name)
{
        // bugfix for SL-46920: preventing filenames that break stuff.
        char * curl_str = curl_escape(name.c_str(), name.size());
        std::string escaped_filename(curl_str);
        curl_free(curl_str);
        curl_str = NULL;

        escaped_filename += ".xml";

        std::string pathName(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "windlight/water", escaped_filename));
        llinfos << "Loading water settings from " << pathName << llendl;

        std::ifstream presetsXML(pathName.c_str());

        if (presetsXML)
        {
                LLSD paramsData(LLSD::emptyMap());

                LLPointer<LLSDParser> parser = new LLSDXMLParser();

                parser->parse(presetsXML, paramsData, LLSDSerialize::SIZE_UNLIMITED);

                std::map<std::string, LLWaterParamSet>::iterator mIt = mParamList.find(name);
                if(mIt == mParamList.end())
                {
                        addParamSet(name, paramsData);
                }
                else 
                {
                        setParamSet(name, paramsData);
                }
        } 
        else 
        {
                llwarns << "Can't find " << name << llendl;
                return;
        }

        getParamSet(name, mCurParams);

        propagateParameters();
}

void LLWaterParamManager::savePreset(const LLString & name)
{
        // bugfix for SL-46920: preventing filenames that break stuff.
        char * curl_str = curl_escape(name.c_str(), name.size());
        std::string escaped_filename(curl_str);
        curl_free(curl_str);
        curl_str = NULL;

        escaped_filename += ".xml";

        // make an empty llsd
        LLSD paramsData(LLSD::emptyMap());
        std::string pathName(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "windlight/water", escaped_filename));

        // fill it with LLSD windlight params
        paramsData = mParamList[name].getAll();

        // write to file
        std::ofstream presetsXML(pathName.c_str());
        LLPointer<LLSDFormatter> formatter = new LLSDXMLFormatter();
        formatter->format(paramsData, presetsXML, LLSDFormatter::OPTIONS_PRETTY);
        presetsXML.close();

        propagateParameters();
}


void LLWaterParamManager::propagateParameters(void)
{
        // bind the variables only if we're using shaders
        if(gPipeline.canUseVertexShaders())
        {
                LLShaderMgr::shader_iter shaders_iter, end_shaders;
                end_shaders = LLShaderMgr::endShaders();
                for(shaders_iter = LLShaderMgr::beginShaders(); shaders_iter != end_shaders; ++shaders_iter)
                {
                        if (shaders_iter->mProgramObject != 0
                                && shaders_iter->mShaderGroup == LLGLSLShader::SG_WATER)
                        {
                                shaders_iter->mUniformsDirty = TRUE;
                        }
                }
        }

        bool err;
        F32 fog_density_slider = 
                log(mCurParams.getFloat(mFogDensity.mName, err)) / 
                log(mFogDensity.mBase);

        setDensitySliderValue(fog_density_slider);
}

void LLWaterParamManager::updateShaderUniforms(LLGLSLShader * shader)
{
        if (shader->mShaderGroup == LLGLSLShader::SG_WATER)
        {
                shader->uniform4fv(LLShaderMgr::LIGHTNORM, 1, LLWLParamManager::instance()->getRotatedLightDir().mV);
                shader->uniform3fv("camPosLocal", 1, LLViewerCamera::getInstance()->getOrigin().mV);
                shader->uniform4fv("waterFogColor", 1, LLDrawPoolWater::sWaterFogColor.mV);
                shader->uniform4fv("waterPlane", 1, mWaterPlane.mV);
                shader->uniform1f("waterFogDensity", getFogDensity());
                shader->uniform1f("waterFogKS", mWaterFogKS);
                shader->uniform4f("distance_multiplier", 0, 0, 0, 0);
        }
}

void LLWaterParamManager::update(LLViewerCamera * cam)
{
        LLFastTimer ftm(LLFastTimer::FTM_UPDATE_WLPARAM);
        
        // update the shaders and the menu
        propagateParameters();
        
        // sync menus if they exist
        if(LLFloaterWater::isOpen()) 
        {
                LLFloaterWater::instance()->syncMenu();
        }

        stop_glerror();

        // only do this if we're dealing with shaders
        if(gPipeline.canUseVertexShaders()) 
        {
                //transform water plane to eye space
                glh::vec3f norm(0.f, 0.f, 1.f);
                glh::vec3f p(0.f, 0.f, gAgent.getRegion()->getWaterHeight()+0.1f);
                
                F32 modelView[16];
                for (U32 i = 0; i < 16; i++)
                {
                        modelView[i] = (F32) gGLModelView[i];
                }

                glh::matrix4f mat(modelView);
                glh::matrix4f invtrans = mat.inverse().transpose();
                glh::vec3f enorm;
                glh::vec3f ep;
                invtrans.mult_matrix_vec(norm, enorm);
                enorm.normalize();
                mat.mult_matrix_vec(p, ep);

                mWaterPlane = LLVector4(enorm.v[0], enorm.v[1], enorm.v[2], -ep.dot(enorm));

                LLVector3 sunMoonDir;
                if (gSky.getSunDirection().mV[2] > NIGHTTIME_ELEVATION_COS)      
                {        
                        sunMoonDir = gSky.getSunDirection();     
                }        
                else     
                {        
                        sunMoonDir = gSky.getMoonDirection();    
                }
                sunMoonDir.normVec();
                mWaterFogKS = 1.f/llmax(sunMoonDir.mV[2], WATER_FOG_LIGHT_CLAMP);

                LLShaderMgr::shader_iter shaders_iter, end_shaders;
                end_shaders = LLShaderMgr::endShaders();
                for(shaders_iter = LLShaderMgr::beginShaders(); shaders_iter != end_shaders; ++shaders_iter)
                {
                        if (shaders_iter->mProgramObject != 0
                                && shaders_iter->mShaderGroup == LLGLSLShader::SG_WATER)
                        {
                                shaders_iter->mUniformsDirty = TRUE;
                        }
                }
        }
}

// static
void LLWaterParamManager::initClass(void)
{
        instance();
}

// static
void LLWaterParamManager::cleanupClass(void)
{
        delete sInstance;
        sInstance = NULL;
}

bool LLWaterParamManager::addParamSet(const std::string& name, LLWaterParamSet& param)
{
        // add a new one if not one there already
        std::map<std::string, LLWaterParamSet>::iterator mIt = mParamList.find(name);
        if(mIt == mParamList.end()) 
        {       
                mParamList[name] = param;
                return true;
        }

        return false;
}

BOOL LLWaterParamManager::addParamSet(const std::string& name, LLSD const & param)
{
        // add a new one if not one there already
        std::map<std::string, LLWaterParamSet>::const_iterator finder = mParamList.find(name);
        if(finder == mParamList.end())
        {
                mParamList[name].setAll(param);
                return TRUE;
        }
        else
        {
                return FALSE;
        }
}

bool LLWaterParamManager::getParamSet(const std::string& name, LLWaterParamSet& param)
{
        // find it and set it
        std::map<std::string, LLWaterParamSet>::iterator mIt = mParamList.find(name);
        if(mIt != mParamList.end()) 
        {
                param = mParamList[name];
                param.mName = name;
                return true;
        }

        return false;
}

bool LLWaterParamManager::setParamSet(const std::string& name, LLWaterParamSet& param)
{
        mParamList[name] = param;

        return true;
}

bool LLWaterParamManager::setParamSet(const std::string& name, const LLSD & param)
{
        // quick, non robust (we won't be working with files, but assets) check
        if(!param.isMap()) 
        {
                return false;
        }
        
        mParamList[name].setAll(param);

        return true;
}

bool LLWaterParamManager::removeParamSet(const std::string& name, bool delete_from_disk)
{
        // remove from param list
        std::map<std::string, LLWaterParamSet>::iterator mIt = mParamList.find(name);
        if(mIt != mParamList.end()) 
        {
                mParamList.erase(mIt);
        }

        if(delete_from_disk)
        {
                LLString path_name(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "windlight/water", ""));
                
                // use full curl escaped name
                char * curl_str = curl_escape(name.c_str(), name.size());
                std::string escaped_name(curl_str);
                curl_free(curl_str);
                curl_str = NULL;
                
                gDirUtilp->deleteFilesInDir(path_name, escaped_name + ".xml");
        }

        return true;
}

F32 LLWaterParamManager::getFogDensity(void)
{
        bool err;

        F32 fogDensity = mCurParams.getFloat("waterFogDensity", err);
        
        // modify if we're underwater
        const F32 water_height = gAgent.getRegion()->getWaterHeight();
        F32 camera_height = gAgent.getCameraPositionAgent().mV[2];
        if(camera_height <= water_height)
        {
                // raise it to the underwater fog density modifier
                fogDensity = pow(fogDensity, mCurParams.getFloat("underWaterFogMod", err));
        }

        return fogDensity;
}

// static
LLWaterParamManager * LLWaterParamManager::instance()
{
        if(NULL == sInstance)
        {
                sInstance = new LLWaterParamManager();

                sInstance->loadAllPresets("");

                sInstance->getParamSet("Default", sInstance->mCurParams);
        }

        return sInstance;
}

---