livie
/
phoenix-firestorm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge with RLVa (pre-EEP fix-up) 

-> Gets a couple of large LL merges out of the way
meow-7.2.2
Kitty Barnett 2020-06-11 12:45:52 +02:00
parent 9d755566f6 17687f7701
commit f747f34da4
9 changed files with 397 additions and 410 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
indra/llmessage/llavatarnamecache.cpp
View File

@ -119,10 +119,6 @@ LLAvatarNameCache::LLAvatarNameCache()
mUsePeopleAPI = true;
// [RLVa:KB] - Checked: 2010-12-08 (RLVa-1.4.0a) | Added: RLVa-1.2.2c
mForceDisplayNames = false;
// [/RLVa:KB]
sHttpRequest = LLCore::HttpRequest::ptr_t(new LLCore::HttpRequest());
sHttpHeaders = LLCore::HttpHeaders::ptr_t(new LLCore::HttpHeaders());
sHttpOptions = LLCore::HttpOptions::ptr_t(new LLCore::HttpOptions());
@ -742,12 +738,12 @@ LLAvatarNameCache::callback_connection_t LLAvatarNameCache::getNameCallback(cons
// [RLVa:KB] - Checked: 2010-12-08 (RLVa-1.4.0a) | Added: RLVa-1.2.2c
bool LLAvatarNameCache::getForceDisplayNames()
{
return mForceDisplayNames;
return mRlvForceDisplayNames;
}
void LLAvatarNameCache::setForceDisplayNames(bool force)
{
mForceDisplayNames = force;
mRlvForceDisplayNames = force;
if ( (!LLAvatarName::useDisplayNames()) && (force) )
{
LLAvatarName::setUseDisplayNames(true);

9
indra/llmessage/llavatarnamecache.h
View File

@ -163,6 +163,11 @@ private:
// For testing, there's a UsePeopleAPI setting that can be flipped (must restart viewer).
bool mUsePeopleAPI;
// [RLVa:KB] - Checked: 2010-12-08 (RLVa-1.4.0a) | Added: RLVa-1.2.2c
// RLVa override for display names
bool mRlvForceDisplayNames = false;
// [/RLVa:KB]
// Base lookup URL for name service.
// On simulator, loaded from indra.xml
// On viewer, usually a simulator capability (at People API team's request)
@ -191,10 +196,6 @@ private:
// Time when unrefreshed cached names were checked last.
F64 mLastExpireCheck;
// [RLVa:KB] - Checked: 2010-12-08 (RLVa-1.4.0a) | Added: RLVa-1.2.2c
bool mForceDisplayNames;
// [/RLVa:KB]
};
// Parse a cache-control header to get the max-age delta-seconds.

6
indra/newview/llfloaterpreference.cpp
View File

@ -2349,8 +2349,10 @@ void LLFloaterPreferenceGraphicsAdvanced::refreshEnabledState()
LLTextBox* sky_text = getChild<LLTextBox>("SkyMeshDetailText");
// ctrl_wind_light->setEnabled(TRUE);
// [RLVa:KB] - Checked: 2010-03-18 (RLVa-1.2.0a) | Modified: RLVa-0.2.0a
// "Atmospheric Shaders" can't be disabled - but can be enabled - under @setenv=n
ctrl_wind_light->setEnabled(((!gRlvHandler.hasBehaviour(RLV_BHVR_SETENV)) || (!gSavedSettings.getBOOL("WindLightUseAtmosShaders"))) );
// // "Atmospheric Shaders" can't be disabled - but can be enabled - under @setenv=n
// bool fCtrlWindLightEnable = fCtrlShaderEnable && shaders;
// ctrl_wind_light->setEnabled(
// fCtrlWindLightEnable && ((!gRlvHandler.hasBehaviour(RLV_BHVR_SETENV)) || (!gSavedSettings.getBOOL("WindLightUseAtmosShaders"))) );
// [/RLVa:KB]
sky->setEnabled(TRUE);
sky_text->setEnabled(TRUE);

25
indra/newview/llviewermessage.cpp
View File

@ -2325,15 +2325,10 @@ bool LLOfferInfo::inventory_task_offer_callback(const LLSD& notification, const
LLUUID destination;
bool accept = true;
// [RLVa:KB] - Checked: 2010-09-23 (RLVa-1.2.1)
bool fRlvNotifyAccepted = false;
// [/RLVa:KB]
// If user accepted, accept to proper folder, if user discarded, accept to trash.
switch(button)
{
case IOR_ACCEPT:
destination = mFolderID;
// [RLVa:KB] - Checked: 2010-09-23 (RLVa-1.2.1)
// Only treat the offer as 'Give to #RLV' if:
// - the user has enabled the feature
@ -2341,28 +2336,28 @@ bool LLOfferInfo::inventory_task_offer_callback(const LLSD& notification, const
// - the name starts with the prefix - mDesc format: '[OBJECTNAME]' ( http://slurl.com/... )
if ( (rlv_handler_t::isEnabled()) && (IM_TASK_INVENTORY_OFFERED == mIM) && (LLAssetType::AT_CATEGORY == mType) && (mDesc.find(RLV_PUTINV_PREFIX) == 1) )
{
fRlvNotifyAccepted = true;
if (!RlvSettings::getForbidGiveToRLV())
{
const LLUUID& idRlvRoot = RlvInventory::instance().getSharedRootID();
if (idRlvRoot.notNull())
mFolderID = idRlvRoot;
fRlvNotifyAccepted = false; // "accepted_in_rlv" is sent from RlvGiveToRLVTaskOffer *after* we have the folder
// "accepted_in_rlv" is sent from RlvGiveToRLVTaskOffer *after* we have the folder
RlvGiveToRLVTaskOffer* pOfferObserver = new RlvGiveToRLVTaskOffer(mTransactionID);
gInventory.addObserver(pOfferObserver);
}
}
if (fRlvNotifyAccepted)
{
std::string::size_type idxToken = mDesc.find("' ( http://");
if (std::string::npos != idxToken)
RlvBehaviourNotifyHandler::sendNotification("accepted_in_inv inv_offer " + mDesc.substr(1, idxToken - 1));
else
{
std::string::size_type idxToken = mDesc.find("' ( http://");
if (std::string::npos != idxToken)
{
RlvBehaviourNotifyHandler::sendNotification("accepted_in_inv inv_offer " + mDesc.substr(1, idxToken - 1));
}
}
}
// [/RLVa:KB]
destination = mFolderID;
//don't spam user if flooded
if (check_offer_throttle(mFromName, true))
{

4
indra/newview/llviewerobject.h
View File

@ -397,10 +397,10 @@ public:
void sendShapeUpdate();
// U8 getAttachmentState() { return mAttachmentState; }
// [RLVa:KB] - Checked: 2010-02-27 (RLVa-1.2.0a) | Added: RLVa-1.2.0a
U8 getAttachmentState() const { return mAttachmentState; }
U8 getAttachmentState() const { return mAttachmentState; }
// [/RLVa:KB]
// U8 getAttachmentState() { return mAttachmentState; }
F32 getAppAngle() const { return mAppAngle; }
F32 getPixelArea() const { return mPixelArea; }

4
indra/newview/rlvdefines.h
View File

@ -35,8 +35,8 @@ const S32 RLV_VERSION_BUILD_COMPAT = 0;
// Implementation version
const S32 RLVa_VERSION_MAJOR = 2;
const S32 RLVa_VERSION_MINOR = 2;
const S32 RLVa_VERSION_PATCH = 2;
const S32 RLVa_VERSION_MINOR = 3;
const S32 RLVa_VERSION_PATCH = 0;
// Uncomment before a final release
#define RLV_RELEASE

685
indra/newview/rlvextensions.cpp
View File

@ -17,9 +17,9 @@
#include "llviewerprecompiledheaders.h"
#include "llagent.h"
#include "llagentcamera.h"
// #include "lldaycyclemanager.h" // [EEPMERGE]
//#include "lldaycyclemanager.h"
#include "llvoavatarself.h"
//#include "llwlparammanager.h" // [EEPMERGE]
//#include "llwlparammanager.h"
#include "rlvextensions.h"
#include "rlvhandler.h"
@ -27,351 +27,349 @@
// ============================================================================
#if 0// [EEPMERGE]
class RlvWindLightControl
{
public:
enum EType { TYPE_COLOR, TYPE_COLOR_R, TYPE_FLOAT, TYPE_UNKNOWN };
enum EColorComponent { COMPONENT_R, COMPONENT_G, COMPONENT_B, COMPONENT_I, COMPONENT_NONE };
public:
RlvWindLightControl(WLColorControl* pCtrl, bool fColorR) : m_eType((!fColorR) ? TYPE_COLOR: TYPE_COLOR_R), m_pColourCtrl(pCtrl), m_pFloatCtrl(NULL) {}
RlvWindLightControl(WLFloatControl* pCtrl) : m_eType(TYPE_FLOAT), m_pColourCtrl(NULL), m_pFloatCtrl(pCtrl) {}
EType getControlType() const { return m_eType; }
bool isColorType() const { return (TYPE_COLOR == m_eType) || (TYPE_COLOR_R == m_eType); }
bool isFloatType() const { return (TYPE_FLOAT == m_eType); }
// TYPE_COLOR and TYPE_COLOR_R
F32 getColorComponent(EColorComponent eComponent, bool& fError) const;
LLVector4 getColorVector(bool& fError) const;
bool setColorComponent(EColorComponent eComponent, F32 nValue);
// TYPE_FLOAT
F32 getFloat(bool& fError) const;
bool setFloat(F32 nValue);
static EColorComponent getComponentFromCharacter(char ch);
protected:
EType m_eType; // Type of the WindLight control
WLColorControl* m_pColourCtrl;
WLFloatControl* m_pFloatCtrl;
};
//class RlvWindLightControl
//{
//public:
// enum EType { TYPE_COLOR, TYPE_COLOR_R, TYPE_FLOAT, TYPE_UNKNOWN };
// enum EColorComponent { COMPONENT_R, COMPONENT_G, COMPONENT_B, COMPONENT_I, COMPONENT_NONE };
//public:
// RlvWindLightControl(WLColorControl* pCtrl, bool fColorR) : m_eType((!fColorR) ? TYPE_COLOR: TYPE_COLOR_R), m_pColourCtrl(pCtrl), m_pFloatCtrl(NULL) {}
// RlvWindLightControl(WLFloatControl* pCtrl) : m_eType(TYPE_FLOAT), m_pColourCtrl(NULL), m_pFloatCtrl(pCtrl) {}
//
// EType getControlType() const { return m_eType; }
// bool isColorType() const { return (TYPE_COLOR == m_eType) || (TYPE_COLOR_R == m_eType); }
// bool isFloatType() const { return (TYPE_FLOAT == m_eType); }
// // TYPE_COLOR and TYPE_COLOR_R
// F32 getColorComponent(EColorComponent eComponent, bool& fError) const;
// LLVector4 getColorVector(bool& fError) const;
// bool setColorComponent(EColorComponent eComponent, F32 nValue);
// // TYPE_FLOAT
// F32 getFloat(bool& fError) const;
// bool setFloat(F32 nValue);
//
// static EColorComponent getComponentFromCharacter(char ch);
//protected:
// EType m_eType; // Type of the WindLight control
// WLColorControl* m_pColourCtrl;
// WLFloatControl* m_pFloatCtrl;
//};
// Checked: 2011-08-29 (RLVa-1.4.1a) | Added: RLVa-1.4.1a
static F32 get_intensity_from_color(const LLVector4& v)
{
return llmax(v.mV[0], v.mV[1], v.mV[2]);
}
//static F32 get_intensity_from_color(const LLVector4& v)
//{
// return llmax(v.mV[0], v.mV[1], v.mV[2]);
//}
// Checked: 2011-08-29 (RLVa-1.4.1a) | Added: RLVa-1.4.1a
F32 RlvWindLightControl::getColorComponent(EColorComponent eComponent, bool& fError) const
{
switch (eComponent)
{
case COMPONENT_R: return getColorVector(fError).mV[0];
case COMPONENT_G: return getColorVector(fError).mV[1];
case COMPONENT_B: return getColorVector(fError).mV[2];
case COMPONENT_I: return get_intensity_from_color(getColorVector(fError)); // SL-2.8: Always seems to be 1.0 so get it manually
default : RLV_ASSERT(false); fError = true; return 0.0;
}
}
//F32 RlvWindLightControl::getColorComponent(EColorComponent eComponent, bool& fError) const
//{
// switch (eComponent)
// {
// case COMPONENT_R: return getColorVector(fError).mV[0];
// case COMPONENT_G: return getColorVector(fError).mV[1];
// case COMPONENT_B: return getColorVector(fError).mV[2];
// case COMPONENT_I: return get_intensity_from_color(getColorVector(fError)); // SL-2.8: Always seems to be 1.0 so get it manually
// default : RLV_ASSERT(false); fError = true; return 0.0;
// }
//}
// Checked: 2011-08-29 (RLVa-1.4.1a) | Added: RLVa-1.4.1a
RlvWindLightControl::EColorComponent RlvWindLightControl::getComponentFromCharacter(char ch)
{
if (('r' == ch) || ('x' == ch))
return COMPONENT_R;
else if (('g' == ch) || ('y' == ch))
return COMPONENT_G;
else if (('b' == ch) || ('d' == ch))
return COMPONENT_B;
else if ('i' == ch)
return COMPONENT_I;
return COMPONENT_NONE;
}
//RlvWindLightControl::EColorComponent RlvWindLightControl::getComponentFromCharacter(char ch)
//{
// if (('r' == ch) || ('x' == ch))
// return COMPONENT_R;
// else if (('g' == ch) || ('y' == ch))
// return COMPONENT_G;
// else if (('b' == ch) || ('d' == ch))
// return COMPONENT_B;
// else if ('i' == ch)
// return COMPONENT_I;
// return COMPONENT_NONE;
//}
// Checked: 2011-08-29 (RLVa-1.4.1a) | Added: RLVa-1.4.1a
LLVector4 RlvWindLightControl::getColorVector(bool& fError) const
{
if ((fError = !isColorType()))
return LLVector4(0, 0, 0, 0);
F32 nMult = (m_pColourCtrl->isSunOrAmbientColor) ? 3.0f : ((m_pColourCtrl->isBlueHorizonOrDensity) ? 2.0f : 1.0f);
return LLWLParamManager::getInstance()->mCurParams.getVector(m_pColourCtrl->mName, fError) / nMult;
}
//LLVector4 RlvWindLightControl::getColorVector(bool& fError) const
//{
// if ((fError = !isColorType()))
// return LLVector4(0, 0, 0, 0);
// F32 nMult = (m_pColourCtrl->isSunOrAmbientColor) ? 3.0f : ((m_pColourCtrl->isBlueHorizonOrDensity) ? 2.0f : 1.0f);
// return LLWLParamManager::getInstance()->mCurParams.getVector(m_pColourCtrl->mName, fError) / nMult;
//}
// 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();
}
//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: 2011-08-29 (RLVa-1.4.1a) | Added: RLVa-1.4.1a
F32 RlvWindLightControl::getFloat(bool& fError) const
{
return (!(fError = (TYPE_FLOAT != m_eType))) ? LLWLParamManager::getInstance()->mCurParams.getVector(m_pFloatCtrl->mName, fError).mV[0] * m_pFloatCtrl->mult : 0.0;
}
// F32 RlvWindLightControl::getFloat(bool& fError) const
// {
// return (!(fError = (TYPE_FLOAT != m_eType))) ? LLWLParamManager::getInstance()->mCurParams.getVector(m_pFloatCtrl->mName, fError).mV[0] * m_pFloatCtrl->mult : 0.0;
// }
// Checked: 2011-08-28 (RLVa-1.4.1a) | Added: RLVa-1.4.1a
bool RlvWindLightControl::setFloat(F32 nValue)
{
if (TYPE_FLOAT == m_eType)
{
m_pFloatCtrl->x = nValue / m_pFloatCtrl->mult;
m_pFloatCtrl->update(LLWLParamManager::getInstance()->mCurParams);
LLWLParamManager::getInstance()->propagateParameters();
}
return (TYPE_FLOAT == m_eType);
}
//bool RlvWindLightControl::setFloat(F32 nValue)
//{
// if (TYPE_FLOAT == m_eType)
// {
// m_pFloatCtrl->x = nValue / m_pFloatCtrl->mult;
// m_pFloatCtrl->update(LLWLParamManager::getInstance()->mCurParams);
// LLWLParamManager::getInstance()->propagateParameters();
// }
// return (TYPE_FLOAT == m_eType);
//}
// ============================================================================
class RlvWindLight : public LLSingleton<RlvWindLight>
{
LLSINGLETON(RlvWindLight);
public:
std::string getValue(const std::string& strSetting, bool& fError);
bool setValue(const std::string& strRlvName, const std::string& strValue);
protected:
std::map<std::string, RlvWindLightControl> m_ControlLookupMap;
};
//class RlvWindLight : public LLSingleton<RlvWindLight>
//{
// LLSINGLETON(RlvWindLight);
//public:
// std::string getValue(const std::string& strSetting, bool& fError);
// bool setValue(const std::string& strRlvName, const std::string& strValue);
//
//protected:
// std::map<std::string, RlvWindLightControl> m_ControlLookupMap;
//};
// Checked: 2011-08-29 (RLVa-1.4.1a) | Added: RLVa-1.4.1a
RlvWindLight::RlvWindLight()
{
LLWLParamManager* pWLParamMgr = LLWLParamManager::getInstance();
// TYPE_FLOAT
m_ControlLookupMap.insert(std::pair<std::string, RlvWindLightControl>("cloudcoverage", RlvWindLightControl(&pWLParamMgr->mCloudCoverage)));
m_ControlLookupMap.insert(std::pair<std::string, RlvWindLightControl>("cloudscale", RlvWindLightControl(&pWLParamMgr->mCloudScale)));
m_ControlLookupMap.insert(std::pair<std::string, RlvWindLightControl>("densitymultiplier", RlvWindLightControl(&pWLParamMgr->mDensityMult)));
m_ControlLookupMap.insert(std::pair<std::string, RlvWindLightControl>("distancemultiplier", RlvWindLightControl(&pWLParamMgr->mDistanceMult)));
m_ControlLookupMap.insert(std::pair<std::string, RlvWindLightControl>("maxaltitude", RlvWindLightControl(&pWLParamMgr->mMaxAlt)));
m_ControlLookupMap.insert(std::pair<std::string, RlvWindLightControl>("scenegamma", RlvWindLightControl(&pWLParamMgr->mWLGamma)));
m_ControlLookupMap.insert(std::pair<std::string, RlvWindLightControl>("hazedensity", RlvWindLightControl(&pWLParamMgr->mHazeDensity)));
m_ControlLookupMap.insert(std::pair<std::string, RlvWindLightControl>("hazehorizon", RlvWindLightControl(&pWLParamMgr->mHazeHorizon)));
// TYPE_COLOR
m_ControlLookupMap.insert(std::pair<std::string, RlvWindLightControl>("ambient", RlvWindLightControl(&pWLParamMgr->mAmbient, false)));
m_ControlLookupMap.insert(std::pair<std::string, RlvWindLightControl>("bluedensity", RlvWindLightControl(&pWLParamMgr->mBlueDensity, false)));
m_ControlLookupMap.insert(std::pair<std::string, RlvWindLightControl>("bluehorizon", RlvWindLightControl(&pWLParamMgr->mBlueHorizon, false)));
m_ControlLookupMap.insert(std::pair<std::string, RlvWindLightControl>("cloud", RlvWindLightControl(&pWLParamMgr->mCloudMain, false)));
m_ControlLookupMap.insert(std::pair<std::string, RlvWindLightControl>("cloudcolor", RlvWindLightControl(&pWLParamMgr->mCloudColor, false)));
m_ControlLookupMap.insert(std::pair<std::string, RlvWindLightControl>("clouddetail", RlvWindLightControl(&pWLParamMgr->mCloudDetail, false)));
m_ControlLookupMap.insert(std::pair<std::string, RlvWindLightControl>("sunmooncolor", RlvWindLightControl(&pWLParamMgr->mSunlight, false)));
}
//RlvWindLight::RlvWindLight()
//{
// LLWLParamManager* pWLParamMgr = LLWLParamManager::getInstance();
//
// // TYPE_FLOAT
// m_ControlLookupMap.insert(std::pair<std::string, RlvWindLightControl>("cloudcoverage", RlvWindLightControl(&pWLParamMgr->mCloudCoverage)));
// m_ControlLookupMap.insert(std::pair<std::string, RlvWindLightControl>("cloudscale", RlvWindLightControl(&pWLParamMgr->mCloudScale)));
// m_ControlLookupMap.insert(std::pair<std::string, RlvWindLightControl>("densitymultiplier", RlvWindLightControl(&pWLParamMgr->mDensityMult)));
// m_ControlLookupMap.insert(std::pair<std::string, RlvWindLightControl>("distancemultiplier", RlvWindLightControl(&pWLParamMgr->mDistanceMult)));
// m_ControlLookupMap.insert(std::pair<std::string, RlvWindLightControl>("maxaltitude", RlvWindLightControl(&pWLParamMgr->mMaxAlt)));
// m_ControlLookupMap.insert(std::pair<std::string, RlvWindLightControl>("scenegamma", RlvWindLightControl(&pWLParamMgr->mWLGamma)));
// m_ControlLookupMap.insert(std::pair<std::string, RlvWindLightControl>("hazedensity", RlvWindLightControl(&pWLParamMgr->mHazeDensity)));
// m_ControlLookupMap.insert(std::pair<std::string, RlvWindLightControl>("hazehorizon", RlvWindLightControl(&pWLParamMgr->mHazeHorizon)));
// // TYPE_COLOR
// m_ControlLookupMap.insert(std::pair<std::string, RlvWindLightControl>("ambient", RlvWindLightControl(&pWLParamMgr->mAmbient, false)));
// m_ControlLookupMap.insert(std::pair<std::string, RlvWindLightControl>("bluedensity", RlvWindLightControl(&pWLParamMgr->mBlueDensity, false)));
// m_ControlLookupMap.insert(std::pair<std::string, RlvWindLightControl>("bluehorizon", RlvWindLightControl(&pWLParamMgr->mBlueHorizon, false)));
// m_ControlLookupMap.insert(std::pair<std::string, RlvWindLightControl>("cloud", RlvWindLightControl(&pWLParamMgr->mCloudMain, false)));
// m_ControlLookupMap.insert(std::pair<std::string, RlvWindLightControl>("cloudcolor", RlvWindLightControl(&pWLParamMgr->mCloudColor, false)));
// m_ControlLookupMap.insert(std::pair<std::string, RlvWindLightControl>("clouddetail", RlvWindLightControl(&pWLParamMgr->mCloudDetail, false)));
// m_ControlLookupMap.insert(std::pair<std::string, RlvWindLightControl>("sunmooncolor", RlvWindLightControl(&pWLParamMgr->mSunlight, false)));
//}
// Checked: 2011-08-29 (RLVa-1.4.1a) | Added: RLVa-1.4.1a
std::string RlvWindLight::getValue(const std::string& strSetting, bool& fError)
{
LLWLParamManager* pWLParams = LLWLParamManager::getInstance();
LLEnvManagerNew* pEnvMgr = LLEnvManagerNew::getInstance();
fError = false; // Assume we won't fail
if ("preset" == strSetting)
return (pEnvMgr->getUseFixedSky()) ? pEnvMgr->getSkyPresetName() : std::string();
else if ("daycycle" == strSetting)
return (pEnvMgr->getUseDayCycle()) ? pEnvMgr->getDayCycleName() : std::string();
F32 nValue = 0.0f;
if ("daytime" == strSetting)
{
nValue = (pEnvMgr->getUseFixedSky()) ? pWLParams->mCurParams.getFloat("sun_angle", fError) / F_TWO_PI : -1.0f;
}
else if (("sunglowfocus" == strSetting) || ("sunglowsize" == strSetting))
{
pWLParams->mGlow = pWLParams->mCurParams.getVector(pWLParams->mGlow.mName, fError);
RLV_ASSERT_DBG(!fError);
if ("sunglowfocus" == strSetting)
nValue = -pWLParams->mGlow.b / 5.0f;
else
nValue = 2 - pWLParams->mGlow.r / 20.0f;
}
else if ("starbrightness" == strSetting) nValue = pWLParams->mCurParams.getStarBrightness();
else if ("eastangle" == strSetting) nValue = pWLParams->mCurParams.getEastAngle() / F_TWO_PI;
else if ("sunmoonposition" == strSetting) nValue = pWLParams->mCurParams.getSunAngle() / F_TWO_PI;
else if ("cloudscrollx" == strSetting) nValue = pWLParams->mCurParams.getCloudScrollX() - 10.0f;
else if ("cloudscrolly" == strSetting) nValue = pWLParams->mCurParams.getCloudScrollY() - 10.0f;
else
{
std::map<std::string, RlvWindLightControl>::const_iterator itControl = m_ControlLookupMap.find(strSetting);
if (m_ControlLookupMap.end() != itControl)
{
switch (itControl->second.getControlType())
{
case RlvWindLightControl::TYPE_FLOAT:
nValue = itControl->second.getFloat(fError);
break;
case RlvWindLightControl::TYPE_COLOR_R:
nValue = itControl->second.getColorComponent(RlvWindLightControl::COMPONENT_R, fError);
break;
default:
fError = true;
break;
}
}
else
{
// Couldn't find the exact name, check for a color control name
RlvWindLightControl::EColorComponent eComponent = RlvWindLightControl::getComponentFromCharacter(strSetting[strSetting.length() - 1]);
if (RlvWindLightControl::COMPONENT_NONE != eComponent)
itControl = m_ControlLookupMap.find(strSetting.substr(0, strSetting.length() - 1));
if ( (m_ControlLookupMap.end() != itControl) && (itControl->second.isColorType()) )
nValue = itControl->second.getColorComponent(eComponent, fError);
else
fError = true;
}
}
return llformat("%f", nValue);
}
//std::string RlvWindLight::getValue(const std::string& strSetting, bool& fError)
//{
// LLWLParamManager* pWLParams = LLWLParamManager::getInstance();
// LLEnvManagerNew* pEnvMgr = LLEnvManagerNew::getInstance();
//
// fError = false; // Assume we won't fail
// if ("preset" == strSetting)
// return (pEnvMgr->getUseFixedSky()) ? pEnvMgr->getSkyPresetName() : std::string();
// else if ("daycycle" == strSetting)
// return (pEnvMgr->getUseDayCycle()) ? pEnvMgr->getDayCycleName() : std::string();
//
// F32 nValue = 0.0f;
// if ("daytime" == strSetting)
// {
// nValue = (pEnvMgr->getUseFixedSky()) ? pWLParams->mCurParams.getFloat("sun_angle", fError) / F_TWO_PI : -1.0f;
// }
// else if (("sunglowfocus" == strSetting) || ("sunglowsize" == strSetting))
// {
// pWLParams->mGlow = pWLParams->mCurParams.getVector(pWLParams->mGlow.mName, fError);
// RLV_ASSERT_DBG(!fError);
//
// if ("sunglowfocus" == strSetting)
// nValue = -pWLParams->mGlow.b / 5.0f;
// else
// nValue = 2 - pWLParams->mGlow.r / 20.0f;
// }
// else if ("starbrightness" == strSetting) nValue = pWLParams->mCurParams.getStarBrightness();
// else if ("eastangle" == strSetting) nValue = pWLParams->mCurParams.getEastAngle() / F_TWO_PI;
// else if ("sunmoonposition" == strSetting) nValue = pWLParams->mCurParams.getSunAngle() / F_TWO_PI;
// else if ("cloudscrollx" == strSetting) nValue = pWLParams->mCurParams.getCloudScrollX() - 10.0f;
// else if ("cloudscrolly" == strSetting) nValue = pWLParams->mCurParams.getCloudScrollY() - 10.0f;
// else
// {
// std::map<std::string, RlvWindLightControl>::const_iterator itControl = m_ControlLookupMap.find(strSetting);
// if (m_ControlLookupMap.end() != itControl)
// {
// switch (itControl->second.getControlType())
// {
// case RlvWindLightControl::TYPE_FLOAT:
// nValue = itControl->second.getFloat(fError);
// break;
// case RlvWindLightControl::TYPE_COLOR_R:
// nValue = itControl->second.getColorComponent(RlvWindLightControl::COMPONENT_R, fError);
// break;
// default:
// fError = true;
// break;
// }
// }
// else
// {
// // Couldn't find the exact name, check for a color control name
// RlvWindLightControl::EColorComponent eComponent = RlvWindLightControl::getComponentFromCharacter(strSetting[strSetting.length() - 1]);
// if (RlvWindLightControl::COMPONENT_NONE != eComponent)
// itControl = m_ControlLookupMap.find(strSetting.substr(0, strSetting.length() - 1));
// if ( (m_ControlLookupMap.end() != itControl) && (itControl->second.isColorType()) )
// nValue = itControl->second.getColorComponent(eComponent, fError);
// else
// fError = true;
// }
// }
// return llformat("%f", nValue);
//}
// Checked: 2011-08-29 (RLVa-1.4.1a) | Added: RLVa-1.4.1a
bool RlvWindLight::setValue(const std::string& strRlvName, const std::string& strValue)
{
F32 nValue = 0.0f;
// Sanity check - make sure strValue specifies a number for all settings except "preset" and "daycycle"
if ( (RlvSettings::getNoSetEnv()) ||
( (!LLStringUtil::convertToF32(strValue, nValue)) && (("preset" != strRlvName) && ("daycycle" != strRlvName)) ) )
{
return false;
}
LLWLParamManager* pWLParams = LLWLParamManager::getInstance();
LLEnvManagerNew* pEnvMgr = LLEnvManagerNew::getInstance();
if ("daytime" == strRlvName)
{
if (0.0f <= nValue)
{
pWLParams->mAnimator.deactivate();
pWLParams->mAnimator.setDayTime(nValue);
pWLParams->mAnimator.update(pWLParams->mCurParams);
}
else
{
pEnvMgr->setUserPrefs(pEnvMgr->getWaterPresetName(), pEnvMgr->getSkyPresetName(), pEnvMgr->getDayCycleName(), false, true);
}
return true;
}
else if ("preset" == strRlvName)
{
std::string strPresetName = pWLParams->findPreset(strValue, LLEnvKey::SCOPE_LOCAL);
if (!strPresetName.empty())
pEnvMgr->useSkyPreset(strPresetName);
return !strPresetName.empty();
}
else if ("daycycle" == strRlvName)
{
std::string strPresetName = LLDayCycleManager::instance().findPreset(strValue);
if (!strPresetName.empty())
pEnvMgr->useDayCycle(strValue, LLEnvKey::SCOPE_LOCAL);
return !strPresetName.empty();
}
bool fError = false;
pWLParams->mAnimator.deactivate();
if (("sunglowfocus" == strRlvName) || ("sunglowsize" == strRlvName))
{
pWLParams->mGlow = pWLParams->mCurParams.getVector(pWLParams->mGlow.mName, fError);
RLV_ASSERT_DBG(!fError);
if ("sunglowfocus" == strRlvName)
pWLParams->mGlow.b = -nValue * 5;
else
pWLParams->mGlow.r = (2 - nValue) * 20;
pWLParams->mGlow.update(pWLParams->mCurParams);
pWLParams->propagateParameters();
return true;
}
else if ("starbrightness" == strRlvName)
{
pWLParams->mCurParams.setStarBrightness(nValue);
return true;
}
else if (("eastangle" == strRlvName) || ("sunmoonposition" == strRlvName))
{
if ("eastangle" == strRlvName)
pWLParams->mCurParams.setEastAngle(F_TWO_PI * nValue);
else
pWLParams->mCurParams.setSunAngle(F_TWO_PI * nValue);
// Set the sun vector
pWLParams->mLightnorm.r = -sin(pWLParams->mCurParams.getEastAngle()) * cos(pWLParams->mCurParams.getSunAngle());
pWLParams->mLightnorm.g = sin(pWLParams->mCurParams.getSunAngle());
pWLParams->mLightnorm.b = cos(pWLParams->mCurParams.getEastAngle()) * cos(pWLParams->mCurParams.getSunAngle());
pWLParams->mLightnorm.i = 1.f;
pWLParams->propagateParameters();
return true;
}
else if ("cloudscrollx" == strRlvName)
{
pWLParams->mCurParams.setCloudScrollX(nValue + 10.0f);
return true;
}
else if ("cloudscrolly" == strRlvName)
{
pWLParams->mCurParams.setCloudScrollY(nValue + 10.0f);
return true;
}
std::map<std::string, RlvWindLightControl>::iterator itControl = m_ControlLookupMap.find(strRlvName);
if (m_ControlLookupMap.end() != itControl)
{
switch (itControl->second.getControlType())
{
case RlvWindLightControl::TYPE_FLOAT:
return itControl->second.setFloat(nValue);
case RlvWindLightControl::TYPE_COLOR_R:
return itControl->second.setColorComponent(RlvWindLightControl::COMPONENT_R, nValue);
default:
RLV_ASSERT(false);
}
}
else
{
// Couldn't find the exact name, check for a color control name
RlvWindLightControl::EColorComponent eComponent = RlvWindLightControl::getComponentFromCharacter(strRlvName[strRlvName.length() - 1]);
if (RlvWindLightControl::COMPONENT_NONE != eComponent)
itControl = m_ControlLookupMap.find(strRlvName.substr(0, strRlvName.length() - 1));
if ( (m_ControlLookupMap.end() != itControl) && (itControl->second.isColorType()) )
return itControl->second.setColorComponent(eComponent, nValue);
}
return false;
}
#endif // [EEPMERGE]
//bool RlvWindLight::setValue(const std::string& strRlvName, const std::string& strValue)
//{
// F32 nValue = 0.0f;
// // Sanity check - make sure strValue specifies a number for all settings except "preset" and "daycycle"
// if ( (RlvSettings::getNoSetEnv()) ||
// ( (!LLStringUtil::convertToF32(strValue, nValue)) && (("preset" != strRlvName) && ("daycycle" != strRlvName)) ) )
// {
// return false;
// }
//
// LLWLParamManager* pWLParams = LLWLParamManager::getInstance();
// LLEnvManagerNew* pEnvMgr = LLEnvManagerNew::getInstance();
//
// if ("daytime" == strRlvName)
// {
// if (0.0f <= nValue)
// {
// pWLParams->mAnimator.deactivate();
// pWLParams->mAnimator.setDayTime(nValue);
// pWLParams->mAnimator.update(pWLParams->mCurParams);
// }
// else
// {
// pEnvMgr->setUserPrefs(pEnvMgr->getWaterPresetName(), pEnvMgr->getSkyPresetName(), pEnvMgr->getDayCycleName(), false, true);
// }
// return true;
// }
// else if ("preset" == strRlvName)
// {
// std::string strPresetName = pWLParams->findPreset(strValue, LLEnvKey::SCOPE_LOCAL);
// if (!strPresetName.empty())
// pEnvMgr->useSkyPreset(strPresetName);
// return !strPresetName.empty();
// }
// else if ("daycycle" == strRlvName)
// {
// std::string strPresetName = LLDayCycleManager::instance().findPreset(strValue);
// if (!strPresetName.empty())
// pEnvMgr->useDayCycle(strValue, LLEnvKey::SCOPE_LOCAL);
// return !strPresetName.empty();
// }
//
// bool fError = false;
// pWLParams->mAnimator.deactivate();
// if (("sunglowfocus" == strRlvName) || ("sunglowsize" == strRlvName))
// {
// pWLParams->mGlow = pWLParams->mCurParams.getVector(pWLParams->mGlow.mName, fError);
// RLV_ASSERT_DBG(!fError);
//
// if ("sunglowfocus" == strRlvName)
// pWLParams->mGlow.b = -nValue * 5;
// else
// pWLParams->mGlow.r = (2 - nValue) * 20;
//
// pWLParams->mGlow.update(pWLParams->mCurParams);
// pWLParams->propagateParameters();
// return true;
// }
// else if ("starbrightness" == strRlvName)
// {
// pWLParams->mCurParams.setStarBrightness(nValue);
// return true;
// }
// else if (("eastangle" == strRlvName) || ("sunmoonposition" == strRlvName))
// {
// if ("eastangle" == strRlvName)
// pWLParams->mCurParams.setEastAngle(F_TWO_PI * nValue);
// else
// pWLParams->mCurParams.setSunAngle(F_TWO_PI * nValue);
//
// // Set the sun vector
// pWLParams->mLightnorm.r = -sin(pWLParams->mCurParams.getEastAngle()) * cos(pWLParams->mCurParams.getSunAngle());
// pWLParams->mLightnorm.g = sin(pWLParams->mCurParams.getSunAngle());
// pWLParams->mLightnorm.b = cos(pWLParams->mCurParams.getEastAngle()) * cos(pWLParams->mCurParams.getSunAngle());
// pWLParams->mLightnorm.i = 1.f;
//
// pWLParams->propagateParameters();
// return true;
// }
// else if ("cloudscrollx" == strRlvName)
// {
// pWLParams->mCurParams.setCloudScrollX(nValue + 10.0f);
// return true;
// }
// else if ("cloudscrolly" == strRlvName)
// {
// pWLParams->mCurParams.setCloudScrollY(nValue + 10.0f);
// return true;
// }
//
// std::map<std::string, RlvWindLightControl>::iterator itControl = m_ControlLookupMap.find(strRlvName);
// if (m_ControlLookupMap.end() != itControl)
// {
// switch (itControl->second.getControlType())
// {
// case RlvWindLightControl::TYPE_FLOAT:
// return itControl->second.setFloat(nValue);
// case RlvWindLightControl::TYPE_COLOR_R:
// return itControl->second.setColorComponent(RlvWindLightControl::COMPONENT_R, nValue);
// default:
// RLV_ASSERT(false);
// }
// }
// else
// {
// // Couldn't find the exact name, check for a color control name
// RlvWindLightControl::EColorComponent eComponent = RlvWindLightControl::getComponentFromCharacter(strRlvName[strRlvName.length() - 1]);
// if (RlvWindLightControl::COMPONENT_NONE != eComponent)
// itControl = m_ControlLookupMap.find(strRlvName.substr(0, strRlvName.length() - 1));
// if ( (m_ControlLookupMap.end() != itControl) && (itControl->second.isColorType()) )
// return itControl->second.setColorComponent(eComponent, nValue);
// }
// return false;
//}
// ============================================================================
@ -441,27 +439,24 @@ bool RlvExtGetSet::processCommand(const RlvCommand& rlvCmd, ERlvCmdRet& eRet)
return true;
}
}
else if ("env" == strBehaviour)
{
bool fError = false;
if ( ("get" == strGetSet) && (RLV_TYPE_REPLY == rlvCmd.getParamType()) )
{
// [EEPMERGE]
//RlvUtil::sendChatReply(rlvCmd.getParam(), RlvWindLight::instance().getValue(strSetting, fError));
eRet = (!fError) ? RLV_RET_SUCCESS : RLV_RET_FAILED_UNKNOWN;
return true;
}
else if ( ("set" == strGetSet) && (RLV_TYPE_FORCE == rlvCmd.getParamType()) )
{
// [EEPMERGE]
//if (!gRlvHandler.hasBehaviourExcept(RLV_BHVR_SETENV, rlvCmd.getObjectID()))
// eRet = (RlvWindLight::instance().setValue(strSetting, rlvCmd.getOption())) ? RLV_RET_SUCCESS : RLV_RET_FAILED_UNKNOWN;
//else
// eRet = RLV_RET_FAILED_LOCK;
// [/EEPMERGE]
return true;
}
}
// else if ("env" == strBehaviour)
// {
// bool fError = false;
// if ( ("get" == strGetSet) && (RLV_TYPE_REPLY == rlvCmd.getParamType()) )
// {
// RlvUtil::sendChatReply(rlvCmd.getParam(), RlvWindLight::instance().getValue(strSetting, fError));
// eRet = (!fError) ? RLV_RET_SUCCESS : RLV_RET_FAILED_UNKNOWN;
// return true;
// }
// else if ( ("set" == strGetSet) && (RLV_TYPE_FORCE == rlvCmd.getParamType()) )
// {
// if (!gRlvHandler.hasBehaviourExcept(RLV_BHVR_SETENV, rlvCmd.getObjectID()))
// eRet = (RlvWindLight::instance().setValue(strSetting, rlvCmd.getOption())) ? RLV_RET_SUCCESS : RLV_RET_FAILED_UNKNOWN;
// else
// eRet = RLV_RET_FAILED_LOCK;
// return true;
// }
// }
}
else if ("setrot" == rlvCmd.getBehaviour())
{

64
indra/newview/rlvhandler.cpp
View File

@ -37,7 +37,6 @@
#include "llavataractions.h" // @stopim IM query
#include "llavatarnamecache.h" // @shownames
#include "llavatarlist.h" // @shownames
// [EEPMERGE]
//#include "llenvmanager.h" // @setenv
#include "llfloatersidepanelcontainer.h"// @shownames
#include "llnotifications.h" // @list IM query
@ -2253,34 +2252,34 @@ void RlvBehaviourToggleHandler<RLV_BHVR_SETDEBUG>::onCommandToggle(ERlvBehaviour
}
// Handles: @setenv=n|y toggles
template<> template<>
void RlvBehaviourToggleHandler<RLV_BHVR_SETENV>::onCommandToggle(ERlvBehaviour eBhvr, bool fHasBhvr)
{
const std::string strEnvFloaters[] = { "env_post_process", "env_settings", "env_delete_preset", "env_edit_sky", "env_edit_water", "env_edit_day_cycle" };
for (int idxFloater = 0, cntFloater = sizeof(strEnvFloaters) / sizeof(std::string); idxFloater < cntFloater; idxFloater++)
{
if (fHasBhvr)
{
// Hide the floater if it's currently visible
LLFloaterReg::const_instance_list_t envFloaters = LLFloaterReg::getFloaterList(strEnvFloaters[idxFloater]);
for (LLFloater* pFloater : envFloaters)
pFloater->closeFloater();
RlvUIEnabler::instance().addGenericFloaterFilter(strEnvFloaters[idxFloater]);
}
else
{
RlvUIEnabler::instance().removeGenericFloaterFilter(strEnvFloaters[idxFloater]);
}
}
// Don't allow toggling "Basic Shaders" and/or "Atmopsheric Shaders" through the debug settings under @setenv=n
gSavedSettings.getControl("WindLightUseAtmosShaders")->setHiddenFromSettingsEditor(fHasBhvr);
// Restore the user's WindLight preferences when releasing
// [EEPMERGE] Use LLEnvironment::loadPreferences()???
//if (!fHasBhvr)
// LLEnvManagerNew::instance().usePrefs();
}
//template<> template<>
//void RlvBehaviourToggleHandler<RLV_BHVR_SETENV>::onCommandToggle(ERlvBehaviour eBhvr, bool fHasBhvr)
//{
// const std::string strEnvFloaters[] = { "env_post_process", "env_settings", "env_delete_preset", "env_edit_sky", "env_edit_water", "env_edit_day_cycle" };
// for (int idxFloater = 0, cntFloater = sizeof(strEnvFloaters) / sizeof(std::string); idxFloater < cntFloater; idxFloater++)
// {
// if (fHasBhvr)
// {
// // Hide the floater if it's currently visible
// LLFloaterReg::const_instance_list_t envFloaters = LLFloaterReg::getFloaterList(strEnvFloaters[idxFloater]);
// for (LLFloater* pFloater : envFloaters)
// pFloater->closeFloater();
// RlvUIEnabler::instance().addGenericFloaterFilter(strEnvFloaters[idxFloater]);
// }
// else
// {
// RlvUIEnabler::instance().removeGenericFloaterFilter(strEnvFloaters[idxFloater]);
// }
// }
//
// // Don't allow toggling "Basic Shaders" and/or "Atmopsheric Shaders" through the debug settings under @setenv=n
// gSavedSettings.getControl("VertexShaderEnable")->setHiddenFromSettingsEditor(fHasBhvr);
// gSavedSettings.getControl("WindLightUseAtmosShaders")->setHiddenFromSettingsEditor(fHasBhvr);
//
// // Restore the user's WindLight preferences when releasing
// if (!fHasBhvr)
// LLEnvManagerNew::instance().usePrefs();
//}
// Handles: @showhovertext:<uuid>=n|y
template<> template<>
@ -2403,13 +2402,12 @@ void RlvBehaviourToggleHandler<RLV_BHVR_SHOWNAMES>::onCommandToggle(ERlvBehaviou
// Force the use of the "display name" cache so we can filter both display and legacy names (or return back to the user's preference)
if (fHasBhvr)
{
LLAvatarNameCache::getInstance()->setForceDisplayNames(true);
LLAvatarNameCache::instance().setForceDisplayNames(true);
}
else
{
LLAvatarNameCache* inst = LLAvatarNameCache::getInstance();
inst->setForceDisplayNames(false);
inst->setUseDisplayNames(gSavedSettings.getBOOL("UseDisplayNames"));
LLAvatarNameCache::instance().setForceDisplayNames(false);
LLAvatarNameCache::instance().setUseDisplayNames(gSavedSettings.getBOOL("UseDisplayNames"));
}
// Refresh all name tags and HUD text

2
indra/newview/rlvhelper.cpp
View File

@ -133,7 +133,7 @@ RlvBehaviourDictionary::RlvBehaviourDictionary()
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_EXCEPTION>("sendimto", RLV_BHVR_SENDIMTO, RlvBehaviourInfo::BHVR_STRICT));
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("sendgesture", RLV_BHVR_SENDGESTURE, RlvBehaviourInfo::BHVR_EXPERIMENTAL));
addEntry(new RlvBehaviourGenericToggleProcessor<RLV_BHVR_SETDEBUG, RLV_OPTION_NONE>("setdebug"));
addEntry(new RlvBehaviourGenericToggleProcessor<RLV_BHVR_SETENV, RLV_OPTION_NONE>("setenv"));
// addEntry(new RlvBehaviourGenericToggleProcessor<RLV_BHVR_SETENV, RLV_OPTION_NONE>("setenv"));
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("setgroup", RLV_BHVR_SETGROUP));
addEntry(new RlvBehaviourInfo("sharedunwear", RLV_BHVR_SHAREDUNWEAR, RLV_TYPE_ADDREM, RlvBehaviourInfo::BHVR_EXTENDED));
addEntry(new RlvBehaviourInfo("sharedwear", RLV_BHVR_SHAREDWEAR, RLV_TYPE_ADDREM, RlvBehaviourInfo::BHVR_EXTENDED));