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

Merge branch 'rlva/development' into master

master
Kitty Barnett 2020-06-13 21:31:28 +02:00
parent fb670069b0 fa07fe8d1c
commit 93a457689d
11 changed files with 230 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
indra/llmath/v3dmath.h
View File

@ -115,6 +115,9 @@ class LLVector3d
friend LLVector3d operator*(const F64 k, const LLVector3d& a); // Return a times scaler k
friend bool operator==(const LLVector3d& a, const LLVector3d& b); // Return a == b
friend bool operator!=(const LLVector3d& a, const LLVector3d& b); // Return a != b
// [RLVa:KB] - RlvBehaviourModifierCompMin/Max
friend bool operator<(const LLVector3 &a, const LLVector3 &b); // Return a < b
// [/RLVa:KB]
friend const LLVector3d& operator+=(LLVector3d& a, const LLVector3d& b); // Return vector a + b
friend const LLVector3d& operator-=(LLVector3d& a, const LLVector3d& b); // Return vector a minus b
@ -395,6 +398,17 @@ inline bool operator!=(const LLVector3d& a, const LLVector3d& b)
||(a.mdV[2] != b.mdV[2]));
}
// [RLVa:KB] - RlvBehaviourModifierCompMin/Max
inline bool operator<(const LLVector3d& lhs, const LLVector3d& rhs)
{
return (lhs.mdV[0] < rhs.mdV[0]
|| (lhs.mdV[0] == rhs.mdV[0]
&& (lhs.mdV[1] < rhs.mdV[1]
|| ((lhs.mdV[1] == rhs.mdV[1])
&& lhs.mdV[2] < rhs.mdV[2]))));
}
// [/RLVa:KB]
inline const LLVector3d& operator+=(LLVector3d& a, const LLVector3d& b)
{
a.mdV[0] += b.mdV[0];

97
indra/newview/llagentcamera.cpp
View File

@ -219,16 +219,21 @@ void LLAgentCamera::init()
mCameraPreset = (ECameraPreset) gSavedSettings.getU32("CameraPresetType");
mCameraOffsetInitial = gSavedSettings.getControl("CameraOffsetRearView");
mFocusOffsetInitial = gSavedSettings.getControl("FocusOffsetRearView");
//// [RLVa:KB] - Checked: RLVa-2.0.0
// mCameraOffsetInitial[CAMERA_RLV_SETCAM_VIEW] = gSavedSettings.declareVec3("CameraOffsetRLVaView", LLVector3(mCameraOffsetInitial[CAMERA_PRESET_REAR_VIEW]->getDefault()), "Declared in code", LLControlVariable::PERSIST_NO);
// mCameraOffsetInitial[CAMERA_RLV_SETCAM_VIEW]->setHiddenFromSettingsEditor(true);
//// [/RLVa:KB]
//// [RLVa:KB] - Checked: RLVa-2.0.0
// mFocusOffsetInitial[CAMERA_RLV_SETCAM_VIEW] = gSavedSettings.declareVec3("FocusOffsetRLVaView", LLVector3(mFocusOffsetInitial[CAMERA_PRESET_REAR_VIEW]->getDefault()), "Declared in code", LLControlVariable::PERSIST_NO);
// mFocusOffsetInitial[CAMERA_RLV_SETCAM_VIEW]->setHiddenFromSettingsEditor(true);
//// [/RLVa:KB]
// mCameraOffsetInitial = gSavedSettings.getControl("CameraOffsetRearView");
// mFocusOffsetInitial = gSavedSettings.getControl("FocusOffsetRearView");
// [RLVa:KB] - @setcam_eyeoffset, @setcam_focusoffset and @setcam_eyeoffsetscale
mCameraOffsetInitialControl = gSavedSettings.getControl("CameraOffsetRearView");
mFocusOffsetInitialControl = gSavedSettings.getControl("FocusOffsetRearView");
if (RlvActions::isRlvEnabled())
{
mRlvCameraOffsetInitialControl = gSavedSettings.declareVec3("CameraOffsetRLVaView", LLVector3::zero, "Declared in code", LLControlVariable::PERSIST_NO);
mRlvCameraOffsetInitialControl->setHiddenFromSettingsEditor(true);
mRlvCameraOffsetScaleControl = gSavedSettings.declareF32("CameraOffsetScaleRLVa", 0.0f, "Declared in code", LLControlVariable::PERSIST_NO);
mRlvCameraOffsetScaleControl->setHiddenFromSettingsEditor(true);
mRlvFocusOffsetInitialControl = gSavedSettings.declareVec3d("FocusOffsetRLVaView", LLVector3d::zero, "Declared in code", LLControlVariable::PERSIST_NO);
mRlvFocusOffsetInitialControl->setHiddenFromSettingsEditor(true);
}
// [/RLVa:KB]
mCameraCollidePlane.clearVec();
mCurrentCameraDistance = getCameraOffsetInitial().magVec() * gSavedSettings.getF32("CameraOffsetScale");
@ -1014,7 +1019,10 @@ void LLAgentCamera::cameraOrbitIn(const F32 meters)
{
if (mFocusOnAvatar && mCameraMode == CAMERA_MODE_THIRD_PERSON)
{
F32 camera_offset_dist = llmax(0.001f, getCameraOffsetInitial().magVec() * gSavedSettings.getF32("CameraOffsetScale"));
// [RLVa:KB] - @setcam_eyeoffsetscale
F32 camera_offset_dist = llmax(0.001f, getCameraOffsetInitial().magVec() * getCameraOffsetScale());
// [/RLVa:KB]
// F32 camera_offset_dist = llmax(0.001f, getCameraOffsetInitial().magVec() * gSavedSettings.getF32("CameraOffsetScale"));
mCameraZoomFraction = (mTargetCameraDistance - meters) / camera_offset_dist;
@ -1727,7 +1735,10 @@ LLVector3d LLAgentCamera::calcThirdPersonFocusOffset()
agent_rot *= ((LLViewerObject*)(gAgentAvatarp->getParent()))->getRenderRotation();
}
focus_offset = convert_from_llsd<LLVector3d>(mFocusOffsetInitial->get(), TYPE_VEC3D, "");
// focus_offset = convert_from_llsd<LLVector3d>(mFocusOffsetInitial->get(), TYPE_VEC3D, "");
// [RLVa:KB] - @setcam_focusoffset
focus_offset = getFocusOffsetInitial();
// [/RLVa:KB]
return focus_offset * agent_rot;
}
@ -1868,7 +1879,10 @@ LLVector3d LLAgentCamera::calcCameraPositionTargetGlobal(BOOL *hit_limit)
}
else
{
local_camera_offset = mCameraZoomFraction * getCameraOffsetInitial() * gSavedSettings.getF32("CameraOffsetScale");
// [RLVa:KB] - @setcam_eyeoffsetscale
local_camera_offset = mCameraZoomFraction * getCameraOffsetInitial() * getCameraOffsetScale();
// [/RLVa:KB]
// local_camera_offset = mCameraZoomFraction * getCameraOffsetInitial() * gSavedSettings.getF32("CameraOffsetScale");
// are we sitting down?
if (isAgentAvatarValid() && gAgentAvatarp->getParent())
@ -2064,7 +2078,10 @@ LLVector3d LLAgentCamera::calcCameraPositionTargetGlobal(BOOL *hit_limit)
// Check focus distance limits
if ( (fCamOriginDistClamped) && (!fCamAvDistLocked) )
{
const LLVector3 offsetCameraLocal = mCameraZoomFraction * getCameraOffsetInitial() * gSavedSettings.getF32("CameraOffsetScale");
// const LLVector3 offsetCameraLocal = mCameraZoomFraction * getCameraOffsetInitial() * gSavedSettings.getF32("CameraOffsetScale");
// [RLVa:KB] - @setcam_eyeoffsetscale
const LLVector3 offsetCameraLocal = mCameraZoomFraction * getCameraOffsetInitial() * getCameraOffsetScale();
// [/RLVa:KB]
const LLVector3d offsetCamera(gAgent.getFrameAgent().rotateToAbsolute(offsetCameraLocal));
const LLVector3d posFocusCam = frame_center_global + head_offset + offsetCamera;
if (clampCameraPosition(camera_position_global, posFocusCam, nCamOriginDistLimitMin, nCamOriginDistLimitMax))
@ -2171,14 +2188,27 @@ bool LLAgentCamera::isJoystickCameraUsed()
LLVector3 LLAgentCamera::getCameraOffsetInitial()
{
return convert_from_llsd<LLVector3>(mCameraOffsetInitial->get(), TYPE_VEC3, "");
// [RLVa:KB] - @setcam_eyeoffset
return convert_from_llsd<LLVector3>( (ECameraPreset::CAMERA_RLV_SETCAM_VIEW != mCameraPreset) ? mCameraOffsetInitialControl->get() : mRlvCameraOffsetInitialControl->get(), TYPE_VEC3, "");
// [/RLVa:KB]
// return convert_from_llsd<LLVector3>(mCameraOffsetInitial->get(), TYPE_VEC3, "");
}
LLVector3d LLAgentCamera::getFocusOffsetInitial()
{
return convert_from_llsd<LLVector3d>(mFocusOffsetInitial->get(), TYPE_VEC3D, "");
// [RLVa:KB] - @setcam_focusoffset
return convert_from_llsd<LLVector3d>( (ECameraPreset::CAMERA_RLV_SETCAM_VIEW != mCameraPreset) ? mFocusOffsetInitialControl->get() : mRlvFocusOffsetInitialControl->get(), TYPE_VEC3D, "");
// [/RLVa:KB]
// return convert_from_llsd<LLVector3d>(mFocusOffsetInitial->get(), TYPE_VEC3D, "");
}
// [RLVa:KB] - @setcam_eyeoffsetscale
F32 LLAgentCamera::getCameraOffsetScale() const
{
return gSavedSettings.getF32( (ECameraPreset::CAMERA_RLV_SETCAM_VIEW != mCameraPreset) ? "CameraOffsetScale" : "CameraOffsetScaleRLVa");
}
// [/RLVa:KB]
// <FS:Ansariel> FIRE-23470: Fix camera controls zoom glitch
//F32 LLAgentCamera::getCameraMaxZoomDistance()
F32 LLAgentCamera::getCameraMaxZoomDistance(bool allow_disabled_constraints /* = false*/)
@ -2268,10 +2298,16 @@ void LLAgentCamera::handleScrollWheel(S32 clicks)
F32 camera_offset_initial_mag = getCameraOffsetInitial().magVec();
F32 current_zoom_fraction = mTargetCameraDistance / (camera_offset_initial_mag * gSavedSettings.getF32("CameraOffsetScale"));
// F32 current_zoom_fraction = mTargetCameraDistance / (camera_offset_initial_mag * gSavedSettings.getF32("CameraOffsetScale"));
// [RLVa:KB] - @setcam_eyeoffsetscale
F32 current_zoom_fraction = mTargetCameraDistance / (camera_offset_initial_mag * getCameraOffsetScale());
// [/RLVa:KB]
current_zoom_fraction *= 1.f - pow(ROOT_ROOT_TWO, clicks);
cameraOrbitIn(current_zoom_fraction * camera_offset_initial_mag * gSavedSettings.getF32("CameraOffsetScale"));
// [RLVa:KB] - @setcam_eyeoffsetscale
cameraOrbitIn(current_zoom_fraction * camera_offset_initial_mag * getCameraOffsetScale());
// [/RLVa:KB]
// cameraOrbitIn(current_zoom_fraction * camera_offset_initial_mag * gSavedSettings.getF32("CameraOffsetScale"));
}
else
{
@ -2623,22 +2659,27 @@ void LLAgentCamera::changeCameraToCustomizeAvatar()
void LLAgentCamera::switchCameraPreset(ECameraPreset preset)
{
// [RLVa:KB] - Checked: RLVa-2.0.0
// [RLVa:KB] - @setcam family
if (RlvActions::isRlvEnabled())
{
// Don't allow changing away from the our view if an object is restricting it
// Don't allow changing away from our view if an object is restricting it
if (RlvActions::isCameraPresetLocked())
preset = CAMERA_RLV_SETCAM_VIEW;
// Don't reset anything if our view is already current
if ( (CAMERA_RLV_SETCAM_VIEW == preset) && (CAMERA_RLV_SETCAM_VIEW == mCameraPreset) )
return;
// Reset our view when switching away
if (CAMERA_RLV_SETCAM_VIEW != preset)
if (CAMERA_RLV_SETCAM_VIEW == preset)
{
//mCameraOffsetInitial[CAMERA_RLV_SETCAM_VIEW]->resetToDefault();
//mFocusOffsetInitial[CAMERA_RLV_SETCAM_VIEW]->resetToDefault();
if (CAMERA_RLV_SETCAM_VIEW == mCameraPreset)
{
// Don't reset anything if our view is already current
return;
}
else
{
// When switching to our view, copy the current values
mRlvCameraOffsetInitialControl->setDefaultValue(convert_to_llsd(getCameraOffsetInitial()));
mRlvFocusOffsetInitialControl->setDefaultValue(convert_to_llsd(getFocusOffsetInitial()));
mRlvCameraOffsetScaleControl->setDefaultValue(getCameraOffsetScale());
}
}
}
// [/RLVa:KB]

30
indra/newview/llagentcamera.h
View File

@ -61,9 +61,9 @@ enum ECameraPreset
/** Current view when a preset is saved */
CAMERA_PRESET_CUSTOM,
// [RLVa:KB] - Checked: RLVa-2.0.0
// [RLVa:KB] - @setcam_eyeoffset and @setcam_focusoffset
/* Used by RLVa */
CAMERA_RLV_SETCAM_VIEW
CAMERA_RLV_SETCAM_VIEW,
// [/RLVa:KB]
};
@ -116,9 +116,17 @@ private:
// Preset
//--------------------------------------------------------------------
public:
// [RLVa:KB] - @setcam family
/** Determines default camera offset scale depending on the current camera preset */
ECameraPreset getCameraPreset() const { return mCameraPreset; }
// [/RLVa:KB]
void switchCameraPreset(ECameraPreset preset);
/** Determines default camera offset depending on the current camera preset */
LLVector3 getCameraOffsetInitial();
// [RLVa:KB] - @setcam_eyeoffsetscale
/** Determines default camera offset scale depending on the current camera preset */
F32 getCameraOffsetScale() const;
// [/RLVa:KB]
/** Determines default focus offset depending on the current camera preset */
LLVector3d getFocusOffsetInitial();
@ -140,10 +148,24 @@ private:
ECameraPreset mCameraPreset;
/** Initial camera offset */
LLPointer<LLControlVariable> mCameraOffsetInitial;
// LLPointer<LLControlVariable> mCameraOffsetInitial;
// [RLVa:KB] - @setcam_eyeoffset
// Renamed to catch their uses
LLPointer<LLControlVariable> mCameraOffsetInitialControl;
LLPointer<LLControlVariable> mRlvCameraOffsetInitialControl;
// [/RLVa:KB]
// [RLVa:KB] - @setcam_eyeoffsetscale
LLPointer<LLControlVariable> mRlvCameraOffsetScaleControl;
// [/RLVa:KB]
/** Initial focus offset */
LLPointer<LLControlVariable> mFocusOffsetInitial;
// LLPointer<LLControlVariable> mFocusOffsetInitial;
// [RLVa:KB] - @setcam_focusoffset
// Renamed to catch their uses
LLPointer<LLControlVariable> mFocusOffsetInitialControl;
LLPointer<LLControlVariable> mRlvFocusOffsetInitialControl;
// [/RLVa:KB]
LLQuaternion mInitSitRot;

10
indra/newview/llfloatercamera.cpp
View File

@ -45,6 +45,9 @@
#include "llhints.h"
#include "lltabcontainer.h"
#include "llvoavatarself.h"
// [RLVa:KB] - @setcam
#include "rlvactions.h"
// [/RLVa:KB]
static LLDefaultChildRegistry::Register<LLPanelCameraItem> r("panel_camera_item");
@ -626,6 +629,13 @@ void LLFloaterCamera::onClickCameraItem(const LLSD& param)
/*static*/
void LLFloaterCamera::switchToPreset(const std::string& name)
{
// [RLVa:KB] - @setcam family
if (RlvActions::isCameraPresetLocked())
{
return;
}
// [/RLVa:KB]
sFreeCamera = false;
clear_camera_tool();
if (PRESETS_REAR_VIEW == name)

6
indra/newview/rlvactions.cpp
View File

@ -42,7 +42,7 @@ 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));
(!gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM_EYEOFFSET)) && (!gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM_EYEOFFSETSCALE)) && (!gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM_FOCUSOFFSET));
}
bool RlvActions::canChangeToMouselook()
@ -70,7 +70,9 @@ bool RlvActions::isCameraFOVClamped()
bool RlvActions::isCameraPresetLocked()
{
return (gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM)) || (gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM_EYEOFFSET)) || (gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM_FOCUSOFFSET));
return
(gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM)) ||
(gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM_EYEOFFSET)) || (gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM_EYEOFFSETSCALE)) || (gRlvHandler.hasBehaviour(RLV_BHVR_SETCAM_FOCUSOFFSET));
}
bool RlvActions::getCameraAvatarDistanceLimits(float& nDistMin, float& nDistMax)

2
indra/newview/rlvcommon.h
View File

@ -57,7 +57,7 @@ class RlvObject;
struct RlvException;
typedef boost::variant<std::string, LLUUID, S32, ERlvBehaviour> RlvExceptionOption;
typedef boost::variant<int, float, bool, LLVector3, LLUUID> RlvBehaviourModifierValue;
typedef boost::variant<int, float, bool, LLVector3, LLVector3d, LLUUID> RlvBehaviourModifierValue;
class RlvGCTimer;

2
indra/newview/rlvdefines.h
View File

@ -214,6 +214,7 @@ enum ERlvBehaviour {
RLV_BHVR_SETCAM_ORIGINDISTMIN, // Enforces a minimum distance from the camera origin (in m)
RLV_BHVR_SETCAM_ORIGINDISTMAX, // Enforces a maximum distance from the camera origin (in m)
RLV_BHVR_SETCAM_EYEOFFSET, // Changes the default camera offset
RLV_BHVR_SETCAM_EYEOFFSETSCALE, // Changes the default camera offset scale
RLV_BHVR_SETCAM_FOCUSOFFSET, // Changes the default camera focus offset
RLV_BHVR_SETCAM_FOCUS, // Forces the camera focus and/or position to a specific object, avatar or position
RLV_BHVR_SETCAM_FOV, // Changes the current - vertical - field of view
@ -267,6 +268,7 @@ enum ERlvBehaviourModifier
RLV_MODIFIER_SETCAM_ORIGINDISTMIN, // Minimum distance between the camera position and the origin point (normal value)
RLV_MODIFIER_SETCAM_ORIGINDISTMAX, // Maximum distance between the camera position and the origin point (normal value)
RLV_MODIFIER_SETCAM_EYEOFFSET, // Specifies the default camera's offset from the camera (vector)
RLV_MODIFIER_SETCAM_EYEOFFSETSCALE, // Specifies the default camera's offset scale (multiplier)
RLV_MODIFIER_SETCAM_FOCUSOFFSET, // Specifies the default camera's focus (vector)
RLV_MODIFIER_SETCAM_FOVMIN, // Minimum value for the camera's field of view (angle in radians)
RLV_MODIFIER_SETCAM_FOVMAX, // Maximum value for the camera's field of view (angle in radians)

114
indra/newview/rlvhandler.cpp
View File

@ -37,6 +37,7 @@
#include "llavataractions.h" // @stopim IM query
#include "llavatarnamecache.h" // @shownames
#include "llavatarlist.h" // @shownames
#include "llfloatercamera.h" // @setcam family
#include "llfloatersidepanelcontainer.h"// @shownames
#include "llnotifications.h" // @list IM query
#include "llnotificationsutil.h"
@ -866,6 +867,23 @@ void RlvHandler::setActiveGroupRole(const LLUUID& idGroup, const std::string& st
m_PendingGroupChange = std::make_pair(LLUUID::null, LLStringUtil::null);
}
// @setcam family
void RlvHandler::setCameraOverride(bool fOverride)
{
if ( (fOverride) && (CAMERA_RLV_SETCAM_VIEW != gAgentCamera.getCameraPreset()) )
{
m_strCameraPresetRestore = gSavedSettings.getString("PresetCameraActive");
gAgentCamera.switchCameraPreset(CAMERA_RLV_SETCAM_VIEW);
}
else if ( (!fOverride) && (CAMERA_RLV_SETCAM_VIEW == gAgentCamera.getCameraPreset() && (!RlvActions::isCameraPresetLocked())) )
{
// We need to clear it or it won't reset properly
gSavedSettings.setString("PresetCameraActive", LLStringUtil::null);
LLFloaterCamera::switchToPreset(m_strCameraPresetRestore);
m_strCameraPresetRestore.clear();
}
}
// ============================================================================
// Externally invoked event handlers
//
@ -2121,20 +2139,23 @@ void RlvBehaviourModifierHandler<RLV_MODIFIER_SETCAM_AVDISTMIN>::onValueChange()
gAgentCamera.changeCameraToThirdPerson();
}
// Handles: @setcam_eyeoffset:<vector3>=n|y and @setcam_focusoffset:<vector3>=n|y toggles
// Handles: @setcam_eyeoffset:<vector3>=n|y, @setcam_eyeoffsetscale:<float>=n|y and @setcam_focusoffset:<vector3>=n|y toggles
template<> template<>
void RlvBehaviourCamEyeFocusOffsetHandler::onCommandToggle(ERlvBehaviour eBhvr, bool fHasBhvr)
{
if (fHasBhvr)
{
gAgentCamera.switchCameraPreset(CAMERA_RLV_SETCAM_VIEW);
gRlvHandler.setCameraOverride(true);
}
else
{
const RlvBehaviourModifier* pBhvrEyeModifier = RlvBehaviourDictionary::instance().getModifier(RLV_MODIFIER_SETCAM_EYEOFFSET);
const RlvBehaviourModifier* pBhvrOffsetModifier = RlvBehaviourDictionary::instance().getModifier(RLV_MODIFIER_SETCAM_FOCUSOFFSET);
if ( (!pBhvrEyeModifier->hasValue()) && (!pBhvrOffsetModifier->hasValue()) )
gAgentCamera.switchCameraPreset(CAMERA_PRESET_REAR_VIEW);
const RlvBehaviourModifier* pBhvrEyeOffsetModifier = RlvBehaviourDictionary::instance().getModifier(RLV_MODIFIER_SETCAM_EYEOFFSET);
const RlvBehaviourModifier* pBhvrEyeOffsetScaleModifier = RlvBehaviourDictionary::instance().getModifier(RLV_MODIFIER_SETCAM_EYEOFFSETSCALE);
const RlvBehaviourModifier* pBhvrFocusOffsetModifier = RlvBehaviourDictionary::instance().getModifier(RLV_MODIFIER_SETCAM_FOCUSOFFSET);
if ( (!pBhvrEyeOffsetModifier->hasValue()) && (!pBhvrEyeOffsetScaleModifier->hasValue()) && (!pBhvrFocusOffsetModifier->hasValue()) )
{
gRlvHandler.setCameraOverride(false);
}
}
}
@ -2152,7 +2173,21 @@ void RlvBehaviourModifierHandler<RLV_MODIFIER_SETCAM_EYEOFFSET>::onValueChange()
}
}
// Handles: @setcam_focusoffset:<vector3>=n|y changes
// Handles: @setcam_eyeoffsetscale:<float>=n|y changes
template<>
void RlvBehaviourModifierHandler<RLV_MODIFIER_SETCAM_EYEOFFSETSCALE>::onValueChange() const
{
if (RlvBehaviourModifier* pBhvrModifier = RlvBehaviourDictionary::instance().getModifier(RLV_MODIFIER_SETCAM_EYEOFFSETSCALE))
{
LLControlVariable* pControl = gSavedSettings.getControl("CameraOffsetScaleRLVa");
if (pBhvrModifier->hasValue())
pControl->setValue(pBhvrModifier->getValue<float>());
else
pControl->resetToDefault();
}
}
// Handles: @setcam_focusoffset:<vector3d>=n|y changes
template<>
void RlvBehaviourModifierHandler<RLV_MODIFIER_SETCAM_FOCUSOFFSET>::onValueChange() const
{
@ -2160,7 +2195,7 @@ void RlvBehaviourModifierHandler<RLV_MODIFIER_SETCAM_FOCUSOFFSET>::onValueChange
{
LLControlVariable* pControl = gSavedSettings.getControl("FocusOffsetRLVaView");
if (pBhvrModifier->hasValue())
pControl->setValue(pBhvrModifier->getValue<LLVector3>().getValue());
pControl->setValue(pBhvrModifier->getValue<LLVector3d>().getValue());
else
pControl->resetToDefault();
}
@ -2279,12 +2314,13 @@ void RlvBehaviourToggleHandler<RLV_BHVR_SETCAM>::onCommandToggle(ERlvBehaviour e
if (fHasCamUnlock != gRlvHandler.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 );
gRlvHandler.setCameraOverride(fHasBhvr);
RlvBehaviourDictionary::instance().getModifier(RLV_MODIFIER_SETCAM_AVDISTMIN)->setPrimaryObject(idRlvObject);
RlvBehaviourDictionary::instance().getModifier(RLV_MODIFIER_SETCAM_AVDISTMAX)->setPrimaryObject(idRlvObject);
RlvBehaviourDictionary::instance().getModifier(RLV_MODIFIER_SETCAM_ORIGINDISTMIN)->setPrimaryObject(idRlvObject);
RlvBehaviourDictionary::instance().getModifier(RLV_MODIFIER_SETCAM_ORIGINDISTMAX)->setPrimaryObject(idRlvObject);
RlvBehaviourDictionary::instance().getModifier(RLV_MODIFIER_SETCAM_EYEOFFSET)->setPrimaryObject(idRlvObject);
RlvBehaviourDictionary::instance().getModifier(RLV_MODIFIER_SETCAM_EYEOFFSETSCALE)->setPrimaryObject(idRlvObject);
RlvBehaviourDictionary::instance().getModifier(RLV_MODIFIER_SETCAM_FOCUSOFFSET)->setPrimaryObject(idRlvObject);
RlvBehaviourDictionary::instance().getModifier(RLV_MODIFIER_SETCAM_FOVMIN)->setPrimaryObject(idRlvObject);
RlvBehaviourDictionary::instance().getModifier(RLV_MODIFIER_SETCAM_FOVMAX)->setPrimaryObject(idRlvObject);
@ -2788,7 +2824,7 @@ ERlvCmdRet RlvForceHandler<RLV_BHVR_REMOUTFIT>::onCommand(const RlvCommand& rlvC
return RLV_RET_SUCCESS;
}
// Handles: @setcam_eyeoffset[:<vector3>]=force and @setcam_focusoffset[:<vector3>]=force
// Handles: @setcam_eyeoffset[:<vector3>]=force, @setcam_eyeoffsetscale[:<float>]=force and @setcam_focusoffset[:<vector3>]=force
template<> template<>
ERlvCmdRet RlvForceCamEyeFocusOffsetHandler::onCommand(const RlvCommand& rlvCmd)
{
@ -2796,22 +2832,54 @@ ERlvCmdRet RlvForceCamEyeFocusOffsetHandler::onCommand(const RlvCommand& rlvCmd)
if (!RlvActions::canChangeCameraPreset(rlvCmd.getObjectID()))
return RLV_RET_FAILED_LOCK;
LLControlVariable* pOffsetControl = gSavedSettings.getControl("CameraOffsetRLVaView");
LLControlVariable* pFocusControl = gSavedSettings.getControl("FocusOffsetRLVaView");
LLControlVariable* pControl = (rlvCmd.getBehaviourType() == RLV_BHVR_SETCAM_EYEOFFSET) ? pOffsetControl : pFocusControl;
if (rlvCmd.hasOption())
LLControlVariable* pEyeOffsetControl = gSavedSettings.getControl("CameraOffsetRLVaView");
LLControlVariable* pEyeOffsetScaleControl = gSavedSettings.getControl("CameraOffsetScaleRLVa");
LLControlVariable* pFocusOffsetControl = gSavedSettings.getControl("FocusOffsetRLVaView");
LLControlVariable* pControl; LLSD sdControlValue;
switch (rlvCmd.getBehaviourType())
{
LLVector3 vecOffset;
if (!RlvCommandOptionHelper::parseOption(rlvCmd.getOption(), vecOffset))
return RLV_RET_FAILED_OPTION;
pControl->setValue(vecOffset.getValue());
}
else
{
pControl->resetToDefault();
case RLV_BHVR_SETCAM_EYEOFFSET:
if (rlvCmd.hasOption())
{
LLVector3 vecOffset;
if (!RlvCommandOptionHelper::parseOption(rlvCmd.getOption(), vecOffset))
return RLV_RET_FAILED_OPTION;
sdControlValue = vecOffset.getValue();
}
pControl = pEyeOffsetControl;
break;
case RLV_BHVR_SETCAM_EYEOFFSETSCALE:
if (rlvCmd.hasOption())
{
float nScale;
if (!RlvCommandOptionHelper::parseOption(rlvCmd.getOption(), nScale))
return RLV_RET_FAILED_OPTION;
sdControlValue = nScale;
}
pControl = pEyeOffsetScaleControl;
break;
case RLV_BHVR_SETCAM_FOCUSOFFSET:
if (rlvCmd.hasOption())
{
LLVector3d vecOffset;
if (!RlvCommandOptionHelper::parseOption(rlvCmd.getOption(), vecOffset))
return RLV_RET_FAILED_OPTION;
sdControlValue = vecOffset.getValue();
}
pControl = pFocusOffsetControl;
break;
default:
return RLV_RET_FAILED;
}
gAgentCamera.switchCameraPreset( ((pOffsetControl->isDefault()) && (pFocusControl->isDefault())) ? CAMERA_PRESET_REAR_VIEW : CAMERA_RLV_SETCAM_VIEW);
if (!sdControlValue.isUndefined())
pControl->setValue(sdControlValue);
else
pControl->resetToDefault();
// NOTE: this doesn't necessarily release the camera preset even if all 3 are at their default now (e.g. @setcam is currently set)
gRlvHandler.setCameraOverride( (!pEyeOffsetControl->isDefault()) || (!pEyeOffsetScaleControl->isDefault()) || (!pFocusOffsetControl->isDefault()) );
return RLV_RET_SUCCESS;
}

3
indra/newview/rlvhandler.h
View File

@ -147,6 +147,7 @@ protected:
void clearOverlayImage(); // @setoverlay=n
void setActiveGroup(const LLUUID& idGroup); // @setgroup=force
void setActiveGroupRole(const LLUUID& idGroup, const std::string& strRole); // @setgroup=force
void setCameraOverride(bool fOverride); // @setcam family
void setOverlayImage(const LLUUID& idTexture); // @setoverlay=n
void onIMQueryListResponse(const LLSD& sdNotification, const LLSD sdResponse);
@ -265,6 +266,8 @@ protected:
LLPointer<LLViewerFetchedTexture> m_pOverlayImage = nullptr; // @setoverlay=n
int m_nOverlayOrigBoost = 0; // @setoverlay=n
std::string m_strCameraPresetRestore; // @setcam_eyeoffset, @setcam_eyeoffsetscale and @setcam_focusoffset
friend class RlvSharedRootFetcher; // Fetcher needs access to m_fFetchComplete
friend class RlvGCTimer; // Timer clear its own point at destruction
template<ERlvBehaviourOptionType> friend struct RlvBehaviourGenericHandler;

13
indra/newview/rlvhelper.cpp
View File

@ -193,10 +193,12 @@ RlvBehaviourDictionary::RlvBehaviourDictionary()
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", RlvBehaviourInfo::BHVR_EXPERIMENTAL));
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_FOCUSOFFSET, RLV_OPTION_MODIFIER, RlvBehaviourCamEyeFocusOffsetHandler>("setcam_focusoffset", RlvBehaviourInfo::BHVR_EXPERIMENTAL));
addModifier(RLV_BHVR_SETCAM_FOCUSOFFSET, RLV_MODIFIER_SETCAM_FOCUSOFFSET, new RlvBehaviourModifierHandler<RLV_MODIFIER_SETCAM_FOCUSOFFSET>("Camera - Focus 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"));
@ -265,8 +267,9 @@ RlvBehaviourDictionary::RlvBehaviourDictionary()
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", RlvBehaviourInfo::BHVR_EXPERIMENTAL));
addEntry(new RlvForceProcessor<RLV_BHVR_SETCAM_FOCUSOFFSET, RlvForceCamEyeFocusOffsetHandler>("setcam_focusoffset", 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"));

4
indra/newview/rlvhelper.h
View File

@ -172,7 +172,7 @@ template<ERlvBehaviour templBhvr> using RlvForceHandler = RlvCommandHandler<RLV_
template<ERlvBehaviour templBhvr> using RlvReplyHandler = RlvCommandHandler<RLV_TYPE_REPLY, templBhvr>;
// List of shared handlers
typedef RlvBehaviourToggleHandler<RLV_BHVR_SETCAM_EYEOFFSET> RlvBehaviourCamEyeFocusOffsetHandler; // Shared between @setcam_eyeoffset and @setcam_focusoffset
typedef RlvBehaviourToggleHandler<RLV_BHVR_SETCAM_EYEOFFSET> RlvBehaviourCamEyeFocusOffsetHandler; // Shared between @setcam_eyeoffset, @setcam_eyeoffsetscale and @setcam_focusoffset
typedef RlvBehaviourHandler<RLV_BHVR_REMATTACH> RlvBehaviourAddRemAttachHandler; // Shared between @addattach and @remattach
typedef RlvBehaviourHandler<RLV_BHVR_SENDCHANNEL> RlvBehaviourSendChannelHandler; // Shared between @sendchannel and @sendchannel_except
typedef RlvBehaviourHandler<RLV_BHVR_SENDIM> RlvBehaviourRecvSendStartIMHandler; // Shared between @recvim, @sendim and @startim
@ -181,7 +181,7 @@ typedef RlvBehaviourToggleHandler<RLV_BHVR_SHOWSELF> RlvBehaviourShowSelfToggleH
typedef RlvBehaviourHandler<RLV_BHVR_CAMZOOMMIN> RlvBehaviourCamZoomMinMaxHandler; // Shared between @camzoommin and @camzoommax (deprecated)
typedef RlvReplyHandler<RLV_BHVR_GETCAM_AVDISTMIN> RlvReplyCamMinMaxModifierHandler; // Shared between @getcam_avdistmin and @getcam_avdistmax
typedef RlvForceHandler<RLV_BHVR_REMATTACH> RlvForceRemAttachHandler; // Shared between @remattach and @detach
typedef RlvForceHandler<RLV_BHVR_SETCAM_EYEOFFSET> RlvForceCamEyeFocusOffsetHandler; // Shared between @setcam_eyeoffset and @setcam_focusoffset
typedef RlvForceHandler<RLV_BHVR_SETCAM_EYEOFFSET> RlvForceCamEyeFocusOffsetHandler; // Shared between @setcam_eyeoffset, @setcam_eyeoffsetscale and @setcam_focusoffset
//
// RlvCommandProcessor - Templated glue class that brings RlvBehaviourInfo, RlvCommandHandlerBaseImpl and RlvCommandHandler together