Singularity-Viewer/SingularityViewer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update LLFloaterWater and LLFloaterWindLight, to be closer to their upstream counterparts.

Browse Source
This commit is contained in:
Lirusaito
2013-06-26 09:07:34 -04:00
parent dbe646c943
commit 14736d24a5
5 changed files with 518 additions and 647 deletions
Download Patch File Download Diff File Expand all files Collapse all files

563
indra/newview/llfloaterwater.cpp
View File

@@ -34,36 +34,22 @@
#include "llfloaterwater.h"
#include "pipeline.h"
#include "llsky.h"
#include "llsliderctrl.h"
#include "llspinctrl.h"
#include "llcolorswatch.h"
// libs
#include "llcheckboxctrl.h"
#include "llcolorswatch.h"
#include "llcombobox.h"
#include "llnotificationsutil.h"
#include "llsliderctrl.h"
#include "lltexturectrl.h"
#include "lluictrlfactory.h"
#include "llviewercamera.h"
#include "llcombobox.h"
#include "lllineeditor.h"
#include "llfloaterdaycycle.h"
#include "llboost.h"
#include "llmultisliderctrl.h"
// newview
#include "llagent.h"
#include "llinventorymodel.h"
#include "llviewerinventory.h"
#include "v4math.h"
#include "llviewerdisplay.h"
#include "llviewercontrol.h"
#include "llviewerwindow.h"
#include "llsavedsettingsglue.h"
#include "llwaterparamset.h"
#include "llwaterparammanager.h"
#include "llwaterparamset.h"
#undef max
#undef max // Fixes a Windows compiler error
LLFloaterWater* LLFloaterWater::sWaterMenu = NULL;
@@ -79,15 +65,13 @@ LLFloaterWater::LLFloaterWater() : LLFloater(std::string("water floater"))
if (mWaterPresetCombo != NULL)
{
populateWaterPresetsList();
mWaterPresetCombo->setCommitCallback(onChangePresetName);
mWaterPresetCombo->setCommitCallback(boost::bind(&LLFloaterWater::onChangePresetName, this, _1));
}
std::string def_water = getString("WLDefaultWaterNames");
// no editing or deleting of the blank string
sDefaultPresets.insert("");
boost_tokenizer tokens(def_water, boost::char_separator<char>(":"));
boost_tokenizer tokens(getString("WLDefaultWaterNames"), boost::char_separator<char>(":"));
for (boost_tokenizer::iterator token_iter = tokens.begin(); token_iter != tokens.end(); ++token_iter)
{
std::string tok(*token_iter);
@@ -102,7 +86,8 @@ LLFloaterWater::~LLFloaterWater()
{
}
void LLFloaterWater::initCallbacks(void) {
void LLFloaterWater::initCallbacks(void)
{
// help buttons
initHelpBtn("WaterFogColorHelp", "HelpWaterFogColor");
@@ -121,52 +106,52 @@ void LLFloaterWater::initCallbacks(void) {
initHelpBtn("WaterWave1Help", "HelpWaterWave1");
initHelpBtn("WaterWave2Help", "HelpWaterWave2");
LLWaterParamManager * param_mgr = LLWaterParamManager::getInstance();
//-------------------------------------------------------------------------
childSetCommitCallback("WaterFogColor", onWaterFogColorMoved, &param_mgr->mFogColor);
LLWaterParamManager& water_mgr = LLWaterParamManager::instance();
//
//childSetCommitCallback("WaterGlow", onColorControlAMoved, &param_mgr->mFogColor);
getChild<LLUICtrl>("WaterFogColor")->setCommitCallback(boost::bind(&LLFloaterWater::onWaterFogColorMoved, this, _1, &water_mgr.mFogColor));
//getChild<LLUICtrl>("WaterGlow")->setCommitCallback(boost::bind(&LLFloaterWater::onColorControlAMoved, this, _1, &water_mgr.mFogColor));
// fog density
childSetCommitCallback("WaterFogDensity", onExpFloatControlMoved, &param_mgr->mFogDensity);
childSetCommitCallback("WaterUnderWaterFogMod", onFloatControlMoved, &param_mgr->mUnderWaterFogMod);
getChild<LLUICtrl>("WaterFogDensity")->setCommitCallback(boost::bind(&LLFloaterWater::onExpFloatControlMoved, this, _1, &water_mgr.mFogDensity));
getChild<LLUICtrl>("WaterUnderWaterFogMod")->setCommitCallback(boost::bind(&LLFloaterWater::onFloatControlMoved, this, _1, &water_mgr.mUnderWaterFogMod));
// blue density
childSetCommitCallback("WaterNormalScaleX", onVector3ControlXMoved, &param_mgr->mNormalScale);
childSetCommitCallback("WaterNormalScaleY", onVector3ControlYMoved, &param_mgr->mNormalScale);
childSetCommitCallback("WaterNormalScaleZ", onVector3ControlZMoved, &param_mgr->mNormalScale);
getChild<LLUICtrl>("WaterNormalScaleX")->setCommitCallback(boost::bind(&LLFloaterWater::onVector3ControlXMoved, this, _1, &water_mgr.mNormalScale));
getChild<LLUICtrl>("WaterNormalScaleY")->setCommitCallback(boost::bind(&LLFloaterWater::onVector3ControlYMoved, this, _1, &water_mgr.mNormalScale));
getChild<LLUICtrl>("WaterNormalScaleZ")->setCommitCallback(boost::bind(&LLFloaterWater::onVector3ControlZMoved, this, _1, &water_mgr.mNormalScale));
// fresnel
childSetCommitCallback("WaterFresnelScale", onFloatControlMoved, &param_mgr->mFresnelScale);
childSetCommitCallback("WaterFresnelOffset", onFloatControlMoved, &param_mgr->mFresnelOffset);
getChild<LLUICtrl>("WaterFresnelScale")->setCommitCallback(boost::bind(&LLFloaterWater::onFloatControlMoved, this, _1, &water_mgr.mFresnelScale));
getChild<LLUICtrl>("WaterFresnelOffset")->setCommitCallback(boost::bind(&LLFloaterWater::onFloatControlMoved, this, _1, &water_mgr.mFresnelOffset));
// scale above/below
childSetCommitCallback("WaterScaleAbove", onFloatControlMoved, &param_mgr->mScaleAbove);
childSetCommitCallback("WaterScaleBelow", onFloatControlMoved, &param_mgr->mScaleBelow);
getChild<LLUICtrl>("WaterScaleAbove")->setCommitCallback(boost::bind(&LLFloaterWater::onFloatControlMoved, this, _1, &water_mgr.mScaleAbove));
getChild<LLUICtrl>("WaterScaleBelow")->setCommitCallback(boost::bind(&LLFloaterWater::onFloatControlMoved, this, _1, &water_mgr.mScaleBelow));
// blur mult
childSetCommitCallback("WaterBlurMult", onFloatControlMoved, &param_mgr->mBlurMultiplier);
getChild<LLUICtrl>("WaterBlurMult")->setCommitCallback(boost::bind(&LLFloaterWater::onFloatControlMoved, this, _1, &water_mgr.mBlurMultiplier));
// Load/save
//childSetAction("WaterLoadPreset", onLoadPreset, mWaterPresetCombo);
childSetAction("WaterNewPreset", onNewPreset, mWaterPresetCombo);
childSetAction("WaterDeletePreset", onDeletePreset, mWaterPresetCombo);
childSetCommitCallback("WaterSavePreset", onSavePreset, this);
//getChild<LLUICtrl>("WaterLoadPreset")->setCommitCallback(boost::bind(&LLFloaterWater::onLoadPreset, this, mWaterPresetCombo));
getChild<LLUICtrl>("WaterNewPreset")->setCommitCallback(boost::bind(&LLFloaterWater::onNewPreset, this));
getChild<LLUICtrl>("WaterDeletePreset")->setCommitCallback(boost::bind(&LLFloaterWater::onDeletePreset, this));
getChild<LLUICtrl>("WaterSavePreset")->setCommitCallback(boost::bind(&LLFloaterWater::onSavePreset, this, _1));
// wave direction
childSetCommitCallback("WaterWave1DirX", onVector2ControlXMoved, &param_mgr->mWave1Dir);
childSetCommitCallback("WaterWave1DirY", onVector2ControlYMoved, &param_mgr->mWave1Dir);
childSetCommitCallback("WaterWave2DirX", onVector2ControlXMoved, &param_mgr->mWave2Dir);
childSetCommitCallback("WaterWave2DirY", onVector2ControlYMoved, &param_mgr->mWave2Dir);
getChild<LLUICtrl>("WaterWave1DirX")->setCommitCallback(boost::bind(&LLFloaterWater::onVector2ControlXMoved, this, _1, &water_mgr.mWave1Dir));
getChild<LLUICtrl>("WaterWave1DirY")->setCommitCallback(boost::bind(&LLFloaterWater::onVector2ControlYMoved, this, _1, &water_mgr.mWave1Dir));
getChild<LLUICtrl>("WaterWave2DirX")->setCommitCallback(boost::bind(&LLFloaterWater::onVector2ControlXMoved, this, _1, &water_mgr.mWave2Dir));
getChild<LLUICtrl>("WaterWave2DirY")->setCommitCallback(boost::bind(&LLFloaterWater::onVector2ControlYMoved, this, _1, &water_mgr.mWave2Dir));
LLTextureCtrl* textCtrl = getChild<LLTextureCtrl>("WaterNormalMap");
textCtrl->setDefaultImageAssetID(DEFAULT_WATER_NORMAL);
childSetCommitCallback("WaterNormalMap", onNormalMapPicked, NULL);
LLTextureCtrl* texture_ctrl = getChild<LLTextureCtrl>("WaterNormalMap");
texture_ctrl->setDefaultImageAssetID(DEFAULT_WATER_NORMAL);
texture_ctrl->setCommitCallback(boost::bind(&LLFloaterWater::onNormalMapPicked, this, _1));
// next/prev buttons
//childSetAction("next", onClickNext, this);
//childSetAction("prev", onClickPrev, this);
//getChild<LLUICtrl>("next")->setCommitCallback(boost::bind(&LLFloaterWater::onClickNext, this));
//getChild<LLUICtrl>("prev")->setCommitCallback(boost::bind(&LLFloaterWater::onClickPrev, this));
}
void LLFloaterWater::onClickHelp(void* data)
@@ -185,14 +170,14 @@ void LLFloaterWater::initHelpBtn(const std::string& name, const std::string& xml
bool LLFloaterWater::newPromptCallback(const LLSD& notification, const LLSD& response)
{
std::string text = response["message"].asString();
S32 option = LLNotification::getSelectedOption(notification, response);
if(text == "")
if(text.empty())
{
return false;
}
if(option == 0) {
S32 option = LLNotification::getSelectedOption(notification, response);
if(option == 0)
{
LLWaterParamManager * param_mgr = LLWaterParamManager::getInstance();
// add the current parameters to the list
@@ -201,10 +186,9 @@ bool LLFloaterWater::newPromptCallback(const LLSD& notification, const LLSD& res
if(!LLWaterParamManager::getInstance()->hasParamSet(text))
{
param_mgr->addParamSet(text, param_mgr->mCurParams);
sWaterMenu->mWaterPresetCombo->add(text);
sWaterMenu->mWaterPresetCombo->sortByName();
sWaterMenu->mWaterPresetCombo->selectByValue(text);
mWaterPresetCombo->add(text);
mWaterPresetCombo->sortByName();
mWaterPresetCombo->selectByValue(text);
param_mgr->savePreset(text);
@@ -214,7 +198,7 @@ bool LLFloaterWater::newPromptCallback(const LLSD& notification, const LLSD& res
}
else
{
LLNotifications::instance().add("ExistsWaterPresetAlert");
LLNotificationsUtil::add("ExistsWaterPresetAlert");
}
}
return false;
@@ -224,9 +208,9 @@ void LLFloaterWater::syncMenu()
{
bool err;
LLWaterParamManager * param_mgr = LLWaterParamManager::getInstance();
LLWaterParamManager& water_mgr = LLWaterParamManager::instance();
LLWaterParamSet & current_params = param_mgr->mCurParams;
LLWaterParamSet& current_params = water_mgr.mCurParams;
if (mWaterPresetCombo->getSelectedItemLabel() != LLEnvManagerNew::instance().getWaterPresetName())
{
@@ -234,58 +218,56 @@ void LLFloaterWater::syncMenu()
}
// blue horizon
param_mgr->mFogColor = current_params.getVector4(param_mgr->mFogColor.mName, err);
water_mgr.mFogColor = current_params.getVector4(water_mgr.mFogColor.mName, err);
LLColor4 col = param_mgr->getFogColor();
//childSetValue("WaterGlow", col.mV[3]);
LLColor4 col = water_mgr.getFogColor();
//getChild<LLUICtrl>("WaterGlow")->setValue(col.mV[3]);
col.mV[3] = 1.0f;
LLColorSwatchCtrl* colCtrl = sWaterMenu->getChild<LLColorSwatchCtrl>("WaterFogColor");
colCtrl->set(col);
getChild<LLColorSwatchCtrl>("WaterFogColor")->set(col);
// fog and wavelets
param_mgr->mFogDensity.mExp =
log(current_params.getFloat(param_mgr->mFogDensity.mName, err)) /
log(param_mgr->mFogDensity.mBase);
param_mgr->setDensitySliderValue(param_mgr->mFogDensity.mExp);
childSetValue("WaterFogDensity", param_mgr->mFogDensity.mExp);
water_mgr.mFogDensity.mExp =
log(current_params.getFloat(water_mgr.mFogDensity.mName, err)) /
log(water_mgr.mFogDensity.mBase);
water_mgr.setDensitySliderValue(water_mgr.mFogDensity.mExp);
getChild<LLUICtrl>("WaterFogDensity")->setValue(water_mgr.mFogDensity.mExp);
param_mgr->mUnderWaterFogMod.mX =
current_params.getFloat(param_mgr->mUnderWaterFogMod.mName, err);
childSetValue("WaterUnderWaterFogMod", param_mgr->mUnderWaterFogMod.mX);
water_mgr.mUnderWaterFogMod.mX =
current_params.getFloat(water_mgr.mUnderWaterFogMod.mName, err);
getChild<LLUICtrl>("WaterUnderWaterFogMod")->setValue(water_mgr.mUnderWaterFogMod.mX);
param_mgr->mNormalScale = current_params.getVector3(param_mgr->mNormalScale.mName, err);
childSetValue("WaterNormalScaleX", param_mgr->mNormalScale.mX);
childSetValue("WaterNormalScaleY", param_mgr->mNormalScale.mY);
childSetValue("WaterNormalScaleZ", param_mgr->mNormalScale.mZ);
water_mgr.mNormalScale = current_params.getVector3(water_mgr.mNormalScale.mName, err);
getChild<LLUICtrl>("WaterNormalScaleX")->setValue(water_mgr.mNormalScale.mX);
getChild<LLUICtrl>("WaterNormalScaleY")->setValue(water_mgr.mNormalScale.mY);
getChild<LLUICtrl>("WaterNormalScaleZ")->setValue(water_mgr.mNormalScale.mZ);
// Fresnel
param_mgr->mFresnelScale.mX = current_params.getFloat(param_mgr->mFresnelScale.mName, err);
childSetValue("WaterFresnelScale", param_mgr->mFresnelScale.mX);
param_mgr->mFresnelOffset.mX = current_params.getFloat(param_mgr->mFresnelOffset.mName, err);
childSetValue("WaterFresnelOffset", param_mgr->mFresnelOffset.mX);
water_mgr.mFresnelScale.mX = current_params.getFloat(water_mgr.mFresnelScale.mName, err);
getChild<LLUICtrl>("WaterFresnelScale")->setValue(water_mgr.mFresnelScale.mX);
water_mgr.mFresnelOffset.mX = current_params.getFloat(water_mgr.mFresnelOffset.mName, err);
getChild<LLUICtrl>("WaterFresnelOffset")->setValue(water_mgr.mFresnelOffset.mX);
// Scale Above/Below
param_mgr->mScaleAbove.mX = current_params.getFloat(param_mgr->mScaleAbove.mName, err);
childSetValue("WaterScaleAbove", param_mgr->mScaleAbove.mX);
param_mgr->mScaleBelow.mX = current_params.getFloat(param_mgr->mScaleBelow.mName, err);
childSetValue("WaterScaleBelow", param_mgr->mScaleBelow.mX);
water_mgr.mScaleAbove.mX = current_params.getFloat(water_mgr.mScaleAbove.mName, err);
getChild<LLUICtrl>("WaterScaleAbove")->setValue(water_mgr.mScaleAbove.mX);
water_mgr.mScaleBelow.mX = current_params.getFloat(water_mgr.mScaleBelow.mName, err);
getChild<LLUICtrl>("WaterScaleBelow")->setValue(water_mgr.mScaleBelow.mX);
// blur mult
param_mgr->mBlurMultiplier.mX = current_params.getFloat(param_mgr->mBlurMultiplier.mName, err);
childSetValue("WaterBlurMult", param_mgr->mBlurMultiplier.mX);
water_mgr.mBlurMultiplier.mX = current_params.getFloat(water_mgr.mBlurMultiplier.mName, err);
getChild<LLUICtrl>("WaterBlurMult")->setValue(water_mgr.mBlurMultiplier.mX);
// wave directions
param_mgr->mWave1Dir = current_params.getVector2(param_mgr->mWave1Dir.mName, err);
childSetValue("WaterWave1DirX", param_mgr->mWave1Dir.mX);
childSetValue("WaterWave1DirY", param_mgr->mWave1Dir.mY);
water_mgr.mWave1Dir = current_params.getVector2(water_mgr.mWave1Dir.mName, err);
getChild<LLUICtrl>("WaterWave1DirX")->setValue(water_mgr.mWave1Dir.mX);
getChild<LLUICtrl>("WaterWave1DirY")->setValue(water_mgr.mWave1Dir.mY);
param_mgr->mWave2Dir = current_params.getVector2(param_mgr->mWave2Dir.mName, err);
childSetValue("WaterWave2DirX", param_mgr->mWave2Dir.mX);
childSetValue("WaterWave2DirY", param_mgr->mWave2Dir.mY);
water_mgr.mWave2Dir = current_params.getVector2(water_mgr.mWave2Dir.mName, err);
getChild<LLUICtrl>("WaterWave2DirX")->setValue(water_mgr.mWave2Dir.mX);
getChild<LLUICtrl>("WaterWave2DirY")->setValue(water_mgr.mWave2Dir.mY);
LLTextureCtrl* textCtrl = sWaterMenu->getChild<LLTextureCtrl>("WaterNormalMap");
textCtrl->setImageAssetID(param_mgr->getNormalMapID());
LLTextureCtrl* textCtrl = getChild<LLTextureCtrl>("WaterNormalMap");
textCtrl->setImageAssetID(water_mgr.getNormalMapID());
}
@@ -342,276 +324,257 @@ void LLFloaterWater::onClose(bool app_quitting)
}
}
// vector control callbacks
void LLFloaterWater::onVector3ControlXMoved(LLUICtrl* ctrl, void* userData)
{
LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
WaterVector3Control * vectorControl = static_cast<WaterVector3Control *>(userData);
vectorControl->mX = sldrCtrl->getValueF32();
vectorControl->update(LLWaterParamManager::getInstance()->mCurParams);
LLWaterParamManager::getInstance()->propagateParameters();
}
// vector control callbacks
void LLFloaterWater::onVector3ControlYMoved(LLUICtrl* ctrl, void* userData)
{
LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
WaterVector3Control * vectorControl = static_cast<WaterVector3Control *>(userData);
vectorControl->mY = sldrCtrl->getValueF32();
vectorControl->update(LLWaterParamManager::getInstance()->mCurParams);
LLWaterParamManager::getInstance()->propagateParameters();
}
// vector control callbacks
void LLFloaterWater::onVector3ControlZMoved(LLUICtrl* ctrl, void* userData)
{
LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
WaterVector3Control * vectorControl = static_cast<WaterVector3Control *>(userData);
vectorControl->mZ = sldrCtrl->getValueF32();
vectorControl->update(LLWaterParamManager::getInstance()->mCurParams);
LLWaterParamManager::getInstance()->propagateParameters();
}
// vector control callbacks
void LLFloaterWater::onVector2ControlXMoved(LLUICtrl* ctrl, void* userData)
{
LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
WaterVector2Control * vectorControl = static_cast<WaterVector2Control *>(userData);
vectorControl->mX = sldrCtrl->getValueF32();
vectorControl->update(LLWaterParamManager::getInstance()->mCurParams);
LLWaterParamManager::getInstance()->propagateParameters();
}
// vector control callbacks
void LLFloaterWater::onVector2ControlYMoved(LLUICtrl* ctrl, void* userData)
{
LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
WaterVector2Control * vectorControl = static_cast<WaterVector2Control *>(userData);
vectorControl->mY = sldrCtrl->getValueF32();
vectorControl->update(LLWaterParamManager::getInstance()->mCurParams);
LLWaterParamManager::getInstance()->propagateParameters();
}
// color control callbacks
void LLFloaterWater::onColorControlRMoved(LLUICtrl* ctrl, void* userData)
void LLFloaterWater::onColorControlRMoved(LLUICtrl* ctrl, WaterColorControl* color_ctrl)
{
LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
WaterColorControl * colorControl = static_cast<WaterColorControl *>(userData);
LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
colorControl->mR = sldrCtrl->getValueF32();
color_ctrl->mR = sldr_ctrl->getValueF32();
// move i if it's the max
if(colorControl->mR >= colorControl->mG
&& colorControl->mR >= colorControl->mB
&& colorControl->mHasSliderName)
if (color_ctrl->mR >= color_ctrl->mG
&& color_ctrl->mR >= color_ctrl->mB
&& color_ctrl->mHasSliderName)
{
colorControl->mI = colorControl->mR;
std::string name = colorControl->mSliderName;
color_ctrl->mI = color_ctrl->mR;
std::string name = color_ctrl->mSliderName;
name.append("I");
sWaterMenu->childSetValue(name, colorControl->mR);
getChild<LLUICtrl>(name)->setValue(color_ctrl->mR);
}
colorControl->update(LLWaterParamManager::getInstance()->mCurParams);
color_ctrl->update(LLWaterParamManager::getInstance()->mCurParams);
LLWaterParamManager::getInstance()->propagateParameters();
}
void LLFloaterWater::onColorControlGMoved(LLUICtrl* ctrl, void* userData)
void LLFloaterWater::onColorControlGMoved(LLUICtrl* ctrl, WaterColorControl* color_ctrl)
{
LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
WaterColorControl * colorControl = static_cast<WaterColorControl *>(userData);
LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
colorControl->mG = sldrCtrl->getValueF32();
color_ctrl->mG = sldr_ctrl->getValueF32();
// move i if it's the max
if(colorControl->mG >= colorControl->mR
&& colorControl->mG >= colorControl->mB
&& colorControl->mHasSliderName)
if (color_ctrl->mG >= color_ctrl->mR
&& color_ctrl->mG >= color_ctrl->mB
&& color_ctrl->mHasSliderName)
{
colorControl->mI = colorControl->mG;
std::string name = colorControl->mSliderName;
color_ctrl->mI = color_ctrl->mG;
std::string name = color_ctrl->mSliderName;
name.append("I");
sWaterMenu->childSetValue(name, colorControl->mG);
getChild<LLUICtrl>(name)->setValue(color_ctrl->mG);
}
colorControl->update(LLWaterParamManager::getInstance()->mCurParams);
color_ctrl->update(LLWaterParamManager::getInstance()->mCurParams);
LLWaterParamManager::getInstance()->propagateParameters();
}
void LLFloaterWater::onColorControlBMoved(LLUICtrl* ctrl, void* userData)
void LLFloaterWater::onColorControlBMoved(LLUICtrl* ctrl, WaterColorControl* color_ctrl)
{
LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
WaterColorControl * colorControl = static_cast<WaterColorControl *>(userData);
LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
colorControl->mB = sldrCtrl->getValueF32();
color_ctrl->mB = sldr_ctrl->getValueF32();
// move i if it's the max
if(colorControl->mB >= colorControl->mR
&& colorControl->mB >= colorControl->mG
&& colorControl->mHasSliderName)
if (color_ctrl->mB >= color_ctrl->mR
&& color_ctrl->mB >= color_ctrl->mG
&& color_ctrl->mHasSliderName)
{
colorControl->mI = colorControl->mB;
std::string name = colorControl->mSliderName;
color_ctrl->mI = color_ctrl->mB;
std::string name = color_ctrl->mSliderName;
name.append("I");
sWaterMenu->childSetValue(name, colorControl->mB);
getChild<LLUICtrl>(name)->setValue(color_ctrl->mB);
}
colorControl->update(LLWaterParamManager::getInstance()->mCurParams);
color_ctrl->update(LLWaterParamManager::getInstance()->mCurParams);
LLWaterParamManager::getInstance()->propagateParameters();
}
void LLFloaterWater::onColorControlAMoved(LLUICtrl* ctrl, void* userData)
void LLFloaterWater::onColorControlAMoved(LLUICtrl* ctrl, WaterColorControl* color_ctrl)
{
LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
WaterColorControl * colorControl = static_cast<WaterColorControl *>(userData);
LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
colorControl->mA = sldrCtrl->getValueF32();
color_ctrl->mA = sldr_ctrl->getValueF32();
colorControl->update(LLWaterParamManager::getInstance()->mCurParams);
color_ctrl->update(LLWaterParamManager::getInstance()->mCurParams);
LLWaterParamManager::getInstance()->propagateParameters();
}
void LLFloaterWater::onColorControlIMoved(LLUICtrl* ctrl, void* userData)
void LLFloaterWater::onColorControlIMoved(LLUICtrl* ctrl, WaterColorControl* color_ctrl)
{
LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
WaterColorControl * colorControl = static_cast<WaterColorControl *>(userData);
LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
colorControl->mI = sldrCtrl->getValueF32();
color_ctrl->mI = sldr_ctrl->getValueF32();
// only for sliders where we pass a name
if(colorControl->mHasSliderName)
if (color_ctrl->mHasSliderName)
{
// set it to the top
F32 maxVal = std::max(std::max(colorControl->mR, colorControl->mG), colorControl->mB);
F32 maxVal = std::max(std::max(color_ctrl->mR, color_ctrl->mG), color_ctrl->mB);
F32 iVal;
iVal = colorControl->mI;
iVal = color_ctrl->mI;
// get the names of the other sliders
std::string rName = colorControl->mSliderName;
std::string rName = color_ctrl->mSliderName;
rName.append("R");
std::string gName = colorControl->mSliderName;
std::string gName = color_ctrl->mSliderName;
gName.append("G");
std::string bName = colorControl->mSliderName;
std::string bName = color_ctrl->mSliderName;
bName.append("B");
// handle if at 0
if(iVal == 0)
{
colorControl->mR = 0;
colorControl->mG = 0;
colorControl->mB = 0;
color_ctrl->mR = 0;
color_ctrl->mG = 0;
color_ctrl->mB = 0;
// if all at the start
// set them all to the intensity
}
else if (maxVal == 0)
{
colorControl->mR = iVal;
colorControl->mG = iVal;
colorControl->mB = iVal;
color_ctrl->mR = iVal;
color_ctrl->mG = iVal;
color_ctrl->mB = iVal;
}
else
{
// add delta amounts to each
F32 delta = (iVal - maxVal) / maxVal;
colorControl->mR *= (1.0f + delta);
colorControl->mG *= (1.0f + delta);
colorControl->mB *= (1.0f + delta);
color_ctrl->mR *= (1.0f + delta);
color_ctrl->mG *= (1.0f + delta);
color_ctrl->mB *= (1.0f + delta);
}
// set the sliders to the new vals
sWaterMenu->childSetValue(rName, colorControl->mR);
sWaterMenu->childSetValue(gName, colorControl->mG);
sWaterMenu->childSetValue(bName, colorControl->mB);
getChild<LLUICtrl>(rName)->setValue(color_ctrl->mR);
getChild<LLUICtrl>(gName)->setValue(color_ctrl->mG);
getChild<LLUICtrl>(bName)->setValue(color_ctrl->mB);
}
// now update the current parameters and send them to shaders
colorControl->update(LLWaterParamManager::getInstance()->mCurParams);
color_ctrl->update(LLWaterParamManager::getInstance()->mCurParams);
LLWaterParamManager::getInstance()->propagateParameters();
}
void LLFloaterWater::onExpFloatControlMoved(LLUICtrl* ctrl, void* userData)
// vector control callbacks
void LLFloaterWater::onVector3ControlXMoved(LLUICtrl* ctrl, WaterVector3Control* vector_ctrl)
{
LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
WaterExpFloatControl * expFloatControl = static_cast<WaterExpFloatControl *>(userData);
LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
F32 val = sldrCtrl->getValueF32();
vector_ctrl->mX = sldr_ctrl->getValueF32();
vector_ctrl->update(LLWaterParamManager::getInstance()->mCurParams);
LLWaterParamManager::getInstance()->propagateParameters();
}
// vector control callbacks
void LLFloaterWater::onVector3ControlYMoved(LLUICtrl* ctrl, WaterVector3Control* vector_ctrl)
{
LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
vector_ctrl->mY = sldr_ctrl->getValueF32();
vector_ctrl->update(LLWaterParamManager::getInstance()->mCurParams);
LLWaterParamManager::getInstance()->propagateParameters();
}
// vector control callbacks
void LLFloaterWater::onVector3ControlZMoved(LLUICtrl* ctrl, WaterVector3Control* vector_ctrl)
{
LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
vector_ctrl->mZ = sldr_ctrl->getValueF32();
vector_ctrl->update(LLWaterParamManager::getInstance()->mCurParams);
LLWaterParamManager::getInstance()->propagateParameters();
}
// vector control callbacks
void LLFloaterWater::onVector2ControlXMoved(LLUICtrl* ctrl, WaterVector2Control* vector_ctrl)
{
LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
vector_ctrl->mX = sldr_ctrl->getValueF32();
vector_ctrl->update(LLWaterParamManager::getInstance()->mCurParams);
LLWaterParamManager::getInstance()->propagateParameters();
}
// vector control callbacks
void LLFloaterWater::onVector2ControlYMoved(LLUICtrl* ctrl, WaterVector2Control* vector_ctrl)
{
LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
vector_ctrl->mY = sldr_ctrl->getValueF32();
vector_ctrl->update(LLWaterParamManager::getInstance()->mCurParams);
LLWaterParamManager::getInstance()->propagateParameters();
}
void LLFloaterWater::onFloatControlMoved(LLUICtrl* ctrl, WaterFloatControl* floatControl)
{
LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
floatControl->mX = sldr_ctrl->getValueF32() / floatControl->mMult;
floatControl->update(LLWaterParamManager::getInstance()->mCurParams);
LLWaterParamManager::getInstance()->propagateParameters();
}
void LLFloaterWater::onExpFloatControlMoved(LLUICtrl* ctrl, WaterExpFloatControl* expFloatControl)
{
LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
F32 val = sldr_ctrl->getValueF32();
expFloatControl->mExp = val;
LLWaterParamManager::getInstance()->setDensitySliderValue(val);
expFloatControl->update(LLWaterParamManager::getInstance()->mCurParams);
LLWaterParamManager::getInstance()->propagateParameters();
}
void LLFloaterWater::onFloatControlMoved(LLUICtrl* ctrl, void* userData)
{
LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
WaterFloatControl * floatControl = static_cast<WaterFloatControl *>(userData);
floatControl->mX = sldrCtrl->getValueF32() / floatControl->mMult;
floatControl->update(LLWaterParamManager::getInstance()->mCurParams);
LLWaterParamManager::getInstance()->propagateParameters();
}
void LLFloaterWater::onWaterFogColorMoved(LLUICtrl* ctrl, void* userData)
void LLFloaterWater::onWaterFogColorMoved(LLUICtrl* ctrl, WaterColorControl* color_ctrl)
{
LLColorSwatchCtrl* swatch = static_cast<LLColorSwatchCtrl*>(ctrl);
WaterColorControl * colorControl = static_cast<WaterColorControl *>(userData);
*colorControl = swatch->get();
*color_ctrl = swatch->get();
colorControl->update(LLWaterParamManager::getInstance()->mCurParams);
color_ctrl->update(LLWaterParamManager::getInstance()->mCurParams);
LLWaterParamManager::getInstance()->propagateParameters();
}
void LLFloaterWater::onBoolToggle(LLUICtrl* ctrl, void* userData)
{
LLCheckBoxCtrl* cbCtrl = static_cast<LLCheckBoxCtrl*>(ctrl);
bool value = cbCtrl->get();
(*(static_cast<BOOL *>(userData))) = value;
}
void LLFloaterWater::onNormalMapPicked(LLUICtrl* ctrl, void* userData)
void LLFloaterWater::onNormalMapPicked(LLUICtrl* ctrl)
{
LLTextureCtrl* textCtrl = static_cast<LLTextureCtrl*>(ctrl);
LLUUID textID = textCtrl->getImageAssetID();
LLWaterParamManager::getInstance()->setNormalMapID(textID);
}
void LLFloaterWater::onNewPreset(void* userData)
//=============================================================================
void LLFloaterWater::onNewPreset()
{
LLNotifications::instance().add("NewWaterPreset", LLSD(), LLSD(), newPromptCallback);
LLNotificationsUtil::add("NewWaterPreset", LLSD(), LLSD(), boost::bind(&LLFloaterWater::newPromptCallback, this, _1, _2));
}
void LLFloaterWater::onSavePreset(LLUICtrl* ctrl, void* userData)
void LLFloaterWater::onSavePreset(LLUICtrl* ctrl)
{
// don't save the empty name
if(sWaterMenu->mWaterPresetCombo->getSelectedItemLabel() == "")
if(mWaterPresetCombo->getSelectedItemLabel().empty())
{
return;
}
@@ -622,25 +585,23 @@ void LLFloaterWater::onSavePreset(LLUICtrl* ctrl, void* userData)
}
else
{
LLWaterParamManager::getInstance()->mCurParams.mName =
sWaterMenu->mWaterPresetCombo->getSelectedItemLabel();
LLWaterParamManager::getInstance()->mCurParams.mName = mWaterPresetCombo->getSelectedItemLabel();
// check to see if it's a default and shouldn't be overwritten
std::set<std::string>::iterator sIt = sDefaultPresets.find(
sWaterMenu->mWaterPresetCombo->getSelectedItemLabel());
std::set<std::string>::iterator sIt = sDefaultPresets.find(mWaterPresetCombo->getSelectedItemLabel());
if(sIt != sDefaultPresets.end() && !gSavedSettings.getBOOL("WaterEditPresets"))
{
LLNotifications::instance().add("WLNoEditDefault");
LLNotificationsUtil::add("WLNoEditDefault");
return;
}
LLNotifications::instance().add("WLSavePresetAlert", LLSD(), LLSD(), saveAlertCallback);
LLNotificationsUtil::add("WLSavePresetAlert", LLSD(), LLSD(), boost::bind(&LLFloaterWater::saveAlertCallback, this, _1, _2));
}
}
bool LLFloaterWater::saveNotecardCallback(const LLSD& notification, const LLSD& response)
{
S32 option = LLNotification::getSelectedOption(notification, response);
S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
// if they choose save, do it. Otherwise, don't do anything
if(option == 0)
{
@@ -653,15 +614,13 @@ bool LLFloaterWater::saveNotecardCallback(const LLSD& notification, const LLSD&
bool LLFloaterWater::saveAlertCallback(const LLSD& notification, const LLSD& response)
{
S32 option = LLNotification::getSelectedOption(notification, response);
S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
// if they choose save, do it. Otherwise, don't do anything
if(option == 0)
{
LLWaterParamManager * param_mgr = LLWaterParamManager::getInstance();
LLWaterParamManager* param_mgr = LLWaterParamManager::getInstance();
param_mgr->setParamSet(
param_mgr->mCurParams.mName,
param_mgr->mCurParams);
param_mgr->setParamSet(param_mgr->mCurParams.mName, param_mgr->mCurParams);
// comment this back in to save to file
param_mgr->savePreset(param_mgr->mCurParams.mName);
@@ -669,22 +628,23 @@ bool LLFloaterWater::saveAlertCallback(const LLSD& notification, const LLSD& res
return false;
}
void LLFloaterWater::onDeletePreset(void* userData)
void LLFloaterWater::onDeletePreset()
{
if(sWaterMenu->mWaterPresetCombo->getSelectedValue().asString() == "")
if(mWaterPresetCombo->getSelectedValue().asString().empty())
{
return;
}
LLSD args;
args["SKY"] = sWaterMenu->mWaterPresetCombo->getSelectedValue().asString();
LLNotifications::instance().add("WLDeletePresetAlert", args, LLSD(), deleteAlertCallback);
args["SKY"] = mWaterPresetCombo->getSelectedValue().asString();
LLNotificationsUtil::add("WLDeletePresetAlert", args, LLSD(), boost::bind(&LLFloaterWater::deleteAlertCallback, this, _1, _2));
}
bool LLFloaterWater::deleteAlertCallback(const LLSD& notification, const LLSD& response)
{
S32 option = LLNotification::getSelectedOption(notification, response);
// if they choose delete, do it. Otherwise, don't do anything
S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
// If they choose delete, do it. Otherwise, don't do anything
if(option == 0)
{
LLFloaterDayCycle* day_cycle = NULL;
@@ -696,22 +656,22 @@ bool LLFloaterWater::deleteAlertCallback(const LLSD& notification, const LLSD& r
key_combo = day_cycle->getChild<LLComboBox>("WaterKeyPresets");
}
std::string name = sWaterMenu->mWaterPresetCombo->getSelectedValue().asString();
std::string name = mWaterPresetCombo->getSelectedValue().asString();
// check to see if it's a default and shouldn't be deleted
std::set<std::string>::iterator sIt = sDefaultPresets.find(name);
if(sIt != sDefaultPresets.end())
{
LLNotifications::instance().add("WaterNoEditDefault");
LLNotificationsUtil::add("WaterNoEditDefault");
return false;
}
LLWaterParamManager::getInstance()->removeParamSet(name, true);
// remove and choose another
S32 new_index = sWaterMenu->mWaterPresetCombo->getCurrentIndex();
S32 new_index = mWaterPresetCombo->getCurrentIndex();
sWaterMenu->mWaterPresetCombo->remove(name);
mWaterPresetCombo->remove(name);
if(key_combo != NULL)
{
@@ -724,23 +684,22 @@ bool LLFloaterWater::deleteAlertCallback(const LLSD& notification, const LLSD& r
// pick the previously selected index after delete
if(new_index > 0)
{
new_index--;
--new_index;
}
if(sWaterMenu->mWaterPresetCombo->getItemCount() > 0)
if(mWaterPresetCombo->getItemCount() > 0)
{
sWaterMenu->mWaterPresetCombo->setCurrentByIndex(new_index);
mWaterPresetCombo->setCurrentByIndex(new_index);
}
}
return false;
}
void LLFloaterWater::onChangePresetName(LLUICtrl* ctrl, void * userData)
void LLFloaterWater::onChangePresetName(LLUICtrl* ctrl)
{
LLComboBox * combo_box = static_cast<LLComboBox*>(ctrl);
LLComboBox* combo_box = static_cast<LLComboBox*>(ctrl);
if(combo_box->getSimple() == "")
if(combo_box->getSimple().empty())
{
return;
}
@@ -756,29 +715,29 @@ void LLFloaterWater::onChangePresetName(LLUICtrl* ctrl, void * userData)
// LLEnvManagerNew::instance().useRegionWater();
LLEnvManagerNew::instance().setUseWaterPreset("Default");
}
sWaterMenu->syncMenu();
syncMenu();
}
void LLFloaterWater::onClickNext(void* user_data)
void LLFloaterWater::onClickNext()
{
S32 index = sWaterMenu->mWaterPresetCombo->getCurrentIndex();
index++;
if (index == sWaterMenu->mWaterPresetCombo->getItemCount())
S32 index = mWaterPresetCombo->getCurrentIndex();
++index;
if (index == mWaterPresetCombo->getItemCount())
index = 0;
sWaterMenu->mWaterPresetCombo->setCurrentByIndex(index);
mWaterPresetCombo->setCurrentByIndex(index);
LLFloaterWater::onChangePresetName(sWaterMenu->mWaterPresetCombo, sWaterMenu);
LLFloaterWater::onChangePresetName(mWaterPresetCombo);
}
void LLFloaterWater::onClickPrev(void* user_data)
void LLFloaterWater::onClickPrev()
{
S32 index = sWaterMenu->mWaterPresetCombo->getCurrentIndex();
S32 index = mWaterPresetCombo->getCurrentIndex();
if (index == 0)
index = sWaterMenu->mWaterPresetCombo->getItemCount();
index--;
sWaterMenu->mWaterPresetCombo->setCurrentByIndex(index);
index = mWaterPresetCombo->getItemCount();
--index;
mWaterPresetCombo->setCurrentByIndex(index);
LLFloaterWater::onChangePresetName(sWaterMenu->mWaterPresetCombo, sWaterMenu);
LLFloaterWater::onChangePresetName(mWaterPresetCombo);
}
void LLFloaterWater::populateWaterPresetsList()

64
indra/newview/llfloaterwater.h
View File

@@ -39,15 +39,16 @@
#include "llfloater.h"
#include <vector>
#include "llwlparamset.h"
#include "llwlparammanager.h" // for LLWLParamKey
struct WaterColorControl;
struct WaterloatControl;
class LLComboBox;
struct WaterVector2Control;
struct WaterVector3Control;
struct WaterColorControl;
struct WaterFloatControl;
struct WaterExpFloatControl;
/// Menuing system for all of windlight's functionality
class LLFloaterWater : public LLFloater
@@ -67,53 +68,54 @@ public:
static void onClickHelp(void* data);
void initHelpBtn(const std::string& name, const std::string& xml_alert);
static bool newPromptCallback(const LLSD& notification, const LLSD& response);
//-- WL stuff begins ------------------------------------------------------
/// general purpose callbacks for dealing with color controllers
static void onColorControlRMoved(LLUICtrl* ctrl, void* userData);
static void onColorControlGMoved(LLUICtrl* ctrl, void* userData);
static void onColorControlBMoved(LLUICtrl* ctrl, void* userData);
static void onColorControlAMoved(LLUICtrl* ctrl, void* userData);
static void onColorControlIMoved(LLUICtrl* ctrl, void* userData);
bool newPromptCallback(const LLSD& notification, const LLSD& response);
static void onVector3ControlXMoved(LLUICtrl* ctrl, void* userData);
static void onVector3ControlYMoved(LLUICtrl* ctrl, void* userData);
static void onVector3ControlZMoved(LLUICtrl* ctrl, void* userData);
// general purpose callbacks for dealing with color controllers
void onColorControlRMoved(LLUICtrl* ctrl, WaterColorControl* color_ctrl);
void onColorControlGMoved(LLUICtrl* ctrl, WaterColorControl* color_ctrl);
void onColorControlBMoved(LLUICtrl* ctrl, WaterColorControl* color_ctrl);
void onColorControlAMoved(LLUICtrl* ctrl, WaterColorControl* color_ctrl);
void onColorControlIMoved(LLUICtrl* ctrl, WaterColorControl* color_ctrl);
static void onVector2ControlXMoved(LLUICtrl* ctrl, void* userData);
static void onVector2ControlYMoved(LLUICtrl* ctrl, void* userData);
void onVector3ControlXMoved(LLUICtrl* ctrl, WaterVector3Control* vector_ctrl);
void onVector3ControlYMoved(LLUICtrl* ctrl, WaterVector3Control* vector_ctrl);
void onVector3ControlZMoved(LLUICtrl* ctrl, WaterVector3Control* vector_ctrl);
static void onFloatControlMoved(LLUICtrl* ctrl, void* userData);
void onVector2ControlXMoved(LLUICtrl* ctrl, WaterVector2Control* vector_ctrl);
void onVector2ControlYMoved(LLUICtrl* ctrl, WaterVector2Control* vector_ctrl);
static void onExpFloatControlMoved(LLUICtrl* ctrl, void* userData);
void onFloatControlMoved(LLUICtrl* ctrl, WaterFloatControl* floatControl);
static void onWaterFogColorMoved(LLUICtrl* ctrl, void* userData);
void onExpFloatControlMoved(LLUICtrl* ctrl, WaterExpFloatControl* expFloatControl);
static void onBoolToggle(LLUICtrl* ctrl, void* userData);
void onWaterFogColorMoved(LLUICtrl* ctrl, WaterColorControl* color_ctrl);
/// handle if they choose a new normal map
static void onNormalMapPicked(LLUICtrl* ctrl, void* userData);
void onNormalMapPicked(LLUICtrl* ctrl); /// handle if they choose a new normal map
//-- WL stuff ends --------------------------------------------------------
/// when user hits the load preset button
static void onNewPreset(void* userData);
void onNewPreset();
/// when user hits the save preset button
static void onSavePreset(LLUICtrl* ctrl, void* userData);
void onSavePreset(LLUICtrl* ctrl);
/// prompts a user when overwriting a preset notecard
static bool saveNotecardCallback(const LLSD& notification, const LLSD& response);
bool saveNotecardCallback(const LLSD& notification, const LLSD& response);
/// prompts a user when overwriting a preset
static bool saveAlertCallback(const LLSD& notification, const LLSD& response);
bool saveAlertCallback(const LLSD& notification, const LLSD& response);
/// when user hits the save preset button
static void onDeletePreset(void* userData);
void onDeletePreset();
/// prompts a user when overwriting a preset
static bool deleteAlertCallback(const LLSD& notification, const LLSD& response);
bool deleteAlertCallback(const LLSD& notification, const LLSD& response);
/// what to do when you change the preset name
static void onChangePresetName(LLUICtrl* ctrl, void* userData);
void onChangePresetName(LLUICtrl* ctrl);
//// menu management
@@ -135,8 +137,8 @@ private:
static std::set<std::string> sDefaultPresets;
static void onClickNext(void* user_data);
static void onClickPrev(void* user_data);
void onClickNext();
void onClickPrev();
void populateWaterPresetsList();

441
indra/newview/llfloaterwindlight.cpp
View File

@@ -34,37 +34,21 @@
#include "llfloaterwindlight.h"
#include "pipeline.h"
#include "llsky.h"
#include "llsliderctrl.h"
#include "llmultislider.h"
#include "llmultisliderctrl.h"
#include "llspinctrl.h"
// libs
#include "llcheckboxctrl.h"
#include "lluictrlfactory.h"
#include "llviewercamera.h"
#include "llcombobox.h"
#include "lllineeditor.h"
#include "llmultisliderctrl.h"
#include "llnotificationsutil.h"
#include "llsliderctrl.h"
#include "llfloaterdaycycle.h"
#include "lltabcontainer.h"
#include "llboost.h"
#include "lluictrlfactory.h"
// newview
#include "llagent.h"
#include "llinventorymodel.h"
#include "llviewerinventory.h"
#include "v4math.h"
#include "llviewerdisplay.h"
#include "llviewercontrol.h"
#include "llviewerwindow.h"
#include "llsavedsettingsglue.h"
#include "llwlparamset.h"
#include "llwlparammanager.h"
#undef max
LLFloaterWindLight* LLFloaterWindLight::sWindLight = NULL;
std::set<std::string> LLFloaterWindLight::sDefaultPresets;
@@ -79,18 +63,16 @@ LLFloaterWindLight::LLFloaterWindLight() : LLFloater(std::string("windlight floa
// add the combo boxes
mSkyPresetCombo = getChild<LLComboBox>("WLPresetsCombo");
if(mSkyPresetCombo != NULL) {
if (mSkyPresetCombo)
{
populateSkyPresetsList();
mSkyPresetCombo->setCommitCallback(onChangePresetName);
mSkyPresetCombo->setCommitCallback(boost::bind(&LLFloaterWindLight::onChangePresetName, this, _1));
}
// add the list of presets
std::string def_days = getString("WLDefaultSkyNames");
// no editing or deleting of the blank string
sDefaultPresets.insert("");
boost_tokenizer tokens(def_days, boost::char_separator<char>(":"));
boost_tokenizer tokens(getString("WLDefaultSkyNames"), boost::char_separator<char>(":"));
for (boost_tokenizer::iterator token_iter = tokens.begin(); token_iter != tokens.end(); ++token_iter)
{
std::string tok(*token_iter);
@@ -105,7 +87,8 @@ LLFloaterWindLight::~LLFloaterWindLight()
{
}
void LLFloaterWindLight::initCallbacks(void) {
void LLFloaterWindLight::initCallbacks(void)
{
// help buttons
initHelpBtn("WLBlueHorizonHelp", "HelpBlueHorizon");
@@ -137,93 +120,92 @@ void LLFloaterWindLight::initCallbacks(void) {
initHelpBtn("WLClassicCloudsHelp", "HelpClassicClouds");
LLWLParamManager * param_mgr = LLWLParamManager::getInstance();
LLWLParamManager& param_mgr = LLWLParamManager::instance();
// blue horizon
childSetCommitCallback("WLBlueHorizonR", onColorControlRMoved, &param_mgr->mBlueHorizon);
childSetCommitCallback("WLBlueHorizonG", onColorControlGMoved, &param_mgr->mBlueHorizon);
childSetCommitCallback("WLBlueHorizonB", onColorControlBMoved, &param_mgr->mBlueHorizon);
childSetCommitCallback("WLBlueHorizonI", onColorControlIMoved, &param_mgr->mBlueHorizon);
getChild<LLUICtrl>("WLBlueHorizonR")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlRMoved, this, _1, &param_mgr.mBlueHorizon));
getChild<LLUICtrl>("WLBlueHorizonG")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlGMoved, this, _1, &param_mgr.mBlueHorizon));
getChild<LLUICtrl>("WLBlueHorizonB")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlBMoved, this, _1, &param_mgr.mBlueHorizon));
getChild<LLUICtrl>("WLBlueHorizonI")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlIMoved, this, _1, &param_mgr.mBlueHorizon));
// haze density, horizon, mult, and altitude
childSetCommitCallback("WLHazeDensity", onFloatControlMoved, &param_mgr->mHazeDensity);
childSetCommitCallback("WLHazeHorizon", onFloatControlMoved, &param_mgr->mHazeHorizon);
childSetCommitCallback("WLDensityMult", onFloatControlMoved, &param_mgr->mDensityMult);
childSetCommitCallback("WLMaxAltitude", onFloatControlMoved, &param_mgr->mMaxAlt);
getChild<LLUICtrl>("WLHazeDensity")->setCommitCallback(boost::bind(&LLFloaterWindLight::onFloatControlMoved, this, _1, &param_mgr.mHazeDensity));
getChild<LLUICtrl>("WLHazeHorizon")->setCommitCallback(boost::bind(&LLFloaterWindLight::onFloatControlMoved, this, _1, &param_mgr.mHazeHorizon));
getChild<LLUICtrl>("WLDensityMult")->setCommitCallback(boost::bind(&LLFloaterWindLight::onFloatControlMoved, this, _1, &param_mgr.mDensityMult));
getChild<LLUICtrl>("WLMaxAltitude")->setCommitCallback(boost::bind(&LLFloaterWindLight::onFloatControlMoved, this, _1, &param_mgr.mMaxAlt));
// blue density
childSetCommitCallback("WLBlueDensityR", onColorControlRMoved, &param_mgr->mBlueDensity);
childSetCommitCallback("WLBlueDensityG", onColorControlGMoved, &param_mgr->mBlueDensity);
childSetCommitCallback("WLBlueDensityB", onColorControlBMoved, &param_mgr->mBlueDensity);
childSetCommitCallback("WLBlueDensityI", onColorControlIMoved, &param_mgr->mBlueDensity);
getChild<LLUICtrl>("WLBlueDensityR")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlRMoved, this, _1, &param_mgr.mBlueDensity));
getChild<LLUICtrl>("WLBlueDensityG")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlGMoved, this, _1, &param_mgr.mBlueDensity));
getChild<LLUICtrl>("WLBlueDensityB")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlBMoved, this, _1, &param_mgr.mBlueDensity));
getChild<LLUICtrl>("WLBlueDensityI")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlIMoved, this, _1, &param_mgr.mBlueDensity));
// Lighting
// sunlight
childSetCommitCallback("WLSunlightR", onColorControlRMoved, &param_mgr->mSunlight);
childSetCommitCallback("WLSunlightG", onColorControlGMoved, &param_mgr->mSunlight);
childSetCommitCallback("WLSunlightB", onColorControlBMoved, &param_mgr->mSunlight);
childSetCommitCallback("WLSunlightI", onColorControlIMoved, &param_mgr->mSunlight);
getChild<LLUICtrl>("WLSunlightR")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlRMoved, this, _1, &param_mgr.mSunlight));
getChild<LLUICtrl>("WLSunlightG")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlGMoved, this, _1, &param_mgr.mSunlight));
getChild<LLUICtrl>("WLSunlightB")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlBMoved, this, _1, &param_mgr.mSunlight));
getChild<LLUICtrl>("WLSunlightI")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlIMoved, this, _1, &param_mgr.mSunlight));
// glow
childSetCommitCallback("WLGlowR", onGlowRMoved, &param_mgr->mGlow);
childSetCommitCallback("WLGlowB", onGlowBMoved, &param_mgr->mGlow);
getChild<LLUICtrl>("WLGlowR")->setCommitCallback(boost::bind(&LLFloaterWindLight::onGlowRMoved, this, _1, &param_mgr.mGlow));
getChild<LLUICtrl>("WLGlowB")->setCommitCallback(boost::bind(&LLFloaterWindLight::onGlowBMoved, this, _1, &param_mgr.mGlow));
// ambient
childSetCommitCallback("WLAmbientR", onColorControlRMoved, &param_mgr->mAmbient);
childSetCommitCallback("WLAmbientG", onColorControlGMoved, &param_mgr->mAmbient);
childSetCommitCallback("WLAmbientB", onColorControlBMoved, &param_mgr->mAmbient);
childSetCommitCallback("WLAmbientI", onColorControlIMoved, &param_mgr->mAmbient);
getChild<LLUICtrl>("WLAmbientR")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlRMoved, this, _1, &param_mgr.mAmbient));
getChild<LLUICtrl>("WLAmbientG")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlGMoved, this, _1, &param_mgr.mAmbient));
getChild<LLUICtrl>("WLAmbientB")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlBMoved, this, _1, &param_mgr.mAmbient));
getChild<LLUICtrl>("WLAmbientI")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlIMoved, this, _1, &param_mgr.mAmbient));
// time of day
childSetCommitCallback("WLSunAngle", onSunMoved, &param_mgr->mLightnorm);
childSetCommitCallback("WLEastAngle", onSunMoved, &param_mgr->mLightnorm);
getChild<LLUICtrl>("WLSunAngle")->setCommitCallback(boost::bind(&LLFloaterWindLight::onSunMoved, this, _1, &param_mgr.mLightnorm));
getChild<LLUICtrl>("WLEastAngle")->setCommitCallback(boost::bind(&LLFloaterWindLight::onSunMoved, this, _1, &param_mgr.mLightnorm));
// Clouds
// Cloud Color
childSetCommitCallback("WLCloudColorR", onColorControlRMoved, &param_mgr->mCloudColor);
childSetCommitCallback("WLCloudColorG", onColorControlGMoved, &param_mgr->mCloudColor);
childSetCommitCallback("WLCloudColorB", onColorControlBMoved, &param_mgr->mCloudColor);
childSetCommitCallback("WLCloudColorI", onColorControlIMoved, &param_mgr->mCloudColor);
getChild<LLUICtrl>("WLCloudColorR")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlRMoved, this, _1, &param_mgr.mCloudColor));
getChild<LLUICtrl>("WLCloudColorG")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlGMoved, this, _1, &param_mgr.mCloudColor));
getChild<LLUICtrl>("WLCloudColorB")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlBMoved, this, _1, &param_mgr.mCloudColor));
getChild<LLUICtrl>("WLCloudColorI")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlIMoved, this, _1, &param_mgr.mCloudColor));
// Cloud
childSetCommitCallback("WLCloudX", onColorControlRMoved, &param_mgr->mCloudMain);
childSetCommitCallback("WLCloudY", onColorControlGMoved, &param_mgr->mCloudMain);
childSetCommitCallback("WLCloudDensity", onColorControlBMoved, &param_mgr->mCloudMain);
getChild<LLUICtrl>("WLCloudX")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlRMoved, this, _1, &param_mgr.mCloudMain));
getChild<LLUICtrl>("WLCloudY")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlGMoved, this, _1, &param_mgr.mCloudMain));
getChild<LLUICtrl>("WLCloudDensity")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlBMoved, this, _1, &param_mgr.mCloudMain));
// Cloud Detail
childSetCommitCallback("WLCloudDetailX", onColorControlRMoved, &param_mgr->mCloudDetail);
childSetCommitCallback("WLCloudDetailY", onColorControlGMoved, &param_mgr->mCloudDetail);
childSetCommitCallback("WLCloudDetailDensity", onColorControlBMoved, &param_mgr->mCloudDetail);
getChild<LLUICtrl>("WLCloudDetailX")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlRMoved, this, _1, &param_mgr.mCloudDetail));
getChild<LLUICtrl>("WLCloudDetailY")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlGMoved, this, _1, &param_mgr.mCloudDetail));
getChild<LLUICtrl>("WLCloudDetailDensity")->setCommitCallback(boost::bind(&LLFloaterWindLight::onColorControlBMoved, this, _1, &param_mgr.mCloudDetail));
// Cloud extras
childSetCommitCallback("WLCloudCoverage", onFloatControlMoved, &param_mgr->mCloudCoverage);
childSetCommitCallback("WLCloudScale", onFloatControlMoved, &param_mgr->mCloudScale);
childSetCommitCallback("WLCloudLockX", onCloudScrollXToggled, NULL);
childSetCommitCallback("WLCloudLockY", onCloudScrollYToggled, NULL);
childSetCommitCallback("WLCloudScrollX", onCloudScrollXMoved, NULL);
childSetCommitCallback("WLCloudScrollY", onCloudScrollYMoved, NULL);
childSetCommitCallback("WLDistanceMult", onFloatControlMoved, &param_mgr->mDistanceMult);
childSetCommitCallback("DrawClassicClouds", onCommitControlSetting(gSavedSettings), (void*)"SkyUseClassicClouds");
getChild<LLUICtrl>("WLCloudCoverage")->setCommitCallback(boost::bind(&LLFloaterWindLight::onFloatControlMoved, this, _1, &param_mgr.mCloudCoverage));
getChild<LLUICtrl>("WLCloudScale")->setCommitCallback(boost::bind(&LLFloaterWindLight::onFloatControlMoved, this, _1, &param_mgr.mCloudScale));
getChild<LLUICtrl>("WLCloudLockX")->setCommitCallback(boost::bind(&LLFloaterWindLight::onCloudScrollXToggled, this, _2));
getChild<LLUICtrl>("WLCloudLockY")->setCommitCallback(boost::bind(&LLFloaterWindLight::onCloudScrollYToggled, this, _2));
getChild<LLUICtrl>("WLCloudScrollX")->setCommitCallback(boost::bind(&LLFloaterWindLight::onCloudScrollXMoved, this, _2));
getChild<LLUICtrl>("WLCloudScrollY")->setCommitCallback(boost::bind(&LLFloaterWindLight::onCloudScrollYMoved, this, _2));
getChild<LLUICtrl>("WLDistanceMult")->setCommitCallback(boost::bind(&LLFloaterWindLight::onFloatControlMoved, this, _1, &param_mgr.mDistanceMult));
// WL Top
childSetAction("WLDayCycleMenuButton", onOpenDayCycle, NULL);
getChild<LLUICtrl>("WLDayCycleMenuButton")->setCommitCallback(boost::bind(LLFloaterDayCycle::show));
// Load/save
//childSetAction("WLLoadPreset", onLoadPreset, mSkyPresetCombo);
childSetAction("WLNewPreset", onNewPreset, mSkyPresetCombo);
childSetAction("WLDeletePreset", onDeletePreset, mSkyPresetCombo);
childSetCommitCallback("WLSavePreset", onSavePreset, this);
//getChild<LLUICtrl>("WLLoadPreset")->setCommitCallback(boost::bind(&LLFloaterWindLight::onLoadPreset, this, mSkyPresetCombo));
getChild<LLUICtrl>("WLNewPreset")->setCommitCallback(boost::bind(&LLFloaterWindLight::onNewPreset, this));
getChild<LLUICtrl>("WLDeletePreset")->setCommitCallback(boost::bind(&LLFloaterWindLight::onDeletePreset, this));
getChild<LLUICtrl>("WLSavePreset")->setCommitCallback(boost::bind(&LLFloaterWindLight::onSavePreset, this, _1));
// Dome
childSetCommitCallback("WLGamma", onFloatControlMoved, &param_mgr->mWLGamma);
childSetCommitCallback("WLStarAlpha", onStarAlphaMoved, NULL);
getChild<LLUICtrl>("WLGamma")->setCommitCallback(boost::bind(&LLFloaterWindLight::onFloatControlMoved, this, _1, &param_mgr.mWLGamma));
getChild<LLUICtrl>("WLStarAlpha")->setCommitCallback(boost::bind(&LLFloaterWindLight::onStarAlphaMoved, this, _1));
// next/prev buttons
//childSetAction("next", onClickNext, this);
//childSetAction("prev", onClickPrev, this);
//getChild<LLUICtrl>("next")->setCommitCallback(boost::bind(&LLFloaterWindLight::onClickNext, this));
//getChild<LLUICtrl>("prev")->setCommitCallback(boost::bind(&LLFloaterWindLight::onClickPrev, this));
}
void LLFloaterWindLight::onClickHelp(void* data)
@@ -242,22 +224,20 @@ void LLFloaterWindLight::initHelpBtn(const std::string& name, const std::string&
bool LLFloaterWindLight::newPromptCallback(const LLSD& notification, const LLSD& response)
{
std::string text = response["message"].asString();
S32 option = LLNotification::getSelectedOption(notification, response);
if(text == "")
if(text.empty())
{
return false;
}
S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
if(option == 0)
{
LLFloaterDayCycle* sDayCycle = NULL;
LLComboBox* keyCombo = NULL;
if(LLFloaterDayCycle::isOpen())
if(LLFloaterDayCycle::isOpen())
{
sDayCycle = LLFloaterDayCycle::instance();
keyCombo = sDayCycle->getChild<LLComboBox>(
"WLKeyPresets");
keyCombo = sDayCycle->getChild<LLComboBox>("WLKeyPresets");
}
// add the current parameters to the list
@@ -268,20 +248,19 @@ bool LLFloaterWindLight::newPromptCallback(const LLSD& notification, const LLSD&
// if not there, add a new one
if(!LLWLParamManager::getInstance()->hasParamSet(key))
{
LLWLParamManager::getInstance()->addParamSet(key,
LLWLParamManager::getInstance()->mCurParams);
sWindLight->mSkyPresetCombo->add(text);
sWindLight->mSkyPresetCombo->sortByName();
LLWLParamManager::getInstance()->addParamSet(key, LLWLParamManager::getInstance()->mCurParams);
mSkyPresetCombo->add(text);
mSkyPresetCombo->sortByName();
// add a blank to the bottom
sWindLight->mSkyPresetCombo->selectFirstItem();
if(sWindLight->mSkyPresetCombo->getSimple() == "")
mSkyPresetCombo->selectFirstItem();
if(mSkyPresetCombo->getSimple().empty())
{
sWindLight->mSkyPresetCombo->remove(0);
mSkyPresetCombo->remove(0);
}
sWindLight->mSkyPresetCombo->add(LLStringUtil::null);
mSkyPresetCombo->add(LLStringUtil::null);
sWindLight->mSkyPresetCombo->selectByValue(text);
mSkyPresetCombo->selectByValue(text);
if(LLFloaterDayCycle::isOpen())
{
@@ -294,10 +273,10 @@ bool LLFloaterWindLight::newPromptCallback(const LLSD& notification, const LLSD&
LLEnvManagerNew::instance().setUseSkyPreset(text);
// otherwise, send a message to the user
}
else
}
else
{
LLNotifications::instance().add("ExistsSkyPresetAlert");
LLNotificationsUtil::add("ExistsSkyPresetAlert");
}
}
return false;
@@ -385,7 +364,6 @@ void LLFloaterWindLight::syncMenu()
bool lockY = !param_mgr->mCurParams.getEnableCloudScrollY();
childSetValue("WLCloudLockX", lockX);
childSetValue("WLCloudLockY", lockY);
childSetValue("DrawClassicClouds", gSavedSettings.getBOOL("SkyUseClassicClouds"));
// disable if locked, enable if not
if (lockX)
@@ -423,16 +401,17 @@ void LLFloaterWindLight::syncMenu()
void LLFloaterWindLight::setColorSwatch(const std::string& name, const WLColorControl& from_ctrl, F32 k)
{
std::string child_name(name);
const size_t end = child_name.length();
LLVector4 color_vec = from_ctrl;
color_vec/=k;
child_name.push_back('R');
childSetValue(name.data(), color_vec[0]);
child_name.replace(child_name.length()-1,1,1,'G');
child_name.replace(end,1,1,'G');
childSetValue(child_name, color_vec[1]);
child_name.replace(child_name.length()-1,1,1,'B');
child_name.replace(end,1,1,'B');
childSetValue(child_name, color_vec[2]);
child_name.replace(child_name.length()-1,1,1,'I');
child_name.replace(end,1,1,'I');
childSetValue(child_name, llmax(color_vec.mV[0], color_vec.mV[1], color_vec.mV[2]));
}
@@ -516,15 +495,15 @@ void LLFloaterWindLight::onColorControlRMoved(LLUICtrl* ctrl, void* userdata)
if (color_ctrl->isSunOrAmbientColor)
{
sWindLight->childSetValue(name, color_ctrl->r / WL_SUN_AMBIENT_SLIDER_SCALE);
childSetValue(name, color_ctrl->r / WL_SUN_AMBIENT_SLIDER_SCALE);
}
else if (color_ctrl->isBlueHorizonOrDensity)
{
sWindLight->childSetValue(name, color_ctrl->r / WL_BLUE_HORIZON_DENSITY_SCALE);
childSetValue(name, color_ctrl->r / WL_BLUE_HORIZON_DENSITY_SCALE);
}
else
{
sWindLight->childSetValue(name, color_ctrl->r);
childSetValue(name, color_ctrl->r);
}
}
@@ -559,15 +538,15 @@ void LLFloaterWindLight::onColorControlGMoved(LLUICtrl* ctrl, void* userdata)
if (color_ctrl->isSunOrAmbientColor)
{
sWindLight->childSetValue(name, color_ctrl->g / WL_SUN_AMBIENT_SLIDER_SCALE);
childSetValue(name, color_ctrl->g / WL_SUN_AMBIENT_SLIDER_SCALE);
}
else if (color_ctrl->isBlueHorizonOrDensity)
{
sWindLight->childSetValue(name, color_ctrl->g / WL_BLUE_HORIZON_DENSITY_SCALE);
childSetValue(name, color_ctrl->g / WL_BLUE_HORIZON_DENSITY_SCALE);
}
else
{
sWindLight->childSetValue(name, color_ctrl->g);
childSetValue(name, color_ctrl->g);
}
}
@@ -602,15 +581,15 @@ void LLFloaterWindLight::onColorControlBMoved(LLUICtrl* ctrl, void* userdata)
if (color_ctrl->isSunOrAmbientColor)
{
sWindLight->childSetValue(name, color_ctrl->b / WL_SUN_AMBIENT_SLIDER_SCALE);
childSetValue(name, color_ctrl->b / WL_SUN_AMBIENT_SLIDER_SCALE);
}
else if (color_ctrl->isBlueHorizonOrDensity)
{
sWindLight->childSetValue(name, color_ctrl->b / WL_BLUE_HORIZON_DENSITY_SCALE);
childSetValue(name, color_ctrl->b / WL_BLUE_HORIZON_DENSITY_SCALE);
}
else
{
sWindLight->childSetValue(name, color_ctrl->b);
childSetValue(name, color_ctrl->b);
}
}
@@ -619,28 +598,27 @@ void LLFloaterWindLight::onColorControlBMoved(LLUICtrl* ctrl, void* userdata)
LLWLParamManager::getInstance()->propagateParameters();
}
void LLFloaterWindLight::onColorControlIMoved(LLUICtrl* ctrl, void* userData)
void LLFloaterWindLight::onColorControlIMoved(LLUICtrl* ctrl, void* userdata)
{
LLWLParamManager::getInstance()->mAnimator.deactivate();
LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
WLColorControl * color_ctrl = static_cast<WLColorControl *>(userData);
WLColorControl* color_ctrl = static_cast<WLColorControl *>(userdata);
color_ctrl->i = sldr_ctrl->getValueF32();
// only for sliders where we pass a name
if(color_ctrl->hasSliderName)
{
// set it to the top
F32 maxVal = std::max(std::max(color_ctrl->r, color_ctrl->g), color_ctrl->b);
F32 maxVal = llmax(llmax(color_ctrl->r, color_ctrl->g), color_ctrl->b);
F32 scale = 1.f;
if(color_ctrl->isSunOrAmbientColor)
scale = WL_SUN_AMBIENT_SLIDER_SCALE;
else if(color_ctrl->isBlueHorizonOrDensity)
scale = WL_BLUE_HORIZON_DENSITY_SCALE;
F32 iVal = color_ctrl->i * scale;
// handle if at 0
@@ -658,7 +636,6 @@ void LLFloaterWindLight::onColorControlIMoved(LLUICtrl* ctrl, void* userData)
color_ctrl->r = iVal;
color_ctrl->g = iVal;
color_ctrl->b = iVal;
}
else
{
@@ -671,12 +648,13 @@ void LLFloaterWindLight::onColorControlIMoved(LLUICtrl* ctrl, void* userData)
// set the sliders to the new vals
std::string child_name(color_ctrl->mSliderName);
const size_t end = child_name.length();
child_name.push_back('R');
sWindLight->childSetValue(child_name, color_ctrl->r/scale);
child_name.replace(child_name.length()-1,1,1,'G');
sWindLight->childSetValue(child_name, color_ctrl->g/scale);
child_name.replace(child_name.length()-1,1,1,'B');
sWindLight->childSetValue(child_name, color_ctrl->b/scale);
childSetValue(child_name, color_ctrl->r/scale);
child_name.replace(end,1,1,'G');
childSetValue(child_name, color_ctrl->g/scale);
child_name.replace(end,1,1,'B');
childSetValue(child_name, color_ctrl->b/scale);
}
// now update the current parameters and send them to shaders
@@ -727,34 +705,23 @@ void LLFloaterWindLight::onFloatControlMoved(LLUICtrl* ctrl, void* userdata)
LLWLParamManager::getInstance()->propagateParameters();
}
void LLFloaterWindLight::onBoolToggle(LLUICtrl* ctrl, void* userData)
{
LLWLParamManager::getInstance()->mAnimator.deactivate();
LLCheckBoxCtrl* cbCtrl = static_cast<LLCheckBoxCtrl*>(ctrl);
bool value = cbCtrl->get();
(*(static_cast<BOOL *>(userData))) = value;
}
// Lighting callbacks
// time of day
void LLFloaterWindLight::onSunMoved(LLUICtrl* ctrl, void* userData)
void LLFloaterWindLight::onSunMoved(LLUICtrl* ctrl, void* userdata)
{
LLWLParamManager::getInstance()->mAnimator.deactivate();
LLSliderCtrl* sunSldr = sWindLight->getChild<LLSliderCtrl>("WLSunAngle");
LLSliderCtrl* eastSldr = sWindLight->getChild<LLSliderCtrl>("WLEastAngle");
WLColorControl * color_ctrl = static_cast<WLColorControl *>(userData);
LLSliderCtrl* sun_sldr = getChild<LLSliderCtrl>("WLSunAngle");
LLSliderCtrl* east_sldr = getChild<LLSliderCtrl>("WLEastAngle");
WLColorControl* color_ctrl = static_cast<WLColorControl *>(userdata);
// get the two angles
LLWLParamManager * param_mgr = LLWLParamManager::getInstance();
param_mgr->mCurParams.setSunAngle(F_TWO_PI * sunSldr->getValueF32());
param_mgr->mCurParams.setEastAngle(F_TWO_PI * eastSldr->getValueF32());
param_mgr->mCurParams.setSunAngle(F_TWO_PI * sun_sldr->getValueF32());
param_mgr->mCurParams.setEastAngle(F_TWO_PI * east_sldr->getValueF32());
// set the sun vector
color_ctrl->r = -sin(param_mgr->mCurParams.getEastAngle()) *
@@ -768,35 +735,59 @@ void LLFloaterWindLight::onSunMoved(LLUICtrl* ctrl, void* userData)
param_mgr->propagateParameters();
}
void LLFloaterWindLight::onFloatTweakMoved(LLUICtrl* ctrl, void* userData)
void LLFloaterWindLight::onStarAlphaMoved(LLUICtrl* ctrl)
{
LLWLParamManager::getInstance()->mAnimator.deactivate();
LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
F32 * tweak = static_cast<F32 *>(userData);
LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
(*tweak) = sldrCtrl->getValueF32();
LLWLParamManager::getInstance()->propagateParameters();
LLWLParamManager::getInstance()->mCurParams.setStarBrightness(sldr_ctrl->getValueF32());
}
void LLFloaterWindLight::onStarAlphaMoved(LLUICtrl* ctrl, void* userData)
// Clouds
void LLFloaterWindLight::onCloudScrollXMoved(const LLSD& value)
{
LLWLParamManager::getInstance()->mAnimator.deactivate();
LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
LLWLParamManager::getInstance()->mCurParams.setStarBrightness(sldrCtrl->getValueF32());
// *HACK all cloud scrolling is off by an additive of 10.
LLWLParamManager::getInstance()->mCurParams.setCloudScrollX(value.asFloat() + 10.0f);
}
void LLFloaterWindLight::onNewPreset(void* userData)
void LLFloaterWindLight::onCloudScrollYMoved(const LLSD& value)
{
LLNotifications::instance().add("NewSkyPreset", LLSD(), LLSD(), newPromptCallback);
LLWLParamManager::getInstance()->mAnimator.deactivate();
// *HACK all cloud scrolling is off by an additive of 10.
LLWLParamManager::getInstance()->mCurParams.setCloudScrollY(value.asFloat() + 10.0f);
}
void LLFloaterWindLight::onSavePreset(LLUICtrl* ctrl, void* userData)
void LLFloaterWindLight::onCloudScrollXToggled(const LLSD& value)
{
LLWLParamManager::getInstance()->mAnimator.deactivate();
bool lock = value.asBoolean();
LLWLParamManager::getInstance()->mCurParams.setEnableCloudScrollX(!lock);
getChild<LLUICtrl>("WLCloudScrollX")->setEnabled(!lock);
}
void LLFloaterWindLight::onCloudScrollYToggled(const LLSD& value)
{
LLWLParamManager::getInstance()->mAnimator.deactivate();
bool lock = value.asBoolean();
LLWLParamManager::getInstance()->mCurParams.setEnableCloudScrollY(!lock);
getChild<LLUICtrl>("WLCloudScrollY")->setEnabled(!lock);
}
void LLFloaterWindLight::onNewPreset()
{
LLNotificationsUtil::add("NewSkyPreset", LLSD(), LLSD(), boost::bind(&LLFloaterWindLight::newPromptCallback, this, _1, _2));
}
void LLFloaterWindLight::onSavePreset(LLUICtrl* ctrl)
{
// don't save the empty name
if(sWindLight->mSkyPresetCombo->getSelectedItemLabel() == "")
if(mSkyPresetCombo->getSelectedItemLabel().empty())
{
return;
}
@@ -808,24 +799,22 @@ void LLFloaterWindLight::onSavePreset(LLUICtrl* ctrl, void* userData)
else
{
// check to see if it's a default and shouldn't be overwritten
std::set<std::string>::iterator sIt = sDefaultPresets.find(
sWindLight->mSkyPresetCombo->getSelectedItemLabel());
std::set<std::string>::iterator sIt = sDefaultPresets.find(mSkyPresetCombo->getSelectedItemLabel());
if(sIt != sDefaultPresets.end() && !gSavedSettings.getBOOL("SkyEditPresets"))
{
LLNotifications::instance().add("WLNoEditDefault");
LLNotificationsUtil::add("WLNoEditDefault");
return;
}
LLWLParamManager::getInstance()->mCurParams.mName =
sWindLight->mSkyPresetCombo->getSelectedItemLabel();
LLWLParamManager::getInstance()->mCurParams.mName = mSkyPresetCombo->getSelectedItemLabel();
LLNotifications::instance().add("WLSavePresetAlert", LLSD(), LLSD(), saveAlertCallback);
LLNotificationsUtil::add("WLSavePresetAlert", LLSD(), LLSD(), boost::bind(&LLFloaterWindLight::saveAlertCallback, this, _1, _2));
}
}
bool LLFloaterWindLight::saveNotecardCallback(const LLSD& notification, const LLSD& response)
{
S32 option = LLNotification::getSelectedOption(notification, response);
S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
// if they choose save, do it. Otherwise, don't do anything
if(option == 0)
{
@@ -838,9 +827,9 @@ bool LLFloaterWindLight::saveNotecardCallback(const LLSD& notification, const LL
bool LLFloaterWindLight::saveAlertCallback(const LLSD& notification, const LLSD& response)
{
S32 option = LLNotification::getSelectedOption(notification, response);
S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
// if they choose save, do it. Otherwise, don't do anything
if(option == 0)
if(option == 0)
{
LLWLParamManager * param_mgr = LLWLParamManager::getInstance();
@@ -853,30 +842,29 @@ bool LLFloaterWindLight::saveAlertCallback(const LLSD& notification, const LLSD&
return false;
}
void LLFloaterWindLight::onDeletePreset(void* userData)
void LLFloaterWindLight::onDeletePreset()
{
if(sWindLight->mSkyPresetCombo->getSelectedValue().asString() == "")
if(mSkyPresetCombo->getSelectedValue().asString().empty())
{
return;
}
LLSD args;
args["SKY"] = sWindLight->mSkyPresetCombo->getSelectedValue().asString();
LLNotifications::instance().add("WLDeletePresetAlert", args, LLSD(),
boost::bind(&LLFloaterWindLight::deleteAlertCallback, sWindLight, _1, _2));
args["SKY"] = mSkyPresetCombo->getSelectedValue().asString();
LLNotificationsUtil::add("WLDeletePresetAlert", args, LLSD(), boost::bind(&LLFloaterWindLight::deleteAlertCallback, this, _1, _2));
}
bool LLFloaterWindLight::deleteAlertCallback(const LLSD& notification, const LLSD& response)
{
S32 option = LLNotification::getSelectedOption(notification, response);
S32 option = LLNotificationsUtil::getSelectedOption(notification, response);
// if they choose delete, do it. Otherwise, don't do anything
if(option == 0)
if(option == 0)
{
LLFloaterDayCycle* day_cycle = NULL;
LLComboBox* key_combo = NULL;
if(LLFloaterDayCycle::isOpen())
if(LLFloaterDayCycle::isOpen())
{
day_cycle = LLFloaterDayCycle::instance();
key_combo = day_cycle->getChild<LLComboBox>("WLKeyPresets");
@@ -888,7 +876,7 @@ bool LLFloaterWindLight::deleteAlertCallback(const LLSD& notification, const LLS
std::set<std::string>::iterator sIt = sDefaultPresets.find(name);
if(sIt != sDefaultPresets.end())
{
LLNotifications::instance().add("WLNoEditDefault");
LLNotificationsUtil::add("WLNoEditDefault");
return false;
}
@@ -907,12 +895,12 @@ bool LLFloaterWindLight::deleteAlertCallback(const LLSD& notification, const LLS
}
// pick the previously selected index after delete
if(new_index > 0)
if(new_index > 0)
{
new_index--;
--new_index;
}
if(mSkyPresetCombo->getItemCount() > 0)
if(mSkyPresetCombo->getItemCount() > 0)
{
mSkyPresetCombo->setCurrentByIndex(new_index);
@@ -929,11 +917,11 @@ bool LLFloaterWindLight::deleteAlertCallback(const LLSD& notification, const LLS
}
void LLFloaterWindLight::onChangePresetName(LLUICtrl* ctrl, void * userData)
void LLFloaterWindLight::onChangePresetName(LLUICtrl* ctrl)
{
LLComboBox * combo_box = static_cast<LLComboBox*>(ctrl);
LLComboBox* combo_box = static_cast<LLComboBox*>(ctrl);
if(combo_box->getSimple() == "")
if(combo_box->getSimple().empty())
{
return;
}
@@ -951,97 +939,30 @@ void LLFloaterWindLight::onChangePresetName(LLUICtrl* ctrl, void * userData)
}
//LL_INFOS("WindLight") << "Current inventory ID: " << LLWLParamManager::getInstance()->mCurParams.mInventoryID << LL_ENDL;
sWindLight->syncMenu();
}
void LLFloaterWindLight::onOpenDayCycle(void* userData)
{
LLFloaterDayCycle::show();
}
// Clouds
void LLFloaterWindLight::onCloudScrollXMoved(LLUICtrl* ctrl, void* userData)
{
LLWLParamManager::getInstance()->mAnimator.deactivate();
LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
// *HACK all cloud scrolling is off by an additive of 10.
LLWLParamManager::getInstance()->mCurParams.setCloudScrollX(sldr_ctrl->getValueF32() + 10.0f);
}
void LLFloaterWindLight::onCloudScrollYMoved(LLUICtrl* ctrl, void* userData)
{
LLWLParamManager::getInstance()->mAnimator.deactivate();
LLSliderCtrl* sldr_ctrl = static_cast<LLSliderCtrl*>(ctrl);
// *HACK all cloud scrolling is off by an additive of 10.
LLWLParamManager::getInstance()->mCurParams.setCloudScrollY(sldr_ctrl->getValueF32() + 10.0f);
}
void LLFloaterWindLight::onCloudScrollXToggled(LLUICtrl* ctrl, void* userData)
{
LLWLParamManager::getInstance()->mAnimator.deactivate();
LLCheckBoxCtrl* cb_ctrl = static_cast<LLCheckBoxCtrl*>(ctrl);
bool lock = cb_ctrl->get();
LLWLParamManager::getInstance()->mCurParams.setEnableCloudScrollX(!lock);
LLSliderCtrl* sldr = sWindLight->getChild<LLSliderCtrl>("WLCloudScrollX");
if (cb_ctrl->get())
{
sldr->setEnabled(false);
}
else
{
sldr->setEnabled(true);
}
}
void LLFloaterWindLight::onCloudScrollYToggled(LLUICtrl* ctrl, void* userData)
{
LLWLParamManager::getInstance()->mAnimator.deactivate();
LLCheckBoxCtrl* cb_ctrl = static_cast<LLCheckBoxCtrl*>(ctrl);
bool lock = cb_ctrl->get();
LLWLParamManager::getInstance()->mCurParams.setEnableCloudScrollY(!lock);
LLSliderCtrl* sldr = sWindLight->getChild<LLSliderCtrl>("WLCloudScrollY");
if (cb_ctrl->get())
{
sldr->setEnabled(false);
}
else
{
sldr->setEnabled(true);
}
syncMenu();
}
void LLFloaterWindLight::onClickNext(void* user_data)
void LLFloaterWindLight::onClickNext()
{
S32 index = sWindLight->mSkyPresetCombo->getCurrentIndex();
index++;
if (index == sWindLight->mSkyPresetCombo->getItemCount())
S32 index = mSkyPresetCombo->getCurrentIndex();
++index;
if (index == mSkyPresetCombo->getItemCount())
index = 0;
sWindLight->mSkyPresetCombo->setCurrentByIndex(index);
mSkyPresetCombo->setCurrentByIndex(index);
LLFloaterWindLight::onChangePresetName(sWindLight->mSkyPresetCombo, sWindLight);
onChangePresetName(mSkyPresetCombo);
}
void LLFloaterWindLight::onClickPrev(void* user_data)
void LLFloaterWindLight::onClickPrev()
{
S32 index = sWindLight->mSkyPresetCombo->getCurrentIndex();
S32 index = mSkyPresetCombo->getCurrentIndex();
if (index == 0)
index = sWindLight->mSkyPresetCombo->getItemCount();
index--;
sWindLight->mSkyPresetCombo->setCurrentByIndex(index);
index = mSkyPresetCombo->getItemCount();
--index;
mSkyPresetCombo->setCurrentByIndex(index);
LLFloaterWindLight::onChangePresetName(sWindLight->mSkyPresetCombo, sWindLight);
onChangePresetName(mSkyPresetCombo);
}
//static

95
indra/newview/llfloaterwindlight.h
View File

@@ -39,9 +39,6 @@
#include "llfloater.h"
#include <vector>
#include "llwlparamset.h"
struct WLColorControl;
struct WLFloatControl;
@@ -55,84 +52,76 @@ public:
LLFloaterWindLight();
virtual ~LLFloaterWindLight();
/// initialize all
// initialize all
void initCallbacks(void);
/// one and one instance only
// one and one instance only
static LLFloaterWindLight* instance();
// help button stuff
static void onClickHelp(void* data);
void initHelpBtn(const std::string& name, const std::string& xml_alert);
static bool newPromptCallback(const LLSD& notification, const LLSD& response);
bool newPromptCallback(const LLSD& notification, const LLSD& response);
void setColorSwatch(const std::string& name, const WLColorControl& from_ctrl, F32 k);
/// general purpose callbacks for dealing with color controllers
static void onColorControlRMoved(LLUICtrl* ctrl, void* userData);
static void onColorControlGMoved(LLUICtrl* ctrl, void* userData);
static void onColorControlBMoved(LLUICtrl* ctrl, void* userData);
static void onColorControlIMoved(LLUICtrl* ctrl, void* userData);
static void onFloatControlMoved(LLUICtrl* ctrl, void* userData);
static void onBoolToggle(LLUICtrl* ctrl, void* userData);
// general purpose callbacks for dealing with color controllers
void onColorControlRMoved(LLUICtrl* ctrl, void* userdata);
void onColorControlGMoved(LLUICtrl* ctrl, void* userdata);
void onColorControlBMoved(LLUICtrl* ctrl, void* userdata);
void onColorControlIMoved(LLUICtrl* ctrl, void* userdata);
void onFloatControlMoved(LLUICtrl* ctrl, void* userdata);
/// lighting callbacks for glow
static void onGlowRMoved(LLUICtrl* ctrl, void* userData);
//static void onGlowGMoved(LLUICtrl* ctrl, void* userData);
static void onGlowBMoved(LLUICtrl* ctrl, void* userData);
// lighting callbacks for glow
void onGlowRMoved(LLUICtrl* ctrl, void* userdata);
void onGlowBMoved(LLUICtrl* ctrl, void* userdata);
/// lighting callbacks for sun
static void onSunMoved(LLUICtrl* ctrl, void* userData);
// lighting callbacks for sun
void onSunMoved(LLUICtrl* ctrl, void* userdata);
/// handle if float is changed
static void onFloatTweakMoved(LLUICtrl* ctrl, void* userData);
// for handling when the star slider is moved to adjust the alpha
void onStarAlphaMoved(LLUICtrl* ctrl);
/// for handling when the star slider is moved to adjust the alpha
static void onStarAlphaMoved(LLUICtrl* ctrl, void* userData);
// when user hits the load preset button
void onNewPreset();
/// when user hits the load preset button
static void onNewPreset(void* userData);
/// when user hits the save to file button
static void onSavePreset(LLUICtrl* ctrl, void* userData);
// when user hits the save to file button
void onSavePreset(LLUICtrl* ctrl);
/// prompts a user when overwriting a preset notecard
static bool saveNotecardCallback(const LLSD& notification, const LLSD& response);
// prompts a user when overwriting a preset notecard
bool saveNotecardCallback(const LLSD& notification, const LLSD& response);
/// prompts a user when overwriting a preset
static bool saveAlertCallback(const LLSD& notification, const LLSD& response);
// prompts a user when overwriting a preset
bool saveAlertCallback(const LLSD& notification, const LLSD& response);
/// when user hits the save preset button
static void onDeletePreset(void* userData);
// when user hits the save preset button
void onDeletePreset();
/// prompts a user when overwriting a preset
// prompts a user when overwriting a preset
bool deleteAlertCallback(const LLSD& notification, const LLSD& response);
/// what to do when you change the preset name
static void onChangePresetName(LLUICtrl* ctrl, void* userData);
// what to do when you change the preset name
void onChangePresetName(LLUICtrl* ctrl);
/// when user hits the save preset button
static void onOpenDayCycle(void* userData);
/// handle cloud scrolling
static void onCloudScrollXMoved(LLUICtrl* ctrl, void* userData);
static void onCloudScrollYMoved(LLUICtrl* ctrl, void* userData);
static void onCloudScrollXToggled(LLUICtrl* ctrl, void* userData);
static void onCloudScrollYToggled(LLUICtrl* ctrl, void* userData);
// handle cloud scrolling
void onCloudScrollXMoved(const LLSD& value);
void onCloudScrollYMoved(const LLSD& value);
void onCloudScrollXToggled(const LLSD& value);
void onCloudScrollYToggled(const LLSD& value);
//// menu management
/// show off our menu
// show off our menu
static void show();
/// return if the menu exists or not
// return if the menu exists or not
static bool isOpen();
/// stuff to do on exit
// stuff to do on exit
virtual void onClose(bool app_quitting);
/// sync up sliders with parameters
// sync up sliders with parameters
void syncMenu();
@@ -144,11 +133,11 @@ private:
static std::set<std::string> sDefaultPresets;
static void onClickNext(void* user_data);
static void onClickPrev(void* user_data);
void onClickNext();
void onClickPrev();
void populateSkyPresetsList();
LLComboBox* mSkyPresetCombo;
};

2
indra/newview/skins/default/xui/en-us/floater_windlight_options.xml
View File

@@ -579,7 +579,7 @@
initial_val="0.5" label="" left="494" max_val="10" min_val="-10"
mouse_opaque="true" name="WLCloudScrollY" show_text="true" value="0.0"
width="200" />
<check_box bottom="-120" control_name="DrawClassicClouds" follows="left"
<check_box bottom="-120" control_name="SkyUseClassicClouds" follows="left"
font="SansSerifSmall" height="16" initial_value="false"
label="Draw Classic Clouds" left="480" mouse_opaque="true"
name="DrawClassicClouds" width="200" />