void LLFloaterWater::onFloatControlMoved(LLUICtrl* ctrl, WaterFloatControl* floatControl)
{
LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
floatControl->mX = sldrCtrl->getValueF32() / floatControl->mMult;
floatControl->update(LLWaterParamManager::instance()->mCurParams);
LLWaterParamManager::instance()->propagateParameters();
}
void LLFloaterWindLight::onCloudScrollYMoved(LLUICtrl* ctrl, void* userData)
{
deactivateAnimator();
LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
// *HACK all cloud scrolling is off by an additive of 10.
LLWLParamManager::instance()->mCurParams.setCloudScrollY(sldrCtrl->getValueF32() + 10.0f);
}
void LLFloaterWindLight::onFloatTweakMoved(LLUICtrl* ctrl, void* userData)
{
deactivateAnimator();
LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
F32 * tweak = static_cast<F32 *>(userData);
(*tweak) = sldrCtrl->getValueF32();
LLWLParamManager::instance()->propagateParameters();
}
void wlfPanel_AdvSettings::onChangeQuality(LLUICtrl *ctrl, void *data)
{
LLSliderCtrl* sldr = static_cast<LLSliderCtrl*>(ctrl);
if(sldr == NULL)
return;
U32 set = (U32)sldr->getValueF32();
LLFeatureManager::getInstance()->setGraphicsLevel(set, true);
}
void LLFloaterWater::onColorControlAMoved(LLUICtrl* ctrl, WaterColorControl* colorControl)
{
LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
colorControl->mA = sldrCtrl->getValueF32();
colorControl->update(LLWaterParamManager::instance()->mCurParams);
LLWaterParamManager::instance()->propagateParameters();
}
void LLFloaterWindLight::onFloatControlMoved(LLUICtrl* ctrl, WLFloatControl* floatControl)
{
deactivateAnimator();
LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
floatControl->x = sldrCtrl->getValueF32() / floatControl->mult;
floatControl->update(LLWLParamManager::instance()->mCurParams);
LLWLParamManager::instance()->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::instance()->mCurParams);
LLWaterParamManager::instance()->propagateParameters();
}
void LLFloaterWater::onExpFloatControlMoved(LLUICtrl* ctrl, WaterExpFloatControl* expFloatControl)
{
LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
F32 val = sldrCtrl->getValueF32();
expFloatControl->mExp = val;
LLWaterParamManager::instance()->setDensitySliderValue(val);
expFloatControl->update(LLWaterParamManager::instance()->mCurParams);
LLWaterParamManager::instance()->propagateParameters();
}
void LLFloaterEnvSettings::onChangeCloudCoverage(LLUICtrl* ctrl)
{
LLSliderCtrl* sldr = static_cast<LLSliderCtrl*>(ctrl);
// deactivate animator
//LLWLParamManager::instance()->mAnimator.mIsRunning = false;
//LLWLParamManager::instance()->mAnimator.mUseLindenTime = false;
F32 val = sldr->getValueF32();
LLWLParamManager::instance()->mCurParams.set("cloud_shadow", val);
}
void LLFloaterEnvSettings::onChangeCloudCoverage(LLUICtrl* ctrl, void* userData)
{
LLSliderCtrl* sldr;
sldr = sEnvSettings->getChild<LLSliderCtrl>("EnvCloudSlider");
// deactivate animator
LLWLParamManager::instance()->mAnimator.deactivate();
F32 val = sldr->getValueF32();
LLWLParamManager::instance()->mCurParams.set("cloud_shadow", val);
}
void LLPanelDisplay::updateSliderText(LLUICtrl* ctrl, void* user_data)
{
// get our UI widgets
LLTextBox* text_box = (LLTextBox*)user_data;
LLSliderCtrl* slider = (LLSliderCtrl*) ctrl;
if(text_box == NULL || slider == NULL)
{
return;
}
//Hack to display 'Off' for avatar physics slider.
if(slider->getName() == "AvatarPhysicsDetail" && !slider->getValueF32())
{
text_box->setText(std::string("Off"));
return;
}
// get range and points when text should change
F32 range = slider->getMaxValue() - slider->getMinValue();
llassert(range > 0);
F32 midPoint = slider->getMinValue() + range / 3.0f;
F32 highPoint = slider->getMinValue() + (2.0f * range / 3.0f);
// choose the right text
if(slider->getValueF32() < midPoint)
{
text_box->setText(std::string("Low"));
}
else if (slider->getValueF32() < highPoint)
{
text_box->setText(std::string("Mid"));
}
else if(slider->getValueF32() < slider->getMaxValue())
{
text_box->setText(std::string("High"));
}
else
{
text_box->setText(std::string("Max"));
}
}
/// \NOTE that we want NEGATIVE (-) B
void LLFloaterWindLight::onGlowBMoved(LLUICtrl* ctrl, WLColorControl* colorControl)
{
deactivateAnimator();
LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
/// \NOTE that we want NEGATIVE (-) B and NOT by 20 as 20 is too big
colorControl->b = -sldrCtrl->getValueF32() * 5;
colorControl->update(LLWLParamManager::instance()->mCurParams);
LLWLParamManager::instance()->propagateParameters();
}
/// GLOW SPECIFIC CODE
void LLFloaterWindLight::onGlowRMoved(LLUICtrl* ctrl, WLColorControl* colorControl)
{
deactivateAnimator();
LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
// scaled by 20
colorControl->r = (2 - sldrCtrl->getValueF32()) * 20;
colorControl->update(LLWLParamManager::instance()->mCurParams);
LLWLParamManager::instance()->propagateParameters();
}
void lggBeamColorMapFloater::fixOrder()
{
myData.rotateSpeed = mColorSlider->getValueF32();
myData.rotateSpeed /= 100.0f;
if(myData.endHue < myData.startHue)
{
F32 temp = myData.startHue;
myData.startHue = myData.endHue;
myData.endHue = temp;
}
}
void LLFloaterEnvSettings::onChangeWaterFogDensity(LLUICtrl* ctrl, WaterExpFloatControl* expFloatControl)
{
LLSliderCtrl* sldr;
sldr = getChild<LLSliderCtrl>("EnvWaterFogSlider");
F32 val = sldr->getValueF32();
expFloatControl->mExp = val;
LLWaterParamManager::instance()->setDensitySliderValue(val);
expFloatControl->update(LLWaterParamManager::instance()->mCurParams);
LLWaterParamManager::instance()->propagateParameters();
}
// time of day
void LLFloaterWindLight::onSunMoved(LLUICtrl* ctrl, WLColorControl* colorControl)
{
deactivateAnimator();
LLSliderCtrl* sunSldr = getChild<LLSliderCtrl>("WLSunAngle");
LLSliderCtrl* eastSldr = getChild<LLSliderCtrl>("WLEastAngle");
// get the two angles
LLWLParamManager * param_mgr = LLWLParamManager::instance();
param_mgr->mCurParams.setSunAngle(F_TWO_PI * sunSldr->getValueF32());
param_mgr->mCurParams.setEastAngle(F_TWO_PI * eastSldr->getValueF32());
// set the sun vector
colorControl->r = -sin(param_mgr->mCurParams.getEastAngle()) *
cos(param_mgr->mCurParams.getSunAngle());
colorControl->g = sin(param_mgr->mCurParams.getSunAngle());
colorControl->b = cos(param_mgr->mCurParams.getEastAngle()) *
cos(param_mgr->mCurParams.getSunAngle());
colorControl->i = 1.f;
colorControl->update(param_mgr->mCurParams);
param_mgr->propagateParameters();
}
void LLPanelDisplay::updateMeterText(LLUICtrl* ctrl, void* user_data)
{
// get our UI widgets
LLPanelDisplay* panel = (LLPanelDisplay*)user_data;
LLSliderCtrl* slider = (LLSliderCtrl*) ctrl;
LLTextBox* m1 = panel->getChild<LLTextBox>("DrawDistanceMeterText1");
LLTextBox* m2 = panel->getChild<LLTextBox>("DrawDistanceMeterText2");
// toggle the two text boxes based on whether we have 1 or two digits
F32 val = slider->getValueF32();
bool two_digits = val < 100;
m1->setVisible(two_digits);
m2->setVisible(!two_digits);
}
void LLPanelDisplay::onChangeQuality(LLUICtrl *ctrl, void *data)
{
LLSliderCtrl* sldr = static_cast<LLSliderCtrl*>(ctrl);
LLPanelDisplay* cur_panel = static_cast<LLPanelDisplay*>(data);
if(sldr == NULL || cur_panel == NULL)
{
return;
}
U32 set = (U32)sldr->getValueF32();
LLFeatureManager::getInstance()->setGraphicsLevel(set, true);
LLFloaterPreference::refreshEnabledGraphics();
cur_panel->refresh();
}
// static
void LLSliderCtrl::onEditorCommit( LLUICtrl* caller, void *userdata )
{
LLSliderCtrl* self = (LLSliderCtrl*) userdata;
llassert( caller == self->mEditor );
BOOL success = FALSE;
F32 val = self->mValue;
F32 saved_val = self->mValue;
std::string text = self->mEditor->getText();
if( LLLineEditor::postvalidateFloat( text ) )
{
LLLocale locale(LLLocale::USER_LOCALE);
val = (F32) atof( text.c_str() );
if( self->mSlider->getMinValue() <= val && val <= self->mSlider->getMaxValue() )
{
if( self->mValidateCallback )
{
self->setValue( val ); // set the value temporarily so that the callback can retrieve it.
if( self->mValidateCallback( self, self->mCallbackUserData ) )
{
success = TRUE;
}
}
else
{
self->setValue( val );
success = TRUE;
}
}
}
if( success )
{
self->onCommit();
}
else
{
if( self->getValueF32() != saved_val )
{
self->setValue( saved_val );
}
self->reportInvalidData();
}
self->updateText();
}
void LLFloaterEnvSettings::onChangeDayTime(LLUICtrl* ctrl)
{
LLSliderCtrl* sldr = static_cast<LLSliderCtrl*>(ctrl);
// deactivate animator
LLWLParamManager::instance()->mAnimator.mIsRunning = false;
LLWLParamManager::instance()->mAnimator.mUseLindenTime = false;
F32 val = sldr->getValueF32() + 0.25f;
if(val > 1.0)
{
val--;
}
LLWLParamManager::instance()->mAnimator.setDayTime((F64)val);
LLWLParamManager::instance()->mAnimator.update(
LLWLParamManager::instance()->mCurParams);
}
void LLFloaterEnvSettings::onChangeDayTime(LLUICtrl* ctrl, void* userData)
{
LLSliderCtrl* sldr;
sldr = sEnvSettings->getChild<LLSliderCtrl>("EnvTimeSlider");
// deactivate animator
LLWLParamManager::instance()->mAnimator.deactivate();
F32 val = sldr->getValueF32() + 0.25f;
if(val > 1.0)
{
val--;
}
LLWLParamManager::instance()->mAnimator.setDayTime((F64)val);
LLWLParamManager::instance()->mAnimator.update(
LLWLParamManager::instance()->mCurParams);
}
void wlfPanel_AdvSettings::onChangeDayTime(LLUICtrl* ctrl, void* userData)
{
LLSliderCtrl* sldr = static_cast<LLSliderCtrl*>(ctrl);
if (sldr) {
// deactivate animator
LLWLParamManager::instance()->mAnimator.deactivate();
F32 val = sldr->getValueF32() + 0.25f;
if(val > 1.0)
{
val--;
}
LLWLParamManager::instance()->mAnimator.setDayTime((F64)val);
LLWLParamManager::instance()->mAnimator.update(
LLWLParamManager::instance()->mCurParams);
}
}
void LLFloaterEnvSettings::onChangeWaterFogDensity(LLUICtrl* ctrl, void* userData)
{
LLSliderCtrl* sldr;
sldr = sEnvSettings->getChild<LLSliderCtrl>("EnvWaterFogSlider");
if(NULL == userData)
{
return;
}
WaterExpFloatControl * expFloatControl = static_cast<WaterExpFloatControl *>(userData);
F32 val = sldr->getValueF32();
expFloatControl->mExp = val;
LLWaterParamManager::instance()->setDensitySliderValue(val);
expFloatControl->update(LLWaterParamManager::instance()->mCurParams);
LLWaterParamManager::instance()->propagateParameters();
}
void LLFloaterWater::onColorControlBMoved(LLUICtrl* ctrl, WaterColorControl* colorControl)
{
LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
colorControl->mB = sldrCtrl->getValueF32();
// move i if it's the max
if(colorControl->mB >= colorControl->mR
&& colorControl->mB >= colorControl->mG
&& colorControl->mHasSliderName)
{
colorControl->mI = colorControl->mB;
std::string name = colorControl->mSliderName;
name.append("I");
childSetValue(name, colorControl->mB);
}
colorControl->update(LLWaterParamManager::instance()->mCurParams);
LLWaterParamManager::instance()->propagateParameters();
}
// static
void LLSliderCtrl::onEditorCommit( LLUICtrl* ctrl, const LLSD& userdata )
{
LLSliderCtrl* self = dynamic_cast<LLSliderCtrl*>(ctrl->getParent());
if (!self)
return;
BOOL success = FALSE;
F32 val = self->mValue;
F32 saved_val = self->mValue;
std::string text = self->mEditor->getText();
if( LLLineEditor::postvalidateFloat( text ) )
{
LLLocale locale(LLLocale::USER_LOCALE);
val = (F32) atof( text.c_str() );
if( self->mSlider->getMinValue() <= val && val <= self->mSlider->getMaxValue() )
{
self->setValue( val ); // set the value temporarily so that the callback can retrieve it.
if( !self->mValidateSignal || (*(self->mValidateSignal))( self, val ) )
{
success = TRUE;
}
}
}
if( success )
{
self->onCommit();
}
else
{
if( self->getValueF32() != saved_val )
{
self->setValue( saved_val );
}
self->reportInvalidData();
}
self->updateText();
}
static void onFOVAdjust(LLUICtrl* source, void* data)
{
LLSliderCtrl* slider = dynamic_cast<LLSliderCtrl*>(source);
LLViewerCamera::getInstance()->setDefaultFOV(slider->getValueF32());
}
void LLFloaterWindLight::onColorControlIMoved(LLUICtrl* ctrl, void* userData)
{
deactivateAnimator();
LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
WLColorControl * colorControl = static_cast<WLColorControl *>(userData);
colorControl->i = sldrCtrl->getValueF32();
// only for sliders where we pass a name
if(colorControl->hasSliderName) {
// set it to the top
F32 maxVal = std::max(std::max(colorControl->r, colorControl->g), colorControl->b);
F32 iVal;
if(colorControl->isSunOrAmbientColor)
{
iVal = colorControl->i * 3;
}
else if(colorControl->isBlueHorizonOrDensity)
{
iVal = colorControl->i * 2;
}
else
{
iVal = colorControl->i;
}
// get the names of the other sliders
std::string rName = colorControl->mSliderName;
rName.append("R");
std::string gName = colorControl->mSliderName;
gName.append("G");
std::string bName = colorControl->mSliderName;
bName.append("B");
// handle if at 0
if(iVal == 0) {
colorControl->r = 0;
colorControl->g = 0;
colorControl->b = 0;
// if all at the start
// set them all to the intensity
} else if (maxVal == 0) {
colorControl->r = iVal;
colorControl->g = iVal;
colorControl->b = iVal;
} else {
// add delta amounts to each
F32 delta = (iVal - maxVal) / maxVal;
colorControl->r *= (1.0f + delta);
colorControl->g *= (1.0f + delta);
colorControl->b *= (1.0f + delta);
}
// divide sun color vals by three
if(colorControl->isSunOrAmbientColor)
{
sWindLight->childSetValue(rName, colorControl->r/3);
sWindLight->childSetValue(gName, colorControl->g/3);
sWindLight->childSetValue(bName, colorControl->b/3);
}
else if(colorControl->isBlueHorizonOrDensity)
{
sWindLight->childSetValue(rName, colorControl->r/2);
sWindLight->childSetValue(gName, colorControl->g/2);
sWindLight->childSetValue(bName, colorControl->b/2);
}
else
{
// set the sliders to the new vals
sWindLight->childSetValue(rName, colorControl->r);
sWindLight->childSetValue(gName, colorControl->g);
sWindLight->childSetValue(bName, colorControl->b);
}
}
// now update the current parameters and send them to shaders
colorControl->update(LLWLParamManager::instance()->mCurParams);
LLWLParamManager::instance()->propagateParameters();
}
