Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • alchemy-archive/alchemy
  • Liru/alchemy
  • TesticularSlingshot/alchemy
3 results
Show changes
Hide whitespace changes
Inline Side-by-side
Showing
with 258 additions and 271 deletions
indra/newview/llworldmapview.cpp
View file @ 655d119b
......@@ -1203,7 +1203,7 @@ void LLWorldMapView::drawAvatar(F32 x_pixels,
{
const F32 HEIGHT_THRESHOLD = 7.f;
LLUIImagePtr dot_image = sAvatarLevelImage;
if (unknown_relative_z)
if (unknown_relative_z && llabs(relative_z) > HEIGHT_THRESHOLD)
{
dot_image = sAvatarUnknownImage;
}
......
indra/newview/pipeline.cpp
View file @ 655d119b
......@@ -991,7 +991,7 @@ bool LLPipeline::allocateScreenBuffer(U32 resX, U32 resY, U32 samples)
mDeferredLight.release();
}
F32 scale = RenderShadowResolutionScale;
F32 scale = llmax(0.f, RenderShadowResolutionScale);
if (shadow_detail > 0)
{ //allocate 4 sun shadow maps
......@@ -3452,7 +3452,7 @@ void LLPipeline::stateSort(LLDrawable* drawablep, LLCamera& camera)
const LLViewerObject* pObj = drawablep->getVObj();
if ( (pObj) && (pObj->isSelected()) &&
( (!RlvActions::isRlvEnabled()) ||
( ((!pObj->isHUDAttachment()) || (!gRlvAttachmentLocks.isLockedAttachment(pObj->getRootEdit()))) &&
( ((!pObj->isHUDAttachment()) || (!RlvAttachmentLocks::instance().isLockedAttachment(pObj->getRootEdit()))) &&
(RlvActions::canEdit(pObj)) ) ) )
// [/RVLa:KB]
{
......@@ -6099,7 +6099,7 @@ void LLPipeline::enableLightsPreview()
light->enable();
light->setPosition(light_pos);
light->setDiffuse(diffuse0);
light->setAmbient(LLColor4::black);
light->setAmbient(ambient);
light->setSpecular(specular0);
light->setSpotExponent(0.f);
light->setSpotCutoff(180.f);
......@@ -6110,7 +6110,7 @@ void LLPipeline::enableLightsPreview()
light->enable();
light->setPosition(light_pos);
light->setDiffuse(diffuse1);
light->setAmbient(LLColor4::black);
light->setAmbient(ambient);
light->setSpecular(specular1);
light->setSpotExponent(0.f);
light->setSpotCutoff(180.f);
......@@ -6120,7 +6120,7 @@ void LLPipeline::enableLightsPreview()
light->enable();
light->setPosition(light_pos);
light->setDiffuse(diffuse2);
light->setAmbient(LLColor4::black);
light->setAmbient(ambient);
light->setSpecular(specular2);
light->setSpotExponent(0.f);
light->setSpotCutoff(180.f);
......@@ -8047,10 +8047,24 @@ void LLPipeline::renderDeferredLighting()
}
const LLViewerObject *vobj = drawablep->getVObj();
LLVOAvatar* avatarp = vobj ? vobj->getAvatar() : nullptr;
if(avatarp && avatarp->isVisuallyMuted())
if (vobj)
{
continue;
LLVOAvatar *av = vobj->getAvatar();
if (av)
{
if (av->isTooComplex() || av->isInMuteList() || dist_vec(av->getPosition(), LLViewerCamera::getInstance()->getOrigin()) > RenderFarClip)
{
continue;
}
}
else
{
const LLViewerObject *root_obj = drawablep->getParent() ? drawablep->getParent()->getVObj() : vobj;
if (root_obj && dist_vec(root_obj->getPosition(), LLViewerCamera::getInstance()->getOrigin()) > RenderFarClip)
{
continue;
}
}
}
LLVector4a center;
......@@ -8058,7 +8072,7 @@ void LLPipeline::renderDeferredLighting()
const F32* c = center.getF32ptr();
F32 s = volume->getLightRadius()*1.5f;
LLColor3 col = volume->getLightSRGBColor();
LLColor3 col = volume->getLightColor();
if (col.magVecSquared() < 0.001f)
{
......@@ -8154,7 +8168,10 @@ void LLPipeline::renderDeferredLighting()
setupSpotLight(gDeferredSpotLightProgram, drawablep);
LLColor3 col = volume->getLightSRGBColor();
LLColor3 col = volume->getLightColor();
/*col.mV[0] = powf(col.mV[0], 2.2f);
col.mV[1] = powf(col.mV[1], 2.2f);
col.mV[2] = powf(col.mV[2], 2.2f);*/
gDeferredSpotLightProgram.uniform3fv(LLShaderMgr::LIGHT_CENTER, 1, c);
gDeferredSpotLightProgram.uniform1f(LLShaderMgr::LIGHT_SIZE, s);
......@@ -8237,7 +8254,7 @@ void LLPipeline::renderDeferredLighting()
setupSpotLight(gDeferredMultiSpotLightProgram, drawablep);
LLColor3 col = volume->getLightSRGBColor();
LLColor3 col = volume->getLightColor();
/*col.mV[0] = powf(col.mV[0], 2.2f);
col.mV[1] = powf(col.mV[1], 2.2f);
......
indra/newview/res/viewerRes.rc
View file @ 655d119b
......@@ -151,11 +151,11 @@ BEGIN
BEGIN
BLOCK "040904b0"
BEGIN
VALUE "CompanyName", "Alchemy Viewer Project"
VALUE "CompanyName", "Alchemy Development Group"
VALUE "FileDescription", "Alchemy"
VALUE "FileVersion", "${VIEWER_VERSION_MAJOR}.${VIEWER_VERSION_MINOR}.${VIEWER_VERSION_PATCH}.${VIEWER_VERSION_REVISION}"
VALUE "InternalName", "Alchemy"
VALUE "LegalCopyright", "Copyright (C) 2013-2018 Alchemy Viewer Project"
VALUE "LegalCopyright", "Copyright (C) 2013-2020 Alchemy Development Group"
VALUE "OriginalFilename", "Alchemy.exe"
VALUE "ProductName", "Alchemy"
VALUE "ProductVersion", "${VIEWER_VERSION_MAJOR}.${VIEWER_VERSION_MINOR}.${VIEWER_VERSION_PATCH}.${VIEWER_VERSION_REVISION}"
......
indra/newview/rlvactions.cpp
View file @ 655d119b
......@@ -34,15 +34,15 @@
bool RlvActions::canChangeCameraFOV(const LLUUID& idRlvObject)
{
// NOTE: if an object has exclusive camera control then all other objects are locked out
return (!gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM)) || (gRlvHandler.hasBehaviour(idRlvObject, RLV_BHVR_SETCAM));
return (!RlvHandler::instance().hasBehaviour(RLV_BHVR_SETCAM)) || (RlvHandler::instance().hasBehaviour(idRlvObject, RLV_BHVR_SETCAM));
}
bool RlvActions::canChangeCameraPreset(const LLUUID& idRlvObject)
{
// NOTE: if an object has exclusive camera control then all other objects are locked out
return
( (!gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM)) || (gRlvHandler.hasBehaviour(idRlvObject, RLV_BHVR_SETCAM)) ) &&
(!gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM_EYEOFFSET)) && (!gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM_FOCUSOFFSET));
( (!RlvHandler::instance().hasBehaviour(RLV_BHVR_SETCAM)) || (RlvHandler::instance().hasBehaviour(idRlvObject, RLV_BHVR_SETCAM)) ) &&
(!RlvHandler::instance().hasBehaviour(RLV_BHVR_SETCAM_EYEOFFSET)) && (!RlvHandler::instance().hasBehaviour(RLV_BHVR_SETCAM_FOCUSOFFSET));
}
bool RlvActions::canChangeToMouselook()
......@@ -52,30 +52,30 @@ bool RlvActions::canChangeToMouselook()
// - there is no minimum camera distance defined (or it's higher than > 0m)
const RlvBehaviourModifier* pCamDistMinModifier = RlvBehaviourDictionary::instance().getModifier(RLV_MODIFIER_SETCAM_AVDISTMIN);
return
( (!gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM)) ? !gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM_MOUSELOOK) : !gRlvHandler.hasBehaviour(pCamDistMinModifier->getPrimaryObject(), RLV_BHVR_SETCAM_MOUSELOOK) ) &&
( (!RlvHandler::instance().hasBehaviour(RLV_BHVR_SETCAM)) ? !RlvHandler::instance().hasBehaviour(RLV_BHVR_SETCAM_MOUSELOOK) : !RlvHandler::instance().hasBehaviour(pCamDistMinModifier->getPrimaryObject(), RLV_BHVR_SETCAM_MOUSELOOK) ) &&
( (!pCamDistMinModifier->hasValue()) || (pCamDistMinModifier->getValue<float>() == 0.f) );
}
bool RlvActions::isCameraDistanceClamped()
{
return
(gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM_AVDISTMIN)) || (gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM_AVDISTMAX)) ||
(gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM_ORIGINDISTMIN)) || (gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM_ORIGINDISTMAX));
(RlvHandler::instance().hasBehaviour(RLV_BHVR_SETCAM_AVDISTMIN)) || (RlvHandler::instance().hasBehaviour(RLV_BHVR_SETCAM_AVDISTMAX)) ||
(RlvHandler::instance().hasBehaviour(RLV_BHVR_SETCAM_ORIGINDISTMIN)) || (RlvHandler::instance().hasBehaviour(RLV_BHVR_SETCAM_ORIGINDISTMAX));
}
bool RlvActions::isCameraFOVClamped()
{
return (gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM_FOVMIN)) || (gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM_FOVMAX));
return (RlvHandler::instance().hasBehaviour(RLV_BHVR_SETCAM_FOVMIN)) || (RlvHandler::instance().hasBehaviour(RLV_BHVR_SETCAM_FOVMAX));
}
bool RlvActions::isCameraPresetLocked()
{
return (gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM)) || (gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM_EYEOFFSET)) || (gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM_FOCUSOFFSET));
return (RlvHandler::instance().hasBehaviour(RLV_BHVR_SETCAM)) || (RlvHandler::instance().hasBehaviour(RLV_BHVR_SETCAM_EYEOFFSET)) || (RlvHandler::instance().hasBehaviour(RLV_BHVR_SETCAM_FOCUSOFFSET));
}
bool RlvActions::getCameraAvatarDistanceLimits(float& nDistMin, float& nDistMax)
{
bool fDistMin = gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM_AVDISTMIN), fDistMax = gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM_AVDISTMAX);
bool fDistMin = RlvHandler::instance().hasBehaviour(RLV_BHVR_SETCAM_AVDISTMIN), fDistMax = RlvHandler::instance().hasBehaviour(RLV_BHVR_SETCAM_AVDISTMAX);
if ( (fDistMin) || (fDistMax) )
{
static RlvCachedBehaviourModifier<float> sCamDistMin(RLV_MODIFIER_SETCAM_AVDISTMIN);
......@@ -90,7 +90,7 @@ bool RlvActions::getCameraAvatarDistanceLimits(float& nDistMin, float& nDistMax)
bool RlvActions::getCameraOriginDistanceLimits(float& nDistMin, float& nDistMax)
{
bool fDistMin = gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM_ORIGINDISTMIN), fDistMax = gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM_ORIGINDISTMAX);
bool fDistMin = RlvHandler::instance().hasBehaviour(RLV_BHVR_SETCAM_ORIGINDISTMIN), fDistMax = RlvHandler::instance().hasBehaviour(RLV_BHVR_SETCAM_ORIGINDISTMAX);
if ( (fDistMin) || (fDistMax) )
{
static RlvCachedBehaviourModifier<float> sCamDistMin(RLV_MODIFIER_SETCAM_ORIGINDISTMIN);
......@@ -105,7 +105,7 @@ bool RlvActions::getCameraOriginDistanceLimits(float& nDistMin, float& nDistMax)
bool RlvActions::getCameraFOVLimits(F32& nFOVMin, F32& nFOVMax)
{
bool fClampMin = gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM_FOVMIN), fClampMax = gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM_FOVMAX);
bool fClampMin = RlvHandler::instance().hasBehaviour(RLV_BHVR_SETCAM_FOVMIN), fClampMax = RlvHandler::instance().hasBehaviour(RLV_BHVR_SETCAM_FOVMAX);
if ( (fClampMin) || (fClampMax) )
{
static RlvCachedBehaviourModifier<float> sCamFovMin(RLV_MODIFIER_SETCAM_FOVMIN);
......@@ -128,7 +128,7 @@ bool RlvActions::canChangeActiveGroup(const LLUUID& idRlvObject)
{
// User can change their active group if:
// - not specifically restricted (by another object that the one specified) from changing their active group
return (idRlvObject.isNull()) ? !gRlvHandler.hasBehaviour(RLV_BHVR_SETGROUP) : !gRlvHandler.hasBehaviourExcept(RLV_BHVR_SETGROUP, idRlvObject);
return (idRlvObject.isNull()) ? !RlvHandler::instance().hasBehaviour(RLV_BHVR_SETGROUP) : !RlvHandler::instance().hasBehaviourExcept(RLV_BHVR_SETGROUP, idRlvObject);
}
// Little helper function to check the IM exclusion range for @recvim, @sendim and @startim (returns: min_dist <= (pos user - pos target) <= max_dist)
......@@ -159,20 +159,20 @@ bool RlvActions::canReceiveIM(const LLUUID& idSender)
// - not specifically restricted from receiving an IM from the sender
return
(!isRlvEnabled()) ||
( ( (!gRlvHandler.hasBehaviour(RLV_BHVR_RECVIM)) || (gRlvHandler.isException(RLV_BHVR_RECVIM, idSender)) || (rlvCheckAvatarIMDistance(idSender, RLV_MODIFIER_RECVIMDISTMIN, RLV_MODIFIER_RECVIMDISTMAX)) ) &&
( (!gRlvHandler.hasBehaviour(RLV_BHVR_RECVIMFROM)) || (!gRlvHandler.isException(RLV_BHVR_RECVIMFROM, idSender)) ) );
( ( (!RlvHandler::instance().hasBehaviour(RLV_BHVR_RECVIM)) || (RlvHandler::instance().isException(RLV_BHVR_RECVIM, idSender)) || (rlvCheckAvatarIMDistance(idSender, RLV_MODIFIER_RECVIMDISTMIN, RLV_MODIFIER_RECVIMDISTMAX)) ) &&
( (!RlvHandler::instance().hasBehaviour(RLV_BHVR_RECVIMFROM)) || (!RlvHandler::instance().isException(RLV_BHVR_RECVIMFROM, idSender)) ) );
}
bool RlvActions::canPlayGestures()
{
return (!gRlvHandler.hasBehaviour(RLV_BHVR_SENDGESTURE));
return (!RlvHandler::instance().hasBehaviour(RLV_BHVR_SENDGESTURE));
}
bool RlvActions::canSendChannel(int nChannel)
{
return
( (!gRlvHandler.hasBehaviour(RLV_BHVR_SENDCHANNEL)) || (gRlvHandler.isException(RLV_BHVR_SENDCHANNEL, nChannel)) ) &&
( (!gRlvHandler.hasBehaviour(RLV_BHVR_SENDCHANNELEXCEPT)) || (!gRlvHandler.isException(RLV_BHVR_SENDCHANNELEXCEPT, nChannel)) );
( (!RlvHandler::instance().hasBehaviour(RLV_BHVR_SENDCHANNEL)) || (RlvHandler::instance().isException(RLV_BHVR_SENDCHANNEL, nChannel)) ) &&
( (!RlvHandler::instance().hasBehaviour(RLV_BHVR_SENDCHANNELEXCEPT)) || (!RlvHandler::instance().isException(RLV_BHVR_SENDCHANNELEXCEPT, nChannel)) );
}
bool RlvActions::canSendIM(const LLUUID& idRecipient)
......@@ -182,8 +182,8 @@ bool RlvActions::canSendIM(const LLUUID& idRecipient)
// - not specifically restricted from sending an IM to the recipient
return
(!isRlvEnabled()) ||
( ( (!gRlvHandler.hasBehaviour(RLV_BHVR_SENDIM)) || (gRlvHandler.isException(RLV_BHVR_SENDIM, idRecipient)) || (rlvCheckAvatarIMDistance(idRecipient, RLV_MODIFIER_SENDIMDISTMIN, RLV_MODIFIER_SENDIMDISTMAX)) ) &&
( (!gRlvHandler.hasBehaviour(RLV_BHVR_SENDIMTO)) || (!gRlvHandler.isException(RLV_BHVR_SENDIMTO, idRecipient)) ) );
( ( (!RlvHandler::instance().hasBehaviour(RLV_BHVR_SENDIM)) || (RlvHandler::instance().isException(RLV_BHVR_SENDIM, idRecipient)) || (rlvCheckAvatarIMDistance(idRecipient, RLV_MODIFIER_SENDIMDISTMIN, RLV_MODIFIER_SENDIMDISTMAX)) ) &&
( (!RlvHandler::instance().hasBehaviour(RLV_BHVR_SENDIMTO)) || (!RlvHandler::instance().isException(RLV_BHVR_SENDIMTO, idRecipient)) ) );
}
bool RlvActions::canStartIM(const LLUUID& idRecipient, bool fIgnoreOpen)
......@@ -194,8 +194,8 @@ bool RlvActions::canStartIM(const LLUUID& idRecipient, bool fIgnoreOpen)
// - the session already exists
return
(!isRlvEnabled()) ||
( ( (!gRlvHandler.hasBehaviour(RLV_BHVR_STARTIM)) || (gRlvHandler.isException(RLV_BHVR_STARTIM, idRecipient)) || (rlvCheckAvatarIMDistance(idRecipient, RLV_MODIFIER_STARTIMDISTMIN, RLV_MODIFIER_STARTIMDISTMAX)) ) &&
( (!gRlvHandler.hasBehaviour(RLV_BHVR_STARTIMTO)) || (!gRlvHandler.isException(RLV_BHVR_STARTIMTO, idRecipient)) ) ) ||
( ( (!RlvHandler::instance().hasBehaviour(RLV_BHVR_STARTIM)) || (RlvHandler::instance().isException(RLV_BHVR_STARTIM, idRecipient)) || (rlvCheckAvatarIMDistance(idRecipient, RLV_MODIFIER_STARTIMDISTMIN, RLV_MODIFIER_STARTIMDISTMAX)) ) &&
( (!RlvHandler::instance().hasBehaviour(RLV_BHVR_STARTIMTO)) || (!RlvHandler::instance().isException(RLV_BHVR_STARTIMTO, idRecipient)) ) ) ||
( (!fIgnoreOpen) && ((hasOpenP2PSession(idRecipient)) || (hasOpenGroupSession(idRecipient))) );
}
......@@ -211,13 +211,13 @@ bool RlvActions::canShowName(EShowNamesContext eContext, const LLUUID& idAgent)
{
// Show/hide avatar nametag
case SNC_NAMETAG:
return (gRlvHandler.isException(RLV_BHVR_SHOWNAMETAGS, idAgent)) || (gAgentID == idAgent);
return (RlvHandler::instance().isException(RLV_BHVR_SHOWNAMETAGS, idAgent)) || (gAgentID == idAgent);
// Show/hide avatar name
case SNC_DEFAULT:
case SNC_COUNT:
case SNC_TELEPORTOFFER:
case SNC_TELEPORTREQUEST:
return gRlvHandler.isException(RLV_BHVR_SHOWNAMES, idAgent) || (gAgentID == idAgent);
return RlvHandler::instance().isException(RLV_BHVR_SHOWNAMES, idAgent) || (gAgentID == idAgent);
}
}
return false;
......@@ -225,7 +225,7 @@ bool RlvActions::canShowName(EShowNamesContext eContext, const LLUUID& idAgent)
bool RlvActions::canShowNearbyAgents()
{
return !gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNEARBY);
return !RlvHandler::instance().hasBehaviour(RLV_BHVR_SHOWNEARBY);
}
// Handles: @chatwhisper, @chatnormal and @chatshout
......@@ -269,7 +269,7 @@ bool RlvActions::canPasteInventory(const LLInventoryItem* pSourceItem, const LLI
bool RlvActions::canPreviewTextures()
{
return (!gRlvHandler.hasBehaviour(RLV_BHVR_VIEWTEXTURE));
return (!RlvHandler::instance().hasBehaviour(RLV_BHVR_VIEWTEXTURE));
}
// ============================================================================
......@@ -278,37 +278,37 @@ bool RlvActions::canPreviewTextures()
bool RlvActions::canAcceptTpOffer(const LLUUID& idSender)
{
return ((!gRlvHandler.hasBehaviour(RLV_BHVR_TPLURE)) || (gRlvHandler.isException(RLV_BHVR_TPLURE, idSender))) && (canStand());
return ((!RlvHandler::instance().hasBehaviour(RLV_BHVR_TPLURE)) || (RlvHandler::instance().isException(RLV_BHVR_TPLURE, idSender))) && (canStand());
}
bool RlvActions::autoAcceptTeleportOffer(const LLUUID& idSender)
{
return ((idSender.notNull()) && (gRlvHandler.isException(RLV_BHVR_ACCEPTTP, idSender))) || (gRlvHandler.hasBehaviour(RLV_BHVR_ACCEPTTP));
return ((idSender.notNull()) && (RlvHandler::instance().isException(RLV_BHVR_ACCEPTTP, idSender))) || (RlvHandler::instance().hasBehaviour(RLV_BHVR_ACCEPTTP));
}
bool RlvActions::canAcceptTpRequest(const LLUUID& idSender)
{
return (!gRlvHandler.hasBehaviour(RLV_BHVR_TPREQUEST)) || (gRlvHandler.isException(RLV_BHVR_TPREQUEST, idSender));
return (!RlvHandler::instance().hasBehaviour(RLV_BHVR_TPREQUEST)) || (RlvHandler::instance().isException(RLV_BHVR_TPREQUEST, idSender));
}
bool RlvActions::autoAcceptTeleportRequest(const LLUUID& idRequester)
{
return ((idRequester.notNull()) && (gRlvHandler.isException(RLV_BHVR_ACCEPTTPREQUEST, idRequester))) || (gRlvHandler.hasBehaviour(RLV_BHVR_ACCEPTTPREQUEST));
return ((idRequester.notNull()) && (RlvHandler::instance().isException(RLV_BHVR_ACCEPTTPREQUEST, idRequester))) || (RlvHandler::instance().hasBehaviour(RLV_BHVR_ACCEPTTPREQUEST));
}
bool RlvActions::canFly()
{
return (!gRlvHandler.getCurrentCommand()) ? !gRlvHandler.hasBehaviour(RLV_BHVR_FLY) : !gRlvHandler.hasBehaviourExcept(RLV_BHVR_FLY, gRlvHandler.getCurrentObject());
return (!RlvHandler::instance().getCurrentCommand()) ? !RlvHandler::instance().hasBehaviour(RLV_BHVR_FLY) : !RlvHandler::instance().hasBehaviourExcept(RLV_BHVR_FLY, RlvHandler::instance().getCurrentObject());
}
bool RlvActions::canFly(const LLUUID& idRlvObjExcept)
{
return !gRlvHandler.hasBehaviourExcept(RLV_BHVR_FLY, idRlvObjExcept);
return !RlvHandler::instance().hasBehaviourExcept(RLV_BHVR_FLY, idRlvObjExcept);
}
bool RlvActions::canJump()
{
return !gRlvHandler.hasBehaviour(RLV_BHVR_JUMP);
return !RlvHandler::instance().hasBehaviour(RLV_BHVR_JUMP);
}
// ============================================================================
......@@ -322,15 +322,15 @@ bool RlvActions::canTeleportToLocal(const LLVector3d& posGlobal)
// - not restricted from "sit teleporting" (or the destination is within the allowed xyz-radius)
// - not restricted from teleporting locally (or the destination is within the allowed xy-radius)
// NOTE: if we're teleporting due to an active command we should disregard any restrictions from the same object
const LLUUID& idRlvObjExcept = gRlvHandler.getCurrentObject();
const LLUUID& idRlvObjExcept = RlvHandler::instance().getCurrentObject();
bool fCanTeleport = RlvActions::canStand(idRlvObjExcept);
if ( (fCanTeleport) && (gRlvHandler.hasBehaviourExcept(RLV_BHVR_SITTP, idRlvObjExcept)) )
if ( (fCanTeleport) && (RlvHandler::instance().hasBehaviourExcept(RLV_BHVR_SITTP, idRlvObjExcept)) )
{
const F32 nDistSq = (posGlobal - gAgent.getPositionGlobal()).lengthSquared();
const F32 nSitTpDist = RlvBehaviourDictionary::instance().getModifier(RLV_MODIFIER_SITTPDIST)->getValue<F32>();
fCanTeleport = nDistSq < nSitTpDist * nSitTpDist;
}
if ( (fCanTeleport) && (gRlvHandler.hasBehaviourExcept(RLV_BHVR_TPLOCAL, idRlvObjExcept)) )
if ( (fCanTeleport) && (RlvHandler::instance().hasBehaviourExcept(RLV_BHVR_TPLOCAL, idRlvObjExcept)) )
{
const F32 nDistSq = (LLVector2(posGlobal.mdV[0], posGlobal.mdV[1]) - LLVector2(gAgent.getPositionGlobal().mdV[0], gAgent.getPositionGlobal().mdV[1])).lengthSquared();
const F32 nTpLocalDist = llmin(RlvBehaviourDictionary::instance().getModifier(RLV_MODIFIER_TPLOCALDIST)->getValue<float>(), RLV_MODIFIER_TPLOCAL_DEFAULT);
......@@ -342,8 +342,8 @@ bool RlvActions::canTeleportToLocal(const LLVector3d& posGlobal)
bool RlvActions::canTeleportToLocation()
{
// NOTE: if we're teleporting due to an active command we should disregard any restrictions from the same object
const LLUUID& idRlvObjExcept = gRlvHandler.getCurrentObject();
return (!gRlvHandler.hasBehaviourExcept(RLV_BHVR_TPLOC, idRlvObjExcept)) && (RlvActions::canStand(idRlvObjExcept));
const LLUUID& idRlvObjExcept = RlvHandler::instance().getCurrentObject();
return (!RlvHandler::instance().hasBehaviourExcept(RLV_BHVR_TPLOC, idRlvObjExcept)) && (RlvActions::canStand(idRlvObjExcept));
}
bool RlvActions::isLocalTp(const LLVector3d& posGlobal)
......@@ -362,8 +362,8 @@ bool RlvActions::canBuild()
// - allowed to edit existing objects OR
// - allowed to rez/create objects
return
(!gRlvHandler.hasBehaviour(RLV_BHVR_EDIT)) ||
(!gRlvHandler.hasBehaviour(RLV_BHVR_REZ));
(!RlvHandler::instance().hasBehaviour(RLV_BHVR_EDIT)) ||
(!RlvHandler::instance().hasBehaviour(RLV_BHVR_REZ));
}
// Handles: @edit and @editobj
......@@ -398,7 +398,7 @@ bool RlvActions::canInteract(const LLViewerObject* pObj, const LLVector3& posOff
bool RlvActions::canRez()
{
return (!gRlvHandler.hasBehaviour(RLV_BHVR_REZ));
return (!RlvHandler::instance().hasBehaviour(RLV_BHVR_REZ));
}
bool RlvActions::canGroundSit()
......@@ -424,7 +424,7 @@ bool RlvActions::canSit(const LLViewerObject* pObj, const LLVector3& posOffset /
(!hasBehaviour(RLV_BHVR_SIT)) &&
( ((!hasBehaviour(RLV_BHVR_UNSIT)) && (!hasBehaviour(RLV_BHVR_STANDTP))) ||
((isAgentAvatarValid()) && (!gAgentAvatarp->isSitting())) ) &&
( ( (NULL != gRlvHandler.getCurrentCommand()) && (RLV_BHVR_SIT == gRlvHandler.getCurrentCommand()->getBehaviourType()) ) ||
( ( (NULL != RlvHandler::instance().getCurrentCommand()) && (RLV_BHVR_SIT == RlvHandler::instance().getCurrentCommand()->getBehaviourType()) ) ||
( ((!hasBehaviour(RLV_BHVR_SITTP)) || (dist_vec_squared(gAgent.getPositionGlobal(), pObj->getPositionGlobal() + LLVector3d(posOffset)) < s_nSitTpDist * s_nSitTpDist)) &&
((!hasBehaviour(RLV_BHVR_FARTOUCH)) || (dist_vec_squared(gAgent.getPositionGlobal(), pObj->getPositionGlobal() + LLVector3d(posOffset)) < s_nFarTouchDist * s_nFarTouchDist)) ) );
}
......@@ -524,19 +524,19 @@ bool RlvActions::canTouch(const LLViewerObject* pObj, const LLVector3& posOffset
bool RlvActions::canStand()
{
// NOTE: return FALSE only if we're @unsit=n restricted and the avie is currently sitting on something and TRUE for everything else
return (!gRlvHandler.hasBehaviour(RLV_BHVR_UNSIT)) || ((isAgentAvatarValid()) && (!gAgentAvatarp->isSitting()));
return (!RlvHandler::instance().hasBehaviour(RLV_BHVR_UNSIT)) || ((isAgentAvatarValid()) && (!gAgentAvatarp->isSitting()));
}
bool RlvActions::canStand(const LLUUID& idRlvObjExcept)
{
// NOTE: must match generic function above
return (!gRlvHandler.hasBehaviourExcept(RLV_BHVR_UNSIT, idRlvObjExcept)) || ((isAgentAvatarValid()) && (!gAgentAvatarp->isSitting()));
return (!RlvHandler::instance().hasBehaviourExcept(RLV_BHVR_UNSIT, idRlvObjExcept)) || ((isAgentAvatarValid()) && (!gAgentAvatarp->isSitting()));
}
// Checked: 2014-02-24 (RLVa-1.4.10)
bool RlvActions::canShowLocation()
{
return !gRlvHandler.hasBehaviour(RLV_BHVR_SHOWLOC);
return !RlvHandler::instance().hasBehaviour(RLV_BHVR_SHOWLOC);
}
// ============================================================================
......@@ -552,7 +552,7 @@ const float& RlvActions::getModifierValue<float>(ERlvBehaviourModifier eBhvrMod)
// Checked: 2013-05-10 (RLVa-1.4.9)
bool RlvActions::hasBehaviour(ERlvBehaviour eBhvr)
{
return gRlvHandler.hasBehaviour(eBhvr);
return RlvHandler::instance().hasBehaviour(eBhvr);
}
// Checked: 2013-05-09 (RLVa-1.4.9)
......
indra/newview/rlvcommon.cpp
View file @ 655d119b
......@@ -139,7 +139,7 @@ void RlvSettings::updateLoginLastLocation()
{
if ( (!LLApp::isQuitting()) && (gSavedPerAccountSettings.controlExists(RLV_SETTING_LOGINLASTLOCATION)) )
{
BOOL fValue = (gRlvHandler.hasBehaviour(RLV_BHVR_TPLOC)) || (!RlvActions::canStand());
BOOL fValue = (RlvHandler::instance().hasBehaviour(RLV_BHVR_TPLOC)) || (!RlvActions::canStand());
if (gSavedPerAccountSettings.getBOOL(RLV_SETTING_LOGINLASTLOCATION) != fValue)
{
gSavedPerAccountSettings.setBOOL(RLV_SETTING_LOGINLASTLOCATION, fValue);
......@@ -291,7 +291,7 @@ void RlvStrings::loadFromFile(const std::string& strFilePath, bool fUserOverride
if (sdFileData.has("strings"))
{
const LLSD& sdStrings = sdFileData["strings"];
for (LLSD::map_const_iterator itString = sdStrings.beginMap(); itString != sdStrings.endMap(); ++itString)
for (LLSD::map_const_iterator itString = sdStrings.beginMap(), itEnd = sdStrings.endMap(); itString != itEnd; ++itString)
{
if ( (!itString->second.has("value")) || ((fUserOverride) && (!hasString(itString->first))) )
continue;
......@@ -314,7 +314,7 @@ void RlvStrings::loadFromFile(const std::string& strFilePath, bool fUserOverride
if (sdFileData.has("anonyms"))
{
const LLSD& sdAnonyms = sdFileData["anonyms"];
for (LLSD::array_const_iterator itAnonym = sdAnonyms.beginArray(); itAnonym != sdAnonyms.endArray(); ++itAnonym)
for (LLSD::array_const_iterator itAnonym = sdAnonyms.beginArray(), endAnonym = sdAnonyms.endArray(); itAnonym != endAnonym; ++itAnonym)
{
m_Anonyms.push_back((*itAnonym).asString());
}
......@@ -515,7 +515,7 @@ void RlvUtil::filterNames(std::string& strUTF8Text, bool fFilterLegacy, bool fCl
void RlvUtil::filterScriptQuestions(S32& nQuestions, LLSD& sdPayload)
{
// Check SCRIPT_PERMISSION_ATTACH
if ((!gRlvAttachmentLocks.canAttach()) && (SCRIPT_PERMISSIONS[SCRIPT_PERMISSION_ATTACH].permbit & nQuestions))
if ((!RlvAttachmentLocks::instance().canAttach()) && (SCRIPT_PERMISSIONS[SCRIPT_PERMISSION_ATTACH].permbit & nQuestions))
{
// Notify the user that we blocked it since they're not allowed to wear any new attachments
sdPayload["rlv_blocked"] = RLV_STRING_BLOCKED_PERMATTACH;
......@@ -523,7 +523,7 @@ void RlvUtil::filterScriptQuestions(S32& nQuestions, LLSD& sdPayload)
}
// Check SCRIPT_PERMISSION_TELEPORT
if ((gRlvHandler.hasBehaviour(RLV_BHVR_TPLOC)) && (SCRIPT_PERMISSIONS[SCRIPT_PERMISSION_TELEPORT].permbit & nQuestions))
if ((RlvHandler::instance().hasBehaviour(RLV_BHVR_TPLOC)) && (SCRIPT_PERMISSIONS[SCRIPT_PERMISSION_TELEPORT].permbit & nQuestions))
{
// Notify the user that we blocked it since they're not allowed to teleport
sdPayload["rlv_blocked"] = RLV_STRING_BLOCKED_PERMTELEPORT;
......@@ -666,8 +666,8 @@ void RlvUtil::sendIMMessage(const LLUUID& idRecipient, const std::string& strMsg
false,
gAgent.getSessionID(),
idRecipient,
strAgentName.c_str(),
strMsg.c_str(),
strAgentName,
strMsg,
((!pBuddyInfo) || (pBuddyInfo->isOnline())) ? IM_ONLINE : IM_OFFLINE,
IM_NOTHING_SPECIAL,
idSession);
......@@ -734,7 +734,7 @@ bool rlvMenuEnableIfNot(const LLSD& sdParam)
if (rlv_handler_t::isEnabled())
{
ERlvBehaviour eBhvr = RlvBehaviourDictionary::instance().getBehaviourFromString(sdParam.asString(), RLV_TYPE_ADDREM);
fEnable = (eBhvr != RLV_BHVR_UNKNOWN) ? !gRlvHandler.hasBehaviour(eBhvr) : true;
fEnable = (eBhvr != RLV_BHVR_UNKNOWN) ? !RlvHandler::instance().hasBehaviour(eBhvr) : true;
}
return fEnable;
}
......@@ -748,16 +748,16 @@ bool rlvCanDeleteOrReturn(const LLViewerObject* pObj)
{
// Block if: @rez=n restricted and owned by us or a group *or* @unsit=n restricted and being sat on by us
return
( (!gRlvHandler.hasBehaviour(RLV_BHVR_REZ)) || ((!pObj->permYouOwner()) && (!pObj->permGroupOwner())) ) &&
( (!gRlvHandler.hasBehaviour(RLV_BHVR_UNSIT)) || (!isAgentAvatarValid()) || (!pObj->getRootEdit()->isChild(gAgentAvatarp)) );
( (!RlvHandler::instance().hasBehaviour(RLV_BHVR_REZ)) || ((!pObj->permYouOwner()) && (!pObj->permGroupOwner())) ) &&
( (!RlvHandler::instance().hasBehaviour(RLV_BHVR_UNSIT)) || (!isAgentAvatarValid()) || (!pObj->getRootEdit()->isChild(gAgentAvatarp)) );
}
// Checked: 2011-05-28 (RLVa-1.4.6) | Modified: RLVa-1.4.0
bool rlvCanDeleteOrReturn()
{
if ( (gRlvHandler.hasBehaviour(RLV_BHVR_REZ)) || (gRlvHandler.hasBehaviour(RLV_BHVR_UNSIT)) )
if ( (RlvHandler::instance().hasBehaviour(RLV_BHVR_REZ)) || (RlvHandler::instance().hasBehaviour(RLV_BHVR_UNSIT)) )
{
struct RlvCanDeleteOrReturn : public LLSelectedObjectFunctor
struct RlvCanDeleteOrReturn final : public LLSelectedObjectFunctor
{
/*virtual*/ bool apply(LLViewerObject* pObj) { return rlvCanDeleteOrReturn(pObj); }
} f;
......@@ -770,7 +770,7 @@ bool rlvCanDeleteOrReturn()
// Checked: 2010-04-20 (RLVa-1.2.0f) | Modified: RLVa-0.2.0f
bool RlvSelectHasLockedAttach::apply(LLSelectNode* pNode)
{
return (pNode->getObject()) ? gRlvAttachmentLocks.isLockedAttachment(pNode->getObject()->getRootEdit()) : false;
return (pNode->getObject()) ? RlvAttachmentLocks::instance().isLockedAttachment(pNode->getObject()->getRootEdit()) : false;
}
// Checked: 2010-11-29 (RLVa-1.3.0c) | Added: RLVa-1.3.0c
......@@ -801,11 +801,11 @@ bool rlvPredCanWearItem(const LLViewerInventoryItem* pItem, ERlvWearMask eWearMa
{
case LLAssetType::AT_BODYPART:
// NOTE: only one body part of each type is allowed so the only way to wear one is if we can replace the current one
return (RLV_WEAR_LOCKED != (gRlvWearableLocks.canWear(pItem) & RLV_WEAR_REPLACE & eWearMask));
return (RLV_WEAR_LOCKED != (RlvWearableLocks::instance().canWear(pItem) & RLV_WEAR_REPLACE & eWearMask));
case LLAssetType::AT_CLOTHING:
return (RLV_WEAR_LOCKED != (gRlvWearableLocks.canWear(pItem) & eWearMask));
return (RLV_WEAR_LOCKED != (RlvWearableLocks::instance().canWear(pItem) & eWearMask));
case LLAssetType::AT_OBJECT:
return (RLV_WEAR_LOCKED != (gRlvAttachmentLocks.canAttach(pItem) & eWearMask));
return (RLV_WEAR_LOCKED != (RlvAttachmentLocks::instance().canAttach(pItem) & eWearMask));
case LLAssetType::AT_GESTURE:
return true;
default:
......@@ -835,7 +835,7 @@ bool rlvPredCanRemoveItem(const LLUUID& idItem)
if (isAgentAvatarValid())
{
const LLViewerObject* pAttachObj = gAgentAvatarp->getWornAttachment(idItem);
return (pAttachObj) && (!gRlvAttachmentLocks.isLockedAttachment(pAttachObj));
return (pAttachObj) && (!RlvAttachmentLocks::instance().isLockedAttachment(pAttachObj));
}
return false;
......@@ -850,9 +850,9 @@ bool rlvPredCanRemoveItem(const LLViewerInventoryItem* pItem)
{
case LLAssetType::AT_BODYPART:
case LLAssetType::AT_CLOTHING:
return gRlvWearableLocks.canRemove(pItem);
return RlvWearableLocks::instance().canRemove(pItem);
case LLAssetType::AT_OBJECT:
return gRlvAttachmentLocks.canDetach(pItem);
return RlvAttachmentLocks::instance().canDetach(pItem);
case LLAssetType::AT_GESTURE:
return true;
case LLAssetType::AT_LINK:
......@@ -894,7 +894,7 @@ BOOL rlvEnableSharedWearEnabler(void* pParam)
{
return false;
// Visually disable the "Enable Shared Wear" option when at least one attachment is non-detachable
return (!gRlvHandler.hasLockedAttachment(RLV_LOCK_REMOVE));
return (!RlvHandler::instance().hasLockedAttachment(RLV_LOCK_REMOVE));
}
*/
......
indra/newview/rlvcommon.h
View file @ 655d119b
......@@ -226,20 +226,20 @@ bool rlvMenuEnableIfNot(const LLSD& sdParam);
bool rlvCanDeleteOrReturn();
bool rlvCanDeleteOrReturn(const LLViewerObject* pObj);
struct RlvSelectHasLockedAttach : public LLSelectedNodeFunctor
struct RlvSelectHasLockedAttach final : public LLSelectedNodeFunctor
{
RlvSelectHasLockedAttach() = default;
virtual bool apply(LLSelectNode* pNode);
};
// Filters out selected objects that can't be editable (i.e. getFirstNode() will return NULL if the selection is fully editable)
struct RlvSelectIsEditable : public LLSelectedNodeFunctor
struct RlvSelectIsEditable final : public LLSelectedNodeFunctor
{
RlvSelectIsEditable() = default;
/*virtual*/ bool apply(LLSelectNode* pNode);
};
struct RlvSelectIsSittingOn : public LLSelectedNodeFunctor
struct RlvSelectIsSittingOn final : public LLSelectedNodeFunctor
{
RlvSelectIsSittingOn(const LLVOAvatar* pAvatar) : m_pAvatar(pAvatar) {}
/*virtual*/ bool apply(LLSelectNode* pNode);
......
indra/newview/rlvextensions.cpp
View file @ 655d119b
......@@ -432,7 +432,7 @@ bool RlvExtGetSet::processCommand(const RlvCommand& rlvCmd, ERlvCmdRet& eRet)
}
else if ( ("set" == strGetSet) && (RLV_TYPE_FORCE == rlvCmd.getParamType()) )
{
if (!gRlvHandler.hasBehaviourExcept(RLV_BHVR_SETDEBUG, rlvCmd.getObjectID()))
if (!RlvHandler::instance().hasBehaviourExcept(RLV_BHVR_SETDEBUG, rlvCmd.getObjectID()))
eRet = onSetDebug(strSetting, rlvCmd.getOption());
else
eRet = RLV_RET_FAILED_LOCK;
......@@ -450,7 +450,7 @@ bool RlvExtGetSet::processCommand(const RlvCommand& rlvCmd, ERlvCmdRet& eRet)
}
else if ( ("set" == strGetSet) && (RLV_TYPE_FORCE == rlvCmd.getParamType()) )
{
if (!gRlvHandler.hasBehaviourExcept(RLV_BHVR_SETENV, rlvCmd.getObjectID()))
if (!RlvHandler::instance().hasBehaviourExcept(RLV_BHVR_SETENV, rlvCmd.getObjectID()))
eRet = (RlvWindLight::instance().setValue(strSetting, rlvCmd.getOption())) ? RLV_RET_SUCCESS : RLV_RET_FAILED_UNKNOWN;
else
eRet = RLV_RET_FAILED_LOCK;
......
indra/newview/rlvextensions.h
View file @ 655d119b
......@@ -27,7 +27,7 @@
*
*/
class RlvExtGetSet : public RlvExtCommandHandler
class RlvExtGetSet final : public RlvExtCommandHandler
{
public:
RlvExtGetSet();
......
indra/newview/rlvfloaters.cpp
View file @ 655d119b
......@@ -210,7 +210,7 @@ std::string rlvFolderLockSourceToTarget(RlvFolderLocks::folderlock_source_t lock
// Checked: 2010-04-18 (RLVa-1.3.1c) | Modified: RLVa-1.2.0e
void RlvFloaterBehaviours::onOpen(const LLSD& sdKey)
{
m_ConnRlvCommand = gRlvHandler.setCommandCallback(boost::bind(&RlvFloaterBehaviours::onCommand, this, _1, _2));
m_ConnRlvCommand = RlvHandler::instance().setCommandCallback(boost::bind(&RlvFloaterBehaviours::onCommand, this, _1, _2));
refreshAll();
}
......@@ -359,7 +359,7 @@ void RlvFloaterBehaviours::refreshAll()
if ( (rlvCmd.hasOption()) && (rlvGetShowException(rlvCmd.getBehaviourType())) )
{
// List under the "Exception" tab
sdExceptRow["enabled"] = gRlvHandler.isException(rlvCmd.getBehaviourType(), idOption);
sdExceptRow["enabled"] = RlvHandler::instance().isException(rlvCmd.getBehaviourType(), idOption);
sdExceptColumns[0]["value"] = rlvCmd.getBehaviour();
sdExceptColumns[1]["value"] = strOption;
sdExceptColumns[2]["value"] = strIssuer;
......@@ -416,7 +416,7 @@ void RlvFloaterBehaviours::refreshAll()
// Checked: 2010-03-11 (RLVa-1.2.0)
void RlvFloaterLocks::onOpen(const LLSD& sdKey)
{
m_ConnRlvCommand = gRlvHandler.setCommandCallback(boost::bind(&RlvFloaterLocks::onRlvCommand, this, _1, _2));
m_ConnRlvCommand = RlvHandler::instance().setCommandCallback(boost::bind(&RlvFloaterLocks::onRlvCommand, this, _1, _2));
refreshAll();
}
......@@ -481,7 +481,7 @@ void RlvFloaterLocks::refreshAll()
sdColumns[0]["value"] = "Attachment";
sdColumns[1]["value"] = "rem";
const RlvAttachmentLocks::rlv_attachobjlock_map_t& attachObjRem = gRlvAttachmentLocks.getAttachObjLocks();
const RlvAttachmentLocks::rlv_attachobjlock_map_t& attachObjRem = RlvAttachmentLocks::instance().getAttachObjLocks();
for (RlvAttachmentLocks::rlv_attachobjlock_map_t::const_iterator itAttachObj = attachObjRem.begin();
itAttachObj != attachObjRem.end(); ++itAttachObj)
{
......@@ -497,7 +497,7 @@ void RlvFloaterLocks::refreshAll()
sdColumns[0]["value"] = "Attachment Point";
sdColumns[1]["value"] = "add";
const RlvAttachmentLocks::rlv_attachptlock_map_t& attachPtAdd = gRlvAttachmentLocks.getAttachPtLocks(RLV_LOCK_ADD);
const RlvAttachmentLocks::rlv_attachptlock_map_t& attachPtAdd = RlvAttachmentLocks::instance().getAttachPtLocks(RLV_LOCK_ADD);
for (RlvAttachmentLocks::rlv_attachptlock_map_t::const_iterator itAttachPt = attachPtAdd.begin();
itAttachPt != attachPtAdd.end(); ++itAttachPt)
{
......@@ -510,7 +510,7 @@ void RlvFloaterLocks::refreshAll()
}
sdColumns[1]["value"] = "rem";
const RlvAttachmentLocks::rlv_attachptlock_map_t& attachPtRem = gRlvAttachmentLocks.getAttachPtLocks(RLV_LOCK_REMOVE);
const RlvAttachmentLocks::rlv_attachptlock_map_t& attachPtRem = RlvAttachmentLocks::instance().getAttachPtLocks(RLV_LOCK_REMOVE);
for (RlvAttachmentLocks::rlv_attachptlock_map_t::const_iterator itAttachPt = attachPtRem.begin();
itAttachPt != attachPtRem.end(); ++itAttachPt)
{
......@@ -528,7 +528,7 @@ void RlvFloaterLocks::refreshAll()
sdColumns[0]["value"] = "Wearable Type";
sdColumns[1]["value"] = "add";
const RlvWearableLocks::rlv_wearabletypelock_map_t& wearableTypeAdd = gRlvWearableLocks.getWearableTypeLocks(RLV_LOCK_ADD);
const RlvWearableLocks::rlv_wearabletypelock_map_t& wearableTypeAdd = RlvWearableLocks::instance().getWearableTypeLocks(RLV_LOCK_ADD);
for (RlvWearableLocks::rlv_wearabletypelock_map_t::const_iterator itWearableType = wearableTypeAdd.begin();
itWearableType != wearableTypeAdd.end(); ++itWearableType)
{
......@@ -539,7 +539,7 @@ void RlvFloaterLocks::refreshAll()
}
sdColumns[1]["value"] = "rem";
const RlvWearableLocks::rlv_wearabletypelock_map_t& wearableTypeRem = gRlvWearableLocks.getWearableTypeLocks(RLV_LOCK_REMOVE);
const RlvWearableLocks::rlv_wearabletypelock_map_t& wearableTypeRem = RlvWearableLocks::instance().getWearableTypeLocks(RLV_LOCK_REMOVE);
for (RlvWearableLocks::rlv_wearabletypelock_map_t::const_iterator itWearableType = wearableTypeRem.begin();
itWearableType != wearableTypeRem.end(); ++itWearableType)
{
......@@ -651,7 +651,7 @@ BOOL RlvFloaterStrings::postBuild()
}
// Populate the combo box
for (LLSD::map_const_iterator itString = m_sdStringsInfo.beginMap(); itString != m_sdStringsInfo.endMap(); ++itString)
for (LLSD::map_const_iterator itString = m_sdStringsInfo.beginMap(), itEnd = m_sdStringsInfo.endMap(); itString != itEnd; ++itString)
{
const LLSD& sdStringInfo = itString->second;
if ( (!sdStringInfo.has("customizable")) || (!sdStringInfo["customizable"].asBoolean()) )
......@@ -760,7 +760,7 @@ BOOL RlvFloaterConsole::postBuild()
void RlvFloaterConsole::onClose(bool fQuitting)
{
RlvBehaviourDictionary::instance().clearModifiers(gAgent.getID());
gRlvHandler.processCommand(gAgent.getID(), "clear", true);
RlvHandler::instance().processCommand(gAgent.getID(), "clear", true);
}
void RlvFloaterConsole::addCommandReply(const std::string& strCommand, const std::string& strReply)
......@@ -796,7 +796,7 @@ void RlvFloaterConsole::onInput(LLUICtrl* pCtrl, const LLSD& sdParam)
boost::tokenizer tokens(strInput, boost::char_separator<char>(",", "", boost::drop_empty_tokens));
for (std::string strCmd : tokens)
{
ERlvCmdRet eRet = gRlvHandler.processCommand(gAgent.getID(), strCmd, true);
ERlvCmdRet eRet = RlvHandler::instance().processCommand(gAgent.getID(), strCmd, true);
if ( RLV_RET_SUCCESS == (eRet & RLV_RET_SUCCESS) )
pstr = &strExecuted;
else if ( RLV_RET_FAILED == (eRet & RLV_RET_FAILED) )
......
indra/newview/rlvfloaters.h
View file @ 655d119b
......@@ -38,7 +38,7 @@ enum class ERlvBehaviourFilter {
ALL
};
class RlvFloaterBehaviours : public LLFloater
class RlvFloaterBehaviours final : public LLFloater
{
friend class LLFloaterReg;
private:
......@@ -74,7 +74,7 @@ protected:
// RlvFloaterLocks class declaration
//
class RlvFloaterLocks : public LLFloater
class RlvFloaterLocks final : public LLFloater
{
friend class LLFloaterReg;
private:
......@@ -106,7 +106,7 @@ protected:
// RlvFloaterStrings class declaration
//
class RlvFloaterStrings : public LLFloater
class RlvFloaterStrings final : public LLFloater
{
friend class LLFloaterReg;
private:
......@@ -135,7 +135,7 @@ protected:
// RlvFloaterConsole - debug console to allow command execution without the need for a script
//
class RlvFloaterConsole : public LLFloater
class RlvFloaterConsole final : public LLFloater
{
friend class LLFloaterReg;
template<ERlvParamType> friend struct RlvCommandHandlerBaseImpl;
......
indra/newview/rlvhandler.cpp
View file @ 655d119b
......@@ -76,8 +76,6 @@
bool RlvHandler::m_fEnabled = false;
rlv_handler_t gRlvHandler;
// ============================================================================
// Command specific helper functions
//
......@@ -154,6 +152,8 @@ RlvHandler::~RlvHandler()
}
//delete m_pGCTimer; // <- deletes itself
LL_INFOS() << "RlvHandler shutdown" << LL_ENDL;
}
// ============================================================================
......@@ -612,7 +612,7 @@ bool RlvHandler::processIMQuery(const LLUUID& idSender, const std::string& strMe
params.substitutions = LLSD().with("NAME_LABEL", LLSLURL("agent", idSender, "completename").getSLURLString()).with("NAME_SLURL", LLSLURL("agent", idSender, "about").getSLURLString());
params.payload = LLSD().with("from_id", idSender).with("command", strMessage);
class RlvPostponedOfferNotification : public LLPostponedNotification
class RlvPostponedOfferNotification final : public LLPostponedNotification
{
protected:
void modifyNotificationParams() override
......@@ -861,7 +861,7 @@ void RlvHandler::onAttach(const LLViewerObject* pAttachObj, const LLViewerJointA
// We need to check this object for an active "@detach=n" and actually lock it down now that it's been attached somewhere
if (itObj->second.hasBehaviour(RLV_BHVR_DETACH, false))
gRlvAttachmentLocks.addAttachmentLock(pAttachObj->getID(), itObj->second.getObjectID());
RlvAttachmentLocks::instance().addAttachmentLock(pAttachObj->getID(), itObj->second.getObjectID());
}
}
}
......@@ -901,7 +901,7 @@ void RlvHandler::onDetach(const LLViewerObject* pAttachObj, const LLViewerJointA
// If this object has an active "@detach=n" then we need to release the attachment lock since it's no longer attached
if (itObj->second.hasBehaviour(RLV_BHVR_DETACH, false))
gRlvAttachmentLocks.removeAttachmentLock(pAttachObj->getID(), itObj->second.getObjectID());
RlvAttachmentLocks::instance().removeAttachmentLock(pAttachObj->getID(), itObj->second.getObjectID());
}
}
}
......@@ -1008,12 +1008,12 @@ bool RlvHandler::onGC()
// -> if it does run it likely means that there's a @detach=n in a *child* prim that we couldn't look up in onAttach()
// -> since RLV doesn't currently support @detach=n from child prims it's actually not such a big deal right now but still
if ( (pObj->isAttachment()) && (itCurObj->second.hasBehaviour(RLV_BHVR_DETACH, false)) )
gRlvAttachmentLocks.addAttachmentLock(pObj->getID(), itCurObj->second.getObjectID());
RlvAttachmentLocks::instance().addAttachmentLock(pObj->getID(), itCurObj->second.getObjectID());
}
}
}
RLV_ASSERT(gRlvAttachmentLocks.verifyAttachmentLocks()); // Verify that we haven't leaked any attachment locks somehow
RLV_ASSERT(RlvAttachmentLocks::instance().verifyAttachmentLocks()); // Verify that we haven't leaked any attachment locks somehow
// Clean up pending temp attachments that we were never able to resolve
rlv_blocked_object_list_t::const_iterator itBlocked = m_BlockedObjects.cbegin(), itCurBlocked;
......@@ -1305,8 +1305,8 @@ bool RlvHandler::redirectChatOrEmote(const std::string& strUTF8Text) const
if ( (!pFolder) || (!pAvatar) )
return false;
// Sanity check - if nothing is locked then we can definitely take it off
if ( (!gRlvAttachmentLocks.hasLockedAttachmentPoint(RLV_LOCK_REMOVE)) ||
(!gRlvWearableLocks.hasLockedWearableType(RLV_LOCK_REMOVE)) )
if ( (!RlvAttachmentLocks::instance().hasLockedAttachmentPoint(RLV_LOCK_REMOVE)) ||
(!RlvWearableLocks::instance().hasLockedWearableType(RLV_LOCK_REMOVE)) )
{
return true;
}
......@@ -1353,7 +1353,7 @@ bool RlvHandler::redirectChatOrEmote(const std::string& strUTF8Text) const
if ( (!pFolder) || (!pAvatar) )
return false;
// Sanity check - if nothing is locked then we can definitely wear it
if ( (!gRlvAttachmentLocks.hasLockedAttachmentPoint(RLV_LOCK_ANY)) || (!gRlvWearableLocks.hacLockedWearableType(RLV_LOCK_ANY)) )
if ( (!RlvAttachmentLocks::instance().hasLockedAttachmentPoint(RLV_LOCK_ANY)) || (!RlvWearableLocks::instance().hacLockedWearableType(RLV_LOCK_ANY)) )
return true;
/*
......@@ -1383,8 +1383,8 @@ bool RlvHandler::redirectChatOrEmote(const std::string& strUTF8Text) const
LLViewerInventoryCategory* pFolder;
if ( (!isWearable(wtType)) ||
( (gAgent.getWearable(wtType)) && (!isRemovable(wtType)) ) ||
( (gRlvHandler.getCompositeInfo(gAgent.getWearableItem(wtType), NULL, &pFolder)) &&
(pFolder->getUUID() != pItem->getParentUUID()) && (!gRlvHandler.canTakeOffComposite(pFolder)) ) )
( (RlvHandler::instance().getCompositeInfo(gAgent.getWearableItem(wtType), NULL, &pFolder)) &&
(pFolder->getUUID() != pItem->getParentUUID()) && (!RlvHandler::instance().canTakeOffComposite(pFolder)) ) )
{
return false;
}
......@@ -1397,8 +1397,8 @@ bool RlvHandler::redirectChatOrEmote(const std::string& strUTF8Text) const
LLViewerInventoryCategory* pFolder;
if ( (!pAttachPt) || (isLockedAttachment(pAttachPt, RLV_LOCK_ADD)) ||
( (pAttachPt->getObject()) && (isLockedAttachment(pAttachPt, RLV_LOCK_REMOVE)) ) ||
( (gRlvHandler.getCompositeInfo(pAttachPt->getItemID(), NULL, &pFolder)) &&
(pFolder->getUUID() != pItem->getParentUUID()) && (!gRlvHandler.canTakeOffComposite(pFolder)) ) )
( (RlvHandler::instance().getCompositeInfo(pAttachPt->getItemID(), NULL, &pFolder)) &&
(pFolder->getUUID() != pItem->getParentUUID()) && (!RlvHandler::instance().canTakeOffComposite(pFolder)) ) )
{
return false;
}
......@@ -1509,9 +1509,9 @@ ERlvCmdRet RlvHandler::processAddRemCommand(const RlvCommand& rlvCmd)
if ( (rlvCmdOption.isEmpty()) || ((LLWearableType::EType)idxType == rlvCmdOption.getWearableType()) )
{
if (RLV_TYPE_ADD == eType)
gRlvWearableLocks.addWearableTypeLock((LLWearableType::EType)idxType, rlvCmd.getObjectID(), eLock);
RlvWearableLocks::instance().addWearableTypeLock((LLWearableType::EType)idxType, rlvCmd.getObjectID(), eLock);
else
gRlvWearableLocks.removeWearableTypeLock((LLWearableType::EType)idxType, rlvCmd.getObjectID(), eLock);
RlvWearableLocks::instance().removeWearableTypeLock((LLWearableType::EType)idxType, rlvCmd.getObjectID(), eLock);
}
}
}
......@@ -1620,7 +1620,7 @@ ERlvCmdRet RlvHandler::processAddRemCommand(const RlvCommand& rlvCmd)
ERlvCmdRet RlvCommandHandlerBaseImpl<RLV_TYPE_ADDREM>::processCommand(const RlvCommand& rlvCmd, RlvBhvrHandlerFunc* pHandlerFunc, RlvBhvrToggleHandlerFunc* pToggleHandlerFunc)
{
ERlvBehaviour eBhvr = rlvCmd.getBehaviourType();
bool fRefCount = false, fHasBhvr = gRlvHandler.hasBehaviour(eBhvr);
bool fRefCount = false, fHasBhvr = RlvHandler::instance().hasBehaviour(eBhvr);
ERlvCmdRet eRet = (*pHandlerFunc)(rlvCmd, fRefCount);
......@@ -1630,23 +1630,23 @@ ERlvCmdRet RlvCommandHandlerBaseImpl<RLV_TYPE_ADDREM>::processCommand(const RlvC
if (RLV_TYPE_ADD == rlvCmd.getParamType())
{
if (rlvCmd.isStrict())
gRlvHandler.addException(rlvCmd.getObjectID(), RLV_BHVR_PERMISSIVE, eBhvr);
gRlvHandler.m_Behaviours[eBhvr]++;
RlvHandler::instance().addException(rlvCmd.getObjectID(), RLV_BHVR_PERMISSIVE, eBhvr);
RlvHandler::instance().m_Behaviours[eBhvr]++;
rlvCmd.markRefCounted();
}
else
{
if (rlvCmd.isStrict())
gRlvHandler.removeException(rlvCmd.getObjectID(), RLV_BHVR_PERMISSIVE, eBhvr);
gRlvHandler.m_Behaviours[eBhvr]--;
RlvHandler::instance().removeException(rlvCmd.getObjectID(), RLV_BHVR_PERMISSIVE, eBhvr);
RlvHandler::instance().m_Behaviours[eBhvr]--;
}
gRlvHandler.m_OnBehaviour(eBhvr, rlvCmd.getParamType());
if (fHasBhvr != gRlvHandler.hasBehaviour(eBhvr))
RlvHandler::instance().m_OnBehaviour(eBhvr, rlvCmd.getParamType());
if (fHasBhvr != RlvHandler::instance().hasBehaviour(eBhvr))
{
if (pToggleHandlerFunc)
(*pToggleHandlerFunc)(eBhvr, !fHasBhvr);
gRlvHandler.m_OnBehaviourToggle(eBhvr, rlvCmd.getParamType());
RlvHandler::instance().m_OnBehaviourToggle(eBhvr, rlvCmd.getParamType());
}
}
......@@ -1675,9 +1675,9 @@ ERlvCmdRet RlvBehaviourGenericHandler<RLV_OPTION_EXCEPTION>::onCommand(const Rlv
return RLV_RET_FAILED_OPTION;
if (RLV_TYPE_ADD == rlvCmd.getParamType())
gRlvHandler.addException(rlvCmd.getObjectID(), rlvCmd.getBehaviourType(), idException);
RlvHandler::instance().addException(rlvCmd.getObjectID(), rlvCmd.getBehaviourType(), idException);
else
gRlvHandler.removeException(rlvCmd.getObjectID(), rlvCmd.getBehaviourType(), idException);
RlvHandler::instance().removeException(rlvCmd.getObjectID(), rlvCmd.getBehaviourType(), idException);
fRefCount = true;
return RLV_RET_SUCCESS;
......@@ -1710,15 +1710,15 @@ ERlvCmdRet RlvBehaviourGenericHandler<RLV_OPTION_MODIFIER>::onCommand(const RlvC
// HACK-RLVa: reference counting doesn't happen until control returns to our caller but the modifier callbacks will happen now so we need to adjust the reference counts here
if (RLV_TYPE_ADD == rlvCmd.getParamType())
{
gRlvHandler.m_Behaviours[rlvCmd.getBehaviourType()]++;
RlvHandler::instance().m_Behaviours[rlvCmd.getBehaviourType()]++;
pBhvrModifier->addValue(modValue, rlvCmd.getObjectID(), rlvCmd.getBehaviourType());
gRlvHandler.m_Behaviours[rlvCmd.getBehaviourType()]--;
RlvHandler::instance().m_Behaviours[rlvCmd.getBehaviourType()]--;
}
else
{
gRlvHandler.m_Behaviours[rlvCmd.getBehaviourType()]--;
RlvHandler::instance().m_Behaviours[rlvCmd.getBehaviourType()]--;
pBhvrModifier->removeValue(modValue, rlvCmd.getObjectID(), rlvCmd.getBehaviourType());
gRlvHandler.m_Behaviours[rlvCmd.getBehaviourType()]++;
RlvHandler::instance().m_Behaviours[rlvCmd.getBehaviourType()]++;
}
fRefCount = true;
......@@ -1740,15 +1740,15 @@ ERlvCmdRet RlvBehaviourGenericHandler<RLV_OPTION_NONE_OR_MODIFIER>::onCommand(co
// HACK-RLVa: reference counting doesn't happen until control returns to our caller but the modifier callbacks will happen now so we need to adjust the reference counts here
if (RLV_TYPE_ADD == rlvCmd.getParamType())
{
gRlvHandler.m_Behaviours[rlvCmd.getBehaviourType()]++;
RlvHandler::instance().m_Behaviours[rlvCmd.getBehaviourType()]++;
pBhvrModifier->addValue(pBhvrModifier->getDefaultValue(), rlvCmd.getObjectID(), rlvCmd.getBehaviourType());
gRlvHandler.m_Behaviours[rlvCmd.getBehaviourType()]--;
RlvHandler::instance().m_Behaviours[rlvCmd.getBehaviourType()]--;
}
else
{
gRlvHandler.m_Behaviours[rlvCmd.getBehaviourType()]--;
RlvHandler::instance().m_Behaviours[rlvCmd.getBehaviourType()]--;
pBhvrModifier->removeValue(pBhvrModifier->getDefaultValue(), rlvCmd.getObjectID(), rlvCmd.getBehaviourType());
gRlvHandler.m_Behaviours[rlvCmd.getBehaviourType()]++;
RlvHandler::instance().m_Behaviours[rlvCmd.getBehaviourType()]++;
}
}
......@@ -1779,9 +1779,9 @@ ERlvCmdRet RlvBehaviourAddRemAttachHandler::onCommand(const RlvCommand& rlvCmd,
if ( (0 == idxAttachPt) || (itAttach->first == idxAttachPt) )
{
if (RLV_TYPE_ADD == rlvCmd.getParamType())
gRlvAttachmentLocks.addAttachmentPointLock(itAttach->first, rlvCmd.getObjectID(), eLock);
RlvAttachmentLocks::instance().addAttachmentPointLock(itAttach->first, rlvCmd.getObjectID(), eLock);
else
gRlvAttachmentLocks.removeAttachmentPointLock(itAttach->first, rlvCmd.getObjectID(), eLock);
RlvAttachmentLocks::instance().removeAttachmentPointLock(itAttach->first, rlvCmd.getObjectID(), eLock);
}
}
......@@ -1804,13 +1804,13 @@ ERlvCmdRet RlvBehaviourHandler<RLV_BHVR_DETACH>::onCommand(const RlvCommand& rlv
// - if it hasn't rezzed yet then it's a @detach=n from a non-attachment and RlvHandler::onAttach() takes care of it
// * @detach=y: - if it ever rezzed as an attachment we'll have cached the UUID of its root
// - if it never rezzed as an attachment there won't be a lock to remove
RlvHandler::rlv_object_map_t::const_iterator itObj = gRlvHandler.m_Objects.find(rlvCmd.getObjectID());
if ( (itObj != gRlvHandler.m_Objects.end()) && (itObj->second.hasLookup()) && (itObj->second.getAttachPt()) )
RlvHandler::rlv_object_map_t::const_iterator itObj = RlvHandler::instance().m_Objects.find(rlvCmd.getObjectID());
if ( (itObj != RlvHandler::instance().m_Objects.end()) && (itObj->second.hasLookup()) && (itObj->second.getAttachPt()) )
{
if (RLV_TYPE_ADD == rlvCmd.getParamType())
gRlvAttachmentLocks.addAttachmentLock(itObj->second.getRootID(), itObj->first);
RlvAttachmentLocks::instance().addAttachmentLock(itObj->second.getRootID(), itObj->first);
else
gRlvAttachmentLocks.removeAttachmentLock(itObj->second.getRootID(), itObj->first);
RlvAttachmentLocks::instance().removeAttachmentLock(itObj->second.getRootID(), itObj->first);
}
}
else // @detach:<attachpt>=n|y - RLV_LOCK_ADD and RLV_LOCK_REMOVE locks an attachment *point*
......@@ -1821,9 +1821,9 @@ ERlvCmdRet RlvBehaviourHandler<RLV_BHVR_DETACH>::onCommand(const RlvCommand& rlv
return RLV_RET_FAILED_OPTION;
if (RLV_TYPE_ADD == rlvCmd.getParamType())
gRlvAttachmentLocks.addAttachmentPointLock(idxAttachPt, rlvCmd.getObjectID(), (ERlvLockMask)(RLV_LOCK_ADD | RLV_LOCK_REMOVE));
RlvAttachmentLocks::instance().addAttachmentPointLock(idxAttachPt, rlvCmd.getObjectID(), (ERlvLockMask)(RLV_LOCK_ADD | RLV_LOCK_REMOVE));
else
gRlvAttachmentLocks.removeAttachmentPointLock(idxAttachPt, rlvCmd.getObjectID(), (ERlvLockMask)(RLV_LOCK_ADD | RLV_LOCK_REMOVE));
RlvAttachmentLocks::instance().removeAttachmentPointLock(idxAttachPt, rlvCmd.getObjectID(), (ERlvLockMask)(RLV_LOCK_ADD | RLV_LOCK_REMOVE));
}
fRefCount = false; // Don't reference count @detach[:<option>]=n
......@@ -1939,7 +1939,7 @@ void RlvBehaviourToggleHandler<RLV_BHVR_SETOVERLAY>::onCommandToggle(ERlvBehavio
{
// Get the UUID of the primary object (there should only be one)
std::list<const RlvObject*> lObjects;
gRlvHandler.findBehaviour(RLV_BHVR_SETOVERLAY, lObjects);
RlvHandler::instance().findBehaviour(RLV_BHVR_SETOVERLAY, lObjects);
RLV_ASSERT(lObjects.size() == 1);
idRlvObject = lObjects.front()->getObjectID();
}
......@@ -1957,9 +1957,9 @@ void RlvBehaviourModifierHandler<RLV_MODIFIER_OVERLAY_TEXTURE>::onValueChange()
if (RlvBehaviourModifier* pBhvrModifier = RlvBehaviourDictionary::instance().getModifier(RLV_MODIFIER_OVERLAY_TEXTURE))
{
if (pBhvrModifier->hasValue())
gRlvHandler.setOverlayImage(pBhvrModifier->getValue<LLUUID>());
RlvHandler::instance().setOverlayImage(pBhvrModifier->getValue<LLUUID>());
else
gRlvHandler.clearOverlayImage();
RlvHandler::instance().clearOverlayImage();
}
}
......@@ -1975,9 +1975,9 @@ ERlvCmdRet RlvBehaviourSendChannelHandler::onCommand(const RlvCommand& rlvCmd, b
return RLV_RET_FAILED_OPTION;
if (RLV_TYPE_ADD == rlvCmd.getParamType())
gRlvHandler.addException(rlvCmd.getObjectID(), rlvCmd.getBehaviourType(), nChannel);
RlvHandler::instance().addException(rlvCmd.getObjectID(), rlvCmd.getBehaviourType(), nChannel);
else
gRlvHandler.removeException(rlvCmd.getObjectID(), rlvCmd.getBehaviourType(), nChannel);
RlvHandler::instance().removeException(rlvCmd.getObjectID(), rlvCmd.getBehaviourType(), nChannel);
}
else
{
......@@ -2105,7 +2105,7 @@ ERlvCmdRet RlvBehaviourSetCamFovHandler::onCommand(const RlvCommand& rlvCmd, boo
{
static float s_nLastCameraAngle = DEFAULT_FIELD_OF_VIEW;
S32 nRefMinBhvr = gRlvHandler.m_Behaviours[RLV_BHVR_SETCAM_FOVMIN], nRefMaxBhvr = gRlvHandler.m_Behaviours[RLV_BHVR_SETCAM_FOVMAX];
S32 nRefMinBhvr = RlvHandler::instance().m_Behaviours[RLV_BHVR_SETCAM_FOVMIN], nRefMaxBhvr = RlvHandler::instance().m_Behaviours[RLV_BHVR_SETCAM_FOVMAX];
LLControlVariable* pSetting = gSavedSettings.getControl("CameraAngle");
// Save the user's current FOV angle if nothing's been restricted (yet)
......@@ -2190,26 +2190,26 @@ void RlvBehaviourToggleHandler<RLV_BHVR_SETCAM>::onCommandToggle(ERlvBehaviour e
// - behaviour modifiers => it's all handled for us once we set the primary object
// - RLV_BHVR_SETCAM_UNLOCK => manually (re)set the reference count (and possibly invoke the toggle handler)
LLUUID idRlvObject; bool fHasCamUnlock = gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM_UNLOCK);
LLUUID idRlvObject; bool fHasCamUnlock = RlvHandler::instance().hasBehaviour(RLV_BHVR_SETCAM_UNLOCK);
if (fHasBhvr)
{
// Get the UUID of the primary object
std::list<const RlvObject*> lObjects;
gRlvHandler.findBehaviour(RLV_BHVR_SETCAM, lObjects);
RlvHandler::instance().findBehaviour(RLV_BHVR_SETCAM, lObjects);
idRlvObject = lObjects.front()->getObjectID();
// Reset the @setcam_unlock reference count
gRlvHandler.m_Behaviours[RLV_BHVR_SETCAM_UNLOCK] = (lObjects.front()->hasBehaviour(RLV_BHVR_SETCAM_UNLOCK, false)) ? 1 : 0;
RlvHandler::instance().m_Behaviours[RLV_BHVR_SETCAM_UNLOCK] = (lObjects.front()->hasBehaviour(RLV_BHVR_SETCAM_UNLOCK, false)) ? 1 : 0;
}
else
{
std::list<const RlvObject*> lObjects;
// Restore the @setcam_unlock reference count
gRlvHandler.findBehaviour(RLV_BHVR_SETCAM_UNLOCK, lObjects);
gRlvHandler.m_Behaviours[RLV_BHVR_SETCAM_UNLOCK] = static_cast<S16>(lObjects.size());
RlvHandler::instance().findBehaviour(RLV_BHVR_SETCAM_UNLOCK, lObjects);
RlvHandler::instance().m_Behaviours[RLV_BHVR_SETCAM_UNLOCK] = static_cast<S16>(lObjects.size());
}
// Manually invoke the @setcam_unlock toggle handler if we toggled it on/off
if (fHasCamUnlock != gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM_UNLOCK))
if (fHasCamUnlock != RlvHandler::instance().hasBehaviour(RLV_BHVR_SETCAM_UNLOCK))
RlvBehaviourToggleHandler<RLV_BHVR_SETCAM_UNLOCK>::onCommandToggle(RLV_BHVR_SETCAM_UNLOCK, !fHasCamUnlock);
gAgentCamera.switchCameraPreset( (fHasBhvr) ? CAMERA_RLV_SETCAM_VIEW : CAMERA_PRESET_REAR_VIEW );
......@@ -2275,9 +2275,9 @@ ERlvCmdRet RlvBehaviourHandler<RLV_BHVR_SHOWHOVERTEXT>::onCommand(const RlvComma
return RLV_RET_FAILED_OPTION;
if (RLV_TYPE_ADD == rlvCmd.getParamType())
gRlvHandler.addException(rlvCmd.getObjectID(), rlvCmd.getBehaviourType(), idException);
RlvHandler::instance().addException(rlvCmd.getObjectID(), rlvCmd.getBehaviourType(), idException);
else
gRlvHandler.removeException(rlvCmd.getObjectID(), rlvCmd.getBehaviourType(), idException);
RlvHandler::instance().removeException(rlvCmd.getObjectID(), rlvCmd.getBehaviourType(), idException);
// Clear/restore the object's hover text as needed
LLViewerObject* pObj = gObjectList.findObject(idException);
......@@ -2479,7 +2479,7 @@ template<>
ERlvCmdRet RlvForceGenericHandler<RLV_OPTION_MODIFIER>::onCommand(const RlvCommand& rlvCmd)
{
// The object should be holding at least one active behaviour
if (!gRlvHandler.hasBehaviour(rlvCmd.getObjectID()))
if (!RlvHandler::instance().hasBehaviour(rlvCmd.getObjectID()))
return RLV_RET_FAILED_NOBEHAVIOUR;
// There should be an option and it should specify a valid modifier (RlvBehaviourModifier performs the appropriate type checks)
......@@ -2609,7 +2609,7 @@ ERlvCmdRet RlvForceRemAttachHandler::onCommand(const RlvCommand& rlvCmd)
RlvCommandOptionGeneric rlvCmdOption;
RlvCommandOptionHelper::parseOption(rlvCmd.getOption(), rlvCmdOption);
if (rlvCmdOption.isSharedFolder())
return gRlvHandler.onForceWear(rlvCmdOption.getSharedFolder(), rlvCmd.getBehaviourFlags());
return RlvHandler::instance().onForceWear(rlvCmdOption.getSharedFolder(), rlvCmd.getBehaviourFlags());
// @remattach:<attachpt>=force - force detach single attachment point
if (rlvCmdOption.isAttachmentPoint())
......@@ -2649,7 +2649,7 @@ ERlvCmdRet RlvForceHandler<RLV_BHVR_REMOUTFIT>::onCommand(const RlvCommand& rlvC
RlvCommandOptionGeneric rlvCmdOption;
RlvCommandOptionHelper::parseOption(rlvCmd.getOption(), rlvCmdOption);
if (rlvCmdOption.isSharedFolder())
return gRlvHandler.onForceWear(rlvCmdOption.getSharedFolder(), rlvCmd.getBehaviourFlags());
return RlvHandler::instance().onForceWear(rlvCmdOption.getSharedFolder(), rlvCmd.getBehaviourFlags());
if ( (!rlvCmdOption.isWearableType()) && (!rlvCmdOption.isEmpty()) )
return RLV_RET_FAILED_OPTION;
......@@ -2779,7 +2779,7 @@ ERlvCmdRet RlvForceHandler<RLV_BHVR_SETCAM_FOV>::onCommand(const RlvCommand& rlv
LLViewerCamera::getInstance()->setDefaultFOV(nFOV);
// Don't persist non-default changes that are due to RLV; but do resume persistance once reset back to the default
if ( (!gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM_FOVMIN)) && (!gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM_FOVMAX)) )
if ( (!RlvHandler::instance().hasBehaviour(RLV_BHVR_SETCAM_FOVMIN)) && (!RlvHandler::instance().hasBehaviour(RLV_BHVR_SETCAM_FOVMAX)) )
{
if (LLControlVariable* pSetting = gSavedSettings.getControl("CameraAngle"))
pSetting->setPersist( (pSetting->isDefault()) ? LLControlVariable::PERSIST_NONDFT : LLControlVariable::PERSIST_NO );
......@@ -2899,13 +2899,13 @@ ERlvCmdRet RlvForceHandler<RLV_BHVR_SETGROUP>::onCommand(const RlvCommand& rlvCm
if (fValid)
{
if (!gRlvHandler.checkActiveGroupThrottle(rlvCmd.getObjectID()))
if (!RlvHandler::instance().checkActiveGroupThrottle(rlvCmd.getObjectID()))
return RLV_RET_FAILED_THROTTLED;
if (optionList.size() == 1)
gRlvHandler.setActiveGroup(idGroup);
RlvHandler::instance().setActiveGroup(idGroup);
else if (optionList.size() == 2)
gRlvHandler.setActiveGroupRole(idGroup, optionList[1]);
RlvHandler::instance().setActiveGroupRole(idGroup, optionList[1]);
}
return (fValid) ? RLV_RET_SUCCESS : RLV_RET_FAILED_OPTION;
......@@ -2932,11 +2932,11 @@ ERlvCmdRet RlvForceHandler<RLV_BHVR_SIT>::onCommand(const RlvCommand& rlvCmd)
if (!RlvActions::canSit(pObj))
return RLV_RET_FAILED_LOCK;
if ((gRlvHandler.hasBehaviour(RLV_BHVR_STANDTP)) && (isAgentAvatarValid()))
if ((RlvHandler::instance().hasBehaviour(RLV_BHVR_STANDTP)) && (isAgentAvatarValid()))
{
if ( (isAgentAvatarValid()) && (gAgentAvatarp->isSitting()) )
return RLV_RET_FAILED_LOCK;
gRlvHandler.m_posSitSource = gAgent.getPositionGlobal();
RlvHandler::instance().m_posSitSource = gAgent.getPositionGlobal();
}
// Copy/paste from handle_sit_or_stand()
......@@ -2995,7 +2995,7 @@ ERlvCmdRet RlvForceHandler<RLV_BHVR_TPTO>::onCommand(const RlvCommand& rlvCmd)
return RLV_RET_FAILED_OPTION;
}
LLWorldMapMessage::url_callback_t cb = boost::bind(&RlvHandler::onTeleportCallback, &gRlvHandler, _1, posRegion, vecLookAt, rlvCmd.getObjectID());
LLWorldMapMessage::url_callback_t cb = boost::bind(&RlvHandler::onTeleportCallback, RlvHandler::getInstance(), _1, posRegion, vecLookAt, rlvCmd.getObjectID());
LLWorldMapMessage::getInstance()->sendNamedRegionRequest(posList[0], cb, std::string(""), true);
}
......@@ -3250,7 +3250,7 @@ ERlvCmdRet RlvHandler::onGetAttachNames(const RlvCommand& rlvCmd, std::string& s
fAdd = (pAttachPt->getNumObjects() > 0);
break;
case RLV_BHVR_GETADDATTACHNAMES: // Every attachment point that can be attached to (wear replace OR wear add)
fAdd = (gRlvAttachmentLocks.canAttach(pAttachPt) & RLV_WEAR);
fAdd = (RlvAttachmentLocks::instance().canAttach(pAttachPt) & RLV_WEAR);
break;
case RLV_BHVR_GETREMATTACHNAMES: // Every attachment point that has at least one attachment that can be force-detached
fAdd = RlvForceWear::isForceDetachable(pAttachPt);
......@@ -3306,12 +3306,12 @@ ERlvCmdRet RlvBehaviourCamZoomMinMaxHandler::onCommand(const RlvCommand& rlvCmd,
{
if (RLV_TYPE_ADD == rlvCmd.getParamType())
{
gRlvHandler.m_Behaviours[(RLV_BHVR_CAMZOOMMIN == rlvCmd.getBehaviourType()) ? RLV_BHVR_SETCAM_FOVMIN : RLV_BHVR_SETCAM_FOVMAX]++;
RlvHandler::instance().m_Behaviours[(RLV_BHVR_CAMZOOMMIN == rlvCmd.getBehaviourType()) ? RLV_BHVR_SETCAM_FOVMIN : RLV_BHVR_SETCAM_FOVMAX]++;
pBhvrModifier->addValue(DEFAULT_FIELD_OF_VIEW / nMult, rlvCmd.getObjectID(), rlvCmd.getBehaviourType());
}
else
{
gRlvHandler.m_Behaviours[(RLV_BHVR_CAMZOOMMIN == rlvCmd.getBehaviourType()) ? RLV_BHVR_SETCAM_FOVMIN : RLV_BHVR_SETCAM_FOVMAX]--;
RlvHandler::instance().m_Behaviours[(RLV_BHVR_CAMZOOMMIN == rlvCmd.getBehaviourType()) ? RLV_BHVR_SETCAM_FOVMIN : RLV_BHVR_SETCAM_FOVMAX]--;
pBhvrModifier->removeValue(DEFAULT_FIELD_OF_VIEW / nMult, rlvCmd.getObjectID(), rlvCmd.getBehaviourType());
}
}
......@@ -3550,7 +3550,7 @@ ERlvCmdRet RlvHandler::onGetOutfitNames(const RlvCommand& rlvCmd, std::string& s
fAdd = (gAgentWearables.getWearableCount(wtType) > 0);
break;
case RLV_BHVR_GETADDOUTFITNAMES: // Every layer that can be worn on (wear replace OR wear add)
fAdd = (gRlvWearableLocks.canWear(wtType) & RLV_WEAR);
fAdd = (RlvWearableLocks::instance().canWear(wtType) & RLV_WEAR);
break;
case RLV_BHVR_GETREMOUTFITNAMES: // Every layer that has at least one wearable that can be force-removed
fAdd = RlvForceWear::isForceRemovable(wtType);
......
indra/newview/rlvhandler.h
View file @ 655d119b
......@@ -32,15 +32,11 @@
// ============================================================================
class RlvHandler : public LLOldEvents::LLSimpleListener, public LLParticularGroupObserver
class RlvHandler final : public LLSingleton<RlvHandler>, public LLOldEvents::LLSimpleListener, public LLParticularGroupObserver
{
// Temporary LLSingleton look-alike
public:
static RlvHandler& instance();
static RlvHandler* getInstance();
LLSINGLETON(RlvHandler);
public:
RlvHandler();
~RlvHandler();
// --------------------------------
......@@ -281,22 +277,11 @@ public:
};
typedef RlvHandler rlv_handler_t;
extern rlv_handler_t gRlvHandler;
// ============================================================================
// Inlined member functions
//
inline RlvHandler& RlvHandler::instance()
{
return gRlvHandler;
}
inline RlvHandler* RlvHandler::getInstance()
{
return &gRlvHandler;
}
inline bool RlvHandler::hasBehaviour(ERlvBehaviour eBhvr, const std::string& strOption) const
{
return hasBehaviourExcept(eBhvr, strOption, LLUUID::null);
......
indra/newview/rlvhelper.cpp
View file @ 655d119b
......@@ -1147,7 +1147,7 @@ void RlvForceWear::forceFolder(const LLViewerInventoryCategory* pFolder, EWearAc
// 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);
ERlvWearMask eWearMask = RlvWearableLocks::instance().canWear(pRlvItem);
if ( ((ACTION_WEAR_REPLACE == eCurAction) && (eWearMask & RLV_WEAR_REPLACE)) ||
((ACTION_WEAR_ADD == eCurAction) && (eWearMask & RLV_WEAR_ADD)) )
{
......@@ -1168,7 +1168,7 @@ void RlvForceWear::forceFolder(const LLViewerInventoryCategory* pFolder, EWearAc
case LLAssetType::AT_OBJECT:
if (isWearAction(eAction))
{
ERlvWearMask eWearMask = gRlvAttachmentLocks.canAttach(pRlvItem);
ERlvWearMask eWearMask = RlvAttachmentLocks::instance().canAttach(pRlvItem);
if ( ((ACTION_WEAR_REPLACE == eCurAction) && (eWearMask & RLV_WEAR_REPLACE)) ||
((ACTION_WEAR_ADD == eCurAction) && (eWearMask & RLV_WEAR_ADD)) )
{
......@@ -1180,10 +1180,10 @@ void RlvForceWear::forceFolder(const LLViewerInventoryCategory* pFolder, EWearAc
LLViewerInventoryCategory* pCompositeFolder = NULL;
if ( (pAttachPt->getObject()) && (RlvSettings::getEnableComposites()) &&
(pAttachPt->getItemID() != pItem->getUUID()) &&
(gRlvHandler.getCompositeInfo(pAttachPt->getItemID(), NULL, &pCompositeFolder)) )
(RlvHandler::instance().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))
if (RlvHandler::instance().canTakeOffComposite(pCompositeFolder))
{
forceFolder(pCompositeFolder, ACTION_DETACH, FLAG_DEFAULT);
addAttachment(pRlvItem);
......@@ -1237,12 +1237,12 @@ bool RlvForceWear::isForceDetachable(const LLViewerObject* pAttachObj, bool fChe
return
(
(pAttachObj) && (pAttachObj->isAttachment())
&& ( (idExcept.isNull()) ? (!gRlvAttachmentLocks.isLockedAttachment(pAttachObj))
: (!gRlvAttachmentLocks.isLockedAttachmentExcept(pAttachObj, idExcept)) )
&& ( (idExcept.isNull()) ? (!RlvAttachmentLocks::instance().isLockedAttachment(pAttachObj))
: (!RlvAttachmentLocks::instance().isLockedAttachmentExcept(pAttachObj, idExcept)) )
&& (isStrippable(pAttachObj->getAttachmentItemID()))
#ifdef RLV_EXPERIMENTAL_COMPOSITEFOLDERS
&& ( (!fCheckComposite) || (!RlvSettings::getEnableComposites()) ||
(!gRlvHandler.getCompositeInfo(pAttachPt->getItemID(), NULL, &pFolder)) || (gRlvHandler.canTakeOffComposite(pFolder)) )
(!RlvHandler::instance().getCompositeInfo(pAttachPt->getItemID(), NULL, &pFolder)) || (RlvHandler::instance().canTakeOffComposite(pFolder)) )
#endif // RLV_EXPERIMENTAL_COMPOSITEFOLDERS
);
}
......@@ -1272,10 +1272,10 @@ void RlvForceWear::forceDetach(const LLViewerObject* pAttachObj)
#ifdef RLV_EXPERIMENTAL_COMPOSITEFOLDERS
LLViewerInventoryCategory* pFolder = NULL;
if ( (RlvSettings::getEnableComposites()) &&
(gRlvHandler.getCompositeInfo(pAttachPt->getItemID(), NULL, &pFolder)) )
(RlvHandler::instance().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))
if (RlvHandler::instance().canTakeOffComposite(pFolder))
forceFolder(pFolder, ACTION_DETACH, FLAG_DEFAULT);
}
else
......@@ -1310,12 +1310,12 @@ bool RlvForceWear::isForceRemovable(const LLViewerWearable* pWearable, bool fChe
return
(
(pWearable) && (LLAssetType::AT_CLOTHING == pWearable->getAssetType())
&& ( (idExcept.isNull()) ? !gRlvWearableLocks.isLockedWearable(pWearable)
: !gRlvWearableLocks.isLockedWearableExcept(pWearable, idExcept) )
&& ( (idExcept.isNull()) ? !RlvWearableLocks::instance().isLockedWearable(pWearable)
: !RlvWearableLocks::instance().isLockedWearableExcept(pWearable, idExcept) )
&& (isStrippable(pWearable->getItemID()))
#ifdef RLV_EXPERIMENTAL_COMPOSITEFOLDERS
&& ( (!fCheckComposite) || (!RlvSettings::getEnableComposites()) ||
(!gRlvHandler.getCompositeInfo(pWearable->getItemID(), NULL, &pFolder)) || (gRlvHandler.canTakeOffComposite(pFolder)) )
(!RlvHandler::instance().getCompositeInfo(pWearable->getItemID(), NULL, &pFolder)) || (RlvHandler::instance().canTakeOffComposite(pFolder)) )
#endif // RLV_EXPERIMENTAL_COMPOSITEFOLDERS
);
}
......@@ -1342,10 +1342,10 @@ void RlvForceWear::forceRemove(const LLViewerWearable* pWearable)
#ifdef RLV_EXPERIMENTAL_COMPOSITEFOLDERS
LLViewerInventoryCategory* pFolder = NULL;
if ( (RlvSettings::getEnableComposites()) &&
(gRlvHandler.getCompositeInfo(gAgent.getWearableItem(wtType), NULL, &pFolder)) )
(RlvHandler::instance().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))
if (RlvHandler::instance().canTakeOffComposite(pFolder))
forceFolder(pFolder, ACTION_DETACH, FLAG_DEFAULT);
}
else
......@@ -1676,7 +1676,7 @@ void RlvForceWear::onWearableArrived(LLWearable* pWearable, void* pParam)
}
}
if ( (idItem.notNull()) && (idItem != gAgent.getWearableItem(pWearable->getType())) &&
(gRlvHandler.getCompositeInfo(gAgent.getWearableItem(pWearable->getType()), NULL, &pFolder)) )
(RlvHandler::instance().getCompositeInfo(gAgent.getWearableItem(pWearable->getType()), NULL, &pFolder)) )
{
RlvForceWear rlvWear;
rlvWear.forceFolder(pFolder, ACTION_DETACH, FLAG_DEFAULT);
......@@ -1698,7 +1698,7 @@ 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));
m_ConnCommand = RlvHandler::instance().setCommandCallback(boost::bind(&RlvBehaviourNotifyHandler::onCommand, this, _1, _2, _3));
}
// Checked: 2010-03-03 (RLVa-1.2.0a) | Modified: RLVa-1.2.0a
......@@ -1775,9 +1775,9 @@ void RlvBehaviourNotifyHandler::onReattach(const LLViewerJointAttachment* pAttac
// Checked: 2010-03-13 (RLVa-1.2.0a) | Modified: RLVa-1.2.0a
BOOL RlvGCTimer::tick()
{
bool fContinue = gRlvHandler.onGC();
bool fContinue = RlvHandler::instance().onGC();
if (!fContinue)
gRlvHandler.m_pGCTimer = NULL;
RlvHandler::instance().m_pGCTimer = NULL;
return !fContinue;
}
......
indra/newview/rlvhelper.h
View file @ 655d119b
......@@ -187,7 +187,7 @@ typedef RlvForceHandler<RLV_BHVR_SETCAM_EYEOFFSET> RlvForceCamEyeFocusOffsetHand
// RlvCommandProcessor - Templated glue class that brings RlvBehaviourInfo, RlvCommandHandlerBaseImpl and RlvCommandHandler together
//
template <ERlvParamType templParamType, ERlvBehaviour templBhvr, typename handlerImpl = RlvCommandHandler<templParamType, templBhvr>, typename baseImpl = RlvCommandHandlerBaseImpl<templParamType>>
class RlvCommandProcessor : public RlvBehaviourInfo
class RlvCommandProcessor final : public RlvBehaviourInfo
{
public:
// Default constructor used by behaviour specializations
......@@ -217,7 +217,7 @@ template<ERlvBehaviourOptionType templOptionType> using RlvForceGenericProcessor
//
template <ERlvBehaviour eBhvr, typename handlerImpl = RlvBehaviourHandler<eBhvr>, typename toggleHandlerImpl = RlvBehaviourToggleHandler<eBhvr>>
class RlvBehaviourToggleProcessor : public RlvBehaviourInfo
class RlvBehaviourToggleProcessor final : public RlvBehaviourInfo
{
public:
RlvBehaviourToggleProcessor(const std::string& strBhvr, U32 nBhvrFlags = 0) : RlvBehaviourInfo(strBhvr, eBhvr, RLV_TYPE_ADDREM, nBhvrFlags) {}
......@@ -563,9 +563,6 @@ protected:
typedef std::map<LLUUID, U8> pendingattachments_map_t;
pendingattachments_map_t m_pendingAttachments;
private:
friend class LLSingleton<RlvForceWear>;
};
// ============================================================================
......@@ -642,7 +639,7 @@ private:
// Various helper classes/timers/functors
//
class RlvGCTimer : public LLEventTimer
class RlvGCTimer final : public LLEventTimer
{
public:
RlvGCTimer() : LLEventTimer(30.0) {}
......@@ -650,7 +647,7 @@ public:
};
// NOTE: Unused as of SL-3.7.2
class RlvCallbackTimerOnce : public LLEventTimer
class RlvCallbackTimerOnce final : public LLEventTimer
{
public:
typedef boost::function<void ()> nullary_func_t;
......
indra/newview/rlvinventory.cpp
View file @ 655d119b
......@@ -37,7 +37,7 @@ const std::string RlvInventory::cstrSharedRoot = RLV_ROOT_FOLDER;
//
// TODO-RLVa: [RLVa-1.2.1] This class really shouldn't be calling "fetchSharedLinks" directly so find a better way
class RlvSharedInventoryFetcher : public LLInventoryFetchDescendentsObserver
class RlvSharedInventoryFetcher final : public LLInventoryFetchDescendentsObserver
{
public:
RlvSharedInventoryFetcher(const uuid_vec_t& idFolders): LLInventoryFetchDescendentsObserver(idFolders) {}
......@@ -783,9 +783,9 @@ bool RlvWearableItemCollector::onCollectFolder(const LLInventoryCategory* pFolde
{
#ifdef RLV_EXPERIMENTAL_COMPOSITEFOLDERS
if ( (!RlvSettings::getEnableComposites()) || // ... if we're not checking composite folders
(!gRlvHandler.isCompositeFolder(pFolder)) || // ... or if it's not a composite folder
((m_fAttach) && (gRlvHandler.canWearComposite(pFolder))) || // ... or if we're attaching and can attach it OR
(!m_fAttach) && (gRlvHandler.canTakeOffComposite(pFolder)) ) // ... or if we're detaching and can detach it
(!RlvHandler::instance().isCompositeFolder(pFolder)) || // ... or if it's not a composite folder
((m_fAttach) && (RlvHandler::instance().canWearComposite(pFolder))) || // ... or if we're attaching and can attach it OR
(!m_fAttach) && (RlvHandler::instance().canTakeOffComposite(pFolder)) ) // ... or if we're detaching and can detach it
#endif // RLV_EXPERIMENTAL_COMPOSITEFOLDERS
{
m_Wearable.push_front(pFolder->getUUID());
......@@ -796,9 +796,9 @@ bool RlvWearableItemCollector::onCollectFolder(const LLInventoryCategory* pFolde
#ifdef RLV_EXPERIMENTAL_COMPOSITEFOLDERS
else if ( (RlvSettings::getEnableComposites()) &&
(RLV_FOLDER_PREFIX_HIDDEN == strFolder[0]) && // Hidden folder that's a...
(gRlvHandler.isCompositeFolder(pFolder)) && // ... composite folder which we...
( ((m_fAttach) && (gRlvHandler.canWearComposite(pFolder))) || // ... are attaching and can attach OR
(!m_fAttach) && (gRlvHandler.canTakeOffComposite(pFolder)) ) ) // ... are detaching and can detach
(RlvHandler::instance().isCompositeFolder(pFolder)) && // ... composite folder which we...
( ((m_fAttach) && (RlvHandler::instance().canWearComposite(pFolder))) || // ... are attaching and can attach OR
(!m_fAttach) && (RlvHandler::instance().canTakeOffComposite(pFolder)) ) ) // ... are detaching and can detach
{
m_Wearable.push_front(pFolder->getUUID());
m_FoldingMap.insert(std::pair<LLUUID, LLUUID>(pFolder->getUUID(), idParent));
......
indra/newview/rlvinventory.h
View file @ 655d119b
......@@ -102,14 +102,13 @@ protected:
private:
static const std::string cstrSharedRoot;
friend class RlvSharedInventoryFetcher;
friend class LLSingleton<RlvInventory>;
};
// ============================================================================
// RlvRenameOnWearObserver - Handles "auto-rename-on-wear" for (linked) items living under #RLV
//
class RlvRenameOnWearObserver : public LLInventoryFetchItemsObserver
class RlvRenameOnWearObserver final : public LLInventoryFetchItemsObserver
{
public:
RlvRenameOnWearObserver(const LLUUID& idItem) : LLInventoryFetchItemsObserver(idItem) {}
......@@ -143,7 +142,7 @@ private:
// [See LLInventoryTransactionObserver which says it's not entirely complete?]
// NOTE: the offer may span mulitple BulkUpdateInventory messages so if we're no longer around then (ie due to "delete this") then
// we'll miss those; in this specific case we only care about the *folder* though and that will be in the very first message
class RlvGiveToRLVTaskOffer : public LLInventoryObserver, RlvGiveToRLVOffer
class RlvGiveToRLVTaskOffer final : public LLInventoryObserver, RlvGiveToRLVOffer
{
public:
RlvGiveToRLVTaskOffer(const LLUUID& idTransaction) : RlvGiveToRLVOffer(), m_idTransaction(idTransaction) {}
......@@ -159,7 +158,7 @@ protected:
LLUUID m_idTransaction;
};
class RlvGiveToRLVAgentOffer : public LLInventoryFetchDescendentsObserver, RlvGiveToRLVOffer
class RlvGiveToRLVAgentOffer final : public LLInventoryFetchDescendentsObserver, RlvGiveToRLVOffer
{
public:
RlvGiveToRLVAgentOffer(const LLUUID& idFolder) : LLInventoryFetchDescendentsObserver(idFolder), RlvGiveToRLVOffer() {}
......@@ -175,7 +174,7 @@ protected:
// RlvCriteriaCategoryCollector - Criteria based folder matching filter used by @findfolder and @findfolders
//
class RlvCriteriaCategoryCollector : public LLInventoryCollectFunctor
class RlvCriteriaCategoryCollector final : public LLInventoryCollectFunctor
{
public:
RlvCriteriaCategoryCollector(const std::string& strCriteria)
......@@ -223,7 +222,7 @@ protected:
// RlvWearableItemCollector - Inventory item filter used by attach/detach/attachall/detachall/getinvworn
//
class RlvWearableItemCollector : public LLInventoryCollectFunctor
class RlvWearableItemCollector final : public LLInventoryCollectFunctor
{
public:
RlvWearableItemCollector(const LLInventoryCategory* pFolder, RlvForceWear::EWearAction eAction, RlvForceWear::EWearFlags eFlags);
......@@ -258,7 +257,7 @@ protected:
// General purpose inventory helper classes
//
class RlvIsLinkType : public LLInventoryCollectFunctor
class RlvIsLinkType final : public LLInventoryCollectFunctor
{
public:
RlvIsLinkType() = default;
......@@ -267,7 +266,7 @@ public:
};
// If the attachment item is linked in COF but isn't worn (or just detached) the function will return inconsistent information
class RlvFindAttachmentsOnPoint : public LLInventoryCollectFunctor
class RlvFindAttachmentsOnPoint final : public LLInventoryCollectFunctor
{
public:
RlvFindAttachmentsOnPoint(const LLViewerJointAttachment* pAttachPt) : m_pAttachPt(pAttachPt) {}
......
indra/newview/rlvlocks.cpp
View file @ 655d119b
......@@ -172,8 +172,6 @@ S32 RlvAttachPtLookup::getAttachPointIndexLegacy(const LLInventoryCategory* pFol
// RlvAttachmentLocks member functions
//
RlvAttachmentLocks gRlvAttachmentLocks;
// Checked: 2010-02-28 (RLVa-1.2.0a) | Modified: RLVa-1.2.0a
void RlvAttachmentLocks::addAttachmentLock(const LLUUID& idAttachObj, const LLUUID& idRlvObj)
{
......@@ -628,7 +626,7 @@ void RlvAttachmentLockWatchdog::onAttach(const LLViewerObject* pAttachObj, const
for (LLViewerJointAttachment::attachedobjs_vec_t::const_iterator itAttachObj = pAttachPt->mAttachedObjects.begin();
((itAttachObj != pAttachPt->mAttachedObjects.end()) && (fAttachAllowed)); ++itAttachObj)
{
if ( (pAttachObj != *itAttachObj) && (gRlvAttachmentLocks.isLockedAttachment(*itAttachObj)) )
if ( (pAttachObj != *itAttachObj) && (RlvAttachmentLocks::instance().isLockedAttachment(*itAttachObj)) )
{
// Fail if we encounter a non-detachable attachment (unless we're only replacing detachable attachments)
if (gSavedSettings.getBOOL("RLVaWearReplaceUnlocked"))
......@@ -673,7 +671,7 @@ void RlvAttachmentLockWatchdog::onDetach(const LLViewerObject* pAttachObj, const
// If the attachment is currently "remove locked" then we should reattach it (unless it's already pending reattach)
bool fDetachAllowed = true;
if (gRlvAttachmentLocks.isLockedAttachment(pAttachObj))
if (RlvAttachmentLocks::instance().isLockedAttachment(pAttachObj))
{
bool fPendingAttach = false;
for (rlv_attach_map_t::const_iterator itReattach = m_PendingAttach.lower_bound(idxAttachPt),
......@@ -768,7 +766,7 @@ void RlvAttachmentLockWatchdog::onWearAttachment(const LLUUID& idItem, ERlvWearM
{
// We only need to keep track of user wears if there's actually anything locked
RLV_ASSERT(idItem.notNull());
if ( (idItem.isNull()) || (!isAgentAvatarValid()) || (!gRlvAttachmentLocks.hasLockedAttachmentPoint(RLV_LOCK_ANY)) )
if ( (idItem.isNull()) || (!isAgentAvatarValid()) || (!RlvAttachmentLocks::instance().hasLockedAttachmentPoint(RLV_LOCK_ANY)) )
return;
// If the attachment point this will end up being attached to is:
......@@ -784,7 +782,7 @@ void RlvAttachmentLockWatchdog::onWearAttachment(const LLUUID& idItem, ERlvWearM
{
const LLViewerJointAttachment* pAttachPt = itAttachPt->second;
// We only need to know which attachments were present for RLV_LOCK_ADD locked attachment points (and not RLV_LOCK_REM locked ones)
if (gRlvAttachmentLocks.isLockedAttachmentPoint(pAttachPt, RLV_LOCK_ADD))
if (RlvAttachmentLocks::instance().isLockedAttachmentPoint(pAttachPt, RLV_LOCK_ADD))
{
uuid_vec_t attachObjs;
for (LLViewerJointAttachment::attachedobjs_vec_t::const_iterator itAttachObj = pAttachPt->mAttachedObjects.begin();
......@@ -810,8 +808,6 @@ void RlvAttachmentLockWatchdog::onWearAttachment(const LLUUID& idItem, ERlvWearM
// RlvWearableLocks member functions
//
RlvWearableLocks gRlvWearableLocks;
// Checked: 2010-03-18 (RLVa-1.2.0c) | Added: RLVa-1.2.0a
void RlvWearableLocks::addWearableTypeLock(LLWearableType::EType eType, const LLUUID& idRlvObj, ERlvLockMask eLock)
{
......@@ -927,7 +923,7 @@ void RlvWearableLocks::removeWearableTypeLock(LLWearableType::EType eType, const
// RlvFolderLocks member functions
//
class RlvLockedDescendentsCollector : public LLInventoryCollectFunctor
class RlvLockedDescendentsCollector final : public LLInventoryCollectFunctor
{
public:
RlvLockedDescendentsCollector(int eSourceTypeMask, RlvFolderLocks::ELockPermission ePermMask, ERlvLockMask eLockTypeMask)
......
indra/newview/rlvlocks.h
View file @ 655d119b
......@@ -57,11 +57,9 @@ private:
//
// TODO-RLVa: [RLVa-1.2.1] Once everything is working for SL-2.0 thin out the member functions since a few of them are duplicates/unneeded
class RlvAttachmentLocks
class RlvAttachmentLocks final : public LLSingleton<RlvAttachmentLocks>
{
public:
RlvAttachmentLocks() : m_fHasLockedHUD(false) {}
LLSINGLETON_EMPTY_CTOR(RlvAttachmentLocks);
public:
// Adds an RLV_LOCK_REMOVE lock (held by idRlvObj) for the attachment
void addAttachmentLock(const LLUUID& idAttachObj, const LLUUID& idRlvObj);
......@@ -128,11 +126,9 @@ private:
rlv_attachptlock_map_t m_AttachPtRem; // Map of attachment points whose attachments can't be detached (idxAttachPt -> idObj)
rlv_attachobjlock_map_t m_AttachObjRem; // Map of attachments that can't be detached (idAttachObj -> idObj)
bool m_fHasLockedHUD;
bool m_fHasLockedHUD = false;
};
extern RlvAttachmentLocks gRlvAttachmentLocks;
// ============================================================================
// RlvAttachmentLockWatchdog - Self contained class that automagically takes care of enforcing attachment locks (ie reattach-on-detach)
//
......@@ -206,7 +202,7 @@ protected:
typedef std::map<LLUUID, RlvWearInfo> rlv_wear_map_t;
rlv_wear_map_t m_PendingWear;
class RlvAttachmentLockWatchdogTimer : public LLEventTimer
class RlvAttachmentLockWatchdogTimer final : public LLEventTimer
{
public:
RlvAttachmentLockWatchdogTimer(RlvAttachmentLockWatchdog* pWatchdog) : LLEventTimer(10), m_pWatchdog(pWatchdog) {}
......@@ -220,8 +216,9 @@ protected:
// RlvWearableLocks class declaration - modelled on RlvAttachmentLocks (attach pt = wearable type - attachment = wearable)
//
class RlvWearableLocks
class RlvWearableLocks final : public LLSingleton<RlvWearableLocks>
{
LLSINGLETON_EMPTY_CTOR(RlvWearableLocks);
public:
// Adds an eLock type lock (held by idRlvObj) for the wearable type
void addWearableTypeLock(LLWearableType::EType eType, const LLUUID& idRlvObj, ERlvLockMask eLock);
......@@ -273,8 +270,6 @@ protected:
rlv_wearabletypelock_map_t m_WearableTypeRem;
};
extern RlvWearableLocks gRlvWearableLocks;
// ============================================================================
// RlvFolderLocks class declaration
//
......@@ -379,8 +374,6 @@ protected:
mutable uuid_vec_t m_LockedAttachmentRem;
mutable folderlock_map_t m_LockedFolderMap;
mutable uuid_vec_t m_LockedWearableRem;
private:
friend class LLSingleton<RlvFolderLocks>;
};
// ============================================================================
......
indra/newview/rlvmodifiers.h
View file @ 655d119b
......@@ -25,7 +25,7 @@
//
template<ERlvBehaviourModifier eBhvrMod>
class RlvBehaviourModifierHandler : public RlvBehaviourModifier
class RlvBehaviourModifierHandler final : public RlvBehaviourModifier
{
public:
//using RlvBehaviourModifier::RlvBehaviourModifier; // Needs VS2015 and up
......@@ -53,7 +53,7 @@ struct RlvBehaviourModifierComp
LLUUID m_idPrimaryObject;
};
struct RlvBehaviourModifierCompMin : public RlvBehaviourModifierComp
struct RlvBehaviourModifierCompMin final : public RlvBehaviourModifierComp
{
bool operator()(const RlvBehaviourModifierValueTuple& lhs, const RlvBehaviourModifierValueTuple& rhs) override
{
......@@ -63,7 +63,7 @@ struct RlvBehaviourModifierCompMin : public RlvBehaviourModifierComp
}
};
struct RlvBehaviourModifierCompMax : public RlvBehaviourModifierComp
struct RlvBehaviourModifierCompMax final : public RlvBehaviourModifierComp
{
bool operator()(const RlvBehaviourModifierValueTuple& lhs, const RlvBehaviourModifierValueTuple& rhs) override
{
......@@ -108,7 +108,7 @@ public:
* Animation timer
*/
protected:
class AnimationTimer : public LLEventTimer, public LLHandleProvider<AnimationTimer>
class AnimationTimer final : public LLEventTimer, public LLHandleProvider<AnimationTimer>
{
public:
AnimationTimer();
......
indra/newview/rlvui.cpp
View file @ 655d119b
......@@ -41,7 +41,7 @@
RlvUIEnabler::RlvUIEnabler()
{
// Connect us to the behaviour toggle signal
gRlvHandler.setBehaviourToggleCallback(boost::bind(&RlvUIEnabler::onBehaviourToggle, this, _1, _2));
RlvHandler::instance().setBehaviourToggleCallback(boost::bind(&RlvUIEnabler::onBehaviourToggle, this, _1, _2));
// onRefreshHoverText()
m_Handlers.insert(std::pair<ERlvBehaviour, behaviour_handler_t>(RLV_BHVR_SHOWLOC, boost::bind(&RlvUIEnabler::onRefreshHoverText, this)));
......@@ -97,11 +97,11 @@ void RlvUIEnabler::onRefreshHoverText()
// Checked: 2010-03-02 (RLVa-1.4.0a) | Modified: RLVa-1.4.0a
void RlvUIEnabler::onToggleMovement()
{
if ( (gRlvHandler.hasBehaviour(RLV_BHVR_FLY)) && (gAgent.getFlying()) )
if ( (RlvHandler::instance().hasBehaviour(RLV_BHVR_FLY)) && (gAgent.getFlying()) )
gAgent.setFlying(FALSE);
if ( (gRlvHandler.hasBehaviour(RLV_BHVR_ALWAYSRUN)) && (gAgent.getAlwaysRun()) )
if ( (RlvHandler::instance().hasBehaviour(RLV_BHVR_ALWAYSRUN)) && (gAgent.getAlwaysRun()) )
gAgent.clearAlwaysRun();
if ( (gRlvHandler.hasBehaviour(RLV_BHVR_TEMPRUN)) && (gAgent.getTempRun()) )
if ( (RlvHandler::instance().hasBehaviour(RLV_BHVR_TEMPRUN)) && (gAgent.getTempRun()) )
gAgent.clearTempRun();
// Force an update since the status only updates when the current parcel changes [see LLFloaterMove::postBuild()]
......@@ -111,7 +111,7 @@ void RlvUIEnabler::onToggleMovement()
// Checked: 2010-04-22 (RLVa-1.2.0f) | Modified: RLVa-1.2.0f
void RlvUIEnabler::onToggleShowLoc()
{
bool fEnable = !gRlvHandler.hasBehaviour(RLV_BHVR_SHOWLOC);
bool fEnable = !RlvHandler::instance().hasBehaviour(RLV_BHVR_SHOWLOC);
if (LLNavigationBar::instanceExists())
LLNavigationBar::instance().refreshLocationCtrl();
......@@ -178,7 +178,7 @@ void RlvUIEnabler::onToggleShowLoc()
// Checked: 2010-02-28 (RLVa-1.4.0a) | Added: RLVa-1.2.0a
void RlvUIEnabler::onToggleShowMinimap()
{
bool fEnable = !gRlvHandler.hasBehaviour(RLV_BHVR_SHOWMINIMAP);
bool fEnable = !RlvHandler::instance().hasBehaviour(RLV_BHVR_SHOWMINIMAP);
// Start or stop filtering showing the mini-map floater
if (!fEnable)
......@@ -209,7 +209,7 @@ void RlvUIEnabler::onToggleShowMinimap()
// Checked: 2010-02-28 (RLVa-1.4.0a) | Added: RLVa-1.2.0a
void RlvUIEnabler::onToggleShowWorldMap()
{
bool fEnable = !gRlvHandler.hasBehaviour(RLV_BHVR_SHOWWORLDMAP);
bool fEnable = !RlvHandler::instance().hasBehaviour(RLV_BHVR_SHOWWORLDMAP);
// Hide the world map if it's currently visible
if ( (!fEnable) && (LLFloaterReg::instanceVisible("world_map")) )
......@@ -229,13 +229,13 @@ void RlvUIEnabler::onToggleTp()
LLButton* pNavBarHomeBtn = LLNavigationBar::getInstance()->findChild<LLButton>("home_btn");
RLV_ASSERT(pNavBarHomeBtn);
if (pNavBarHomeBtn)
pNavBarHomeBtn->setEnabled(!(gRlvHandler.hasBehaviour(RLV_BHVR_TPLM) && gRlvHandler.hasBehaviour(RLV_BHVR_TPLOC)));
pNavBarHomeBtn->setEnabled(!(RlvHandler::instance().hasBehaviour(RLV_BHVR_TPLM) && RlvHandler::instance().hasBehaviour(RLV_BHVR_TPLOC)));
}
// Checked: 2010-03-01 (RLVa-1.2.0c) | Added: RLVa-1.2.0a
void RlvUIEnabler::onToggleUnsit()
{
bool fEnable = !gRlvHandler.hasBehaviour(RLV_BHVR_UNSIT);
bool fEnable = !RlvHandler::instance().hasBehaviour(RLV_BHVR_UNSIT);
LLPanelStandStopFlying* pPanelStand = LLPanelStandStopFlying::getInstance();
RLV_ASSERT(pPanelStand);
......@@ -252,8 +252,8 @@ void RlvUIEnabler::onToggleUnsit()
void RlvUIEnabler::onToggleViewXXX()
{
// If any of the three are still active then we keep filtering
bool fHasViewXXX = (gRlvHandler.hasBehaviour(RLV_BHVR_VIEWNOTE)) ||
(gRlvHandler.hasBehaviour(RLV_BHVR_VIEWSCRIPT)) || (gRlvHandler.hasBehaviour(RLV_BHVR_VIEWTEXTURE));
bool fHasViewXXX = (RlvHandler::instance().hasBehaviour(RLV_BHVR_VIEWNOTE)) ||
(RlvHandler::instance().hasBehaviour(RLV_BHVR_VIEWSCRIPT)) || (RlvHandler::instance().hasBehaviour(RLV_BHVR_VIEWTEXTURE));
// Start or stop filtering opening the preview floaters
if ( (fHasViewXXX) && (!m_ConnFloaterViewXXX.connected()) )
......@@ -327,17 +327,17 @@ bool RlvUIEnabler::filterPanelShowLoc(const std::string& strFloater, const std::
// Checked: 2010-03-01 (RLVa-1.2.0b) | Added: RLVa-1.2.0a
bool RlvUIEnabler::filterFloaterViewXXX(const std::string& strName, const LLSD&)
{
if ( (gRlvHandler.hasBehaviour(RLV_BHVR_VIEWNOTE)) && ("preview_notecard" == strName) )
if ( (RlvHandler::instance().hasBehaviour(RLV_BHVR_VIEWNOTE)) && ("preview_notecard" == strName) )
{
RlvUtil::notifyBlockedViewXXX(LLAssetType::AT_NOTECARD);
return false;
}
else if ( (gRlvHandler.hasBehaviour(RLV_BHVR_VIEWSCRIPT)) && (("preview_script" == strName) || ("preview_scriptedit" == strName)) )
else if ( (RlvHandler::instance().hasBehaviour(RLV_BHVR_VIEWSCRIPT)) && (("preview_script" == strName) || ("preview_scriptedit" == strName)) )
{
RlvUtil::notifyBlockedViewXXX(LLAssetType::AT_SCRIPT);
return false;
}
else if ( (gRlvHandler.hasBehaviour(RLV_BHVR_VIEWTEXTURE)) && ("preview_texture" == strName) )
else if ( (RlvHandler::instance().hasBehaviour(RLV_BHVR_VIEWTEXTURE)) && ("preview_texture" == strName) )
{
RlvUtil::notifyBlockedViewXXX(LLAssetType::AT_TEXTURE);
return false;
......@@ -351,8 +351,8 @@ bool RlvUIEnabler::filterFloaterViewXXX(const std::string& strName, const LLSD&)
bool RlvUIEnabler::canViewParcelProperties()
{
// We'll allow "About Land" as long as the user has the ability to return prims (through ownership or through group powers)
bool fShow = !gRlvHandler.hasBehaviour(RLV_BHVR_SHOWLOC);
if (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWLOC))
bool fShow = !RlvHandler::instance().hasBehaviour(RLV_BHVR_SHOWLOC);
if (RlvHandler::instance().hasBehaviour(RLV_BHVR_SHOWLOC))
{
// RELEASE-RLVa: [SL-3.2] Check that opening the "About Land" floater still sets focus to the current parcel is none is selected
const LLParcel* pParcel = NULL;
......@@ -397,8 +397,8 @@ bool RlvUIEnabler::canViewParcelProperties()
bool RlvUIEnabler::canViewRegionProperties()
{
// We'll allow "Region / Estate" if the user is either the region owner or an estate manager
bool fShow = !gRlvHandler.hasBehaviour(RLV_BHVR_SHOWLOC);
if (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWLOC))
bool fShow = !RlvHandler::instance().hasBehaviour(RLV_BHVR_SHOWLOC);
if (RlvHandler::instance().hasBehaviour(RLV_BHVR_SHOWLOC))
{
// [See LLRegion::canManageEstate() but without the "god-like" exception]
const LLViewerRegion* pRegion = gAgent.getRegion();
......