// time of day
void LLFloaterWindLight::onSunMoved(LLUICtrl* ctrl, void* userData)
{
deactivateAnimator();
LLSliderCtrl* sunSldr = sWindLight->getChild<LLSliderCtrl>("WLSunAngle");
LLSliderCtrl* eastSldr = sWindLight->getChild<LLSliderCtrl>("WLEastAngle");
WLColorControl * colorControl = static_cast<WLColorControl *>(userData);
// 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 LLFloaterWindLight::onColorControlBMoved(LLUICtrl* ctrl, void* userData)
{
deactivateAnimator();
LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
WLColorControl * colorControl = static_cast<WLColorControl *>(userData);
colorControl->b = sldrCtrl->getValueF32();
if(colorControl->isSunOrAmbientColor) {
colorControl->b *= 3;
}
if(colorControl->isBlueHorizonOrDensity) {
colorControl->b *= 2;
}
// move i if it's the max
if(colorControl->b >= colorControl->r && colorControl->b >= colorControl->g
&& colorControl->hasSliderName) {
colorControl->i = colorControl->b;
std::string name = colorControl->mSliderName;
name.append("I");
if(colorControl->isSunOrAmbientColor) {
sWindLight->childSetValue(name, colorControl->b / 3);
} else if(colorControl->isBlueHorizonOrDensity) {
sWindLight->childSetValue(name, colorControl->b / 2);
} else {
sWindLight->childSetValue(name, colorControl->b);
}
}
colorControl->update(LLWLParamManager::instance()->mCurParams);
LLWLParamManager::instance()->propagateParameters();
}
/// \NOTE that we want NEGATIVE (-) B
void LLFloaterWindLight::onGlowBMoved(LLUICtrl* ctrl, void* userData)
{
deactivateAnimator();
LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
WLColorControl * colorControl = static_cast<WLColorControl *>(userData);
/// \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, void* userData)
{
deactivateAnimator();
LLSliderCtrl* sldrCtrl = static_cast<LLSliderCtrl*>(ctrl);
WLColorControl * colorControl = static_cast<WLColorControl *>(userData);
// scaled by 20
colorControl->r = (2 - sldrCtrl->getValueF32()) * 20;
colorControl->update(LLWLParamManager::instance()->mCurParams);
LLWLParamManager::instance()->propagateParameters();
}
// Checked: 2011-08-28 (RLVa-1.4.1a) | Added: RLVa-1.4.1a
bool RlvWindLightControl::setColorComponent(EColorComponent eComponent, F32 nValue)
{
if (isColorType())
{
nValue *= (m_pColourCtrl->isSunOrAmbientColor) ? 3.0f : ((m_pColourCtrl->isBlueHorizonOrDensity) ? 2.0f : 1.0f);
if (COMPONENT_I == eComponent) // (See: LLFloaterWindLight::onColorControlIMoved)
{
if (m_pColourCtrl->hasSliderName)
{
F32 curMax = llmax(m_pColourCtrl->r, m_pColourCtrl->g, m_pColourCtrl->b);
if ( (0.0f == nValue) || (0.0f == curMax) )
{
m_pColourCtrl->r = m_pColourCtrl->g = m_pColourCtrl->b = m_pColourCtrl->i = nValue;
}
else
{
F32 nDelta = (nValue - curMax) / curMax;
m_pColourCtrl->r *= (1.0f + nDelta);
m_pColourCtrl->g *= (1.0f + nDelta);
m_pColourCtrl->b *= (1.0f + nDelta);
m_pColourCtrl->i = nValue;
}
}
}
else // (See: LLFloaterWindLight::onColorControlRMoved)
{
F32* pnValue = (COMPONENT_R == eComponent) ? &m_pColourCtrl->r : (COMPONENT_G == eComponent) ? &m_pColourCtrl->g : (COMPONENT_B == eComponent) ? &m_pColourCtrl->b : NULL;
if (pnValue)
*pnValue = nValue;
if (m_pColourCtrl->hasSliderName)
m_pColourCtrl->i = llmax(m_pColourCtrl->r, m_pColourCtrl->g, m_pColourCtrl->b);
}
m_pColourCtrl->update(LLWLParamManager::getInstance()->mCurParams);
LLWLParamManager::getInstance()->propagateParameters();
}
return isColorType();
}
// Checked: 2009-09-16 (RLVa-1.0.3c) | Modified: RLVa-1.0.3c
ERlvCmdRet RlvExtGetSet::onSetEnv(std::string strSetting, const std::string& strValue)
{
// HACK: see RlvExtGetSet::onGetEnv
if (!LLFloaterWindLight::isOpen())
{
LLFloaterWindLight::instance()->close();
LLFloaterWindLight::instance()->syncMenu();
}
LLWLParamManager* pWLParams = LLWLParamManager::instance();
WLFloatControl* pFloat = NULL;
WLColorControl* pColour = NULL;
F32 nValue = 0.0f;
// Sanity check - make sure strValue specifies a number for all settings except "preset"
if ( (RlvSettings::getNoSetEnv()) || ( (!LLStringUtil::convertToF32(strValue, nValue)) && ("preset" != strSetting) ))
return RLV_RET_FAILED_OPTION;
// Not quite correct, but RLV-1.16.0 will halt the default daytime cycle on invalid commands so we need to as well
pWLParams->mAnimator.deactivate();
//pWLParams->mAnimator.mUseLindenTime = false;
// See LLWorldEnvSettings::handleEvent()
if ("daytime" == strSetting)
{
if (0.0f <= nValue)
{
pWLParams->mAnimator.setDayTime(llmin(nValue, 1.0f));
pWLParams->mAnimator.update(pWLParams->mCurParams);
}
else
{
pWLParams->mAnimator.activate(LLWLAnimator::TIME_LINDEN);
}
return RLV_RET_SUCCESS;
}
// See LLFloaterWindLight::onChangePresetName()
else if ("preset" == strSetting)
{
// LLEnvManagerNew manages using presets now -KC
//pWLParams->loadPreset(strValue, true);
LLEnvManagerNew::instance().useSkyPreset(strValue);
return RLV_RET_SUCCESS;
}
// See LLFloaterWindLight::onStarAlphaMoved
else if ("starbrightness" == strSetting)
{
pWLParams->mCurParams.setStarBrightness(nValue);
return RLV_RET_SUCCESS;
}
// See LLFloaterWindLight::onGlowRMoved() / LLFloaterWindLight::onGlowBMoved()
else if ( ("sunglowfocus" == strSetting) || ("sunglowsize" == strSetting) )
{
WLColorControl *pColour = &pWLParams->mGlow;
if ("sunglowfocus" == strSetting)
pColour->b = -nValue * 5;
else
pColour->r = (2 - nValue) * 20;
pColour->update(pWLParams->mCurParams);
pWLParams->propagateParameters();
return RLV_RET_SUCCESS;
}
// See LLFloaterWindLight::onSunMoved()
else if ( ("eastangle" == strSetting) || ("sunmoonposition" == strSetting) )
{
if ("eastangle" == strSetting)
pWLParams->mCurParams.setEastAngle(F_TWO_PI * nValue);
else
pWLParams->mCurParams.setSunAngle(F_TWO_PI * nValue);
// TODO-RLVa: it looks like propagateParameters() will actually take care of this for us, making this redundant?
WLColorControl* pColour = &pWLParams->mLightnorm;
pColour->r = -sin(pWLParams->mCurParams.getEastAngle()) * cos(pWLParams->mCurParams.getSunAngle());
pColour->g = sin(pWLParams->mCurParams.getSunAngle());
pColour->b = cos(pWLParams->mCurParams.getEastAngle()) * cos(pWLParams->mCurParams.getSunAngle());
pColour->i = 1.f;
pColour->update(pWLParams->mCurParams);
pWLParams->propagateParameters();
return RLV_RET_SUCCESS;
}
// See LLFloaterWindLight::onCloudScrollXMoved() / LLFloaterWindLight::onCloudScrollYMoved()
else if ("cloudscrollx" == strSetting)
{
pWLParams->mCurParams.setCloudScrollX(nValue + 10.0f);
return RLV_RET_SUCCESS;
}
else if ("cloudscrolly" == strSetting)
{
pWLParams->mCurParams.setCloudScrollY(nValue + 10.0f);
return RLV_RET_SUCCESS;
}
// See LLFloaterWindLight::onFloatControlMoved()
else if ("cloudcoverage" == strSetting) pFloat = &pWLParams->mCloudCoverage;
else if ("cloudscale" == strSetting) pFloat = &pWLParams->mCloudScale;
else if ("densitymultiplier" == strSetting) pFloat = &pWLParams->mDensityMult;
else if ("distancemultiplier" == strSetting) pFloat = &pWLParams->mDistanceMult;
else if ("maxaltitude" == strSetting) pFloat = &pWLParams->mMaxAlt;
else if ("scenegamma" == strSetting) pFloat = &pWLParams->mWLGamma;
// See LLFloaterWindLight::onColorControlRMoved()
else if ("hazedensity" == strSetting) pColour = &pWLParams->mHazeDensity;
else if ("hazehorizon" == strSetting) pColour = &pWLParams->mHazeHorizon;
if (pFloat)
{
pFloat->x = nValue / pFloat->mult;
pFloat->update(pWLParams->mCurParams);
pWLParams->propagateParameters();
return RLV_RET_SUCCESS;
}
else if (pColour)
{
pColour->r = nValue;
pColour->update(pWLParams->mCurParams);
pWLParams->propagateParameters();
return RLV_RET_SUCCESS;
}
// RGBI settings
char ch = strSetting[strSetting.length() - 1];
if ('x' == ch) ch = 'r';
else if ('y' == ch) ch = 'g';
else if ('d' == ch) ch = 'b';
if ( ('r' == ch) || ('g' == ch) || ('b' == ch) || ('i' == ch) )
{
strSetting.erase(strSetting.length() - 1, 1);
if ("ambient" == strSetting) pColour = &pWLParams->mAmbient;
else if ("bluedensity" == strSetting) pColour = &pWLParams->mBlueDensity;
else if ("bluehorizon" == strSetting) pColour = &pWLParams->mBlueHorizon;
else if ("sunmooncolor" == strSetting) pColour = &pWLParams->mSunlight;
else if ("cloudcolor" == strSetting) pColour = &pWLParams->mCloudColor;
else if ("cloud" == strSetting) pColour = &pWLParams->mCloudMain;
else if ("clouddetail" == strSetting) pColour = &pWLParams->mCloudDetail;
if (pColour)
{
if (pColour->isBlueHorizonOrDensity) nValue *= 2.0f;
else if (pColour->isSunOrAmbientColor) nValue *= 3.0f;
if ('i' == ch) // (See: LLFloaterWindLight::onColorControlIMoved)
{
if (!pColour->hasSliderName)
return RLV_RET_FAILED_UNKNOWN;
F32 curMax = llmax(pColour->r, pColour->g, pColour->b);
if ( (0.0f == nValue) || (0.0f == curMax) )
pColour->r = pColour->g = pColour->b = pColour->i = nValue;
else
{
F32 nDelta = (nValue - curMax) / curMax;
pColour->r *= (1.0f + nDelta);
pColour->g *= (1.0f + nDelta);
pColour->b *= (1.0f + nDelta);
pColour->i = nValue;
}
}
else // (See: LLFloaterWindLight::onColorControlRMoved)
{
F32* pnValue = ('r' == ch) ? &pColour->r : ('g' == ch) ? &pColour->g : ('b' == ch) ? &pColour->b : NULL;
if (pnValue)
*pnValue = nValue;
pColour->i = llmax(pColour->r, pColour->g, pColour->b);
}
pColour->update(pWLParams->mCurParams);
pWLParams->propagateParameters();
return RLV_RET_SUCCESS;
}
}
return RLV_RET_FAILED_UNKNOWN;
}
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();
}
