2122 lines
107 KiB
C++
2122 lines
107 KiB
C++
/**
|
|
*
|
|
* Copyright (c) 2009-2020, Kitty Barnett
|
|
*
|
|
* The source code in this file is provided to you under the terms of the
|
|
* GNU Lesser General Public License, version 2.1, but WITHOUT ANY WARRANTY;
|
|
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
|
|
* PARTICULAR PURPOSE. Terms of the LGPL can be found in doc/LGPL-licence.txt
|
|
* in this distribution, or online at http://www.gnu.org/licenses/lgpl-2.1.txt
|
|
*
|
|
* By copying, modifying or distributing this software, you acknowledge that
|
|
* you have read and understood your obligations described above, and agree to
|
|
* abide by those obligations.
|
|
*
|
|
*/
|
|
|
|
#include "llviewerprecompiledheaders.h"
|
|
#include "llappearancemgr.h"
|
|
#include "llattachmentsmgr.h"
|
|
#include "llfeaturemanager.h"
|
|
#include "llgesturemgr.h"
|
|
#include "llnotificationsutil.h"
|
|
#include "llviewerobjectlist.h"
|
|
#include "pipeline.h"
|
|
|
|
//<FS:TS> FIRE-4453 bridge detached by the RLV command @remattach=force
|
|
#include "fslslbridge.h"
|
|
//</FS:TS> FIRE-4453
|
|
|
|
#include "rlvcommon.h"
|
|
#include "rlveffects.h"
|
|
#include "rlvhelper.h"
|
|
#include "rlvhandler.h"
|
|
#include "rlvinventory.h"
|
|
#include "rlvmodifiers.h"
|
|
|
|
#include <boost/algorithm/string.hpp>
|
|
|
|
// ============================================================================
|
|
// RlvBehaviourDictionary
|
|
//
|
|
|
|
/*
|
|
* Processing of RLVa commands used to be a big switch/case loop with one function for each command type(addrem, reply
|
|
* and force). This is slowly being replaced with templated command handling which might be more confusing intially
|
|
* (also due to my poor naming schemes) but is actually far simpler and less error-prone than the old way.
|
|
*
|
|
* In the general case you just add a definition for the command below and then write the function body in rlvhandler.cpp
|
|
* and you're done! Told you this was easy.
|
|
*
|
|
* Reply command
|
|
* =============
|
|
* Definition: RlvReplyProcessor<RLV_BHVR_COMMANDNAME>("commandname"[, <options>]));
|
|
* Implement : ERlvCmdRet RlvReplyHandler<RLV_BHVR_COMMANDNAME>::onCommand(const RlvCommand& rlvCmd, std::string& strReply)
|
|
*
|
|
* Force command
|
|
* =============
|
|
* Definition: new RlvForceProcessor<RLV_BHVR_COMMANDNAME>("commandname"[, <options>]));
|
|
* Implement : ERlvCmdRet RlvForceProcessor<RLV_BHVR_COMMANDNAME>::onCommand(const RlvCommand& rlvCmd)
|
|
*
|
|
* Behaviours
|
|
* ==========
|
|
* Behaviours come in many forms but the added complexity is only in the variety of choices. The implementation is as
|
|
* easy as reply or force commands.
|
|
*
|
|
* For simple behaviours that only require recordkeeping and don't run code when set/unset (see ERlvBehaviourOptionType):
|
|
* Definition: RlvBehaviourGenericProcessor<RLV_OPTION_TYPE>("commandname", RLV_BHVR_COMMANDNAME)
|
|
* Implement : nothing! (it automagically works)
|
|
* For simple behaviours that only require recordkeeping and only run code when they toggle:
|
|
* Definition: RlvBehaviourGenericToggleProcessor<RLV_BHVR_COMMANDNAME, RLV_OPTION_TYPE>("commandname"))
|
|
* Implement : void RlvBehaviourToggleHandler<RLV_BHVR_COMMANDNAME>::onCommandToggle(ERlvBehaviour eBhvr, bool fHasBhvr)
|
|
* For behaviours that require manual processing:
|
|
* Definition: RlvBehaviourProcessor<RLV_BHVR_COMMANDNAME>("commandname"))
|
|
* Implement : ERlvCmdRet RlvBehaviourHandler<RLV_BHVR_COMMANDNAME>::onCommand(const RlvCommand& rlvCmd, bool& fRefCount)
|
|
* For behaviours that run code when their modifier changes:
|
|
* Definition: addModifier(RLV_BHVR_COMMANDNAME, RLV_MODIFIER_COMMANDNAME, new RlvBehaviourModifierHandler<RLV_MODIFIER_COMMANDNAME>(<default>, <auto-add>, <comparator>));
|
|
* Implement : void RlvBehaviourModifierHandler::onValueChanged()
|
|
*
|
|
*/
|
|
RlvBehaviourDictionary::RlvBehaviourDictionary()
|
|
{
|
|
// Array auto-initialization to 0 is still not supported in VS2013
|
|
memset(m_BehaviourModifiers, 0, sizeof(RlvBehaviourModifier*) * RLV_MODIFIER_COUNT);
|
|
|
|
//
|
|
// Restrictions
|
|
//
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("acceptpermission", RLV_BHVR_ACCEPTPERMISSION));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE_OR_EXCEPTION>("accepttp", RLV_BHVR_ACCEPTTP, RlvBehaviourInfo::BHVR_STRICT));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE_OR_EXCEPTION>("accepttprequest", RLV_BHVR_ACCEPTTPREQUEST, RlvBehaviourInfo::BHVR_STRICT | RlvBehaviourInfo::BHVR_EXTENDED));
|
|
addEntry(new RlvBehaviourProcessor<RLV_BHVR_ADDATTACH, RlvBehaviourAddRemAttachHandler>("addattach"));
|
|
addEntry(new RlvBehaviourInfo("addoutfit", RLV_BHVR_ADDOUTFIT, RLV_TYPE_ADDREM));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("allowidle", RLV_BHVR_ALLOWIDLE, RlvBehaviourInfo::BHVR_EXPERIMENTAL));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("alwaysrun", RLV_BHVR_ALWAYSRUN));
|
|
addEntry(new RlvBehaviourInfo("attachthis", RLV_BHVR_ATTACHTHIS, RLV_TYPE_ADDREM, RlvBehaviourInfo::FORCEWEAR_NODE));
|
|
addEntry(new RlvBehaviourInfo("attachallthis", RLV_BHVR_ATTACHTHIS, RLV_TYPE_ADDREM, RlvBehaviourInfo::FORCEWEAR_SUBTREE));
|
|
addEntry(new RlvBehaviourInfo("attachthis_except", RLV_BHVR_ATTACHTHISEXCEPT, RLV_TYPE_ADDREM, RlvBehaviourInfo::FORCEWEAR_NODE));
|
|
addEntry(new RlvBehaviourInfo("attachallthis_except", RLV_BHVR_ATTACHTHISEXCEPT, RLV_TYPE_ADDREM, RlvBehaviourInfo::FORCEWEAR_SUBTREE));
|
|
addEntry(new RlvBehaviourGenericToggleProcessor<RLV_BHVR_BUY, RLV_OPTION_NONE>("buy"));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("chatwhisper", RLV_BHVR_CHATWHISPER));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("chatnormal", RLV_BHVR_CHATNORMAL));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("chatshout", RLV_BHVR_CHATSHOUT));
|
|
addEntry(new RlvBehaviourProcessor<RLV_BHVR_DETACH>("detach"));
|
|
addEntry(new RlvBehaviourInfo("detachthis", RLV_BHVR_DETACHTHIS, RLV_TYPE_ADDREM, RlvBehaviourInfo::FORCEWEAR_NODE));
|
|
addEntry(new RlvBehaviourInfo("detachallthis", RLV_BHVR_DETACHTHIS, RLV_TYPE_ADDREM, RlvBehaviourInfo::FORCEWEAR_SUBTREE));
|
|
addEntry(new RlvBehaviourInfo("detachthis_except", RLV_BHVR_DETACHTHISEXCEPT, RLV_TYPE_ADDREM, RlvBehaviourInfo::FORCEWEAR_NODE));
|
|
addEntry(new RlvBehaviourInfo("detachallthis_except", RLV_BHVR_DETACHTHISEXCEPT, RLV_TYPE_ADDREM, RlvBehaviourInfo::FORCEWEAR_SUBTREE));
|
|
addEntry(new RlvBehaviourGenericToggleProcessor<RLV_BHVR_EDIT, RLV_OPTION_NONE_OR_EXCEPTION>("edit"));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("editattach", RLV_BHVR_EDITATTACH));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_EXCEPTION>("editobj", RLV_BHVR_EDITOBJ));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("editworld", RLV_BHVR_EDITWORLD));
|
|
addEntry(new RlvBehaviourGenericToggleProcessor<RLV_BHVR_VIEWTRANSPARENT, RLV_OPTION_NONE>("viewtransparent", RlvBehaviourInfo::BHVR_EXPERIMENTAL));
|
|
addEntry(new RlvBehaviourGenericToggleProcessor<RLV_BHVR_VIEWWIREFRAME, RLV_OPTION_NONE>("viewwireframe", RlvBehaviourInfo::BHVR_EXPERIMENTAL));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("emote", RLV_BHVR_EMOTE));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE_OR_MODIFIER>("fartouch", RLV_BHVR_FARTOUCH));
|
|
addModifier(RLV_BHVR_FARTOUCH, RLV_MODIFIER_FARTOUCHDIST, new RlvBehaviourModifier("Fartouch Distance", RLV_MODIFIER_FARTOUCH_DEFAULT, true, new RlvBehaviourModifierCompMin));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("fly", RLV_BHVR_FLY));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("interact", RLV_BHVR_INTERACT, RlvBehaviourInfo::BHVR_EXTENDED));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("jump", RLV_BHVR_JUMP));
|
|
addEntry(new RlvBehaviourInfo("notify", RLV_BHVR_NOTIFY, RLV_TYPE_ADDREM));
|
|
addEntry(new RlvBehaviourGenericToggleProcessor<RLV_BHVR_PAY, RLV_OPTION_NONE>("pay"));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("permissive", RLV_BHVR_PERMISSIVE));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE_OR_EXCEPTION>("recvchat", RLV_BHVR_RECVCHAT, RlvBehaviourInfo::BHVR_STRICT));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_EXCEPTION>("recvchatfrom", RLV_BHVR_RECVCHATFROM, RlvBehaviourInfo::BHVR_STRICT));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE_OR_EXCEPTION>("recvemote", RLV_BHVR_RECVEMOTE, RlvBehaviourInfo::BHVR_STRICT));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_EXCEPTION>("recvemotefrom", RLV_BHVR_RECVEMOTEFROM, RlvBehaviourInfo::BHVR_STRICT));
|
|
addEntry(new RlvBehaviourProcessor<RLV_BHVR_RECVIM, RlvBehaviourRecvSendStartIMHandler>("recvim", RlvBehaviourInfo::BHVR_STRICT));
|
|
addModifier(RLV_BHVR_RECVIM, RLV_MODIFIER_RECVIMDISTMIN, new RlvBehaviourModifier("RecvIM Distance (Min)", F32_MAX, true, new RlvBehaviourModifierCompMax));
|
|
addModifier(RLV_BHVR_RECVIM, RLV_MODIFIER_RECVIMDISTMAX, new RlvBehaviourModifier("RecvIM Distance (Max)", F32_MAX, true, new RlvBehaviourModifierCompMin));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_EXCEPTION>("recvimfrom", RLV_BHVR_RECVIMFROM, RlvBehaviourInfo::BHVR_STRICT));
|
|
addEntry(new RlvBehaviourInfo("redirchat", RLV_BHVR_REDIRCHAT, RLV_TYPE_ADDREM));
|
|
addEntry(new RlvBehaviourInfo("rediremote", RLV_BHVR_REDIREMOTE, RLV_TYPE_ADDREM));
|
|
addEntry(new RlvBehaviourProcessor<RLV_BHVR_REMATTACH, RlvBehaviourAddRemAttachHandler>("remattach"));
|
|
addEntry(new RlvBehaviourInfo("remoutfit", RLV_BHVR_REMOUTFIT, RLV_TYPE_ADDREM));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("rez", RLV_BHVR_REZ));
|
|
addEntry(new RlvBehaviourProcessor<RLV_BHVR_SENDCHANNEL, RlvBehaviourSendChannelHandler>("sendchannel", RlvBehaviourInfo::BHVR_STRICT));
|
|
addEntry(new RlvBehaviourProcessor<RLV_BHVR_SENDCHANNELEXCEPT, RlvBehaviourSendChannelHandler>("sendchannel_except", RlvBehaviourInfo::BHVR_STRICT | RlvBehaviourInfo::BHVR_EXPERIMENTAL));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("sendchat", RLV_BHVR_SENDCHAT));
|
|
addEntry(new RlvBehaviourToggleProcessor<RLV_BHVR_SENDIM, RlvBehaviourRecvSendStartIMHandler>("sendim", RlvBehaviourInfo::BHVR_STRICT));
|
|
addModifier(RLV_BHVR_SENDIM, RLV_MODIFIER_SENDIMDISTMIN, new RlvBehaviourModifier("SendIM Distance (Min)", F32_MAX, true, new RlvBehaviourModifierCompMax));
|
|
addModifier(RLV_BHVR_SENDIM, RLV_MODIFIER_SENDIMDISTMAX, new RlvBehaviourModifier("SendIM Distance (Max)", F32_MAX, true, new RlvBehaviourModifierCompMin));
|
|
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 RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("setgroup", RLV_BHVR_SETGROUP));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE_OR_EXCEPTION>("share", RLV_BHVR_SHARE, RlvBehaviourInfo::BHVR_STRICT));
|
|
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));
|
|
addEntry(new RlvBehaviourProcessor<RLV_BHVR_SHOWHOVERTEXT>("showhovertext"));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("showhovertextall", RLV_BHVR_SHOWHOVERTEXTALL));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("showhovertexthud", RLV_BHVR_SHOWHOVERTEXTHUD));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("showhovertextworld", RLV_BHVR_SHOWHOVERTEXTWORLD));
|
|
addEntry(new RlvBehaviourGenericToggleProcessor<RLV_BHVR_SHOWINV, RLV_OPTION_NONE>("showinv"));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("showloc", RLV_BHVR_SHOWLOC));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("showminimap", RLV_BHVR_SHOWMINIMAP));
|
|
addEntry(new RlvBehaviourToggleProcessor<RLV_BHVR_SHOWNAMES>("shownames", RlvBehaviourInfo::BHVR_STRICT));
|
|
addEntry(new RlvBehaviourProcessor<RLV_BHVR_SHOWNAMETAGS>("shownametags", RlvBehaviourInfo::BHVR_STRICT));
|
|
addModifier(RLV_BHVR_SHOWNAMETAGS, RLV_MODIFIER_SHOWNAMETAGSDIST, new RlvBehaviourModifierHandler<RLV_MODIFIER_SHOWNAMETAGSDIST>("Name Tags - Visible Distance", 0.0f, true, new RlvBehaviourModifierCompMin));
|
|
addEntry(new RlvBehaviourGenericToggleProcessor<RLV_BHVR_SHOWNEARBY, RLV_OPTION_NONE>("shownearby", RlvBehaviourInfo::BHVR_EXPERIMENTAL));
|
|
addEntry(new RlvBehaviourGenericToggleProcessor<RLV_BHVR_SHOWSELF, RLV_OPTION_NONE, RlvBehaviourShowSelfToggleHandler>("showself", RlvBehaviourInfo::BHVR_EXPERIMENTAL));
|
|
addEntry(new RlvBehaviourGenericToggleProcessor<RLV_BHVR_SHOWSELFHEAD, RLV_OPTION_NONE, RlvBehaviourShowSelfToggleHandler>("showselfhead", RlvBehaviourInfo::BHVR_EXPERIMENTAL));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("showworldmap", RLV_BHVR_SHOWWORLDMAP));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("sit", RLV_BHVR_SIT));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE_OR_MODIFIER>("sittp", RLV_BHVR_SITTP));
|
|
addModifier(RLV_BHVR_SITTP, RLV_MODIFIER_SITTPDIST, new RlvBehaviourModifier("SitTp Distance", RLV_MODIFIER_SITTP_DEFAULT, true, new RlvBehaviourModifierCompMin));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("standtp", RLV_BHVR_STANDTP));
|
|
addEntry(new RlvBehaviourProcessor<RLV_BHVR_STARTIM, RlvBehaviourRecvSendStartIMHandler>("startim", RlvBehaviourInfo::BHVR_STRICT));
|
|
addModifier(RLV_BHVR_STARTIM, RLV_MODIFIER_STARTIMDISTMIN, new RlvBehaviourModifier("StartIM Distance (Min)", F32_MAX, true, new RlvBehaviourModifierCompMax));
|
|
addModifier(RLV_BHVR_STARTIM, RLV_MODIFIER_STARTIMDISTMAX, new RlvBehaviourModifier("StartIM Distance (Max)", F32_MAX, true, new RlvBehaviourModifierCompMin));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_EXCEPTION>("startimto", RLV_BHVR_STARTIMTO, RlvBehaviourInfo::BHVR_STRICT));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("temprun", RLV_BHVR_TEMPRUN));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("touchall", RLV_BHVR_TOUCHALL));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE_OR_EXCEPTION>("touchattach", RLV_BHVR_TOUCHATTACH));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE_OR_EXCEPTION>("touchattachother", RLV_BHVR_TOUCHATTACHOTHER));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("touchattachself", RLV_BHVR_TOUCHATTACHSELF));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE_OR_MODIFIER>("touchfar", RLV_BHVR_FARTOUCH, RlvBehaviourInfo::BHVR_SYNONYM));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE_OR_EXCEPTION>("touchhud", RLV_BHVR_TOUCHHUD, RlvBehaviourInfo::BHVR_EXTENDED));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("touchme", RLV_BHVR_TOUCHME));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_EXCEPTION>("touchthis", RLV_BHVR_TOUCHTHIS));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE_OR_EXCEPTION>("touchworld", RLV_BHVR_TOUCHWORLD));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("tplm", RLV_BHVR_TPLM));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("tploc", RLV_BHVR_TPLOC));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE_OR_MODIFIER>("tplocal", RLV_BHVR_TPLOCAL, RlvBehaviourInfo::BHVR_EXPERIMENTAL));
|
|
addModifier(RLV_BHVR_TPLOCAL, RLV_MODIFIER_TPLOCALDIST, new RlvBehaviourModifier("Local Teleport Distance", RLV_MODIFIER_TPLOCAL_DEFAULT, true, new RlvBehaviourModifierCompMin));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE_OR_EXCEPTION>("tplure", RLV_BHVR_TPLURE, RlvBehaviourInfo::BHVR_STRICT));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE_OR_EXCEPTION>("tprequest", RLV_BHVR_TPREQUEST, RlvBehaviourInfo::BHVR_STRICT | RlvBehaviourInfo::BHVR_EXTENDED));
|
|
addEntry(new RlvBehaviourInfo("unsharedunwear", RLV_BHVR_UNSHAREDUNWEAR, RLV_TYPE_ADDREM));
|
|
addEntry(new RlvBehaviourInfo("unsharedwear", RLV_BHVR_UNSHAREDWEAR, RLV_TYPE_ADDREM));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("unsit", RLV_BHVR_UNSIT));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("viewnote", RLV_BHVR_VIEWNOTE));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("viewscript", RLV_BHVR_VIEWSCRIPT));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE>("viewtexture", RLV_BHVR_VIEWTEXTURE));
|
|
|
|
// Camera
|
|
addEntry(new RlvBehaviourGenericToggleProcessor<RLV_BHVR_SETCAM, RLV_OPTION_NONE>("setcam"));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_MODIFIER>("setcam_avdist", RLV_BHVR_SETCAM_AVDIST));
|
|
addModifier(RLV_BHVR_SETCAM_AVDIST, RLV_MODIFIER_SETCAM_AVDIST, new RlvBehaviourModifier("Camera - Silhouette Distance", 0.0f, false, new RlvBehaviourModifierCompMax()));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_MODIFIER>("setcam_avdistmin", RLV_BHVR_SETCAM_AVDISTMIN, RlvBehaviourInfo::BHVR_EXPERIMENTAL));
|
|
addModifier(RLV_BHVR_SETCAM_AVDISTMIN, RLV_MODIFIER_SETCAM_AVDISTMIN, new RlvBehaviourModifierHandler<RLV_MODIFIER_SETCAM_AVDISTMIN>("Camera - Avatar Distance (Min)", 0.0f, false, new RlvBehaviourModifierCompMax()));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_MODIFIER>("setcam_avdistmax", RLV_BHVR_SETCAM_AVDISTMAX, RlvBehaviourInfo::BHVR_EXPERIMENTAL));
|
|
addModifier(RLV_BHVR_SETCAM_AVDISTMAX, RLV_MODIFIER_SETCAM_AVDISTMAX, new RlvBehaviourModifier("Camera - Avatar Distance (Max)", F32_MAX, false, new RlvBehaviourModifierCompMin));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_MODIFIER>("setcam_origindistmin", RLV_BHVR_SETCAM_ORIGINDISTMIN, RlvBehaviourInfo::BHVR_EXPERIMENTAL));
|
|
addModifier(RLV_BHVR_SETCAM_ORIGINDISTMIN, RLV_MODIFIER_SETCAM_ORIGINDISTMIN, new RlvBehaviourModifier("Camera - Focus Distance (Min)", 0.0f, true, new RlvBehaviourModifierCompMax));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_MODIFIER>("setcam_origindistmax", RLV_BHVR_SETCAM_ORIGINDISTMAX, RlvBehaviourInfo::BHVR_EXPERIMENTAL));
|
|
addModifier(RLV_BHVR_SETCAM_ORIGINDISTMAX, RLV_MODIFIER_SETCAM_ORIGINDISTMAX, new RlvBehaviourModifier("Camera - Focus Distance (Max)", F32_MAX, true, new RlvBehaviourModifierCompMin));
|
|
addEntry(new RlvBehaviourGenericToggleProcessor<RLV_BHVR_SETCAM_EYEOFFSET, RLV_OPTION_MODIFIER, RlvBehaviourCamEyeFocusOffsetHandler>("setcam_eyeoffset"));
|
|
addModifier(RLV_BHVR_SETCAM_EYEOFFSET, RLV_MODIFIER_SETCAM_EYEOFFSET, new RlvBehaviourModifierHandler<RLV_MODIFIER_SETCAM_EYEOFFSET>("Camera - Eye Offset", LLVector3::zero, true, nullptr));
|
|
addEntry(new RlvBehaviourGenericToggleProcessor<RLV_BHVR_SETCAM_EYEOFFSETSCALE, RLV_OPTION_MODIFIER, RlvBehaviourCamEyeFocusOffsetHandler>("setcam_eyeoffsetscale"));
|
|
addModifier(RLV_BHVR_SETCAM_EYEOFFSETSCALE, RLV_MODIFIER_SETCAM_EYEOFFSETSCALE, new RlvBehaviourModifierHandler<RLV_MODIFIER_SETCAM_EYEOFFSETSCALE>("Camera - Eye Offset Scale", 0, true, nullptr));
|
|
addEntry(new RlvBehaviourGenericToggleProcessor<RLV_BHVR_SETCAM_FOCUSOFFSET, RLV_OPTION_MODIFIER, RlvBehaviourCamEyeFocusOffsetHandler>("setcam_focusoffset"));
|
|
addModifier(RLV_BHVR_SETCAM_FOCUSOFFSET, RLV_MODIFIER_SETCAM_FOCUSOFFSET, new RlvBehaviourModifierHandler<RLV_MODIFIER_SETCAM_FOCUSOFFSET>("Camera - Focus Offset", LLVector3d::zero, true, nullptr));
|
|
addEntry(new RlvBehaviourProcessor<RLV_BHVR_SETCAM_FOVMIN, RlvBehaviourSetCamFovHandler>("setcam_fovmin"));
|
|
addModifier(RLV_BHVR_SETCAM_FOVMIN, RLV_MODIFIER_SETCAM_FOVMIN, new RlvBehaviourModifierHandler<RLV_MODIFIER_SETCAM_FOVMIN>("Camera - FOV (Min)", DEFAULT_FIELD_OF_VIEW, true, new RlvBehaviourModifierCompMax));
|
|
addEntry(new RlvBehaviourProcessor<RLV_BHVR_SETCAM_FOVMAX, RlvBehaviourSetCamFovHandler>("setcam_fovmax"));
|
|
addModifier(RLV_BHVR_SETCAM_FOVMAX, RLV_MODIFIER_SETCAM_FOVMAX, new RlvBehaviourModifierHandler<RLV_MODIFIER_SETCAM_FOVMAX>("Camera - FOV (Max)", DEFAULT_FIELD_OF_VIEW, true, new RlvBehaviourModifierCompMin));
|
|
addEntry(new RlvBehaviourGenericToggleProcessor<RLV_BHVR_SETCAM_MOUSELOOK, RLV_OPTION_NONE>("setcam_mouselook"));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE_OR_MODIFIER>("setcam_textures", RLV_BHVR_SETCAM_TEXTURES));
|
|
addModifier(RLV_BHVR_SETCAM_TEXTURES, RLV_MODIFIER_SETCAM_TEXTURE, new RlvBehaviourModifierHandler<RLV_MODIFIER_SETCAM_TEXTURE>("Camera - Forced Texture", IMG_DEFAULT, true, nullptr));
|
|
addEntry(new RlvBehaviourGenericToggleProcessor<RLV_BHVR_SETCAM_UNLOCK, RLV_OPTION_NONE>("setcam_unlock"));
|
|
// Camera (compatibility shim - to be deprecated)
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_MODIFIER>("camavdist", RLV_BHVR_SETCAM_AVDIST, RlvBehaviourInfo::BHVR_SYNONYM | RlvBehaviourInfo::BHVR_DEPRECATED));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_MODIFIER>("camdistmin", RLV_BHVR_SETCAM_AVDISTMIN, RlvBehaviourInfo::BHVR_SYNONYM | RlvBehaviourInfo::BHVR_DEPRECATED));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_MODIFIER>("camdistmax", RLV_BHVR_SETCAM_AVDISTMAX, RlvBehaviourInfo::BHVR_SYNONYM | RlvBehaviourInfo::BHVR_DEPRECATED));
|
|
addEntry(new RlvBehaviourGenericProcessor<RLV_OPTION_NONE_OR_MODIFIER>("camtextures", RLV_BHVR_SETCAM_TEXTURES, RlvBehaviourInfo::BHVR_SYNONYM | RlvBehaviourInfo::BHVR_DEPRECATED));
|
|
addEntry(new RlvBehaviourProcessor<RLV_BHVR_CAMZOOMMIN, RlvBehaviourCamZoomMinMaxHandler>("camzoommin", RlvBehaviourInfo::BHVR_DEPRECATED));
|
|
addEntry(new RlvBehaviourProcessor<RLV_BHVR_CAMZOOMMAX, RlvBehaviourCamZoomMinMaxHandler>("camzoommax", RlvBehaviourInfo::BHVR_DEPRECATED));
|
|
addEntry(new RlvBehaviourGenericToggleProcessor<RLV_BHVR_SETCAM_UNLOCK, RLV_OPTION_NONE>("camunlock", RlvBehaviourInfo::BHVR_SYNONYM | RlvBehaviourInfo::BHVR_DEPRECATED));
|
|
|
|
// Overlay
|
|
RlvBehaviourInfo* pSetOverlayBhvr = new RlvBehaviourProcessor<RLV_BHVR_SETOVERLAY>("setoverlay");
|
|
pSetOverlayBhvr->addModifier(ERlvLocalBhvrModifier::OverlayAlpha, typeid(float), "alpha", &RlvOverlayEffect::onAlphaValueChanged);
|
|
pSetOverlayBhvr->addModifier(ERlvLocalBhvrModifier::OverlayTexture, typeid(LLUUID), "texture", &RlvOverlayEffect::onTextureChanged);
|
|
pSetOverlayBhvr->addModifier(ERlvLocalBhvrModifier::OverlayTint, typeid(LLVector3), "tint", &RlvOverlayEffect::onColorValueChanged);
|
|
addEntry(pSetOverlayBhvr);
|
|
addEntry(new RlvBehaviourProcessor<RLV_BHVR_SETOVERLAY_TOUCH>("setoverlay_touch"));
|
|
addEntry(new RlvForceProcessor<RLV_BHVR_SETOVERLAY_TWEEN>("setoverlay_tween"));
|
|
|
|
// Sphere
|
|
RlvBehaviourInfo* pSetSphereBhvr = new RlvBehaviourProcessor<RLV_BHVR_SETSPHERE>("setsphere");
|
|
pSetSphereBhvr->addModifier(ERlvLocalBhvrModifier::SphereMode, typeid(int), "mode", &RlvSphereEffect::onModeChanged);
|
|
pSetSphereBhvr->addModifier(ERlvLocalBhvrModifier::SphereOrigin, typeid(int), "origin", &RlvSphereEffect::onOriginChanged);
|
|
pSetSphereBhvr->addModifier(ERlvLocalBhvrModifier::SphereColor, typeid(LLVector3), "color", &RlvSphereEffect::onColorChanged);
|
|
pSetSphereBhvr->addModifier(ERlvLocalBhvrModifier::SphereDistMin, typeid(float), "distmin", &RlvSphereEffect::onDistMinChanged);
|
|
pSetSphereBhvr->addModifier(ERlvLocalBhvrModifier::SphereDistMax, typeid(float), "distmax", &RlvSphereEffect::onDistMaxChanged);
|
|
pSetSphereBhvr->addModifier(ERlvLocalBhvrModifier::SphereDistExtend, typeid(int), "distextend", &RlvSphereEffect::onDistExtendChanged);
|
|
pSetSphereBhvr->addModifier(ERlvLocalBhvrModifier::SphereParams, typeid(LLVector4), "param", &RlvSphereEffect::onParamsChanged);
|
|
pSetSphereBhvr->addModifier(ERlvLocalBhvrModifier::SphereTween, typeid(float), "tween", &RlvSphereEffect::onTweenDurationChanged);
|
|
pSetSphereBhvr->addModifier(ERlvLocalBhvrModifier::SphereValueMin, typeid(float), "valuemin", &RlvSphereEffect::onValueMinChanged);
|
|
pSetSphereBhvr->addModifier(ERlvLocalBhvrModifier::SphereValueMax, typeid(float), "valuemax", &RlvSphereEffect::onValueMaxChanged);
|
|
addEntry(pSetSphereBhvr);
|
|
|
|
//
|
|
// Force-wear
|
|
//
|
|
addEntry(new RlvBehaviourInfo("attach", RLV_CMD_FORCEWEAR, RLV_TYPE_FORCE, RlvBehaviourInfo::FORCEWEAR_WEAR_REPLACE | RlvBehaviourInfo::FORCEWEAR_NODE | RlvBehaviourInfo::FORCEWEAR_CONTEXT_NONE));
|
|
addEntry(new RlvBehaviourInfo("attachall", RLV_CMD_FORCEWEAR, RLV_TYPE_FORCE, RlvBehaviourInfo::FORCEWEAR_WEAR_REPLACE | RlvBehaviourInfo::FORCEWEAR_SUBTREE | RlvBehaviourInfo::FORCEWEAR_CONTEXT_NONE));
|
|
addEntry(new RlvBehaviourInfo("attachover", RLV_CMD_FORCEWEAR, RLV_TYPE_FORCE, RlvBehaviourInfo::FORCEWEAR_WEAR_ADD | RlvBehaviourInfo::FORCEWEAR_NODE | RlvBehaviourInfo::FORCEWEAR_CONTEXT_NONE));
|
|
addEntry(new RlvBehaviourInfo("attachallover", RLV_CMD_FORCEWEAR, RLV_TYPE_FORCE, RlvBehaviourInfo::FORCEWEAR_WEAR_ADD | RlvBehaviourInfo::FORCEWEAR_SUBTREE | RlvBehaviourInfo::FORCEWEAR_CONTEXT_NONE));
|
|
addEntry(new RlvBehaviourInfo("attachthis", RLV_CMD_FORCEWEAR, RLV_TYPE_FORCE, RlvBehaviourInfo::FORCEWEAR_WEAR_REPLACE | RlvBehaviourInfo::FORCEWEAR_NODE | RlvBehaviourInfo::FORCEWEAR_CONTEXT_OBJECT));
|
|
addEntry(new RlvBehaviourInfo("attachallthis", RLV_CMD_FORCEWEAR, RLV_TYPE_FORCE, RlvBehaviourInfo::FORCEWEAR_WEAR_REPLACE | RlvBehaviourInfo::FORCEWEAR_SUBTREE | RlvBehaviourInfo::FORCEWEAR_CONTEXT_OBJECT));
|
|
addEntry(new RlvBehaviourInfo("attachthisover", RLV_CMD_FORCEWEAR, RLV_TYPE_FORCE, RlvBehaviourInfo::FORCEWEAR_WEAR_ADD | RlvBehaviourInfo::FORCEWEAR_NODE | RlvBehaviourInfo::FORCEWEAR_CONTEXT_OBJECT));
|
|
addEntry(new RlvBehaviourInfo("attachallthisover", RLV_CMD_FORCEWEAR, RLV_TYPE_FORCE, RlvBehaviourInfo::FORCEWEAR_WEAR_ADD | RlvBehaviourInfo::FORCEWEAR_SUBTREE | RlvBehaviourInfo::FORCEWEAR_CONTEXT_OBJECT));
|
|
addEntry(new RlvForceProcessor<RLV_BHVR_DETACH, RlvForceRemAttachHandler>("detach", RlvBehaviourInfo::FORCEWEAR_WEAR_REMOVE | RlvBehaviourInfo::FORCEWEAR_NODE | RlvBehaviourInfo::FORCEWEAR_CONTEXT_NONE));
|
|
addEntry(new RlvBehaviourInfo("detachall", RLV_CMD_FORCEWEAR, RLV_TYPE_FORCE, RlvBehaviourInfo::FORCEWEAR_WEAR_REMOVE | RlvBehaviourInfo::FORCEWEAR_SUBTREE | RlvBehaviourInfo::FORCEWEAR_CONTEXT_NONE));
|
|
addEntry(new RlvBehaviourInfo("detachthis", RLV_CMD_FORCEWEAR, RLV_TYPE_FORCE, RlvBehaviourInfo::FORCEWEAR_WEAR_REMOVE | RlvBehaviourInfo::FORCEWEAR_NODE | RlvBehaviourInfo::FORCEWEAR_CONTEXT_OBJECT));
|
|
addEntry(new RlvBehaviourInfo("detachallthis", RLV_CMD_FORCEWEAR, RLV_TYPE_FORCE, RlvBehaviourInfo::FORCEWEAR_WEAR_REMOVE | RlvBehaviourInfo::FORCEWEAR_SUBTREE | RlvBehaviourInfo::FORCEWEAR_CONTEXT_OBJECT));
|
|
addEntry(new RlvForceProcessor<RLV_BHVR_REMATTACH, RlvForceRemAttachHandler>("remattach", RlvBehaviourInfo::FORCEWEAR_WEAR_REMOVE | RlvBehaviourInfo::FORCEWEAR_NODE | RlvBehaviourInfo::FORCEWEAR_CONTEXT_NONE));
|
|
addEntry(new RlvForceProcessor<RLV_BHVR_REMOUTFIT>("remoutfit", RlvBehaviourInfo::FORCEWEAR_WEAR_REMOVE | RlvBehaviourInfo::FORCEWEAR_NODE | RlvBehaviourInfo::FORCEWEAR_CONTEXT_NONE));
|
|
// Synonyms (addoutfit* -> attach*)
|
|
addEntry(new RlvBehaviourInfo("addoutfit", RLV_CMD_FORCEWEAR, RLV_TYPE_FORCE, RlvBehaviourInfo::FORCEWEAR_WEAR_REPLACE | RlvBehaviourInfo::FORCEWEAR_NODE | RlvBehaviourInfo::FORCEWEAR_CONTEXT_NONE | RlvBehaviourInfo::BHVR_SYNONYM));
|
|
addEntry(new RlvBehaviourInfo("addoutfitall", RLV_CMD_FORCEWEAR, RLV_TYPE_FORCE, RlvBehaviourInfo::FORCEWEAR_WEAR_REPLACE | RlvBehaviourInfo::FORCEWEAR_SUBTREE | RlvBehaviourInfo::FORCEWEAR_CONTEXT_NONE | RlvBehaviourInfo::BHVR_SYNONYM));
|
|
addEntry(new RlvBehaviourInfo("addoutfitover", RLV_CMD_FORCEWEAR, RLV_TYPE_FORCE, RlvBehaviourInfo::FORCEWEAR_WEAR_ADD | RlvBehaviourInfo::FORCEWEAR_NODE | RlvBehaviourInfo::FORCEWEAR_CONTEXT_NONE | RlvBehaviourInfo::BHVR_SYNONYM));
|
|
addEntry(new RlvBehaviourInfo("addoutfitallover", RLV_CMD_FORCEWEAR, RLV_TYPE_FORCE, RlvBehaviourInfo::FORCEWEAR_WEAR_ADD | RlvBehaviourInfo::FORCEWEAR_SUBTREE | RlvBehaviourInfo::FORCEWEAR_CONTEXT_NONE | RlvBehaviourInfo::BHVR_SYNONYM));
|
|
addEntry(new RlvBehaviourInfo("addoutfitthis", RLV_CMD_FORCEWEAR, RLV_TYPE_FORCE, RlvBehaviourInfo::FORCEWEAR_WEAR_REPLACE | RlvBehaviourInfo::FORCEWEAR_NODE | RlvBehaviourInfo::FORCEWEAR_CONTEXT_OBJECT | RlvBehaviourInfo::BHVR_SYNONYM));
|
|
addEntry(new RlvBehaviourInfo("addoutfitallthis", RLV_CMD_FORCEWEAR, RLV_TYPE_FORCE, RlvBehaviourInfo::FORCEWEAR_WEAR_REPLACE | RlvBehaviourInfo::FORCEWEAR_SUBTREE | RlvBehaviourInfo::FORCEWEAR_CONTEXT_OBJECT | RlvBehaviourInfo::BHVR_SYNONYM));
|
|
addEntry(new RlvBehaviourInfo("addoutfitthisover", RLV_CMD_FORCEWEAR, RLV_TYPE_FORCE, RlvBehaviourInfo::FORCEWEAR_WEAR_ADD | RlvBehaviourInfo::FORCEWEAR_NODE | RlvBehaviourInfo::FORCEWEAR_CONTEXT_OBJECT | RlvBehaviourInfo::BHVR_SYNONYM));
|
|
addEntry(new RlvBehaviourInfo("addoutfitallthisover", RLV_CMD_FORCEWEAR, RLV_TYPE_FORCE, RlvBehaviourInfo::FORCEWEAR_WEAR_ADD | RlvBehaviourInfo::FORCEWEAR_SUBTREE | RlvBehaviourInfo::FORCEWEAR_CONTEXT_OBJECT | RlvBehaviourInfo::BHVR_SYNONYM));
|
|
// Synonyms (attach*overorreplace -> attach*)
|
|
addEntry(new RlvBehaviourInfo("attachoverorreplace", RLV_CMD_FORCEWEAR, RLV_TYPE_FORCE, RlvBehaviourInfo::FORCEWEAR_WEAR_REPLACE | RlvBehaviourInfo::FORCEWEAR_NODE | RlvBehaviourInfo::FORCEWEAR_CONTEXT_NONE | RlvBehaviourInfo::BHVR_SYNONYM));
|
|
addEntry(new RlvBehaviourInfo("attachalloverorreplace", RLV_CMD_FORCEWEAR, RLV_TYPE_FORCE, RlvBehaviourInfo::FORCEWEAR_WEAR_REPLACE | RlvBehaviourInfo::FORCEWEAR_SUBTREE | RlvBehaviourInfo::FORCEWEAR_CONTEXT_NONE | RlvBehaviourInfo::BHVR_SYNONYM));
|
|
addEntry(new RlvBehaviourInfo("attachthisoverorreplace",RLV_CMD_FORCEWEAR, RLV_TYPE_FORCE, RlvBehaviourInfo::FORCEWEAR_WEAR_REPLACE | RlvBehaviourInfo::FORCEWEAR_NODE | RlvBehaviourInfo::FORCEWEAR_CONTEXT_OBJECT | RlvBehaviourInfo::BHVR_SYNONYM));
|
|
addEntry(new RlvBehaviourInfo("attachallthisoverorreplace",RLV_CMD_FORCEWEAR,RLV_TYPE_FORCE,RlvBehaviourInfo::FORCEWEAR_WEAR_REPLACE | RlvBehaviourInfo::FORCEWEAR_SUBTREE | RlvBehaviourInfo::FORCEWEAR_CONTEXT_OBJECT | RlvBehaviourInfo::BHVR_SYNONYM));
|
|
|
|
//
|
|
// Force-only
|
|
//
|
|
addEntry(new RlvBehaviourInfo("adjustheight", RLV_BHVR_ADJUSTHEIGHT, RLV_TYPE_FORCE));
|
|
addEntry(new RlvForceProcessor<RLV_BHVR_DETACHME>("detachme"));
|
|
addEntry(new RlvForceProcessor<RLV_BHVR_FLY>("fly"));
|
|
addEntry(new RlvForceProcessor<RLV_BHVR_SETCAM_FOCUS>("setcam_focus", RlvBehaviourInfo::BHVR_EXPERIMENTAL));
|
|
addEntry(new RlvForceProcessor<RLV_BHVR_SETCAM_EYEOFFSET, RlvForceCamEyeFocusOffsetHandler>("setcam_eyeoffset"));
|
|
addEntry(new RlvForceProcessor<RLV_BHVR_SETCAM_EYEOFFSETSCALE, RlvForceCamEyeFocusOffsetHandler>("setcam_eyeoffsetscale"));
|
|
addEntry(new RlvForceProcessor<RLV_BHVR_SETCAM_FOCUSOFFSET, RlvForceCamEyeFocusOffsetHandler>("setcam_focusoffset"));
|
|
addEntry(new RlvForceProcessor<RLV_BHVR_SETCAM_FOV>("setcam_fov", RlvBehaviourInfo::BHVR_EXPERIMENTAL));
|
|
addEntry(new RlvForceProcessor<RLV_BHVR_SETCAM_MODE>("setcam_mode", RlvBehaviourInfo::BHVR_EXPERIMENTAL));
|
|
addEntry(new RlvForceProcessor<RLV_BHVR_SETGROUP>("setgroup"));
|
|
addEntry(new RlvForceProcessor<RLV_BHVR_SIT>("sit"));
|
|
addEntry(new RlvForceProcessor<RLV_BHVR_SITGROUND>("sitground"));
|
|
addEntry(new RlvForceProcessor<RLV_BHVR_TPTO>("tpto"));
|
|
addEntry(new RlvBehaviourInfo("unsit", RLV_BHVR_UNSIT, RLV_TYPE_FORCE));
|
|
|
|
//
|
|
// Reply-only
|
|
//
|
|
addEntry(new RlvBehaviourInfo("findfolder", RLV_BHVR_FINDFOLDER, RLV_TYPE_REPLY));
|
|
addEntry(new RlvBehaviourInfo("findfolders", RLV_BHVR_FINDFOLDERS, RLV_TYPE_REPLY, RlvBehaviourInfo::BHVR_EXTENDED));
|
|
addEntry(new RlvBehaviourInfo("getaddattachnames", RLV_BHVR_GETADDATTACHNAMES, RLV_TYPE_REPLY, RlvBehaviourInfo::BHVR_EXPERIMENTAL));
|
|
addEntry(new RlvBehaviourInfo("getaddoutfitnames", RLV_BHVR_GETADDOUTFITNAMES, RLV_TYPE_REPLY, RlvBehaviourInfo::BHVR_EXPERIMENTAL));
|
|
addEntry(new RlvBehaviourInfo("getattach", RLV_BHVR_GETATTACH, RLV_TYPE_REPLY));
|
|
addEntry(new RlvBehaviourInfo("getattachnames", RLV_BHVR_GETATTACHNAMES, RLV_TYPE_REPLY, RlvBehaviourInfo::BHVR_EXPERIMENTAL));
|
|
addEntry(new RlvReplyProcessor<RLV_BHVR_GETCAM_AVDIST>("getcam_avdist", RlvBehaviourInfo::BHVR_EXPERIMENTAL));
|
|
addEntry(new RlvReplyProcessor<RLV_BHVR_GETCAM_AVDISTMIN, RlvReplyCamMinMaxModifierHandler>("getcam_avdistmin", RlvBehaviourInfo::BHVR_EXPERIMENTAL));
|
|
addEntry(new RlvReplyProcessor<RLV_BHVR_GETCAM_AVDISTMAX, RlvReplyCamMinMaxModifierHandler>("getcam_avdistmax", RlvBehaviourInfo::BHVR_EXPERIMENTAL));
|
|
addEntry(new RlvReplyProcessor<RLV_BHVR_GETCAM_FOV>("getcam_fov", RlvBehaviourInfo::BHVR_EXPERIMENTAL));
|
|
addEntry(new RlvReplyProcessor<RLV_BHVR_GETCAM_FOVMIN, RlvReplyCamMinMaxModifierHandler>("getcam_fovmin", RlvBehaviourInfo::BHVR_EXPERIMENTAL));
|
|
addEntry(new RlvReplyProcessor<RLV_BHVR_GETCAM_FOVMAX, RlvReplyCamMinMaxModifierHandler>("getcam_fovmax", RlvBehaviourInfo::BHVR_EXPERIMENTAL));
|
|
addEntry(new RlvReplyProcessor<RLV_BHVR_GETCAM_TEXTURES>("getcam_textures", RlvBehaviourInfo::BHVR_EXPERIMENTAL));
|
|
addEntry(new RlvReplyProcessor<RLV_BHVR_GETCOMMAND>("getcommand", RlvBehaviourInfo::BHVR_EXTENDED));
|
|
addEntry(new RlvBehaviourInfo("getgroup", RLV_BHVR_GETGROUP, RLV_TYPE_REPLY));
|
|
addEntry(new RlvReplyProcessor<RLV_BHVR_GETHEIGHTOFFSET>("getheightoffset", RlvBehaviourInfo::BHVR_EXTENDED));
|
|
addEntry(new RlvBehaviourInfo("getinv", RLV_BHVR_GETINV, RLV_TYPE_REPLY));
|
|
addEntry(new RlvBehaviourInfo("getinvworn", RLV_BHVR_GETINVWORN, RLV_TYPE_REPLY));
|
|
addEntry(new RlvBehaviourInfo("getoutfit", RLV_BHVR_GETOUTFIT, RLV_TYPE_REPLY));
|
|
addEntry(new RlvBehaviourInfo("getoutfitnames", RLV_BHVR_GETOUTFITNAMES, RLV_TYPE_REPLY, RlvBehaviourInfo::BHVR_EXPERIMENTAL));
|
|
addEntry(new RlvBehaviourInfo("getpath", RLV_BHVR_GETPATH, RLV_TYPE_REPLY));
|
|
addEntry(new RlvBehaviourInfo("getpathnew", RLV_BHVR_GETPATHNEW, RLV_TYPE_REPLY));
|
|
addEntry(new RlvBehaviourInfo("getremattachnames", RLV_BHVR_GETREMATTACHNAMES, RLV_TYPE_REPLY, RlvBehaviourInfo::BHVR_EXPERIMENTAL));
|
|
addEntry(new RlvBehaviourInfo("getremoutfitnames", RLV_BHVR_GETREMOUTFITNAMES, RLV_TYPE_REPLY, RlvBehaviourInfo::BHVR_EXPERIMENTAL));
|
|
addEntry(new RlvBehaviourInfo("getsitid", RLV_BHVR_GETSITID, RLV_TYPE_REPLY));
|
|
addEntry(new RlvBehaviourInfo("getstatus", RLV_BHVR_GETSTATUS, RLV_TYPE_REPLY));
|
|
addEntry(new RlvBehaviourInfo("getstatusall", RLV_BHVR_GETSTATUSALL, RLV_TYPE_REPLY));
|
|
addEntry(new RlvBehaviourInfo("version", RLV_BHVR_VERSION, RLV_TYPE_REPLY));
|
|
addEntry(new RlvBehaviourInfo("versionnew", RLV_BHVR_VERSIONNEW, RLV_TYPE_REPLY));
|
|
addEntry(new RlvBehaviourInfo("versionnum", RLV_BHVR_VERSIONNUM, RLV_TYPE_REPLY));
|
|
|
|
// Populate m_String2InfoMap (the tuple <behaviour, type> should be unique)
|
|
for (const RlvBehaviourInfo* pBhvrInfo : m_BhvrInfoList)
|
|
{
|
|
RLV_VERIFY(m_String2InfoMap.insert(std::make_pair(std::make_pair(pBhvrInfo->getBehaviour(), (ERlvParamType)pBhvrInfo->getParamTypeMask()), pBhvrInfo)).second == true);
|
|
}
|
|
|
|
// Populate m_Bhvr2InfoMap (there can be multiple entries per ERlvBehaviour)
|
|
for (const RlvBehaviourInfo* pBhvrInfo : m_BhvrInfoList)
|
|
{
|
|
if ( (pBhvrInfo->getParamTypeMask() & RLV_TYPE_ADDREM) && (!pBhvrInfo->isSynonym()) )
|
|
{
|
|
#ifdef RLV_DEBUG
|
|
for (const rlv_bhvr2info_map_t::value_type& itBhvr : boost::make_iterator_range(m_Bhvr2InfoMap.lower_bound(pBhvrInfo->getBehaviourType()), m_Bhvr2InfoMap.upper_bound(pBhvrInfo->getBehaviourType())))
|
|
{
|
|
RLV_ASSERT( (itBhvr.first != pBhvrInfo->getBehaviourType()) || (itBhvr.second->getBehaviourFlags() != pBhvrInfo->getBehaviourFlags()) );
|
|
}
|
|
#endif // RLV_DEBUG
|
|
m_Bhvr2InfoMap.insert(std::pair<ERlvBehaviour, const RlvBehaviourInfo*>(pBhvrInfo->getBehaviourType(), pBhvrInfo));
|
|
}
|
|
}
|
|
|
|
// Process blocked commands
|
|
if (RlvSettings::getNoSetEnv())
|
|
toggleBehaviourFlag("setenv", RLV_TYPE_ADDREM, RlvBehaviourInfo::BHVR_BLOCKED, true);
|
|
}
|
|
|
|
RlvBehaviourDictionary::~RlvBehaviourDictionary()
|
|
{
|
|
for (const RlvBehaviourInfo* pBhvrInfo : m_BhvrInfoList)
|
|
delete pBhvrInfo;
|
|
m_BhvrInfoList.clear();
|
|
|
|
for (int idxBhvrMod = 0; idxBhvrMod < RLV_MODIFIER_COUNT; idxBhvrMod++)
|
|
{
|
|
delete m_BehaviourModifiers[idxBhvrMod];
|
|
m_BehaviourModifiers[idxBhvrMod] = nullptr;
|
|
}
|
|
}
|
|
|
|
void RlvBehaviourDictionary::addEntry(const RlvBehaviourInfo* pEntry)
|
|
{
|
|
// Filter experimental commands (if disabled)
|
|
static LLCachedControl<bool> sEnableExperimental(gSavedSettings, "RLVaExperimentalCommands");
|
|
if ( (!pEntry) || ((!sEnableExperimental) && (pEntry->isExperimental())) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Sanity check for duplicate entries
|
|
#ifndef LL_RELEASE_FOR_DOWNLOAD
|
|
std::for_each(m_BhvrInfoList.begin(), m_BhvrInfoList.end(),
|
|
[&pEntry](const RlvBehaviourInfo* pBhvrInfo) {
|
|
RLV_ASSERT_DBG( ((pBhvrInfo->getBehaviour()) != (pEntry->getBehaviour())) || ((pBhvrInfo->getParamTypeMask() & pEntry->getParamTypeMask()) == 0) );
|
|
});
|
|
#endif // LL_RELEASE_FOR_DOWNLOAD
|
|
|
|
m_BhvrInfoList.push_back(pEntry);
|
|
}
|
|
|
|
void RlvBehaviourDictionary::addModifier(ERlvBehaviour eBhvr, ERlvBehaviourModifier eModifier, RlvBehaviourModifier* pModifierEntry)
|
|
{
|
|
if (eModifier < RLV_MODIFIER_COUNT)
|
|
{
|
|
m_BehaviourModifiers[eModifier] = pModifierEntry;
|
|
m_Bhvr2ModifierMap.insert(std::make_pair(eBhvr, eModifier));
|
|
}
|
|
}
|
|
|
|
// Convenience function to add both the behaviour entry as well as the corresponding modifier entry
|
|
void RlvBehaviourDictionary::addModifier(const RlvBehaviourInfo* pBhvrEntry, ERlvBehaviourModifier eModifier, RlvBehaviourModifier* pModifierEntry)
|
|
{
|
|
addEntry(pBhvrEntry);
|
|
addModifier(pBhvrEntry->getBehaviourType(), eModifier, pModifierEntry);
|
|
}
|
|
|
|
// TODO: this shouldn't be in this class - find a better spot for it
|
|
void RlvBehaviourDictionary::clearModifiers(const LLUUID& idRlvObj)
|
|
{
|
|
for (int idxModifier = 0; idxModifier < RLV_MODIFIER_COUNT; idxModifier++)
|
|
{
|
|
if (m_BehaviourModifiers[idxModifier])
|
|
m_BehaviourModifiers[idxModifier]->clearValues(idRlvObj);
|
|
}
|
|
}
|
|
|
|
const RlvBehaviourInfo* RlvBehaviourDictionary::getBehaviourInfo(ERlvBehaviour eBhvr, ERlvParamType eParamType) const
|
|
{
|
|
const RlvBehaviourInfo* pBhvrInfo = nullptr;
|
|
for (auto itBhvrLower = m_Bhvr2InfoMap.lower_bound(eBhvr), itBhvrUpper = m_Bhvr2InfoMap.upper_bound(eBhvr);
|
|
std::find_if(itBhvrLower, itBhvrUpper, [eParamType](const rlv_bhvr2info_map_t::value_type& bhvrEntry) { return bhvrEntry.second->getParamTypeMask() == eParamType; }) != itBhvrUpper;
|
|
++itBhvrLower)
|
|
{
|
|
if (pBhvrInfo)
|
|
return nullptr;
|
|
pBhvrInfo = itBhvrLower->second;
|
|
}
|
|
return pBhvrInfo;
|
|
}
|
|
|
|
const RlvBehaviourInfo* RlvBehaviourDictionary::getBehaviourInfo(const std::string& strBhvr, ERlvParamType eParamType, bool* pfStrict, ERlvLocalBhvrModifier* peBhvrModifier) const
|
|
{
|
|
size_t idxBhvrLastPart = strBhvr.find_last_of('_');
|
|
std::string strBhvrLastPart((std::string::npos != idxBhvrLastPart) && (idxBhvrLastPart < strBhvr.size()) ? strBhvr.substr(idxBhvrLastPart + 1) : LLStringUtil::null);
|
|
|
|
bool fStrict = (strBhvrLastPart.compare("sec") == 0);
|
|
if (pfStrict)
|
|
*pfStrict = fStrict;
|
|
ERlvLocalBhvrModifier eBhvrModifier = ERlvLocalBhvrModifier::Unknown;
|
|
|
|
rlv_string2info_map_t::const_iterator itBhvr = m_String2InfoMap.find(std::make_pair( (!fStrict) ? strBhvr : strBhvr.substr(0, strBhvr.size() - 4), (eParamType & RLV_TYPE_ADDREM) ? RLV_TYPE_ADDREM : eParamType));
|
|
if ( (m_String2InfoMap.end() == itBhvr) && (!fStrict) && (!strBhvrLastPart.empty()) && (RLV_TYPE_FORCE == eParamType) )
|
|
{
|
|
// No match found but it could still be a local scope modifier
|
|
auto itBhvrMod = m_String2InfoMap.find(std::make_pair(strBhvr.substr(0, idxBhvrLastPart), RLV_TYPE_ADDREM));
|
|
if ( (m_String2InfoMap.end() != itBhvrMod) && (eBhvrModifier = itBhvrMod->second->lookupBehaviourModifier(strBhvrLastPart)) != ERlvLocalBhvrModifier::Unknown)
|
|
itBhvr = itBhvrMod;
|
|
}
|
|
|
|
if (peBhvrModifier)
|
|
*peBhvrModifier = eBhvrModifier;
|
|
return ( (itBhvr != m_String2InfoMap.end()) && ((!fStrict) || (itBhvr->second->hasStrict())) ) ? itBhvr->second : nullptr;
|
|
}
|
|
|
|
ERlvBehaviour RlvBehaviourDictionary::getBehaviourFromString(const std::string& strBhvr, ERlvParamType eParamType, bool* pfStrict) const
|
|
{
|
|
ERlvLocalBhvrModifier eBhvrModifier;
|
|
const RlvBehaviourInfo* pBhvrInfo = getBehaviourInfo(strBhvr, eParamType, pfStrict, &eBhvrModifier);
|
|
// Filter out locally scoped modifier commands since they don't actually have a unique behaviour value of their own
|
|
return (pBhvrInfo && ERlvLocalBhvrModifier::Unknown == eBhvrModifier) ? pBhvrInfo->getBehaviourType() : RLV_BHVR_UNKNOWN;
|
|
}
|
|
|
|
bool RlvBehaviourDictionary::getCommands(const std::string& strMatch, ERlvParamType eParamType, std::list<std::string>& cmdList) const
|
|
{
|
|
cmdList.clear();
|
|
for (const RlvBehaviourInfo* pBhvrInfo : m_BhvrInfoList)
|
|
{
|
|
if ( (pBhvrInfo->getParamTypeMask() & eParamType) || (RLV_TYPE_UNKNOWN == eParamType) )
|
|
{
|
|
std::string strCmd = pBhvrInfo->getBehaviour();
|
|
if ( (std::string::npos != strCmd.find(strMatch)) || (strMatch.empty()) )
|
|
cmdList.push_back(strCmd);
|
|
if ( (pBhvrInfo->hasStrict()) && ((std::string::npos != strCmd.append("_sec").find(strMatch)) || (strMatch.empty())) )
|
|
cmdList.push_back(strCmd);
|
|
}
|
|
}
|
|
return !cmdList.empty();
|
|
}
|
|
|
|
bool RlvBehaviourDictionary::getHasStrict(ERlvBehaviour eBhvr) const
|
|
{
|
|
for (const rlv_bhvr2info_map_t::value_type& itBhvr : boost::make_iterator_range(m_Bhvr2InfoMap.lower_bound(eBhvr), m_Bhvr2InfoMap.upper_bound(eBhvr)))
|
|
{
|
|
// Only restrictions can be strict
|
|
if (RLV_TYPE_ADDREM != itBhvr.second->getParamTypeMask())
|
|
continue;
|
|
return itBhvr.second->hasStrict();
|
|
}
|
|
RLV_ASSERT(false);
|
|
return false;
|
|
}
|
|
|
|
RlvBehaviourModifier* RlvBehaviourDictionary::getModifierFromBehaviour(ERlvBehaviour eBhvr) const
|
|
{
|
|
rlv_bhvr2mod_map_t::const_iterator itMod = m_Bhvr2ModifierMap.find(eBhvr);
|
|
ERlvBehaviourModifier eBhvrMod = (m_Bhvr2ModifierMap.end() != itMod) ? itMod->second : RLV_MODIFIER_UNKNOWN;
|
|
return (eBhvrMod < RLV_MODIFIER_UNKNOWN) ? m_BehaviourModifiers[eBhvrMod] : nullptr;
|
|
}
|
|
|
|
void RlvBehaviourDictionary::toggleBehaviourFlag(const std::string& strBhvr, ERlvParamType eParamType, RlvBehaviourInfo::EBehaviourFlags eBhvrFlag, bool fEnable)
|
|
{
|
|
rlv_string2info_map_t::const_iterator itBhvr = m_String2InfoMap.find(std::make_pair(strBhvr, (eParamType & RLV_TYPE_ADDREM) ? RLV_TYPE_ADDREM : eParamType));
|
|
if (m_String2InfoMap.end() != itBhvr)
|
|
{
|
|
const_cast<RlvBehaviourInfo*>(itBhvr->second)->toggleBehaviourFlag(eBhvrFlag, fEnable);
|
|
}
|
|
}
|
|
|
|
// ============================================================================
|
|
// RlvBehaviourInfo
|
|
//
|
|
|
|
// virtual
|
|
ERlvCmdRet RlvBehaviourInfo::processModifier(const RlvCommand& rlvCmd) const
|
|
{
|
|
// The object should have the base behaviour set (or else there's nothing to modify)
|
|
if (!gRlvHandler.hasBehaviour(rlvCmd.getObjectID(), rlvCmd.getBehaviourType()))
|
|
return RLV_RET_FAILED_UNHELDBEHAVIOUR;
|
|
|
|
auto itBhvrModifier = std::find_if(m_BhvrModifiers.begin(), m_BhvrModifiers.end(), [&rlvCmd](const modifier_lookup_t::value_type& entry) { return std::get<0>(entry.second) == rlvCmd.getBehaviourModifier(); });
|
|
if (m_BhvrModifiers.end() == itBhvrModifier)
|
|
return RLV_RET_FAILED_UNKNOWN;
|
|
|
|
ERlvCmdRet eCmdRet; const modifier_handler_func_t& fnHandler = std::get<2>(itBhvrModifier->second);
|
|
if (rlvCmd.hasOption())
|
|
{
|
|
// If there's an option parse it (and perform type checking)
|
|
RlvBehaviourModifierValue modValue;
|
|
if ( (rlvCmd.hasOption()) && (!RlvBehaviourModifier::convertOptionValue(rlvCmd.getOption(), std::get<1>(itBhvrModifier->second), modValue)) )
|
|
return RLV_RET_FAILED_OPTION;
|
|
eCmdRet = (fnHandler) ? fnHandler(rlvCmd.getObjectID(), modValue) : RLV_RET_SUCCESS;
|
|
if (RLV_RET_SUCCESS == eCmdRet)
|
|
gRlvHandler.getObject(rlvCmd.getObjectID())->setModifierValue(rlvCmd.getBehaviourModifier(), modValue);
|
|
}
|
|
else
|
|
{
|
|
eCmdRet = (fnHandler) ? fnHandler(rlvCmd.getObjectID(), boost::none) : RLV_RET_SUCCESS;
|
|
if (RLV_RET_SUCCESS == eCmdRet)
|
|
gRlvHandler.getObject(rlvCmd.getObjectID())->clearModifierValue(rlvCmd.getBehaviourModifier());
|
|
}
|
|
|
|
return eCmdRet;
|
|
}
|
|
|
|
// ============================================================================
|
|
// RlvBehaviourModifier
|
|
//
|
|
|
|
RlvBehaviourModifier::RlvBehaviourModifier(std::string strName, const RlvBehaviourModifierValue& defaultValue, bool fAddDefaultOnEmpty, RlvBehaviourModifierComp* pValueComparator)
|
|
: m_strName(strName), m_DefaultValue(defaultValue), m_fAddDefaultOnEmpty(fAddDefaultOnEmpty), m_pValueComparator(pValueComparator)
|
|
{
|
|
m_pValueComparator = (pValueComparator) ? pValueComparator : new RlvBehaviourModifierComp();
|
|
}
|
|
|
|
RlvBehaviourModifier::~RlvBehaviourModifier()
|
|
{
|
|
if (m_pValueComparator)
|
|
{
|
|
delete m_pValueComparator;
|
|
m_pValueComparator = NULL;
|
|
}
|
|
}
|
|
|
|
bool RlvBehaviourModifier::addValue(const RlvBehaviourModifierValue& modValue, const LLUUID& idRlvObj, ERlvBehaviour eBhvr)
|
|
{
|
|
if (modValue.which() == m_DefaultValue.which())
|
|
{
|
|
m_Values.insert((m_pValueComparator) ? std::lower_bound(m_Values.begin(), m_Values.end(), std::make_tuple(modValue, idRlvObj, eBhvr), boost::bind(&RlvBehaviourModifierComp::operator(), m_pValueComparator, _1, _2)) : m_Values.end(), std::make_tuple(modValue, idRlvObj, eBhvr));
|
|
// NOTE: change signal needs to trigger before modifier handlers so cached values have a chance to update properly
|
|
m_ChangeSignal(getValue());
|
|
onValueChange();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void RlvBehaviourModifier::clearValues(const LLUUID& idRlvObj)
|
|
{
|
|
size_t origCount = m_Values.size();
|
|
m_Values.erase(std::remove_if(m_Values.begin(), m_Values.end(),
|
|
[&idRlvObj](const RlvBehaviourModifierValueTuple& modValue) {
|
|
return (std::get<1>(modValue) == idRlvObj) && (std::get<2>(modValue) == RLV_BHVR_UNKNOWN);
|
|
}), m_Values.end());
|
|
if (origCount != m_Values.size())
|
|
{
|
|
onValueChange();
|
|
m_ChangeSignal(getValue());
|
|
}
|
|
}
|
|
|
|
const LLUUID& RlvBehaviourModifier::getPrimaryObject() const
|
|
{
|
|
return (m_pValueComparator) ? m_pValueComparator->m_idPrimaryObject : LLUUID::null;
|
|
}
|
|
|
|
bool RlvBehaviourModifier::hasValue() const {
|
|
// If no primary object is set this returns "any value set"; otherwise it returns "any value set by the primary object"
|
|
if ( (!m_pValueComparator) || (m_pValueComparator->m_idPrimaryObject.isNull()) )
|
|
return !m_Values.empty();
|
|
return (!m_Values.empty()) ? std::get<1>(m_Values.front()) == m_pValueComparator->m_idPrimaryObject : false;
|
|
}
|
|
|
|
bool RlvBehaviourModifier::hasValue(const LLUUID& idRlvObj) const
|
|
{
|
|
return m_Values.end() != std::find_if(m_Values.begin(), m_Values.end(), [&idRlvObj](const RlvBehaviourModifierValueTuple& cmpValue) { return std::get<1>(cmpValue) == idRlvObj; });
|
|
}
|
|
|
|
void RlvBehaviourModifier::removeValue(const RlvBehaviourModifierValue& modValue, const LLUUID& idRlvObj, ERlvBehaviour eBhvr)
|
|
{
|
|
if ( (modValue.which() == m_DefaultValue.which()) )
|
|
{
|
|
auto itValue = std::find(m_Values.begin(), m_Values.end(), std::make_tuple(modValue, idRlvObj, eBhvr));
|
|
if (m_Values.end() != itValue)
|
|
{
|
|
m_Values.erase(itValue);
|
|
onValueChange();
|
|
m_ChangeSignal(getValue());
|
|
}
|
|
}
|
|
}
|
|
|
|
void RlvBehaviourModifier::setPrimaryObject(const LLUUID& idPrimaryObject)
|
|
{
|
|
if (m_pValueComparator)
|
|
{
|
|
m_pValueComparator->m_idPrimaryObject = idPrimaryObject;
|
|
m_Values.sort(boost::bind(&RlvBehaviourModifierComp::operator(), m_pValueComparator, _1, _2));
|
|
onValueChange();
|
|
m_ChangeSignal(getValue());
|
|
}
|
|
}
|
|
|
|
void RlvBehaviourModifier::setValue(const RlvBehaviourModifierValue& modValue, const LLUUID& idRlvObj)
|
|
{
|
|
if ( (modValue.which() == m_DefaultValue.which()) )
|
|
{
|
|
auto itValue = std::find_if(m_Values.begin(), m_Values.end(),
|
|
[&idRlvObj](const RlvBehaviourModifierValueTuple& cmpValue) {
|
|
return (std::get<1>(cmpValue) == idRlvObj) && (std::get<2>(cmpValue) == RLV_BHVR_UNKNOWN);
|
|
});
|
|
if (m_Values.end() != itValue)
|
|
{
|
|
// The object already has a modifier value set => change it
|
|
std::get<0>(*itValue) = modValue;
|
|
if (m_pValueComparator)
|
|
m_Values.sort(boost::bind(&RlvBehaviourModifierComp::operator(), m_pValueComparator, _1, _2));
|
|
onValueChange();
|
|
m_ChangeSignal(getValue());
|
|
}
|
|
else
|
|
{
|
|
// The command doesn't have a modifier value yet => add it
|
|
addValue(modValue, idRlvObj, RLV_BHVR_UNKNOWN);
|
|
}
|
|
}
|
|
}
|
|
|
|
// static
|
|
bool RlvBehaviourModifier::convertOptionValue(const std::string& optionValue, const std::type_index& modType, RlvBehaviourModifierValue& modValue)
|
|
{
|
|
try
|
|
{
|
|
if (modType == typeid(float))
|
|
{
|
|
modValue = std::stof(optionValue);
|
|
return true;
|
|
}
|
|
else if (modType == typeid(int))
|
|
{
|
|
modValue = std::stoi(optionValue);
|
|
return true;
|
|
}
|
|
else if (modType == typeid(LLVector3))
|
|
{
|
|
LLVector3 vecOption;
|
|
if (3 == sscanf(optionValue.c_str(), "%f/%f/%f", vecOption.mV + 0, vecOption.mV + 1, vecOption.mV + 2))
|
|
{
|
|
modValue = vecOption;
|
|
return true;
|
|
}
|
|
}
|
|
else if (modType == typeid(LLVector4))
|
|
{
|
|
LLVector4 vecOption;
|
|
if (4 == sscanf(optionValue.c_str(), "%f/%f/%f/%f", vecOption.mV + 0, vecOption.mV + 1, vecOption.mV + 2, vecOption.mV + 3))
|
|
{
|
|
modValue = vecOption;
|
|
return true;
|
|
}
|
|
}
|
|
else if (modType == typeid(LLUUID))
|
|
{
|
|
LLUUID idOption;
|
|
if (LLUUID::parseUUID(optionValue, &idOption))
|
|
{
|
|
modValue = idOption;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
catch (const std::invalid_argument&)
|
|
{
|
|
return false;
|
|
}
|
|
catch (const std::out_of_range&)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// ============================================================================
|
|
// RlvCommmand
|
|
//
|
|
|
|
RlvCommand::RlvCommand(const LLUUID& idObj, const std::string& strCommand)
|
|
: m_idObj(idObj)
|
|
{
|
|
if ((m_fValid = parseCommand(strCommand, m_strBehaviour, m_strOption, m_strParam)))
|
|
{
|
|
S32 nTemp = 0;
|
|
if ( ("n" == m_strParam) || ("add" == m_strParam) )
|
|
m_eParamType = RLV_TYPE_ADD;
|
|
else if ( ("y" == m_strParam) || ("rem" == m_strParam) )
|
|
m_eParamType = RLV_TYPE_REMOVE;
|
|
else if (m_strBehaviour == "clear") // clear is the odd one out so just make it its own type
|
|
m_eParamType = RLV_TYPE_CLEAR;
|
|
else if ("force" == m_strParam)
|
|
m_eParamType = RLV_TYPE_FORCE;
|
|
else if (LLStringUtil::convertToS32(m_strParam, nTemp)) // Assume it's a reply command if we can convert <param> to an S32
|
|
m_eParamType = RLV_TYPE_REPLY;
|
|
else
|
|
{
|
|
m_eParamType = RLV_TYPE_UNKNOWN;
|
|
m_fValid = false;
|
|
}
|
|
}
|
|
|
|
if (!m_fValid)
|
|
{
|
|
m_strOption = m_strParam = "";
|
|
return;
|
|
}
|
|
|
|
m_pBhvrInfo = RlvBehaviourDictionary::instance().getBehaviourInfo(m_strBehaviour, m_eParamType, &m_fStrict, &m_eBhvrModifier);
|
|
}
|
|
|
|
RlvCommand::RlvCommand(const RlvCommand& rlvCmd, ERlvParamType eParamType)
|
|
: m_fValid(rlvCmd.m_fValid), m_idObj(rlvCmd.m_idObj), m_strBehaviour(rlvCmd.m_strBehaviour), m_pBhvrInfo(rlvCmd.m_pBhvrInfo)
|
|
, m_eParamType( (RLV_TYPE_UNKNOWN == eParamType) ? rlvCmd.m_eParamType : eParamType), m_eBhvrModifier(rlvCmd.m_eBhvrModifier)
|
|
, m_fStrict(rlvCmd.m_fStrict), m_strOption(rlvCmd.m_strOption), m_strParam(rlvCmd.m_strParam), m_fRefCounted(rlvCmd.m_fRefCounted)
|
|
{
|
|
}
|
|
|
|
bool RlvCommand::parseCommand(const std::string& strCommand, std::string& strBehaviour, std::string& strOption, std::string& strParam)
|
|
{
|
|
// (See behaviour notes for the command parsing truth table)
|
|
|
|
// Format: <behaviour>[:<option>]=<param>
|
|
int idxParam = static_cast<int>(strCommand.find('='));
|
|
int idxOption = (idxParam > 0) ? static_cast<int>(strCommand.find(':')) : -1;
|
|
if (idxOption > idxParam - 1)
|
|
idxOption = -1;
|
|
|
|
// If <behaviour> is missing it's always an improperly formatted command
|
|
if ( (0 == idxOption) || (0 == idxParam) )
|
|
return false;
|
|
|
|
strBehaviour = strCommand.substr(0, (-1 != idxOption) ? idxOption : idxParam);
|
|
strOption = strParam = "";
|
|
|
|
// If <param> is missing it's an improperly formatted command
|
|
if ( (-1 == idxParam) || ((int)strCommand.length() - 1 == idxParam) )
|
|
{
|
|
// Unless "<behaviour> == "clear" AND (idxOption == 0)"
|
|
// OR <behaviour> == "clear" AND (idxParam != 0) [see table above]
|
|
if ( ("clear" == strBehaviour) && ( (!idxOption) || (idxParam) ) )
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
if ( (-1 != idxOption) && (idxOption + 1 != idxParam) )
|
|
strOption = strCommand.substr(idxOption + 1, idxParam - idxOption - 1);
|
|
strParam = strCommand.substr(idxParam + 1);
|
|
|
|
return true;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Command option parsing utility classes
|
|
//
|
|
|
|
template<>
|
|
bool RlvCommandOptionHelper::parseOption<std::string>(const std::string& strOption, std::string& valueOption)
|
|
{
|
|
valueOption = strOption;
|
|
return true;
|
|
}
|
|
|
|
template<>
|
|
bool RlvCommandOptionHelper::parseOption<LLUUID>(const std::string& strOption, LLUUID& idOption)
|
|
{
|
|
return idOption.set(strOption, false);
|
|
}
|
|
|
|
template<>
|
|
bool RlvCommandOptionHelper::parseOption<int>(const std::string& strOption, int& nOption)
|
|
{
|
|
try
|
|
{
|
|
nOption = std::stoi(strOption);
|
|
}
|
|
catch (const std::invalid_argument&)
|
|
{
|
|
return false;
|
|
}
|
|
catch (const std::out_of_range&)
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
template<>
|
|
bool RlvCommandOptionHelper::parseOption<bool>(const std::string& strOption, bool& fOption)
|
|
{
|
|
try
|
|
{
|
|
// Try and parse it as a number first
|
|
int nOption = std::stoi(strOption);
|
|
fOption = (bool)nOption;
|
|
return (nOption == 0) || (nOption == 1);
|
|
}
|
|
catch (const std::invalid_argument&)
|
|
{
|
|
// Then try and parse it as true/false
|
|
std::istringstream ss(strOption);
|
|
ss >> std::boolalpha >> fOption;
|
|
return !ss.fail();
|
|
}
|
|
catch (const std::out_of_range&)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
template<>
|
|
bool RlvCommandOptionHelper::parseOption<float>(const std::string& strOption, float& nOption)
|
|
{
|
|
try
|
|
{
|
|
nOption = std::stof(strOption);
|
|
}
|
|
catch (const std::invalid_argument&)
|
|
{
|
|
return false;
|
|
}
|
|
catch (const std::out_of_range&)
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
template<>
|
|
bool RlvCommandOptionHelper::parseOption<LLWearableType::EType>(const std::string& strOption, LLWearableType::EType& wtOption)
|
|
{
|
|
wtOption = LLWearableType::getInstance()->typeNameToType(strOption);
|
|
return (LLWearableType::WT_INVALID != wtOption) && (LLWearableType::WT_NONE != wtOption);
|
|
}
|
|
|
|
template<>
|
|
bool RlvCommandOptionHelper::parseOption<LLViewerJointAttachment*>(const std::string& strOption, LLViewerJointAttachment*& pAttachPt)
|
|
{
|
|
pAttachPt = RlvAttachPtLookup::getAttachPoint(strOption);
|
|
return pAttachPt != NULL;
|
|
}
|
|
|
|
template<>
|
|
bool RlvCommandOptionHelper::parseOption<ERlvAttachGroupType>(const std::string& strOption, ERlvAttachGroupType& eAttachGroup)
|
|
{
|
|
eAttachGroup = rlvAttachGroupFromString(strOption);
|
|
return eAttachGroup != RLV_ATTACHGROUP_INVALID;
|
|
}
|
|
|
|
template<>
|
|
bool RlvCommandOptionHelper::parseOption<LLViewerInventoryCategory*>(const std::string& strOption, LLViewerInventoryCategory*& pFolder)
|
|
{
|
|
pFolder = RlvInventory::instance().getSharedFolder(strOption);
|
|
return pFolder != NULL;
|
|
}
|
|
|
|
template<>
|
|
bool RlvCommandOptionHelper::parseOption<LLVector2>(const std::string& strOption, LLVector2& vecOption)
|
|
{
|
|
if (!strOption.empty())
|
|
{
|
|
S32 cntToken = sscanf(strOption.c_str(), "%f/%f", vecOption.mV + 0, vecOption.mV + 1);
|
|
return (2 == cntToken);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
template<>
|
|
bool RlvCommandOptionHelper::parseOption<LLVector3>(const std::string& strOption, LLVector3& vecOption)
|
|
{
|
|
if (!strOption.empty())
|
|
{
|
|
S32 cntToken = sscanf(strOption.c_str(), "%f/%f/%f", vecOption.mV + 0, vecOption.mV + 1, vecOption.mV + 2);
|
|
return (3 == cntToken);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
template<>
|
|
bool RlvCommandOptionHelper::parseOption<LLVector3d>(const std::string& strOption, LLVector3d& vecOption)
|
|
{
|
|
if (!strOption.empty())
|
|
{
|
|
S32 cntToken = sscanf(strOption.c_str(), "%lf/%lf/%lf", vecOption.mdV + 0, vecOption.mdV + 1, vecOption.mdV + 2);
|
|
return (3 == cntToken);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
template<>
|
|
bool RlvCommandOptionHelper::parseOption<LLColor3>(const std::string& strOption, LLColor3& clrOption)
|
|
{
|
|
if (!strOption.empty())
|
|
{
|
|
S32 cntToken = sscanf(strOption.c_str(), "%f/%f/%f", clrOption.mV + 0, clrOption.mV + 1, clrOption.mV + 2);
|
|
return (3 == cntToken);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
template<>
|
|
bool RlvCommandOptionHelper::parseOption<RlvCommandOptionGeneric>(const std::string& strOption, RlvCommandOptionGeneric& genericOption)
|
|
{
|
|
LLWearableType::EType wtType(LLWearableType::WT_INVALID); LLUUID idOption; ERlvAttachGroupType eAttachGroup(RLV_ATTACHGROUP_INVALID);
|
|
LLViewerJointAttachment* pAttachPt = NULL; LLViewerInventoryCategory* pFolder = NULL; LLVector3d posOption; float nOption;
|
|
|
|
if (!strOption.empty()) // <option> could be an empty string
|
|
{
|
|
if (RlvCommandOptionHelper::parseOption(strOption, wtType))
|
|
genericOption = wtType; // ... or specify a (valid) clothing layer
|
|
else if (RlvCommandOptionHelper::parseOption(strOption, pAttachPt))
|
|
genericOption = pAttachPt; // ... or specify an attachment point
|
|
else if (RlvCommandOptionHelper::parseOption(strOption, idOption))
|
|
genericOption = idOption; // ... or specify an UUID
|
|
else if (RlvCommandOptionHelper::parseOption(strOption, pFolder))
|
|
genericOption = pFolder; // ... or specify a shared folder path
|
|
else if (RlvCommandOptionHelper::parseOption(strOption, eAttachGroup))
|
|
genericOption = eAttachGroup; // ... or specify an attachment point group
|
|
else if (RlvCommandOptionHelper::parseOption(strOption, posOption))
|
|
genericOption = posOption; // ... or specify a vector (region or global coordinates)
|
|
else if (RlvCommandOptionHelper::parseOption(strOption, nOption))
|
|
genericOption = nOption; // ... or specify a number
|
|
else
|
|
genericOption = strOption; // ... or it might just be a string
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool RlvCommandOptionHelper::parseStringList(const std::string& strOption, std::vector<std::string>& optionList, const std::string& strSeparator)
|
|
{
|
|
if (!strOption.empty())
|
|
boost::split(optionList, strOption, boost::is_any_of(strSeparator));
|
|
return !optionList.empty();
|
|
}
|
|
|
|
// ============================================================================
|
|
// RlvCommandOption structures
|
|
//
|
|
|
|
// Checked: 2012-07-28 (RLVa-1.4.7)
|
|
class RlvCommandOptionGetPathCallback
|
|
{
|
|
public:
|
|
RlvCommandOptionGetPathCallback(const LLUUID& idAttachObj, RlvCommandOptionGetPath::getpath_callback_t cb)
|
|
: mObjectId(idAttachObj), mCallback(cb)
|
|
{
|
|
if (isAgentAvatarValid())
|
|
mAttachmentConnection = gAgentAvatarp->setAttachmentCallback(boost::bind(&RlvCommandOptionGetPathCallback::onAttachment, this, _1, _3));
|
|
gIdleCallbacks.addFunction(&onIdle, this);
|
|
}
|
|
|
|
~RlvCommandOptionGetPathCallback()
|
|
{
|
|
if (mAttachmentConnection.connected())
|
|
mAttachmentConnection.disconnect();
|
|
gIdleCallbacks.deleteFunction(&onIdle, this);
|
|
}
|
|
|
|
void onAttachment(LLViewerObject* pAttachObj, LLVOAvatarSelf::EAttachAction eAction)
|
|
{
|
|
if ( (LLVOAvatarSelf::ACTION_ATTACH == eAction) && (pAttachObj->getID() == mObjectId) )
|
|
{
|
|
uuid_vec_t idItems(1, pAttachObj->getAttachmentItemID());
|
|
mCallback(idItems);
|
|
delete this;
|
|
}
|
|
}
|
|
|
|
static void onIdle(void* pData)
|
|
{
|
|
RlvCommandOptionGetPathCallback* pInstance = reinterpret_cast<RlvCommandOptionGetPathCallback*>(pData);
|
|
if (pInstance->mExpirationTimer.getElapsedTimeF32() > 30.0f)
|
|
delete pInstance;
|
|
}
|
|
|
|
protected:
|
|
LLUUID mObjectId;
|
|
RlvCommandOptionGetPath::getpath_callback_t mCallback;
|
|
boost::signals2::connection mAttachmentConnection;
|
|
LLFrameTimer mExpirationTimer;
|
|
};
|
|
|
|
// Checked: 2010-11-30 (RLVa-1.3.0b) | Modified: RLVa-1.3.0b
|
|
RlvCommandOptionGetPath::RlvCommandOptionGetPath(const RlvCommand& rlvCmd, getpath_callback_t cb)
|
|
: m_fCallback(false)
|
|
{
|
|
m_fValid = true; // Assume the option will be a valid one until we find out otherwise
|
|
|
|
// @getpath[:<option>]=<channel> => <option> is transformed to a list of inventory item UUIDs to get the path of
|
|
RlvCommandOptionGeneric rlvCmdOption;
|
|
RlvCommandOptionHelper::parseOption(rlvCmd.getOption(), rlvCmdOption);
|
|
if (rlvCmdOption.isWearableType()) // <option> can be a clothing layer
|
|
{
|
|
getItemIDs(rlvCmdOption.getWearableType(), m_idItems);
|
|
}
|
|
else if (rlvCmdOption.isAttachmentPoint()) // ... or it can specify an attachment point
|
|
{
|
|
getItemIDs(rlvCmdOption.getAttachmentPoint(), m_idItems);
|
|
}
|
|
else if (rlvCmdOption.isUUID()) // ... or it can specify a specific attachment
|
|
{
|
|
const LLViewerObject* pAttachObj = gObjectList.findObject(rlvCmdOption.getUUID());
|
|
if ( (pAttachObj) && (pAttachObj->isAttachment()) && (pAttachObj->permYouOwner()) )
|
|
m_idItems.push_back(pAttachObj->getAttachmentItemID());
|
|
else
|
|
m_fValid = false;
|
|
}
|
|
else if (rlvCmdOption.isEmpty()) // ... or it can be empty (in which case we act on the object that issued the command)
|
|
{
|
|
const LLViewerObject* pObj = gObjectList.findObject(rlvCmd.getObjectID());
|
|
if (pObj)
|
|
{
|
|
if (pObj->isAttachment())
|
|
m_idItems.push_back(pObj->getAttachmentItemID());
|
|
}
|
|
else if (!cb.empty())
|
|
{
|
|
new RlvCommandOptionGetPathCallback(rlvCmd.getObjectID(), cb);
|
|
m_fCallback = true;
|
|
return;
|
|
}
|
|
}
|
|
else // ... but anything else isn't a valid option
|
|
{
|
|
m_fValid = false;
|
|
return;
|
|
}
|
|
|
|
if (!cb.empty())
|
|
{
|
|
cb(getItemIDs());
|
|
}
|
|
}
|
|
|
|
// Checked: 2013-10-12 (RLVa-1.4.9)
|
|
bool RlvCommandOptionGetPath::getItemIDs(const LLViewerJointAttachment* pAttachPt, uuid_vec_t& idItems)
|
|
{
|
|
uuid_vec_t::size_type cntItemsPrev = idItems.size();
|
|
|
|
LLInventoryModel::cat_array_t folders; LLInventoryModel::item_array_t items;
|
|
RlvFindAttachmentsOnPoint f(pAttachPt);
|
|
gInventory.collectDescendentsIf(LLAppearanceMgr::instance().getCOF(), folders, items, false, f);
|
|
for (LLInventoryModel::item_array_t::const_iterator itItem = items.begin(); itItem != items.end(); ++itItem)
|
|
{
|
|
const LLViewerInventoryItem* pItem = *itItem;
|
|
if (pItem)
|
|
idItems.push_back(pItem->getLinkedUUID());
|
|
}
|
|
|
|
return (cntItemsPrev != idItems.size());
|
|
}
|
|
|
|
// Checked: 2013-10-12 (RLVa-1.4.9)
|
|
bool RlvCommandOptionGetPath::getItemIDs(LLWearableType::EType wtType, uuid_vec_t& idItems)
|
|
{
|
|
uuid_vec_t::size_type cntItemsPrev = idItems.size();
|
|
|
|
LLInventoryModel::cat_array_t folders; LLInventoryModel::item_array_t items;
|
|
LLFindWearablesOfType f(wtType);
|
|
gInventory.collectDescendentsIf(LLAppearanceMgr::instance().getCOF(), folders, items, false, f);
|
|
for (LLInventoryModel::item_array_t::const_iterator itItem = items.begin(); itItem != items.end(); ++itItem)
|
|
{
|
|
const LLViewerInventoryItem* pItem = *itItem;
|
|
if (pItem)
|
|
idItems.push_back(pItem->getLinkedUUID());
|
|
}
|
|
|
|
return (cntItemsPrev != idItems.size());
|
|
}
|
|
|
|
// Checked: 2015-03-30 (RLVa-1.5.0)
|
|
RlvCommandOptionAdjustHeight::RlvCommandOptionAdjustHeight(const RlvCommand& rlvCmd)
|
|
: m_nPelvisToFoot(0.0f), m_nPelvisToFootDeltaMult(0.0f), m_nPelvisToFootOffset(0.0f)
|
|
{
|
|
std::vector<std::string> cmdTokens;
|
|
boost::split(cmdTokens, rlvCmd.getOption(), boost::is_any_of(std::string(";")));
|
|
if (1 == cmdTokens.size())
|
|
{
|
|
m_fValid = (LLStringUtil::convertToF32(cmdTokens[0], m_nPelvisToFootOffset));
|
|
m_nPelvisToFootOffset /= 100;
|
|
}
|
|
else if ( (2 <= cmdTokens.size()) && (cmdTokens.size() <= 3) )
|
|
{
|
|
m_fValid = (LLStringUtil::convertToF32(cmdTokens[0], m_nPelvisToFoot)) &&
|
|
(LLStringUtil::convertToF32(cmdTokens[1], m_nPelvisToFootDeltaMult)) &&
|
|
( (2 == cmdTokens.size()) || (LLStringUtil::convertToF32(cmdTokens[2], m_nPelvisToFootOffset)) );
|
|
}
|
|
}
|
|
|
|
// =========================================================================
|
|
// RlvObject
|
|
//
|
|
|
|
RlvObject::RlvObject(const LLUUID& idObj) : m_idObj(idObj), m_nLookupMisses(0)
|
|
{
|
|
LLViewerObject* pObj = gObjectList.findObject(idObj);
|
|
m_fLookup = (NULL != pObj);
|
|
m_idxAttachPt = (pObj) ? ATTACHMENT_ID_FROM_STATE(pObj->getAttachmentState()) : 0;
|
|
m_idRoot = (pObj) ? pObj->getRootEdit()->getID() : LLUUID::null;
|
|
}
|
|
|
|
const RlvCommand& RlvObject::addCommand(const RlvCommand& rlvCmd, bool& fAdded)
|
|
{
|
|
RLV_ASSERT(RLV_TYPE_ADD == rlvCmd.getParamType());
|
|
|
|
// Don't add duplicate commands for this object (ie @detach=n followed by another @detach=n later on)
|
|
for (rlv_command_list_t::iterator itCmd = m_Commands.begin(); itCmd != m_Commands.end(); ++itCmd)
|
|
{
|
|
if ( (itCmd->getBehaviour() == rlvCmd.getBehaviour()) && (itCmd->getOption() == rlvCmd.getOption()) &&
|
|
(itCmd->isStrict() == rlvCmd.isStrict() ) )
|
|
{
|
|
fAdded = false;
|
|
return *itCmd;
|
|
}
|
|
}
|
|
|
|
// Now that we know it's not a duplicate, add it to the end of the list
|
|
m_Commands.push_back(rlvCmd);
|
|
fAdded = true;
|
|
return m_Commands.back();
|
|
}
|
|
|
|
bool RlvObject::removeCommand(const RlvCommand& rlvCmd)
|
|
{
|
|
RLV_ASSERT(RLV_TYPE_REMOVE == rlvCmd.getParamType());
|
|
|
|
for (rlv_command_list_t::iterator itCmd = m_Commands.begin(); itCmd != m_Commands.end(); ++itCmd)
|
|
{
|
|
//if (*itCmd == rlvCmd) <- commands will never be equal since one is an add and the other is a remove *rolls eyes*
|
|
if ( (itCmd->getBehaviour() == rlvCmd.getBehaviour()) && (itCmd->getOption() == rlvCmd.getOption()) &&
|
|
(itCmd->isStrict() == rlvCmd.isStrict() ) )
|
|
{
|
|
m_Commands.erase(itCmd);
|
|
return true;
|
|
}
|
|
}
|
|
return false; // Command was never added so nothing to remove now
|
|
}
|
|
|
|
bool RlvObject::hasBehaviour(ERlvBehaviour eBehaviour, bool fStrictOnly) const
|
|
{
|
|
for (rlv_command_list_t::const_iterator itCmd = m_Commands.begin(); itCmd != m_Commands.end(); ++itCmd)
|
|
if ( (itCmd->getBehaviourType() == eBehaviour) && (itCmd->getOption().empty()) && ((!fStrictOnly) || (itCmd->isStrict())) )
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
bool RlvObject::hasBehaviour(ERlvBehaviour eBehaviour, const std::string& strOption, bool fStrictOnly) const
|
|
{
|
|
for (const RlvCommand& rlvCmd : m_Commands)
|
|
{
|
|
// The specified behaviour is contained within the current object if:
|
|
// - the (parsed) behaviour matches
|
|
// - the option matches (or we're checking for an empty option and the command was reference counted)
|
|
// - we're not matching on strict (or it is a strict command)
|
|
if ( (rlvCmd.getBehaviourType() == eBehaviour) &&
|
|
( (rlvCmd.getOption() == strOption) || ((strOption.empty()) && (rlvCmd.isRefCounted())) ) &&
|
|
( (!fStrictOnly) ||(rlvCmd.isStrict()) ) )
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Checked: 2009-11-27 (RLVa-1.1.0f) | Modified: RLVa-1.1.0f
|
|
std::string RlvObject::getStatusString(const std::string& strFilter, const std::string& strSeparator) const
|
|
{
|
|
std::string strStatus, strCmd;
|
|
|
|
for (rlv_command_list_t::const_iterator itCmd = m_Commands.begin(); itCmd != m_Commands.end(); ++itCmd)
|
|
{
|
|
strCmd = itCmd->asString();
|
|
if ( (strFilter.empty()) || (std::string::npos != strCmd.find(strFilter)) )
|
|
strStatus.append(strSeparator).append(strCmd);
|
|
}
|
|
|
|
return strStatus;
|
|
}
|
|
|
|
void RlvObject::clearModifiers(ERlvBehaviour eBhvr)
|
|
{
|
|
if (const RlvBehaviourInfo* pBhvrInfo = RlvBehaviourDictionary::instance().getBehaviourInfo(eBhvr, RLV_TYPE_ADDREM))
|
|
{
|
|
for (const auto& modifierEntry : pBhvrInfo->getModifiers())
|
|
{
|
|
clearModifierValue(std::get<0>(modifierEntry.second));
|
|
}
|
|
}
|
|
}
|
|
|
|
void RlvObject::clearModifierValue(ERlvLocalBhvrModifier eBhvrModifier)
|
|
{
|
|
m_Modifiers.erase(eBhvrModifier);
|
|
}
|
|
|
|
void RlvObject::setModifierValue(ERlvLocalBhvrModifier eBhvrModifier, const RlvBehaviourModifierValue& newValue)
|
|
{
|
|
auto itBhvrModifierValue = m_Modifiers.find(eBhvrModifier);
|
|
if (m_Modifiers.end() != itBhvrModifierValue)
|
|
itBhvrModifierValue->second = newValue;
|
|
else
|
|
m_Modifiers.insert(std::make_pair(eBhvrModifier, newValue));
|
|
}
|
|
|
|
// ============================================================================
|
|
// RlvForceWear
|
|
//
|
|
|
|
// Checked: 2010-04-05 (RLVa-1.2.0d) | Modified: RLVa-1.2.0d
|
|
bool RlvForceWear::isWearingItem(const LLInventoryItem* pItem)
|
|
{
|
|
if (pItem)
|
|
{
|
|
switch (pItem->getActualType())
|
|
{
|
|
case LLAssetType::AT_BODYPART:
|
|
case LLAssetType::AT_CLOTHING:
|
|
return gAgentWearables.isWearingItem(pItem->getUUID());
|
|
case LLAssetType::AT_OBJECT:
|
|
return (isAgentAvatarValid()) && (gAgentAvatarp->isWearingAttachment(pItem->getUUID()));
|
|
case LLAssetType::AT_GESTURE:
|
|
return LLGestureMgr::instance().isGestureActive(pItem->getUUID());
|
|
case LLAssetType::AT_LINK:
|
|
return isWearingItem(gInventory.getItem(pItem->getLinkedUUID()));
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Checked: 2010-03-21 (RLVa-1.2.0a) | Modified: RLVa-1.2.0a
|
|
void RlvForceWear::forceFolder(const LLViewerInventoryCategory* pFolder, EWearAction eAction, EWearFlags eFlags)
|
|
{
|
|
// [See LLWearableBridge::wearOnAvatar(): don't wear anything until initial wearables are loaded, can destroy clothing items]
|
|
if (!gAgentWearables.areWearablesLoaded())
|
|
{
|
|
LLNotificationsUtil::add("CanNotChangeAppearanceUntilLoaded");
|
|
return;
|
|
}
|
|
if (!isAgentAvatarValid())
|
|
return;
|
|
|
|
// Grab a list of all the items we'll be wearing/attaching
|
|
LLInventoryModel::cat_array_t folders; LLInventoryModel::item_array_t items;
|
|
RlvWearableItemCollector f(pFolder, eAction, eFlags);
|
|
gInventory.collectDescendentsIf(pFolder->getUUID(), folders, items, false, f, true);
|
|
|
|
// true if we've already encountered this LLWearableType::EType (used only on wear actions and only for AT_CLOTHING)
|
|
bool fSeenWType[LLWearableType::WT_COUNT] = { false };
|
|
|
|
EWearAction eCurAction = eAction;
|
|
for (size_t idxItem = 0, cntItem = items.size(); idxItem < cntItem; idxItem++)
|
|
{
|
|
LLViewerInventoryItem* pRlvItem = items.at(idxItem);
|
|
LLViewerInventoryItem* pItem = (LLAssetType::AT_LINK == pRlvItem->getActualType()) ? pRlvItem->getLinkedItem() : pRlvItem;
|
|
|
|
// If it's wearable it should be worn on detach
|
|
// if ( (ACTION_DETACH == eAction) && (isWearableItem(pItem)) && (!isWearingItem(pItem)) )
|
|
// continue;
|
|
|
|
// Each folder can specify its own EWearAction override
|
|
if (isWearAction(eAction))
|
|
eCurAction = f.getWearAction(pRlvItem->getParentUUID());
|
|
else
|
|
eCurAction = eAction;
|
|
|
|
// NOTES: * if there are composite items then RlvWearableItemCollector made sure they can be worn (or taken off depending)
|
|
// * some scripts issue @remattach=force,attach:worn-items=force so we need to attach items even if they're currently worn
|
|
switch (pItem->getType())
|
|
{
|
|
case LLAssetType::AT_BODYPART:
|
|
RLV_ASSERT(isWearAction(eAction)); // RlvWearableItemCollector shouldn't be supplying us with body parts on detach
|
|
case LLAssetType::AT_CLOTHING:
|
|
if (isWearAction(eAction))
|
|
{
|
|
// The first time we encounter any given clothing type we use 'eCurAction' (replace or add)
|
|
// The second time we encounter a given clothing type we'll always add (rather than replace the previous iteration)
|
|
eCurAction = (!fSeenWType[pItem->getWearableType()]) ? eCurAction : ACTION_WEAR_ADD;
|
|
|
|
ERlvWearMask eWearMask = gRlvWearableLocks.canWear(pRlvItem);
|
|
if ( ((ACTION_WEAR_REPLACE == eCurAction) && (eWearMask & RLV_WEAR_REPLACE)) ||
|
|
((ACTION_WEAR_ADD == eCurAction) && (eWearMask & RLV_WEAR_ADD)) )
|
|
{
|
|
// The check for whether we're replacing a currently worn composite item happens in onWearableArrived()
|
|
if (!isAddWearable(pItem))
|
|
addWearable(pRlvItem, eCurAction);
|
|
fSeenWType[pItem->getWearableType()] = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
const LLViewerWearable* pWearable = gAgentWearables.getWearableFromItemID(pItem->getUUID());
|
|
if ( (pWearable) && (isForceRemovable(pWearable, false)) )
|
|
remWearable(pWearable);
|
|
}
|
|
break;
|
|
|
|
case LLAssetType::AT_OBJECT:
|
|
if (isWearAction(eAction))
|
|
{
|
|
ERlvWearMask eWearMask = gRlvAttachmentLocks.canAttach(pRlvItem);
|
|
if ( ((ACTION_WEAR_REPLACE == eCurAction) && (eWearMask & RLV_WEAR_REPLACE)) ||
|
|
((ACTION_WEAR_ADD == eCurAction) && (eWearMask & RLV_WEAR_ADD)) )
|
|
{
|
|
if (!isAddAttachment(pRlvItem))
|
|
{
|
|
#ifdef RLV_EXPERIMENTAL_COMPOSITEFOLDERS
|
|
// We still need to check whether we're about to replace a currently worn composite item
|
|
// (which we're not if we're just reattaching an attachment we're already wearing)
|
|
LLViewerInventoryCategory* pCompositeFolder = NULL;
|
|
if ( (pAttachPt->getObject()) && (RlvSettings::getEnableComposites()) &&
|
|
(pAttachPt->getItemID() != pItem->getUUID()) &&
|
|
(gRlvHandler.getCompositeInfo(pAttachPt->getItemID(), NULL, &pCompositeFolder)) )
|
|
{
|
|
// If we can't take off the composite folder this item would replace then don't allow it to get attached
|
|
if (gRlvHandler.canTakeOffComposite(pCompositeFolder))
|
|
{
|
|
forceFolder(pCompositeFolder, ACTION_DETACH, FLAG_DEFAULT);
|
|
addAttachment(pRlvItem);
|
|
}
|
|
}
|
|
else
|
|
#endif // RLV_EXPERIMENTAL_COMPOSITEFOLDERS
|
|
{
|
|
addAttachment(pRlvItem, eCurAction);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
const LLViewerObject* pAttachObj = gAgentAvatarp->getWornAttachment(pItem->getUUID());
|
|
if ( (pAttachObj) && (isForceDetachable(pAttachObj, false)) )
|
|
remAttachment(pAttachObj);
|
|
}
|
|
break;
|
|
|
|
case LLAssetType::AT_GESTURE:
|
|
if (isWearAction(eAction))
|
|
{
|
|
if (std::find_if(m_addGestures.begin(), m_addGestures.end(), RlvPredIsEqualOrLinkedItem(pRlvItem)) == m_addGestures.end())
|
|
m_addGestures.push_back(pRlvItem);
|
|
}
|
|
else
|
|
{
|
|
if (std::find_if(m_remGestures.begin(), m_remGestures.end(), RlvPredIsEqualOrLinkedItem(pRlvItem)) == m_remGestures.end())
|
|
m_remGestures.push_back(pRlvItem);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Checked: 2010-03-19 (RLVa-1.2.0a) | Modified: RLVa-1.2.0a
|
|
bool RlvForceWear::isForceDetachable(const LLViewerObject* pAttachObj, bool fCheckComposite /*=true*/, const LLUUID& idExcept /*=LLUUID::null*/)
|
|
{
|
|
// Attachment can be detached by an RLV command if:
|
|
// - it's not "remove locked" by anything (or anything except the object specified by pExceptObj)
|
|
// - it's strippable
|
|
// - composite folders are disabled *or* it isn't part of a composite folder that has at least one item locked
|
|
//<FS:TS> FIRE-4453 bridge detached by the RLV command @remattach=force
|
|
// - it's not the LSL bridge, which should never be affected by RLV
|
|
//</FS:TS> FIRE-4453
|
|
#ifdef RLV_EXPERIMENTAL_COMPOSITEFOLDERS
|
|
LLViewerInventoryCategory* pFolder = NULL;
|
|
#endif // RLV_EXPERIMENTAL_COMPOSITEFOLDERS
|
|
return
|
|
(
|
|
(pAttachObj) && (pAttachObj->isAttachment())
|
|
&& ( (idExcept.isNull()) ? (!gRlvAttachmentLocks.isLockedAttachment(pAttachObj))
|
|
: (!gRlvAttachmentLocks.isLockedAttachmentExcept(pAttachObj, idExcept)) )
|
|
&& (isStrippable(pAttachObj->getAttachmentItemID()))
|
|
//<FS:TS> FIRE-4453 bridge detached by the RLV command @remattach=force
|
|
&& (pAttachObj->getID() != FSLSLBridge::instance().getAttachedID())
|
|
//</FS:TS> FIRE-4453
|
|
#ifdef RLV_EXPERIMENTAL_COMPOSITEFOLDERS
|
|
&& ( (!fCheckComposite) || (!RlvSettings::getEnableComposites()) ||
|
|
(!gRlvHandler.getCompositeInfo(pAttachPt->getItemID(), NULL, &pFolder)) || (gRlvHandler.canTakeOffComposite(pFolder)) )
|
|
#endif // RLV_EXPERIMENTAL_COMPOSITEFOLDERS
|
|
);
|
|
}
|
|
|
|
// Checked: 2010-03-19 (RLVa-1.2.0a) | Added: RLVa-1.2.0a
|
|
bool RlvForceWear::isForceDetachable(const LLViewerJointAttachment* pAttachPt, bool fCheckComposite /*=true*/, const LLUUID& idExcept /*=LLUUID::null*/)
|
|
{
|
|
// Attachment point can be detached by an RLV command if there's at least one attachment that can be removed
|
|
for (LLViewerJointAttachment::attachedobjs_vec_t::const_iterator itAttachObj = pAttachPt->mAttachedObjects.begin();
|
|
itAttachObj != pAttachPt->mAttachedObjects.end(); ++itAttachObj)
|
|
{
|
|
if (isForceDetachable(*itAttachObj, fCheckComposite, idExcept))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Checked: 2010-03-19 (RLVa-1.2.0a) | Added: RLVa-1.1.0i
|
|
void RlvForceWear::forceDetach(const LLViewerObject* pAttachObj)
|
|
{
|
|
// Sanity check - no need to process duplicate removes
|
|
if ( (!pAttachObj) || (isRemAttachment(pAttachObj)) )
|
|
return;
|
|
|
|
if (isForceDetachable(pAttachObj))
|
|
{
|
|
#ifdef RLV_EXPERIMENTAL_COMPOSITEFOLDERS
|
|
LLViewerInventoryCategory* pFolder = NULL;
|
|
if ( (RlvSettings::getEnableComposites()) &&
|
|
(gRlvHandler.getCompositeInfo(pAttachPt->getItemID(), NULL, &pFolder)) )
|
|
{
|
|
// Attachment belongs to a composite folder so detach the entire folder (if we can take it off)
|
|
if (gRlvHandler.canTakeOffComposite(pFolder))
|
|
forceFolder(pFolder, ACTION_DETACH, FLAG_DEFAULT);
|
|
}
|
|
else
|
|
#endif // RLV_EXPERIMENTAL_COMPOSITEFOLDERS
|
|
{
|
|
remAttachment(pAttachObj);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Checked: 2010-03-19 (RLVa-1.2.0a) | Added: RLVa-1.2.0a
|
|
void RlvForceWear::forceDetach(const LLViewerJointAttachment* pAttachPt)
|
|
{
|
|
for (LLViewerJointAttachment::attachedobjs_vec_t::const_iterator itAttachObj = pAttachPt->mAttachedObjects.begin();
|
|
itAttachObj != pAttachPt->mAttachedObjects.end(); ++itAttachObj)
|
|
{
|
|
forceDetach(*itAttachObj);
|
|
}
|
|
}
|
|
|
|
// Checked: 2010-03-19 (RLVa-1.2.0c) | Modified: RLVa-1.2.0a
|
|
bool RlvForceWear::isForceRemovable(const LLViewerWearable* pWearable, bool fCheckComposite /*=true*/, const LLUUID& idExcept /*=LLUUID::null*/)
|
|
{
|
|
// Wearable can be removed by an RLV command if:
|
|
// - its asset type is AT_CLOTHING
|
|
// - it's not "remove locked" by anything (or anything except the object specified by idExcept)
|
|
// - it's strippable
|
|
// - composite folders are disabled *or* it isn't part of a composite folder that has at least one item locked
|
|
#ifdef RLV_EXPERIMENTAL_COMPOSITEFOLDERS
|
|
LLViewerInventoryCategory* pFolder = NULL;
|
|
#endif // RLV_EXPERIMENTAL_COMPOSITEFOLDERS
|
|
return
|
|
(
|
|
(pWearable) && (LLAssetType::AT_CLOTHING == pWearable->getAssetType())
|
|
&& ( (idExcept.isNull()) ? !gRlvWearableLocks.isLockedWearable(pWearable)
|
|
: !gRlvWearableLocks.isLockedWearableExcept(pWearable, idExcept) )
|
|
&& (isStrippable(pWearable->getItemID()))
|
|
#ifdef RLV_EXPERIMENTAL_COMPOSITEFOLDERS
|
|
&& ( (!fCheckComposite) || (!RlvSettings::getEnableComposites()) ||
|
|
(!gRlvHandler.getCompositeInfo(pWearable->getItemID(), NULL, &pFolder)) || (gRlvHandler.canTakeOffComposite(pFolder)) )
|
|
#endif // RLV_EXPERIMENTAL_COMPOSITEFOLDERS
|
|
);
|
|
}
|
|
|
|
// Checked: 2010-03-19 (RLVa-1.2.0a) | Added: RLVa-1.2.0a
|
|
bool RlvForceWear::isForceRemovable(LLWearableType::EType wtType, bool fCheckComposite /*=true*/, const LLUUID& idExcept /*=LLUUID::null*/)
|
|
{
|
|
// Wearable type can be removed by an RLV command if there's at least one currently worn wearable that can be removed
|
|
for (U32 idxWearable = 0, cntWearable = gAgentWearables.getWearableCount(wtType); idxWearable < cntWearable; idxWearable++)
|
|
if (isForceRemovable(gAgentWearables.getViewerWearable(wtType, idxWearable), fCheckComposite, idExcept))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
// Checked: 2010-03-19 (RLVa-1.2.0a) | Modified: RLVa-1.2.0a
|
|
void RlvForceWear::forceRemove(const LLViewerWearable* pWearable)
|
|
{
|
|
// Sanity check - no need to process duplicate removes
|
|
if ( (!pWearable) || (isRemWearable(pWearable)) )
|
|
return;
|
|
|
|
if (isForceRemovable(pWearable))
|
|
{
|
|
#ifdef RLV_EXPERIMENTAL_COMPOSITEFOLDERS
|
|
LLViewerInventoryCategory* pFolder = NULL;
|
|
if ( (RlvSettings::getEnableComposites()) &&
|
|
(gRlvHandler.getCompositeInfo(gAgent.getWearableItem(wtType), NULL, &pFolder)) )
|
|
{
|
|
// Wearable belongs to a composite folder so detach the entire folder (if we can take it off)
|
|
if (gRlvHandler.canTakeOffComposite(pFolder))
|
|
forceFolder(pFolder, ACTION_DETACH, FLAG_DEFAULT);
|
|
}
|
|
else
|
|
#endif // RLV_EXPERIMENTAL_COMPOSITEFOLDERS
|
|
{
|
|
remWearable(pWearable);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Checked: 2010-03-19 (RLVa-1.2.0a) | Added: RLVa-1.2.0a
|
|
void RlvForceWear::forceRemove(LLWearableType::EType wtType)
|
|
{
|
|
for (U32 idxWearable = 0, cntWearable = gAgentWearables.getWearableCount(wtType); idxWearable < cntWearable; idxWearable++)
|
|
forceRemove(gAgentWearables.getViewerWearable(wtType, idxWearable));
|
|
}
|
|
|
|
// Checked: 2010-03-19 (RLVa-1.2.0c) | Modified: RLVa-1.2.0a
|
|
bool RlvForceWear::isStrippable(const LLInventoryItem* pItem)
|
|
{
|
|
// An item is exempt from @detach or @remoutfit if:
|
|
// - its name contains "nostrip" (anywhere in the name)
|
|
// - its parent folder contains "nostrip" (anywhere in the name)
|
|
if (pItem)
|
|
{
|
|
// If the item is an inventory link then we first examine its target before examining the link itself (and never its name)
|
|
if (LLAssetType::AT_LINK == pItem->getActualType())
|
|
{
|
|
if (!isStrippable(pItem->getLinkedUUID()))
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
if (std::string::npos != pItem->getName().find(RLV_FOLDER_FLAG_NOSTRIP))
|
|
return false;
|
|
}
|
|
|
|
LLViewerInventoryCategory* pFolder = gInventory.getCategory(pItem->getParentUUID());
|
|
while (pFolder)
|
|
{
|
|
if (std::string::npos != pFolder->getName().find(RLV_FOLDER_FLAG_NOSTRIP))
|
|
return false;
|
|
// If the item's parent is a folded folder then we need to check its parent as well
|
|
if ( (gInventory.getRootFolderID() != pFolder->getParentUUID()) && (RlvInventory::isFoldedFolder(pFolder, true)) )
|
|
pFolder = gInventory.getCategory(pFolder->getParentUUID());
|
|
else
|
|
pFolder = NULL;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Checked: 2010-08-30 (RLVa-1.2.1c) | Modified: RLVa-1.2.1c
|
|
void RlvForceWear::addAttachment(const LLViewerInventoryItem* pItem, EWearAction eAction)
|
|
{
|
|
// Remove it from 'm_remAttachments' if it's queued for detaching
|
|
const LLViewerObject* pAttachObj = (isAgentAvatarValid()) ? gAgentAvatarp->getWornAttachment(pItem->getLinkedUUID()) : NULL;
|
|
if ( (pAttachObj) && (isRemAttachment(pAttachObj)) )
|
|
m_remAttachments.erase(std::remove(m_remAttachments.begin(), m_remAttachments.end(), pAttachObj), m_remAttachments.end());
|
|
|
|
S32 idxAttachPt = RlvAttachPtLookup::getAttachPointIndex(pItem, true);
|
|
if (ACTION_WEAR_ADD == eAction)
|
|
{
|
|
// Insert it at the back if it's not already there
|
|
idxAttachPt |= ATTACHMENT_ADD;
|
|
if (!isAddAttachment(pItem))
|
|
{
|
|
addattachments_map_t::iterator itAddAttachments = m_addAttachments.find(idxAttachPt);
|
|
if (itAddAttachments == m_addAttachments.end())
|
|
{
|
|
m_addAttachments.insert(addattachment_pair_t(idxAttachPt, LLInventoryModel::item_array_t()));
|
|
itAddAttachments = m_addAttachments.find(idxAttachPt);
|
|
}
|
|
itAddAttachments->second.push_back((LLViewerInventoryItem*)pItem);
|
|
}
|
|
}
|
|
else if (ACTION_WEAR_REPLACE == eAction)
|
|
{
|
|
// Replace all pending attachments on this attachment point with the specified item (don't clear if it's the default attach point)
|
|
addattachments_map_t::iterator itAddAttachments = m_addAttachments.find(idxAttachPt | ATTACHMENT_ADD);
|
|
if ( (0 != idxAttachPt) && (itAddAttachments != m_addAttachments.end()) )
|
|
itAddAttachments->second.clear();
|
|
|
|
itAddAttachments = m_addAttachments.find(idxAttachPt);
|
|
if (itAddAttachments == m_addAttachments.end())
|
|
{
|
|
m_addAttachments.insert(addattachment_pair_t(idxAttachPt, LLInventoryModel::item_array_t()));
|
|
itAddAttachments = m_addAttachments.find(idxAttachPt);
|
|
}
|
|
|
|
if (0 != idxAttachPt)
|
|
itAddAttachments->second.clear();
|
|
itAddAttachments->second.push_back((LLViewerInventoryItem*)pItem);
|
|
}
|
|
}
|
|
|
|
// Checked: 2010-08-30 (RLVa-1.2.1c) | Modified: RLVa-1.2.1c
|
|
void RlvForceWear::remAttachment(const LLViewerObject* pAttachObj)
|
|
{
|
|
// Remove it from 'm_addAttachments' if it's queued for attaching
|
|
const LLViewerInventoryItem* pItem = (pAttachObj->isAttachment()) ? gInventory.getItem(pAttachObj->getAttachmentItemID()) : NULL;
|
|
if (pItem)
|
|
{
|
|
addattachments_map_t::iterator itAddAttachments = m_addAttachments.begin();
|
|
while (itAddAttachments != m_addAttachments.end())
|
|
{
|
|
LLInventoryModel::item_array_t& wearItems = itAddAttachments->second;
|
|
if (std::find_if(wearItems.begin(), wearItems.end(), RlvPredIsEqualOrLinkedItem(pItem)) != wearItems.end())
|
|
wearItems.erase(std::remove_if(wearItems.begin(), wearItems.end(), RlvPredIsEqualOrLinkedItem(pItem)), wearItems.end());
|
|
|
|
if (wearItems.empty())
|
|
m_addAttachments.erase(itAddAttachments++);
|
|
else
|
|
++itAddAttachments;
|
|
}
|
|
}
|
|
|
|
// Add it to 'm_remAttachments' if it's not already there
|
|
if (!isRemAttachment(pAttachObj))
|
|
{
|
|
m_remAttachments.push_back(const_cast<LLViewerObject*>(pAttachObj));
|
|
}
|
|
}
|
|
|
|
// Checked: 2010-08-30 (RLVa-1.2.1c) | Modified: RLVa-1.2.1c
|
|
void RlvForceWear::addWearable(const LLViewerInventoryItem* pItem, EWearAction eAction)
|
|
{
|
|
const LLViewerWearable* pWearable = gAgentWearables.getWearableFromItemID(pItem->getLinkedUUID());
|
|
// When replacing remove all currently worn wearables of this type *unless* the item is currently worn
|
|
if ( (ACTION_WEAR_REPLACE == eAction) && (!pWearable) )
|
|
forceRemove(pItem->getWearableType());
|
|
// Remove it from 'm_remWearables' if it's pending removal
|
|
if ( (pWearable) && (isRemWearable(pWearable)) )
|
|
m_remWearables.erase(std::remove(m_remWearables.begin(), m_remWearables.end(), pWearable), m_remWearables.end());
|
|
|
|
addwearables_map_t::iterator itAddWearables = m_addWearables.find(pItem->getWearableType());
|
|
if (itAddWearables == m_addWearables.end())
|
|
{
|
|
m_addWearables.insert(addwearable_pair_t(pItem->getWearableType(), LLInventoryModel::item_array_t()));
|
|
itAddWearables = m_addWearables.find(pItem->getWearableType());
|
|
}
|
|
|
|
if (ACTION_WEAR_ADD == eAction) // Add it at the back if it's not already there
|
|
{
|
|
if (!isAddWearable(pItem))
|
|
itAddWearables->second.push_back((LLViewerInventoryItem*)pItem);
|
|
}
|
|
else if (ACTION_WEAR_REPLACE == eAction) // Replace all pending wearables of this type with the specified item
|
|
{
|
|
itAddWearables->second.clear();
|
|
itAddWearables->second.push_back((LLViewerInventoryItem*)pItem);
|
|
}
|
|
}
|
|
|
|
// Checked: 2010-08-30 (RLVa-1.2.1c) | Modified: RLVa-1.2.1c
|
|
void RlvForceWear::remWearable(const LLViewerWearable* pWearable)
|
|
{
|
|
// Remove it from 'm_addWearables' if it's queued for wearing
|
|
const LLViewerInventoryItem* pItem = gInventory.getItem(pWearable->getItemID());
|
|
if ( (pItem) && (isAddWearable(pItem)) )
|
|
{
|
|
addwearables_map_t::iterator itAddWearables = m_addWearables.find(pItem->getWearableType());
|
|
|
|
LLInventoryModel::item_array_t& wearItems = itAddWearables->second;
|
|
wearItems.erase(std::remove_if(wearItems.begin(), wearItems.end(), RlvPredIsEqualOrLinkedItem(pItem)), wearItems.end());
|
|
if (wearItems.empty())
|
|
m_addWearables.erase(itAddWearables);
|
|
}
|
|
|
|
// Add it to 'm_remWearables' if it's not already there
|
|
if (!isRemWearable(pWearable))
|
|
m_remWearables.push_back(pWearable);
|
|
}
|
|
|
|
// Checked: 2015-05-05 (RLVa-1.4.12)
|
|
void RlvForceWear::updatePendingAttachments()
|
|
{
|
|
if (RlvForceWear::instanceExists())
|
|
{
|
|
RlvForceWear* pThis = RlvForceWear::getInstance();
|
|
for (const pendingattachments_map_t::value_type& itAttach : pThis->m_pendingAttachments)
|
|
LLAttachmentsMgr::instance().addAttachmentRequest(itAttach.first, itAttach.second & ~ATTACHMENT_ADD, itAttach.second & ATTACHMENT_ADD);
|
|
pThis->m_pendingAttachments.clear();
|
|
}
|
|
}
|
|
|
|
// Checked: 2015-05-05 (RLVa-1.4.12)
|
|
void RlvForceWear::addPendingAttachment(const LLUUID& idItem, U8 idxPoint)
|
|
{
|
|
auto itAttach = m_pendingAttachments.find(idItem);
|
|
if (m_pendingAttachments.end() == itAttach)
|
|
m_pendingAttachments.insert(std::make_pair(idItem, idxPoint));
|
|
else
|
|
itAttach->second = idxPoint;
|
|
}
|
|
|
|
// Checked: 2015-05-05 (RLVa-1.4.12)
|
|
void RlvForceWear::remPendingAttachment(const LLUUID& idItem)
|
|
{
|
|
m_pendingAttachments.erase(idItem);
|
|
}
|
|
|
|
// Checked: 2015-05-05 (RLVa-1.4.12)
|
|
void RlvForceWear::done()
|
|
{
|
|
// Sanity check - don't go through all the motions below only to find out there's nothing to actually do
|
|
if ( (m_remWearables.empty()) && (m_remAttachments.empty()) && (m_remGestures.empty()) &&
|
|
(m_addWearables.empty()) && (m_addAttachments.empty()) && (m_addGestures.empty()) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Process removals
|
|
//
|
|
|
|
uuid_vec_t remItems;
|
|
|
|
// Wearables
|
|
if (m_remWearables.size())
|
|
{
|
|
for (const LLViewerWearable* pWearable : m_remWearables)
|
|
remItems.push_back(pWearable->getItemID());
|
|
m_remWearables.clear();
|
|
}
|
|
|
|
// Gestures
|
|
if (m_remGestures.size())
|
|
{
|
|
// NOTE: LLGestureMgr::deactivateGesture() will call LLAppearanceMgr::removeCOFItemLinks() for us and supply its own callback
|
|
for (const LLViewerInventoryItem* pItem : m_remGestures)
|
|
LLGestureMgr::instance().deactivateGesture(pItem->getUUID());
|
|
m_remGestures.clear();
|
|
}
|
|
|
|
// Attachments
|
|
if (m_remAttachments.size())
|
|
{
|
|
LLAgentWearables::userRemoveMultipleAttachments(m_remAttachments);
|
|
for (const LLViewerObject* pAttachObj : m_remAttachments)
|
|
remItems.push_back(pAttachObj->getAttachmentItemID());
|
|
m_remAttachments.clear();
|
|
}
|
|
|
|
//
|
|
// Process additions
|
|
//
|
|
|
|
// Wearables need to be split into AT_BODYPART and AT_CLOTHING for COF
|
|
LLInventoryModel::item_array_t addBodyParts, addClothing;
|
|
for (addwearables_map_t::const_iterator itAddWearables = m_addWearables.cbegin(); itAddWearables != m_addWearables.cend(); ++itAddWearables)
|
|
{
|
|
// NOTE: LLAppearanceMgr will filter our duplicates so no need for us to check here
|
|
for (LLViewerInventoryItem* pItem : itAddWearables->second)
|
|
{
|
|
if (LLAssetType::AT_BODYPART == pItem->getType())
|
|
addBodyParts.push_back(pItem);
|
|
else
|
|
addClothing.push_back(pItem);
|
|
}
|
|
}
|
|
m_addWearables.clear();
|
|
|
|
// Until LL provides a way for updateCOF to selectively attach add/replace we have to deal with attachments ourselves
|
|
for (addattachments_map_t::const_iterator itAddAttachments = m_addAttachments.cbegin(); itAddAttachments != m_addAttachments.cend(); ++itAddAttachments)
|
|
{
|
|
for (const LLViewerInventoryItem* pItem : itAddAttachments->second)
|
|
addPendingAttachment(pItem->getLinkedUUID(), itAddAttachments->first);
|
|
}
|
|
m_addAttachments.clear();
|
|
|
|
//
|
|
// Tie it all together
|
|
//
|
|
|
|
// | Wearables | Attachments | Gestures |
|
|
// |======================================================|
|
|
// Add : | LLAppearanceMgr | <custom> | LLAppearanceMgr |
|
|
// Remove : | LLAppearanceMgr | LLAppearanceMgr | LLGestureMgr |
|
|
LLPointer<LLInventoryCallback> cb = new LLUpdateAppearanceOnDestroy(false, false, boost::bind(RlvForceWear::updatePendingAttachments));
|
|
|
|
if (!remItems.empty())
|
|
{
|
|
LLAppearanceMgr::instance().removeItemsFromAvatar(remItems, no_op, cb, true);
|
|
}
|
|
|
|
if ( (addBodyParts.empty()) && (!addClothing.empty()) && (m_addGestures.empty()) )
|
|
{
|
|
// Clothing items only
|
|
uuid_vec_t idClothing;
|
|
for (const LLViewerInventoryItem* pItem : addClothing)
|
|
idClothing.push_back(pItem->getUUID());
|
|
LLAppearanceMgr::instance().wearItemsOnAvatar(idClothing, false, false, cb);
|
|
}
|
|
else if ( (!addBodyParts.empty()) || (!addClothing.empty()) || (!m_addGestures.empty()) )
|
|
{
|
|
// Mixture of body parts, clothing and/or gestures
|
|
LLInventoryModel::item_array_t addAttachments;
|
|
LLAppearanceMgr::instance().updateCOF(addBodyParts, addClothing, addAttachments, m_addGestures, true, LLUUID::null, cb);
|
|
|
|
m_addGestures.clear();
|
|
}
|
|
|
|
// Make sure there are no leftovers for the next cycle
|
|
RLV_ASSERT( (m_remWearables.empty()) && (m_remAttachments.empty()) && (m_remGestures.empty()) );
|
|
RLV_ASSERT( (m_addWearables.empty()) && (m_addAttachments.empty()) && (m_addGestures.empty()) );
|
|
}
|
|
|
|
// Checked: 2010-02-17 (RLVa-1.1.0o) | Modified: RLVa-1.1.0o
|
|
/*
|
|
void RlvForceWear::onWearableArrived(LLWearable* pWearable, void* pParam)
|
|
{
|
|
#ifdef RLV_EXPERIMENTAL_COMPOSITEFOLDERS
|
|
// If this wearable will end up replacing a currently worn one that belongs to a composite folder then we need to detach the composite
|
|
LLViewerInventoryCategory* pFolder = NULL;
|
|
if ( (RlvSettings::getEnableComposites()) && (pWearable) && (gAgent.getWearable(pWearable->getType())) )
|
|
{
|
|
// If we're just rewearing the same item we're already wearing then we're not replacing a composite folder
|
|
LLWearableHoldingPattern* pWearData = (LLWearableHoldingPattern*)pParam; LLUUID idItem;
|
|
for (LLWearableHoldingPattern::found_list_t::const_iterator itWearable = pWearData->mFoundList.begin();
|
|
itWearable != pWearData->mFoundList.end(); ++itWearable)
|
|
{
|
|
LLFoundData* pFound = *itWearable;
|
|
if (pWearable->getID() == pFound->mAssetID)
|
|
{
|
|
idItem = pFound->mItemID;
|
|
break;
|
|
}
|
|
}
|
|
if ( (idItem.notNull()) && (idItem != gAgent.getWearableItem(pWearable->getType())) &&
|
|
(gRlvHandler.getCompositeInfo(gAgent.getWearableItem(pWearable->getType()), NULL, &pFolder)) )
|
|
{
|
|
RlvForceWear rlvWear;
|
|
rlvWear.forceFolder(pFolder, ACTION_DETACH, FLAG_DEFAULT);
|
|
rlvWear.done();
|
|
}
|
|
}
|
|
#endif // RLV_EXPERIMENTAL_COMPOSITEFOLDERS
|
|
|
|
wear_inventory_category_on_avatar_loop(pWearable, pParam);
|
|
}
|
|
*/
|
|
|
|
// ============================================================================
|
|
// RlvBehaviourNotifyObserver
|
|
//
|
|
|
|
// Checked: 2010-03-03 (RLVa-1.2.0a) | Added: RLVa-1.2.0a
|
|
RlvBehaviourNotifyHandler::RlvBehaviourNotifyHandler()
|
|
{
|
|
// NOTE: the reason we use rlv_command_signal_t instead of the better-suited rlv_behaviour_signal_t is because
|
|
// RLV will notify scripts about "invalid" commands so we need to as well
|
|
m_ConnCommand = gRlvHandler.setCommandCallback(boost::bind(&RlvBehaviourNotifyHandler::onCommand, this, _1, _2, _3));
|
|
}
|
|
|
|
// Checked: 2010-03-03 (RLVa-1.2.0a) | Modified: RLVa-1.2.0a
|
|
void RlvBehaviourNotifyHandler::onCommand(const RlvCommand& rlvCmd, ERlvCmdRet eRet, bool fInternal)
|
|
{
|
|
if (fInternal)
|
|
return;
|
|
|
|
switch (rlvCmd.getParamType())
|
|
{
|
|
case RLV_TYPE_ADD:
|
|
case RLV_TYPE_REMOVE:
|
|
sendNotification(rlvCmd.asString(), "=" + rlvCmd.getParam());
|
|
break;
|
|
case RLV_TYPE_CLEAR:
|
|
sendNotification(rlvCmd.asString());
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Checked: 2011-03-31 (RLVa-1.3.0f) | Modify: RLVa-1.3.0f
|
|
void RlvBehaviourNotifyHandler::sendNotification(const std::string& strText, const std::string& strSuffix)
|
|
{
|
|
if (instanceExists())
|
|
{
|
|
RlvBehaviourNotifyHandler* pThis = getInstance();
|
|
|
|
// NOTE: notifications have two parts (which are concatenated without token) where only the first part is subject to the filter
|
|
for (std::multimap<LLUUID, notifyData>::const_iterator itNotify = pThis->m_Notifications.begin();
|
|
itNotify != pThis->m_Notifications.end(); ++itNotify)
|
|
{
|
|
if ( (itNotify->second.strFilter.empty()) || (boost::icontains(strText, itNotify->second.strFilter)) )
|
|
RlvUtil::sendChatReply(itNotify->second.nChannel, "/" + strText + strSuffix);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Checked: 2011-03-31 (RLVa-1.3.0f) | Added: RLVa-1.3.0f
|
|
void RlvBehaviourNotifyHandler::onWear(LLWearableType::EType eType, bool fAllowed)
|
|
{
|
|
sendNotification(llformat("worn %s %s", (fAllowed) ? "legally" : "illegally", LLWearableType::getInstance()->getTypeName(eType).c_str()));
|
|
}
|
|
|
|
// Checked: 2011-03-31 (RLVa-1.3.0f) | Added: RLVa-1.3.0f
|
|
void RlvBehaviourNotifyHandler::onTakeOff(LLWearableType::EType eType, bool fAllowed)
|
|
{
|
|
sendNotification(llformat("unworn %s %s", (fAllowed) ? "legally" : "illegally", LLWearableType::getInstance()->getTypeName(eType).c_str()));
|
|
}
|
|
|
|
// Checked: 2011-03-31 (RLVa-1.3.0f) | Added: RLVa-1.3.0f
|
|
void RlvBehaviourNotifyHandler::onAttach(const LLViewerJointAttachment* pAttachPt, bool fAllowed)
|
|
{
|
|
sendNotification(llformat("attached %s %s", (fAllowed) ? "legally" : "illegally", pAttachPt->getName().c_str()));
|
|
}
|
|
|
|
// Checked: 2011-03-31 (RLVa-1.3.0f) | Added: RLVa-1.3.0f
|
|
void RlvBehaviourNotifyHandler::onDetach(const LLViewerJointAttachment* pAttachPt, bool fAllowed)
|
|
{
|
|
sendNotification(llformat("detached %s %s", (fAllowed) ? "legally" : "illegally", pAttachPt->getName().c_str()));
|
|
}
|
|
|
|
// Checked: 2011-03-31 (RLVa-1.3.0f) | Added: RLVa-1.3.0f
|
|
void RlvBehaviourNotifyHandler::onReattach(const LLViewerJointAttachment* pAttachPt, bool fAllowed)
|
|
{
|
|
sendNotification(llformat("reattached %s %s", (fAllowed) ? "legally" : "illegally", pAttachPt->getName().c_str()));
|
|
}
|
|
|
|
void RlvBehaviourNotifyHandler::onSit(const LLUUID& idObj, bool fAllowed)
|
|
{
|
|
if (idObj.isNull())
|
|
sendNotification(llformat("sat ground %s", (fAllowed) ? "legally" : "illegally"));
|
|
else
|
|
sendNotification(llformat("sat object %s %s", (fAllowed) ? "legally" : "illegally", idObj.asString().c_str()));
|
|
}
|
|
|
|
void RlvBehaviourNotifyHandler::onStand(const LLUUID& idObj, bool fAllowed)
|
|
{
|
|
if (idObj.isNull())
|
|
sendNotification(llformat("unsat ground %s", (fAllowed) ? "legally" : "illegally"));
|
|
else
|
|
sendNotification(llformat("unsat object %s %s", (fAllowed) ? "legally" : "illegally", idObj.asString().c_str()));
|
|
}
|
|
|
|
// =========================================================================
|
|
// Various helper classes/timers/functors
|
|
//
|
|
|
|
// Checked: 2010-03-13 (RLVa-1.2.0a) | Modified: RLVa-1.2.0a
|
|
bool RlvGCTimer::tick()
|
|
{
|
|
bool fContinue = gRlvHandler.onGC();
|
|
if (!fContinue)
|
|
gRlvHandler.m_pGCTimer = NULL;
|
|
return !fContinue;
|
|
}
|
|
|
|
// ============================================================================
|
|
// Various helper functions
|
|
//
|
|
|
|
// ============================================================================
|
|
// Attachment group helper functions
|
|
//
|
|
|
|
// Has to match the order of ERlvAttachGroupType
|
|
const std::string cstrAttachGroups[RLV_ATTACHGROUP_COUNT] = { "head", "torso", "arms", "legs", "hud" };
|
|
|
|
// Checked: 2009-10-19 (RLVa-1.1.0e) | Added: RLVa-1.1.0e
|
|
ERlvAttachGroupType rlvAttachGroupFromIndex(S32 idxGroup)
|
|
{
|
|
switch (idxGroup)
|
|
{
|
|
case 0: // Right Hand
|
|
case 1: // Right Arm
|
|
case 3: // Left Arm
|
|
case 4: // Left Hand
|
|
return RLV_ATTACHGROUP_ARMS;
|
|
case 2: // Head
|
|
return RLV_ATTACHGROUP_HEAD;
|
|
case 5: // Left Leg
|
|
case 7: // Right Leg
|
|
return RLV_ATTACHGROUP_LEGS;
|
|
case 6: // Torso
|
|
return RLV_ATTACHGROUP_TORSO;
|
|
case 8: // HUD
|
|
return RLV_ATTACHGROUP_HUD;
|
|
default:
|
|
return RLV_ATTACHGROUP_INVALID;
|
|
}
|
|
}
|
|
|
|
// Checked: 2009-10-19 (RLVa-1.1.0e) | Added: RLVa-1.1.0e
|
|
ERlvAttachGroupType rlvAttachGroupFromString(const std::string& strGroup)
|
|
{
|
|
for (int idx = 0; idx < RLV_ATTACHGROUP_COUNT; idx++)
|
|
if (cstrAttachGroups[idx] == strGroup)
|
|
return (ERlvAttachGroupType)idx;
|
|
return RLV_ATTACHGROUP_INVALID;
|
|
}
|
|
|
|
// =========================================================================
|
|
// String helper functions
|
|
//
|
|
|
|
// Checked: 2009-07-29 (RLVa-1.0.1b) | Added: RLVa-1.0.1b
|
|
std::string rlvGetFirstParenthesisedText(const std::string& strText, std::string::size_type* pidxMatch /*=NULL*/)
|
|
{
|
|
if (pidxMatch)
|
|
*pidxMatch = std::string::npos; // Assume we won't find anything
|
|
|
|
std::string::size_type idxIt, idxStart; int cntLevel = 1;
|
|
if ((idxStart = strText.find_first_of('(')) == std::string::npos)
|
|
return std::string();
|
|
|
|
const char* pstrText = strText.c_str(); idxIt = idxStart;
|
|
while ( (cntLevel > 0) && (++idxIt < strText.length()) )
|
|
{
|
|
if ('(' == pstrText[idxIt])
|
|
cntLevel++;
|
|
else if (')' == pstrText[idxIt])
|
|
cntLevel--;
|
|
}
|
|
|
|
if (idxIt < strText.length())
|
|
{
|
|
if (pidxMatch)
|
|
*pidxMatch = idxStart; // Return the character index of the starting '('
|
|
return strText.substr(idxStart + 1, idxIt - idxStart - 1);
|
|
}
|
|
return std::string();
|
|
}
|
|
|
|
// Checked: 2009-07-29 (RLVa-1.0.1b) | Added: RLVa-1.0.1b
|
|
std::string rlvGetLastParenthesisedText(const std::string& strText, std::string::size_type* pidxStart /*=NULL*/)
|
|
{
|
|
if (pidxStart)
|
|
*pidxStart = std::string::npos; // Assume we won't find anything
|
|
|
|
// Extracts the last - matched - parenthesised text from the input string
|
|
size_t idxIt; std::string::size_type idxEnd; int cntLevel = 1;
|
|
if ((idxEnd = strText.find_last_of(')')) == std::string::npos)
|
|
return std::string();
|
|
|
|
const char* pstrText = strText.c_str(); idxIt = idxEnd;
|
|
while ( (cntLevel > 0) && (--idxIt >= 0) && (idxIt < strText.length()) )
|
|
{
|
|
if (')' == pstrText[idxIt])
|
|
cntLevel++;
|
|
else if ('(' == pstrText[idxIt])
|
|
cntLevel--;
|
|
}
|
|
|
|
if ( (idxIt >= 0) && (idxIt < strText.length()) ) // NOTE: allow for std::string::size_type to be signed or unsigned
|
|
{
|
|
if (pidxStart)
|
|
*pidxStart = idxIt; // Return the character index of the starting '('
|
|
return strText.substr(idxIt + 1, idxEnd - idxIt - 1);
|
|
}
|
|
return std::string();
|
|
}
|
|
|
|
// =========================================================================
|
|
// Various helper functions
|
|
//
|
|
|
|
namespace Rlv
|
|
{
|
|
void forceAtmosphericShadersIfAvailable()
|
|
{
|
|
if ( (LLFeatureManager::getInstance()->isFeatureAvailable("WindLightUseAtmosShaders")) && (!LLPipeline::WindLightUseAtmosShaders) )
|
|
{
|
|
// Triggers handleSetShaderChanged() which will do the actual work for us
|
|
gSavedSettings.setBOOL("WindLightUseAtmosShaders", true);
|
|
}
|
|
}
|
|
|
|
int getObjectLinkNumber(const LLUUID& idObj)
|
|
{
|
|
const LLViewerObject* pObj = gObjectList.findObject(idObj);
|
|
const LLViewerObject* pRootObj = (pObj) ? pObj->getRootEdit() : nullptr;
|
|
if ( (!pRootObj) || (pRootObj->getChildren().empty()) )
|
|
return 0;
|
|
else if (pRootObj == pObj)
|
|
return 1;
|
|
return 2 + std::distance(pRootObj->getChildren().begin(), std::find(pRootObj->getChildren().begin(), pRootObj->getChildren().end(), pObj));
|
|
}
|
|
|
|
const LLUUID& getObjectRootId(const LLUUID& idObj)
|
|
{
|
|
if (const LLViewerObject* pObj = gObjectList.findObject(idObj))
|
|
{
|
|
pObj = pObj->getRootEdit();
|
|
return pObj->getID();
|
|
}
|
|
return idObj;
|
|
}
|
|
}
|
|
|
|
// =========================================================================
|