diff --git a/indra/newview/llagent.cpp b/indra/newview/llagent.cpp
index 5ee026f02122105df931fcfd9662974ef9622af1..5dd42152061d906b569d37de669e6a7775df626f 100644
--- a/indra/newview/llagent.cpp
+++ b/indra/newview/llagent.cpp
@@ -82,8 +82,6 @@
#include "llworld.h"
#include "llworldmap.h"
-LLAgentCamera gAgentCameraHACK; // Seraph delete
-
using namespace LLVOAvatarDefines;
extern LLMenuBarGL* gMenuBarView;
@@ -110,65 +108,20 @@ const F32 AUTOPILOT_MAX_TIME_NO_PROGRESS = 1.5f; // seconds
const LLVector3d FACE_EDIT_CAMERA_OFFSET(0.4f, -0.05f, 0.07f);
const LLVector3d FACE_EDIT_TARGET_OFFSET(0.f, 0.f, 0.05f);
-/*
-// Mousewheel camera zoom
-const F32 MIN_ZOOM_FRACTION = 0.25f;
-const F32 INITIAL_ZOOM_FRACTION = 1.f;
-const F32 MAX_ZOOM_FRACTION = 8.f;
-*/
-
const F32 METERS_PER_WHEEL_CLICK = 1.f;
const F32 MAX_TIME_DELTA = 1.f;
-/*
-const F32 CAMERA_ZOOM_HALF_LIFE = 0.07f; // seconds
-const F32 FOV_ZOOM_HALF_LIFE = 0.07f; // seconds
-
-const F32 CAMERA_FOCUS_HALF_LIFE = 0.f;//0.02f;
-const F32 CAMERA_LAG_HALF_LIFE = 0.25f;
-const F32 MIN_CAMERA_LAG = 0.5f;
-const F32 MAX_CAMERA_LAG = 5.f;
-
-const F32 CAMERA_COLLIDE_EPSILON = 0.1f;
-const F32 MIN_CAMERA_DISTANCE = 0.1f;
-const F32 AVATAR_ZOOM_MIN_X_FACTOR = 0.55f;
-const F32 AVATAR_ZOOM_MIN_Y_FACTOR = 0.7f;
-const F32 AVATAR_ZOOM_MIN_Z_FACTOR = 1.15f;
-
-const F32 MAX_CAMERA_DISTANCE_FROM_AGENT = 50.f;
-
-const F32 MAX_CAMERA_SMOOTH_DISTANCE = 50.0f;
-
-const F32 HEAD_BUFFER_SIZE = 0.3f;
-const F32 CUSTOMIZE_AVATAR_CAMERA_ANIM_SLOP = 0.2f;
-
-const F32 LAND_MIN_ZOOM = 0.15f;
-const F32 AVATAR_MIN_ZOOM = 0.5f;
-const F32 OBJECT_MIN_ZOOM = 0.02f;
-
-const F32 APPEARANCE_MIN_ZOOM = 0.39f;
-const F32 APPEARANCE_MAX_ZOOM = 8.f;
-*/
-
// fidget constants
const F32 MIN_FIDGET_TIME = 8.f; // seconds
const F32 MAX_FIDGET_TIME = 20.f; // seconds
const S32 MAX_NUM_CHAT_POSITIONS = 10;
-/*
-const F32 GROUND_TO_AIR_CAMERA_TRANSITION_TIME = 0.5f;
-const F32 GROUND_TO_AIR_CAMERA_TRANSITION_START_TIME = 0.5f;
-*/
const F32 MAX_VELOCITY_AUTO_LAND_SQUARED = 4.f * 4.f;
const F32 MAX_FOCUS_OFFSET = 20.f;
-/*
-const F32 OBJECT_EXTENTS_PADDING = 0.5f;
-*/
-
const F32 MIN_RADIUS_ALPHA_SIZZLE = 0.5f;
const F64 CHAT_AGE_FAST_RATE = 3.0;
@@ -231,20 +184,12 @@ bool handleSlowMotionAnimation(const LLSD& newvalue)
// LLAgent()
//-----------------------------------------------------------------------------
LLAgent::LLAgent() :
- mDrawDistance( DEFAULT_FAR_PLANE ),
-
mGroupPowers(0),
mHideGroupTitle(FALSE),
mGroupID(),
-//// mLookAt(NULL),
-//// mPointAt(NULL),
-
-//// mHUDTargetZoom(1.f),
-//// mHUDCurZoom(1.f),
mInitialized(FALSE),
mListener(),
-//// mForceMouselook(FALSE),
mDoubleTapRunTimer(),
mDoubleTapRunMode(DOUBLETAP_NONE),
@@ -267,48 +212,10 @@ LLAgent::LLAgent() :
mRenderState(0),
mTypingTimer(),
-//// mCameraMode( CAMERA_MODE_THIRD_PERSON ),
-//// mLastCameraMode( CAMERA_MODE_THIRD_PERSON ),
mViewsPushed(FALSE),
-//// mCameraPreset(CAMERA_PRESET_REAR_VIEW),
-
mCustomAnim(FALSE),
mShowAvatar(TRUE),
-//// mCameraAnimating( FALSE ),
-//// mAnimationCameraStartGlobal(),
-//// mAnimationFocusStartGlobal(),
-//// mAnimationTimer(),
-//// mAnimationDuration(0.33f),
-
-//// mCameraFOVZoomFactor(0.f),
-//// mCameraCurrentFOVZoomFactor(0.f),
-//// mCameraFocusOffset(),
-//// mCameraFOVDefault(DEFAULT_FIELD_OF_VIEW),
-
-//// mCameraCollidePlane(),
-
-//// mCurrentCameraDistance(2.f), // meters, set in init()
-//// mTargetCameraDistance(2.f),
-//// mCameraZoomFraction(1.f), // deprecated
-//// mThirdPersonHeadOffset(0.f, 0.f, 1.f),
-//// mSitCameraEnabled(FALSE),
-//// mCameraSmoothingLastPositionGlobal(),
-//// mCameraSmoothingLastPositionAgent(),
-//// mCameraSmoothingStop(FALSE),
-
-//// mCameraUpVector(LLVector3::z_axis), // default is straight up
-
-//// mFocusOnAvatar(TRUE),
-//// mFocusGlobal(),
-//// mFocusTargetGlobal(),
-//// mFocusObject(NULL),
-//// mFocusObjectDist(0.f),
-//// mFocusObjectOffset(),
-//// mFocusDotRadius( 0.1f ), // meters
-//// mTrackFocusObject(TRUE),
-// mUIOffset(0.f),
-
mFrameAgent(),
mIsBusy(FALSE),
@@ -320,20 +227,6 @@ LLAgent::LLAgent() :
mYawKey(0.f),
mPitchKey(0.f),
- mOrbitLeftKey(0.f),
- mOrbitRightKey(0.f),
- mOrbitUpKey(0.f),
- mOrbitDownKey(0.f),
- mOrbitInKey(0.f),
- mOrbitOutKey(0.f),
-
- mPanUpKey(0.f),
- mPanDownKey(0.f),
- mPanLeftKey(0.f),
- mPanRightKey(0.f),
- mPanInKey(0.f),
- mPanOutKey(0.f),
-
mControlFlags(0x00000000),
mbFlagsDirty(FALSE),
mbFlagsNeedReset(FALSE),
@@ -371,7 +264,6 @@ LLAgent::LLAgent() :
mControlsTakenPassedOnCount[i] = 0;
}
-//// mFollowCam.setMaxCameraDistantFromSubject( MAX_CAMERA_DISTANCE_FROM_AGENT );
mListener.reset(new LLAgentListener(*this));
}
@@ -385,39 +277,10 @@ void LLAgent::init()
gSavedSettings.declareBOOL("SlowMotionAnimation", FALSE, "Declared in code", FALSE);
gSavedSettings.getControl("SlowMotionAnimation")->getSignal()->connect(boost::bind(&handleSlowMotionAnimation, _2));
- mDrawDistance = gSavedSettings.getF32("RenderFarClip");
-
// *Note: this is where LLViewerCamera::getInstance() used to be constructed.
setFlying( gSavedSettings.getBOOL("FlyingAtExit") );
-/*
- LLViewerCamera::getInstance()->setView(DEFAULT_FIELD_OF_VIEW);
- // Leave at 0.1 meters until we have real near clip management
- LLViewerCamera::getInstance()->setNear(0.1f);
- LLViewerCamera::getInstance()->setFar(mDrawDistance); // if you want to change camera settings, do so in camera.h
- LLViewerCamera::getInstance()->setAspect( gViewerWindow->getWorldViewAspectRatio() ); // default, overridden in LLViewerWindow::reshape
- LLViewerCamera::getInstance()->setViewHeightInPixels(768); // default, overridden in LLViewerWindow::reshape
-
-//// mCameraFocusOffsetTarget = LLVector4(gSavedSettings.getVector3("CameraOffsetBuild"));
-
-//// mCameraPreset = (ECameraPreset) gSavedSettings.getU32("CameraPreset");
-
-//// mCameraOffsetInitial[CAMERA_PRESET_REAR_VIEW] = gSavedSettings.getVector3("CameraOffsetRearView");
-//// mCameraOffsetInitial[CAMERA_PRESET_FRONT_VIEW] = gSavedSettings.getVector3("CameraOffsetFrontView");
-//// mCameraOffsetInitial[CAMERA_PRESET_GROUP_VIEW] = gSavedSettings.getVector3("CameraOffsetGroupView");
-
-//// mFocusOffsetInitial[CAMERA_PRESET_REAR_VIEW] = gSavedSettings.getVector3d("FocusOffsetRearView");
-//// mFocusOffsetInitial[CAMERA_PRESET_FRONT_VIEW] = gSavedSettings.getVector3d("FocusOffsetFrontView");
-//// mFocusOffsetInitial[CAMERA_PRESET_GROUP_VIEW] = gSavedSettings.getVector3d("FocusOffsetGroupView");
-
-//// mCameraCollidePlane.clearVec();
-//// mCurrentCameraDistance = getCameraOffsetInitial().magVec() * gSavedSettings.getF32("CameraOffsetScale");
-//// mTargetCameraDistance = mCurrentCameraDistance;
-//// mCameraZoomFraction = 1.f;
-//// mTrackFocusObject = gSavedSettings.getBOOL("TrackFocusObject");
-*/
-
mEffectColor = LLUIColorTable::instance().getColor("EffectColor");
gSavedSettings.getControl("PreferredMaturity")->getValidateSignal()->connect(boost::bind(&LLAgent::validateMaturity, this, _2));
@@ -433,7 +296,7 @@ void LLAgent::cleanup()
{
mAvatarObject = NULL;
mRegionp = NULL;
- gAgentCameraHACK.cleanup();
+ gAgentCamera.cleanup();
}
//-----------------------------------------------------------------------------
@@ -446,85 +309,6 @@ LLAgent::~LLAgent()
// *Note: this is where LLViewerCamera::getInstance() used to be deleted.
}
-/*
-// Change camera back to third person, stop the autopilot,
-// deselect stuff, etc.
-//-----------------------------------------------------------------------------
-// resetView()
-//-----------------------------------------------------------------------------
-void LLAgent::resetView(BOOL reset_camera, BOOL change_camera)
-{
- if (mAutoPilot)
- {
- stopAutoPilot(TRUE);
- }
-
- if (!gNoRender)
- {
- LLSelectMgr::getInstance()->unhighlightAll();
-
- // By popular request, keep land selection while walking around. JC
- // LLViewerParcelMgr::getInstance()->deselectLand();
-
- // force deselect when walking and attachment is selected
- // this is so people don't wig out when their avatar moves without animating
- if (LLSelectMgr::getInstance()->getSelection()->isAttachment())
- {
- LLSelectMgr::getInstance()->deselectAll();
- }
-
- // Hide all popup menus
- gMenuHolder->hideMenus();
- }
-
- if (change_camera && !gSavedSettings.getBOOL("FreezeTime"))
- {
- changeCameraToDefault();
-
- if (LLViewerJoystick::getInstance()->getOverrideCamera())
- {
- handle_toggle_flycam();
- }
-
- // reset avatar mode from eventual residual motion
- if (LLToolMgr::getInstance()->inBuildMode())
- {
- LLViewerJoystick::getInstance()->moveAvatar(true);
- }
-
- //Camera Tool is needed for Free Camera Control Mode
- if (!LLFloaterCamera::inFreeCameraMode())
- {
- LLFloaterReg::hideInstance("build");
-
- // Switch back to basic toolset
- LLToolMgr::getInstance()->setCurrentToolset(gBasicToolset);
- }
-
- gViewerWindow->showCursor();
- }
-
-
- if (reset_camera && !gSavedSettings.getBOOL("FreezeTime"))
- {
- if (!gViewerWindow->getLeftMouseDown() && cameraThirdPerson())
- {
- // leaving mouse-steer mode
- LLVector3 agent_at_axis = getAtAxis();
- agent_at_axis -= projected_vec(agent_at_axis, getReferenceUpVector());
- agent_at_axis.normalize();
- gAgent.resetAxes(lerp(getAtAxis(), agent_at_axis, LLCriticalDamp::getInterpolant(0.3f)));
- }
-
- setFocusOnAvatar(TRUE, ANIMATE);
-
- mCameraFOVZoomFactor = 0.f;
- }
-
- mHUDTargetZoom = 1.f;
-}
-*/
-
// Handle any actions that need to be performed when the main app gains focus
// (such as through alt-tab).
//-----------------------------------------------------------------------------
@@ -532,9 +316,9 @@ void LLAgent::resetView(BOOL reset_camera, BOOL change_camera)
//-----------------------------------------------------------------------------
void LLAgent::onAppFocusGained()
{
- if (CAMERA_MODE_MOUSELOOK == gAgentCameraHACK.mCameraMode)
+ if (CAMERA_MODE_MOUSELOOK == gAgentCamera.mCameraMode)
{
- gAgentCameraHACK.changeCameraToDefault();
+ gAgentCamera.changeCameraToDefault();
LLToolMgr::getInstance()->clearSavedTool();
}
}
@@ -551,24 +335,6 @@ void LLAgent::ageChat()
}
}
-/*
-// Allow camera to be moved somewhere other than behind avatar.
-//-----------------------------------------------------------------------------
-// unlockView()
-//-----------------------------------------------------------------------------
-void LLAgent::unlockView()
-{
- if (getFocusOnAvatar())
- {
- if (mAvatarObject.notNull())
- {
- setFocusGlobal( LLVector3d::zero, mAvatarObject->mID );
- }
- setFocusOnAvatar(FALSE, FALSE); // no animation
- }
-}
-*/
-
//-----------------------------------------------------------------------------
// moveAt()
//-----------------------------------------------------------------------------
@@ -590,7 +356,7 @@ void LLAgent::moveAt(S32 direction, bool reset)
if (reset)
{
- gAgentCameraHACK.resetView();
+ gAgentCamera.resetView();
}
}
@@ -613,7 +379,7 @@ void LLAgent::moveAtNudge(S32 direction)
setControlFlags(AGENT_CONTROL_NUDGE_AT_NEG);
}
- gAgentCameraHACK.resetView();
+ gAgentCamera.resetView();
}
//-----------------------------------------------------------------------------
@@ -635,7 +401,7 @@ void LLAgent::moveLeft(S32 direction)
setControlFlags(AGENT_CONTROL_LEFT_NEG | AGENT_CONTROL_FAST_LEFT);
}
- gAgentCameraHACK.resetView();
+ gAgentCamera.resetView();
}
//-----------------------------------------------------------------------------
@@ -657,7 +423,7 @@ void LLAgent::moveLeftNudge(S32 direction)
setControlFlags(AGENT_CONTROL_NUDGE_LEFT_NEG);
}
- gAgentCameraHACK.resetView();
+ gAgentCamera.resetView();
}
//-----------------------------------------------------------------------------
@@ -679,7 +445,7 @@ void LLAgent::moveUp(S32 direction)
setControlFlags(AGENT_CONTROL_UP_NEG | AGENT_CONTROL_FAST_UP);
}
- gAgentCameraHACK.resetView();
+ gAgentCamera.resetView();
}
//-----------------------------------------------------------------------------
@@ -700,7 +466,7 @@ void LLAgent::moveYaw(F32 mag, bool reset_view)
if (reset_view)
{
- gAgentCameraHACK.resetView();
+ gAgentCamera.resetView();
}
}
@@ -811,7 +577,7 @@ void LLAgent::toggleFlying()
BOOL fly = !gAgent.getFlying();
gAgent.setFlying( fly );
- gAgentCameraHACK.resetView();
+ gAgentCamera.resetView();
}
// static
@@ -883,8 +649,7 @@ void LLAgent::setRegion(LLViewerRegion *regionp)
LLVector3 delta;
delta.setVec(regionp->getOriginGlobal());
- setPositionAgent
-(getPositionAgent() - delta);
+ setPositionAgent(getPositionAgent() - delta);
LLVector3 camera_position_agent = LLViewerCamera::getInstance()->getOrigin();
LLViewerCamera::getInstance()->setOrigin(camera_position_agent - delta);
@@ -1034,19 +799,6 @@ void LLAgent::setPositionAgent(const LLVector3 &pos_agent)
}
}
-/*
-//-----------------------------------------------------------------------------
-// slamLookAt()
-//-----------------------------------------------------------------------------
-void LLAgent::slamLookAt(const LLVector3 &look_at)
-{
- LLVector3 look_at_norm = look_at;
- look_at_norm.mV[VZ] = 0.f;
- look_at_norm.normalize();
- resetAxes(look_at_norm);
-}
-*/
-
//-----------------------------------------------------------------------------
// getPositionGlobal()
//-----------------------------------------------------------------------------
@@ -1201,7 +953,7 @@ LLVector3 LLAgent::getReferenceUpVector()
mAvatarObject->getParent() &&
mAvatarObject->mDrawable.notNull())
{
- U32 camera_mode = gAgentCameraHACK.mCameraAnimating ? gAgentCameraHACK.mLastCameraMode : gAgentCameraHACK.mCameraMode;
+ U32 camera_mode = gAgentCamera.mCameraAnimating ? gAgentCamera.mLastCameraMode : gAgentCamera.mCameraMode;
// and in third person...
if (camera_mode == CAMERA_MODE_THIRD_PERSON)
{
@@ -1300,3290 +1052,959 @@ LLQuaternion LLAgent::getQuat() const
return mFrameAgent.getQuaternion();
}
-/*
//-----------------------------------------------------------------------------
-// calcFocusOffset()
+// setKey()
//-----------------------------------------------------------------------------
-LLVector3 LLAgent::calcFocusOffset(LLViewerObject *object, LLVector3 original_focus_point, S32 x, S32 y)
+void LLAgent::setKey(const S32 direction, S32 &key)
{
- LLMatrix4 obj_matrix = object->getRenderMatrix();
- LLQuaternion obj_rot = object->getRenderRotation();
- LLVector3 obj_pos = object->getRenderPosition();
-
- BOOL is_avatar = object->isAvatar();
- // if is avatar - don't do any funk heuristics to position the focal point
- // see DEV-30589
- if (is_avatar)
+ if (direction > 0)
{
- return original_focus_point - obj_pos;
+ key = 1;
+ }
+ else if (direction < 0)
+ {
+ key = -1;
}
-
-
- LLQuaternion inv_obj_rot = ~obj_rot; // get inverse of rotation
- LLVector3 object_extents = object->getScale();
- // make sure they object extents are non-zero
- object_extents.clamp(0.001f, F32_MAX);
-
- // obj_to_cam_ray is unit vector pointing from object center to camera, in the coordinate frame of the object
- LLVector3 obj_to_cam_ray = obj_pos - LLViewerCamera::getInstance()->getOrigin();
- obj_to_cam_ray.rotVec(inv_obj_rot);
- obj_to_cam_ray.normalize();
-
- // obj_to_cam_ray_proportions are the (positive) ratios of
- // the obj_to_cam_ray x,y,z components with the x,y,z object dimensions.
- LLVector3 obj_to_cam_ray_proportions;
- obj_to_cam_ray_proportions.mV[VX] = llabs(obj_to_cam_ray.mV[VX] / object_extents.mV[VX]);
- obj_to_cam_ray_proportions.mV[VY] = llabs(obj_to_cam_ray.mV[VY] / object_extents.mV[VY]);
- obj_to_cam_ray_proportions.mV[VZ] = llabs(obj_to_cam_ray.mV[VZ] / object_extents.mV[VZ]);
-
- // find the largest ratio stored in obj_to_cam_ray_proportions
- // this corresponds to the object's local axial plane (XY, YZ, XZ) that is *most* facing the camera
- LLVector3 longest_object_axis;
- // is x-axis longest?
- if (obj_to_cam_ray_proportions.mV[VX] > obj_to_cam_ray_proportions.mV[VY]
- && obj_to_cam_ray_proportions.mV[VX] > obj_to_cam_ray_proportions.mV[VZ])
- {
- // then grab it
- longest_object_axis.setVec(obj_matrix.getFwdRow4());
- }
- // is y-axis longest?
- else if (obj_to_cam_ray_proportions.mV[VY] > obj_to_cam_ray_proportions.mV[VZ])
- {
- // then grab it
- longest_object_axis.setVec(obj_matrix.getLeftRow4());
- }
- // otherwise, use z axis
else
{
- longest_object_axis.setVec(obj_matrix.getUpRow4());
+ key = 0;
}
+}
- // Use this axis as the normal to project mouse click on to plane with that normal, at the object center.
- // This generates a point behind the mouse cursor that is approximately in the middle of the object in
- // terms of depth.
- // We do this to allow the camera rotation tool to "tumble" the object by rotating the camera.
- // If the focus point were the object surface under the mouse, camera rotation would introduce an undesirable
- // eccentricity to the object orientation
- LLVector3 focus_plane_normal(longest_object_axis);
- focus_plane_normal.normalize();
-
- LLVector3d focus_pt_global;
- gViewerWindow->mousePointOnPlaneGlobal(focus_pt_global, x, y, gAgent.getPosGlobalFromAgent(obj_pos), focus_plane_normal);
- LLVector3 focus_pt = gAgent.getPosAgentFromGlobal(focus_pt_global);
-
- // find vector from camera to focus point in object space
- LLVector3 camera_to_focus_vec = focus_pt - LLViewerCamera::getInstance()->getOrigin();
- camera_to_focus_vec.rotVec(inv_obj_rot);
-
- // find vector from object origin to focus point in object coordinates
- LLVector3 focus_offset_from_object_center = focus_pt - obj_pos;
- // convert to object-local space
- focus_offset_from_object_center.rotVec(inv_obj_rot);
-
- // We need to project the focus point back into the bounding box of the focused object.
- // Do this by calculating the XYZ scale factors needed to get focus offset back in bounds along the camera_focus axis
- LLVector3 clip_fraction;
- // for each axis...
- for (U32 axis = VX; axis <= VZ; axis++)
+//-----------------------------------------------------------------------------
+// getControlFlags()
+//-----------------------------------------------------------------------------
+U32 LLAgent::getControlFlags()
+{
+/*
+ // HACK -- avoids maintenance of control flags when camera mode is turned on or off,
+ // only worries about it when the flags are measured
+ if (mCameraMode == CAMERA_MODE_MOUSELOOK)
{
- //...calculate distance that focus offset sits outside of bounding box along that axis...
- //NOTE: dist_out_of_bounds keeps the sign of focus_offset_from_object_center
- F32 dist_out_of_bounds;
- if (focus_offset_from_object_center.mV[axis] > 0.f)
- {
- dist_out_of_bounds = llmax(0.f, focus_offset_from_object_center.mV[axis] - (object_extents.mV[axis] * 0.5f));
- }
- else
- {
- dist_out_of_bounds = llmin(0.f, focus_offset_from_object_center.mV[axis] + (object_extents.mV[axis] * 0.5f));
- }
-
- //...then calculate the scale factor needed to push camera_to_focus_vec back in bounds along current axis
- if (llabs(camera_to_focus_vec.mV[axis]) < 0.0001f)
- {
- // don't divide by very small number
- clip_fraction.mV[axis] = 0.f;
- }
- else
+ if ( !(mControlFlags & AGENT_CONTROL_MOUSELOOK) )
{
- clip_fraction.mV[axis] = dist_out_of_bounds / camera_to_focus_vec.mV[axis];
+ mControlFlags |= AGENT_CONTROL_MOUSELOOK;
}
}
+*/
+ return mControlFlags;
+}
- LLVector3 abs_clip_fraction = clip_fraction;
- abs_clip_fraction.abs();
-
- // find axis of focus offset that is *most* outside the bounding box and use that to
- // rescale focus offset to inside object extents
- if (abs_clip_fraction.mV[VX] > abs_clip_fraction.mV[VY]
- && abs_clip_fraction.mV[VX] > abs_clip_fraction.mV[VZ])
- {
- focus_offset_from_object_center -= clip_fraction.mV[VX] * camera_to_focus_vec;
- }
- else if (abs_clip_fraction.mV[VY] > abs_clip_fraction.mV[VZ])
- {
- focus_offset_from_object_center -= clip_fraction.mV[VY] * camera_to_focus_vec;
- }
- else
- {
- focus_offset_from_object_center -= clip_fraction.mV[VZ] * camera_to_focus_vec;
- }
-
- // convert back to world space
- focus_offset_from_object_center.rotVec(obj_rot);
-
- // now, based on distance of camera from object relative to object size
- // push the focus point towards the near surface of the object when (relatively) close to the objcet
- // or keep the focus point in the object middle when (relatively) far
- // NOTE: leave focus point in middle of avatars, since the behavior you want when alt-zooming on avatars
- // is almost always "tumble about middle" and not "spin around surface point"
- if (!is_avatar)
- {
- LLVector3 obj_rel = original_focus_point - object->getRenderPosition();
-
- //now that we have the object relative position, we should bias toward the center of the object
- //based on the distance of the camera to the focus point vs. the distance of the camera to the focus
-
- F32 relDist = llabs(obj_rel * LLViewerCamera::getInstance()->getAtAxis());
- F32 viewDist = dist_vec(obj_pos + obj_rel, LLViewerCamera::getInstance()->getOrigin());
-
-
- LLBBox obj_bbox = object->getBoundingBoxAgent();
- F32 bias = 0.f;
+//-----------------------------------------------------------------------------
+// setControlFlags()
+//-----------------------------------------------------------------------------
+void LLAgent::setControlFlags(U32 mask)
+{
+ mControlFlags |= mask;
+ mbFlagsDirty = TRUE;
+}
- // virtual_camera_pos is the camera position we are simulating by backing the camera off
- // and adjusting the FOV
- LLVector3 virtual_camera_pos = gAgent.getPosAgentFromGlobal(mFocusTargetGlobal + (getCameraPositionGlobal() - mFocusTargetGlobal) / (1.f + mCameraFOVZoomFactor));
- // if the camera is inside the object (large, hollow objects, for example)
- // leave focus point all the way to destination depth, away from object center
- if(!obj_bbox.containsPointAgent(virtual_camera_pos))
- {
- // perform magic number biasing of focus point towards surface vs. planar center
- bias = clamp_rescale(relDist/viewDist, 0.1f, 0.7f, 0.0f, 1.0f);
- obj_rel = lerp(focus_offset_from_object_center, obj_rel, bias);
- }
-
- focus_offset_from_object_center = obj_rel;
+//-----------------------------------------------------------------------------
+// clearControlFlags()
+//-----------------------------------------------------------------------------
+void LLAgent::clearControlFlags(U32 mask)
+{
+ U32 old_flags = mControlFlags;
+ mControlFlags &= ~mask;
+ if (old_flags != mControlFlags)
+ {
+ mbFlagsDirty = TRUE;
}
+}
- return focus_offset_from_object_center;
+//-----------------------------------------------------------------------------
+// controlFlagsDirty()
+//-----------------------------------------------------------------------------
+BOOL LLAgent::controlFlagsDirty() const
+{
+ return mbFlagsDirty;
}
//-----------------------------------------------------------------------------
-// calcCameraMinDistance()
+// enableControlFlagReset()
//-----------------------------------------------------------------------------
-BOOL LLAgent::calcCameraMinDistance(F32 &obj_min_distance)
+void LLAgent::enableControlFlagReset()
{
- BOOL soft_limit = FALSE; // is the bounding box to be treated literally (volumes) or as an approximation (avatars)
+ mbFlagsNeedReset = TRUE;
+}
- if (!mFocusObject || mFocusObject->isDead())
+//-----------------------------------------------------------------------------
+// resetControlFlags()
+//-----------------------------------------------------------------------------
+void LLAgent::resetControlFlags()
+{
+ if (mbFlagsNeedReset)
{
- obj_min_distance = 0.f;
- return TRUE;
+ mbFlagsNeedReset = FALSE;
+ mbFlagsDirty = FALSE;
+ // reset all of the ephemeral flags
+ // some flags are managed elsewhere
+ mControlFlags &= AGENT_CONTROL_AWAY | AGENT_CONTROL_FLY | AGENT_CONTROL_MOUSELOOK;
}
+}
- if (mFocusObject->mDrawable.isNull())
+//-----------------------------------------------------------------------------
+// setAFK()
+//-----------------------------------------------------------------------------
+void LLAgent::setAFK()
+{
+ // Drones can't go AFK
+ if (gNoRender)
{
-#ifdef LL_RELEASE_FOR_DOWNLOAD
- llwarns << "Focus object with no drawable!" << llendl;
-#else
- mFocusObject->dump();
- llerrs << "Focus object with no drawable!" << llendl;
-#endif
- obj_min_distance = 0.f;
- return TRUE;
+ return;
}
-
- LLQuaternion inv_object_rot = ~mFocusObject->getRenderRotation();
- LLVector3 target_offset_origin = mFocusObjectOffset;
- LLVector3 camera_offset_target(getCameraPositionAgent() - getPosAgentFromGlobal(mFocusTargetGlobal));
-
- // convert offsets into object local space
- camera_offset_target.rotVec(inv_object_rot);
- target_offset_origin.rotVec(inv_object_rot);
- // push around object extents based on target offset
- LLVector3 object_extents = mFocusObject->getScale();
- if (mFocusObject->isAvatar())
+ if (!gAgent.getRegion())
{
- // fudge factors that lets you zoom in on avatars a bit more (which don't do FOV zoom)
- object_extents.mV[VX] *= AVATAR_ZOOM_MIN_X_FACTOR;
- object_extents.mV[VY] *= AVATAR_ZOOM_MIN_Y_FACTOR;
- object_extents.mV[VZ] *= AVATAR_ZOOM_MIN_Z_FACTOR;
- soft_limit = TRUE;
+ // Don't set AFK if we're not talking to a region yet.
+ return;
}
- LLVector3 abs_target_offset = target_offset_origin;
- abs_target_offset.abs();
-
- LLVector3 target_offset_dir = target_offset_origin;
- F32 object_radius = mFocusObject->getVObjRadius();
- BOOL target_outside_object_extents = FALSE;
-
- for (U32 i = VX; i <= VZ; i++)
+ if (!(mControlFlags & AGENT_CONTROL_AWAY))
{
- if (abs_target_offset.mV[i] * 2.f > object_extents.mV[i] + OBJECT_EXTENTS_PADDING)
- {
- target_outside_object_extents = TRUE;
- }
- if (camera_offset_target.mV[i] > 0.f)
- {
- object_extents.mV[i] -= target_offset_origin.mV[i] * 2.f;
- }
- else
+ sendAnimationRequest(ANIM_AGENT_AWAY, ANIM_REQUEST_START);
+ setControlFlags(AGENT_CONTROL_AWAY | AGENT_CONTROL_STOP);
+ gAwayTimer.start();
+ if (gAFKMenu)
{
- object_extents.mV[i] += target_offset_origin.mV[i] * 2.f;
+ gAFKMenu->setLabel(LLTrans::getString("AvatarSetNotAway"));
}
}
+}
- // don't shrink the object extents so far that the object inverts
- object_extents.clamp(0.001f, F32_MAX);
-
- // move into first octant
- LLVector3 camera_offset_target_abs_norm = camera_offset_target;
- camera_offset_target_abs_norm.abs();
- // make sure offset is non-zero
- camera_offset_target_abs_norm.clamp(0.001f, F32_MAX);
- camera_offset_target_abs_norm.normalize();
-
- // find camera position relative to normalized object extents
- LLVector3 camera_offset_target_scaled = camera_offset_target_abs_norm;
- camera_offset_target_scaled.mV[VX] /= object_extents.mV[VX];
- camera_offset_target_scaled.mV[VY] /= object_extents.mV[VY];
- camera_offset_target_scaled.mV[VZ] /= object_extents.mV[VZ];
+//-----------------------------------------------------------------------------
+// clearAFK()
+//-----------------------------------------------------------------------------
+void LLAgent::clearAFK()
+{
+ gAwayTriggerTimer.reset();
- if (camera_offset_target_scaled.mV[VX] > camera_offset_target_scaled.mV[VY] &&
- camera_offset_target_scaled.mV[VX] > camera_offset_target_scaled.mV[VZ])
- {
- if (camera_offset_target_abs_norm.mV[VX] < 0.001f)
- {
- obj_min_distance = object_extents.mV[VX] * 0.5f;
- }
- else
- {
- obj_min_distance = object_extents.mV[VX] * 0.5f / camera_offset_target_abs_norm.mV[VX];
- }
- }
- else if (camera_offset_target_scaled.mV[VY] > camera_offset_target_scaled.mV[VZ])
+ // Gods can sometimes get into away state (via gestures)
+ // without setting the appropriate control flag. JC
+ LLVOAvatar* av = mAvatarObject;
+ if (mControlFlags & AGENT_CONTROL_AWAY
+ || (av
+ && (av->mSignaledAnimations.find(ANIM_AGENT_AWAY) != av->mSignaledAnimations.end())))
{
- if (camera_offset_target_abs_norm.mV[VY] < 0.001f)
- {
- obj_min_distance = object_extents.mV[VY] * 0.5f;
- }
- else
+ sendAnimationRequest(ANIM_AGENT_AWAY, ANIM_REQUEST_STOP);
+ clearControlFlags(AGENT_CONTROL_AWAY);
+ if (gAFKMenu)
{
- obj_min_distance = object_extents.mV[VY] * 0.5f / camera_offset_target_abs_norm.mV[VY];
- }
- }
- else
- {
- if (camera_offset_target_abs_norm.mV[VZ] < 0.001f)
- {
- obj_min_distance = object_extents.mV[VZ] * 0.5f;
- }
- else
- {
- obj_min_distance = object_extents.mV[VZ] * 0.5f / camera_offset_target_abs_norm.mV[VZ];
+ gAFKMenu->setLabel(LLTrans::getString("AvatarSetAway"));
}
}
+}
- LLVector3 object_split_axis;
- LLVector3 target_offset_scaled = target_offset_origin;
- target_offset_scaled.abs();
- target_offset_scaled.normalize();
- target_offset_scaled.mV[VX] /= object_extents.mV[VX];
- target_offset_scaled.mV[VY] /= object_extents.mV[VY];
- target_offset_scaled.mV[VZ] /= object_extents.mV[VZ];
+//-----------------------------------------------------------------------------
+// getAFK()
+//-----------------------------------------------------------------------------
+BOOL LLAgent::getAFK() const
+{
+ return (mControlFlags & AGENT_CONTROL_AWAY) != 0;
+}
- if (target_offset_scaled.mV[VX] > target_offset_scaled.mV[VY] &&
- target_offset_scaled.mV[VX] > target_offset_scaled.mV[VZ])
- {
- object_split_axis = LLVector3::x_axis;
- }
- else if (target_offset_scaled.mV[VY] > target_offset_scaled.mV[VZ])
+//-----------------------------------------------------------------------------
+// setBusy()
+//-----------------------------------------------------------------------------
+void LLAgent::setBusy()
+{
+ sendAnimationRequest(ANIM_AGENT_BUSY, ANIM_REQUEST_START);
+ mIsBusy = TRUE;
+ if (gBusyMenu)
{
- object_split_axis = LLVector3::y_axis;
+ gBusyMenu->setLabel(LLTrans::getString("AvatarSetNotBusy"));
}
- else
+ LLNotificationsUI::LLChannelManager::getInstance()->muteAllChannels(true);
+}
+
+//-----------------------------------------------------------------------------
+// clearBusy()
+//-----------------------------------------------------------------------------
+void LLAgent::clearBusy()
+{
+ mIsBusy = FALSE;
+ sendAnimationRequest(ANIM_AGENT_BUSY, ANIM_REQUEST_STOP);
+ if (gBusyMenu)
{
- object_split_axis = LLVector3::z_axis;
+ gBusyMenu->setLabel(LLTrans::getString("AvatarSetBusy"));
}
+ LLNotificationsUI::LLChannelManager::getInstance()->muteAllChannels(false);
+}
- LLVector3 camera_offset_object(getCameraPositionAgent() - mFocusObject->getPositionAgent());
+//-----------------------------------------------------------------------------
+// getBusy()
+//-----------------------------------------------------------------------------
+BOOL LLAgent::getBusy() const
+{
+ return mIsBusy;
+}
- // length projected orthogonal to target offset
- F32 camera_offset_dist = (camera_offset_object - target_offset_dir * (camera_offset_object * target_offset_dir)).magVec();
- // calculate whether the target point would be "visible" if it were outside the bounding box
- // on the opposite of the splitting plane defined by object_split_axis;
- BOOL exterior_target_visible = FALSE;
- if (camera_offset_dist > object_radius)
+//-----------------------------------------------------------------------------
+// startAutoPilotGlobal()
+//-----------------------------------------------------------------------------
+void LLAgent::startAutoPilotGlobal(const LLVector3d &target_global, const std::string& behavior_name, const LLQuaternion *target_rotation, void (*finish_callback)(BOOL, void *), void *callback_data, F32 stop_distance, F32 rot_threshold)
+{
+ if (!gAgent.getAvatarObject())
{
- // target is visible from camera, so turn off fov zoom
- exterior_target_visible = TRUE;
+ return;
}
+
+ mAutoPilotFinishedCallback = finish_callback;
+ mAutoPilotCallbackData = callback_data;
+ mAutoPilotRotationThreshold = rot_threshold;
+ mAutoPilotBehaviorName = behavior_name;
- F32 camera_offset_clip = camera_offset_object * object_split_axis;
- F32 target_offset_clip = target_offset_dir * object_split_axis;
-
- // target has moved outside of object extents
- // check to see if camera and target are on same side
- if (target_outside_object_extents)
- {
- if (camera_offset_clip > 0.f && target_offset_clip > 0.f)
- {
- return FALSE;
- }
- else if (camera_offset_clip < 0.f && target_offset_clip < 0.f)
- {
- return FALSE;
- }
- }
+ LLVector3d delta_pos( target_global );
+ delta_pos -= getPositionGlobal();
+ F64 distance = delta_pos.magVec();
+ LLVector3d trace_target = target_global;
- // clamp obj distance to diagonal of 10 by 10 cube
- obj_min_distance = llmin(obj_min_distance, 10.f * F_SQRT3);
+ trace_target.mdV[VZ] -= 10.f;
- obj_min_distance += LLViewerCamera::getInstance()->getNear() + (soft_limit ? 0.1f : 0.2f);
-
- return TRUE;
-}
+ LLVector3d intersection;
+ LLVector3 normal;
+ LLViewerObject *hit_obj;
+ F32 heightDelta = LLWorld::getInstance()->resolveStepHeightGlobal(NULL, target_global, trace_target, intersection, normal, &hit_obj);
-F32 LLAgent::getCameraZoomFraction()
-{
- // 0.f -> camera zoomed all the way out
- // 1.f -> camera zoomed all the way in
- LLObjectSelectionHandle selection = LLSelectMgr::getInstance()->getSelection();
- if (selection->getObjectCount() && selection->getSelectType() == SELECT_TYPE_HUD)
- {
- // already [0,1]
- return mHUDTargetZoom;
- }
- else if (mFocusOnAvatar && cameraThirdPerson())
- {
- return clamp_rescale(mCameraZoomFraction, MIN_ZOOM_FRACTION, MAX_ZOOM_FRACTION, 1.f, 0.f);
- }
- else if (cameraCustomizeAvatar())
+ if (stop_distance > 0.f)
{
- F32 distance = (F32)mCameraFocusOffsetTarget.magVec();
- return clamp_rescale(distance, APPEARANCE_MIN_ZOOM, APPEARANCE_MAX_ZOOM, 1.f, 0.f );
+ mAutoPilotStopDistance = stop_distance;
}
else
{
- F32 min_zoom;
- const F32 DIST_FUDGE = 16.f; // meters
- F32 max_zoom = llmin(mDrawDistance - DIST_FUDGE,
- LLWorld::getInstance()->getRegionWidthInMeters() - DIST_FUDGE,
- MAX_CAMERA_DISTANCE_FROM_AGENT);
-
- F32 distance = (F32)mCameraFocusOffsetTarget.magVec();
- if (mFocusObject.notNull())
- {
- if (mFocusObject->isAvatar())
- {
- min_zoom = AVATAR_MIN_ZOOM;
- }
- else
- {
- min_zoom = OBJECT_MIN_ZOOM;
- }
- }
- else
+ // Guess at a reasonable stop distance.
+ mAutoPilotStopDistance = fsqrtf( distance );
+ if (mAutoPilotStopDistance < 0.5f)
{
- min_zoom = LAND_MIN_ZOOM;
+ mAutoPilotStopDistance = 0.5f;
}
-
- return clamp_rescale(distance, min_zoom, max_zoom, 1.f, 0.f);
}
-}
-void LLAgent::setCameraZoomFraction(F32 fraction)
-{
- // 0.f -> camera zoomed all the way out
- // 1.f -> camera zoomed all the way in
- LLObjectSelectionHandle selection = LLSelectMgr::getInstance()->getSelection();
+ mAutoPilotFlyOnStop = getFlying();
- if (selection->getObjectCount() && selection->getSelectType() == SELECT_TYPE_HUD)
- {
- mHUDTargetZoom = fraction;
- }
- else if (mFocusOnAvatar && cameraThirdPerson())
+ if (distance > 30.0)
{
- mCameraZoomFraction = rescale(fraction, 0.f, 1.f, MAX_ZOOM_FRACTION, MIN_ZOOM_FRACTION);
+ setFlying(TRUE);
}
- else if (cameraCustomizeAvatar())
+
+ if ( distance > 1.f && heightDelta > (sqrtf(mAutoPilotStopDistance) + 1.f))
{
- LLVector3d camera_offset_dir = mCameraFocusOffsetTarget;
- camera_offset_dir.normalize();
- mCameraFocusOffsetTarget = camera_offset_dir * rescale(fraction, 0.f, 1.f, APPEARANCE_MAX_ZOOM, APPEARANCE_MIN_ZOOM);
+ setFlying(TRUE);
+ mAutoPilotFlyOnStop = TRUE;
}
- else
- {
- F32 min_zoom = LAND_MIN_ZOOM;
- const F32 DIST_FUDGE = 16.f; // meters
- F32 max_zoom = llmin(mDrawDistance - DIST_FUDGE,
- LLWorld::getInstance()->getRegionWidthInMeters() - DIST_FUDGE,
- MAX_CAMERA_DISTANCE_FROM_AGENT);
- if (mFocusObject.notNull())
- {
- if (mFocusObject.notNull())
- {
- if (mFocusObject->isAvatar())
- {
- min_zoom = AVATAR_MIN_ZOOM;
- }
- else
- {
- min_zoom = OBJECT_MIN_ZOOM;
- }
- }
- }
+ mAutoPilot = TRUE;
+ mAutoPilotTargetGlobal = target_global;
- LLVector3d camera_offset_dir = mCameraFocusOffsetTarget;
- camera_offset_dir.normalize();
- mCameraFocusOffsetTarget = camera_offset_dir * rescale(fraction, 0.f, 1.f, max_zoom, min_zoom);
- }
- startCameraAnimation();
-}
+ // trace ray down to find height of destination from ground
+ LLVector3d traceEndPt = target_global;
+ traceEndPt.mdV[VZ] -= 20.f;
+
+ LLVector3d targetOnGround;
+ LLVector3 groundNorm;
+ LLViewerObject *obj;
+ LLWorld::getInstance()->resolveStepHeightGlobal(NULL, target_global, traceEndPt, targetOnGround, groundNorm, &obj);
+ F64 target_height = llmax((F64)gAgent.getAvatarObject()->getPelvisToFoot(), target_global.mdV[VZ] - targetOnGround.mdV[VZ]);
-//-----------------------------------------------------------------------------
-// cameraOrbitAround()
-//-----------------------------------------------------------------------------
-void LLAgent::cameraOrbitAround(const F32 radians)
-{
- LLObjectSelectionHandle selection = LLSelectMgr::getInstance()->getSelection();
- if (selection->getObjectCount() && selection->getSelectType() == SELECT_TYPE_HUD)
- {
- // do nothing for hud selection
- }
- else if (mFocusOnAvatar && (mCameraMode == CAMERA_MODE_THIRD_PERSON || mCameraMode == CAMERA_MODE_FOLLOW))
+ // clamp z value of target to minimum height above ground
+ mAutoPilotTargetGlobal.mdV[VZ] = targetOnGround.mdV[VZ] + target_height;
+ mAutoPilotTargetDist = (F32)dist_vec(gAgent.getPositionGlobal(), mAutoPilotTargetGlobal);
+ if (target_rotation)
{
- mFrameAgent.rotate(radians, getReferenceUpVector());
+ mAutoPilotUseRotation = TRUE;
+ mAutoPilotTargetFacing = LLVector3::x_axis * *target_rotation;
+ mAutoPilotTargetFacing.mV[VZ] = 0.f;
+ mAutoPilotTargetFacing.normalize();
}
else
{
- mCameraFocusOffsetTarget.rotVec(radians, 0.f, 0.f, 1.f);
-
- cameraZoomIn(1.f);
+ mAutoPilotUseRotation = FALSE;
}
+
+ mAutoPilotNoProgressFrameCount = 0;
}
//-----------------------------------------------------------------------------
-// cameraOrbitOver()
+// startFollowPilot()
//-----------------------------------------------------------------------------
-void LLAgent::cameraOrbitOver(const F32 angle)
+void LLAgent::startFollowPilot(const LLUUID &leader_id)
{
- LLObjectSelectionHandle selection = LLSelectMgr::getInstance()->getSelection();
- if (selection->getObjectCount() && selection->getSelectType() == SELECT_TYPE_HUD)
- {
- // do nothing for hud selection
- }
- else if (mFocusOnAvatar && mCameraMode == CAMERA_MODE_THIRD_PERSON)
- {
- pitch(angle);
- }
- else
- {
- LLVector3 camera_offset_unit(mCameraFocusOffsetTarget);
- camera_offset_unit.normalize();
-
- F32 angle_from_up = acos( camera_offset_unit * getReferenceUpVector() );
-
- LLVector3d left_axis;
- left_axis.setVec(LLViewerCamera::getInstance()->getLeftAxis());
- F32 new_angle = llclamp(angle_from_up - angle, 1.f * DEG_TO_RAD, 179.f * DEG_TO_RAD);
- mCameraFocusOffsetTarget.rotVec(angle_from_up - new_angle, left_axis);
-
- cameraZoomIn(1.f);
- }
-}
+ if (!mAutoPilot) return;
-//-----------------------------------------------------------------------------
-// cameraZoomIn()
-//-----------------------------------------------------------------------------
-void LLAgent::cameraZoomIn(const F32 fraction)
-{
- if (gDisconnected)
- {
- return;
- }
+ mLeaderID = leader_id;
+ if ( mLeaderID.isNull() ) return;
- LLObjectSelectionHandle selection = LLSelectMgr::getInstance()->getSelection();
- if (selection->getObjectCount() && selection->getSelectType() == SELECT_TYPE_HUD)
+ LLViewerObject* object = gObjectList.findObject(mLeaderID);
+ if (!object)
{
- // just update hud zoom level
- mHUDTargetZoom /= fraction;
+ mLeaderID = LLUUID::null;
return;
}
+ startAutoPilotGlobal(object->getPositionGlobal());
+}
- LLVector3d camera_offset(mCameraFocusOffsetTarget);
- LLVector3d camera_offset_unit(mCameraFocusOffsetTarget);
- F32 min_zoom = LAND_MIN_ZOOM;
- F32 current_distance = (F32)camera_offset_unit.normalize();
- F32 new_distance = current_distance * fraction;
- // Don't move through focus point
- if (mFocusObject)
+//-----------------------------------------------------------------------------
+// stopAutoPilot()
+//-----------------------------------------------------------------------------
+void LLAgent::stopAutoPilot(BOOL user_cancel)
+{
+ if (mAutoPilot)
{
- LLVector3 camera_offset_dir((F32)camera_offset_unit.mdV[VX], (F32)camera_offset_unit.mdV[VY], (F32)camera_offset_unit.mdV[VZ]);
-
- if (mFocusObject->isAvatar())
+ mAutoPilot = FALSE;
+ if (mAutoPilotUseRotation && !user_cancel)
{
- calcCameraMinDistance(min_zoom);
+ resetAxes(mAutoPilotTargetFacing);
}
- else
+ //NB: auto pilot can terminate for a reason other than reaching the destination
+ if (mAutoPilotFinishedCallback)
{
- min_zoom = OBJECT_MIN_ZOOM;
+ mAutoPilotFinishedCallback(!user_cancel && dist_vec(gAgent.getPositionGlobal(), mAutoPilotTargetGlobal) < mAutoPilotStopDistance, mAutoPilotCallbackData);
}
- }
-
- new_distance = llmax(new_distance, min_zoom);
-
- // Don't zoom too far back
- const F32 DIST_FUDGE = 16.f; // meters
- F32 max_distance = llmin(mDrawDistance - DIST_FUDGE,
- LLWorld::getInstance()->getRegionWidthInMeters() - DIST_FUDGE );
-
- if (new_distance > max_distance)
- {
- new_distance = max_distance;
+ mLeaderID = LLUUID::null;
- // Unless camera is unlocked
- //if (!LLViewerCamera::sDisableCameraConstraints)
- //{
- // return;
- //}
- }
+ // If the user cancelled, don't change the fly state
+ if (!user_cancel)
+ {
+ setFlying(mAutoPilotFlyOnStop);
+ }
+ setControlFlags(AGENT_CONTROL_STOP);
- if( cameraCustomizeAvatar() )
- {
- new_distance = llclamp( new_distance, APPEARANCE_MIN_ZOOM, APPEARANCE_MAX_ZOOM );
+ if (user_cancel && !mAutoPilotBehaviorName.empty())
+ {
+ if (mAutoPilotBehaviorName == "Sit")
+ LLNotificationsUtil::add("CancelledSit");
+ else if (mAutoPilotBehaviorName == "Attach")
+ LLNotificationsUtil::add("CancelledAttach");
+ else
+ LLNotificationsUtil::add("Cancelled");
+ }
}
-
- mCameraFocusOffsetTarget = new_distance * camera_offset_unit;
}
+
+// Returns necessary agent pitch and yaw changes, radians.
//-----------------------------------------------------------------------------
-// cameraOrbitIn()
+// autoPilot()
//-----------------------------------------------------------------------------
-void LLAgent::cameraOrbitIn(const F32 meters)
+void LLAgent::autoPilot(F32 *delta_yaw)
{
- if (mFocusOnAvatar && mCameraMode == CAMERA_MODE_THIRD_PERSON)
+ if (mAutoPilot)
{
- F32 camera_offset_dist = llmax(0.001f, getCameraOffsetInitial().magVec() * gSavedSettings.getF32("CameraOffsetScale"));
-
- mCameraZoomFraction = (mTargetCameraDistance - meters) / camera_offset_dist;
-
- if (!gSavedSettings.getBOOL("FreezeTime") && mCameraZoomFraction < MIN_ZOOM_FRACTION && meters > 0.f)
+ if (!mLeaderID.isNull())
{
- // No need to animate, camera is already there.
- changeCameraToMouselook(FALSE);
+ LLViewerObject* object = gObjectList.findObject(mLeaderID);
+ if (!object)
+ {
+ stopAutoPilot();
+ return;
+ }
+ mAutoPilotTargetGlobal = object->getPositionGlobal();
}
-
- mCameraZoomFraction = llclamp(mCameraZoomFraction, MIN_ZOOM_FRACTION, MAX_ZOOM_FRACTION);
- }
- else
- {
- LLVector3d camera_offset(mCameraFocusOffsetTarget);
- LLVector3d camera_offset_unit(mCameraFocusOffsetTarget);
- F32 current_distance = (F32)camera_offset_unit.normalize();
- F32 new_distance = current_distance - meters;
- F32 min_zoom = LAND_MIN_ZOOM;
- // Don't move through focus point
- if (mFocusObject.notNull())
+ if (mAvatarObject.isNull())
{
- if (mFocusObject->isAvatar())
- {
- min_zoom = AVATAR_MIN_ZOOM;
- }
- else
- {
- min_zoom = OBJECT_MIN_ZOOM;
- }
+ return;
}
- new_distance = llmax(new_distance, min_zoom);
+ if (mAvatarObject->mInAir)
+ {
+ setFlying(TRUE);
+ }
+
+ LLVector3 at;
+ at.setVec(mFrameAgent.getAtAxis());
+ LLVector3 target_agent = getPosAgentFromGlobal(mAutoPilotTargetGlobal);
+ LLVector3 direction = target_agent - getPositionAgent();
- // Don't zoom too far back
- const F32 DIST_FUDGE = 16.f; // meters
- F32 max_distance = llmin(mDrawDistance - DIST_FUDGE,
- LLWorld::getInstance()->getRegionWidthInMeters() - DIST_FUDGE );
+ F32 target_dist = direction.magVec();
- if (new_distance > max_distance)
+ if (target_dist >= mAutoPilotTargetDist)
{
- // Unless camera is unlocked
- if (!gSavedSettings.getBOOL("DisableCameraConstraints"))
+ mAutoPilotNoProgressFrameCount++;
+ if (mAutoPilotNoProgressFrameCount > AUTOPILOT_MAX_TIME_NO_PROGRESS * gFPSClamped)
{
+ stopAutoPilot();
return;
}
}
- if( CAMERA_MODE_CUSTOMIZE_AVATAR == getCameraMode() )
- {
- new_distance = llclamp( new_distance, APPEARANCE_MIN_ZOOM, APPEARANCE_MAX_ZOOM );
- }
-
- // Compute new camera offset
- mCameraFocusOffsetTarget = new_distance * camera_offset_unit;
- cameraZoomIn(1.f);
- }
-}
-
-
-//-----------------------------------------------------------------------------
-// cameraPanIn()
-//-----------------------------------------------------------------------------
-void LLAgent::cameraPanIn(F32 meters)
-{
- LLVector3d at_axis;
- at_axis.setVec(LLViewerCamera::getInstance()->getAtAxis());
-
- mFocusTargetGlobal += meters * at_axis;
- mFocusGlobal = mFocusTargetGlobal;
- // don't enforce zoom constraints as this is the only way for users to get past them easily
- updateFocusOffset();
- // NOTE: panning movements expect the camera to move exactly with the focus target, not animated behind -Nyx
- mCameraSmoothingLastPositionGlobal = calcCameraPositionTargetGlobal();
-}
-
-//-----------------------------------------------------------------------------
-// cameraPanLeft()
-//-----------------------------------------------------------------------------
-void LLAgent::cameraPanLeft(F32 meters)
-{
- LLVector3d left_axis;
- left_axis.setVec(LLViewerCamera::getInstance()->getLeftAxis());
-
- mFocusTargetGlobal += meters * left_axis;
- mFocusGlobal = mFocusTargetGlobal;
-
- // disable smoothing for camera pan, which causes some residents unhappiness
- mCameraSmoothingStop = TRUE;
-
- cameraZoomIn(1.f);
- updateFocusOffset();
- // NOTE: panning movements expect the camera to move exactly with the focus target, not animated behind - Nyx
- mCameraSmoothingLastPositionGlobal = calcCameraPositionTargetGlobal();
-}
-
-//-----------------------------------------------------------------------------
-// cameraPanUp()
-//-----------------------------------------------------------------------------
-void LLAgent::cameraPanUp(F32 meters)
-{
- LLVector3d up_axis;
- up_axis.setVec(LLViewerCamera::getInstance()->getUpAxis());
-
- mFocusTargetGlobal += meters * up_axis;
- mFocusGlobal = mFocusTargetGlobal;
-
- // disable smoothing for camera pan, which causes some residents unhappiness
- mCameraSmoothingStop = TRUE;
-
- cameraZoomIn(1.f);
- updateFocusOffset();
- // NOTE: panning movements expect the camera to move exactly with the focus target, not animated behind -Nyx
- mCameraSmoothingLastPositionGlobal = calcCameraPositionTargetGlobal();
-}
-*/
-
-//-----------------------------------------------------------------------------
-// setKey()
-//-----------------------------------------------------------------------------
-void LLAgent::setKey(const S32 direction, S32 &key)
-{
- if (direction > 0)
- {
- key = 1;
- }
- else if (direction < 0)
- {
- key = -1;
- }
- else
- {
- key = 0;
- }
-}
-
-
-//-----------------------------------------------------------------------------
-// getControlFlags()
-//-----------------------------------------------------------------------------
-U32 LLAgent::getControlFlags()
-{
-/*
- // HACK -- avoids maintenance of control flags when camera mode is turned on or off,
- // only worries about it when the flags are measured
- if (mCameraMode == CAMERA_MODE_MOUSELOOK)
- {
- if ( !(mControlFlags & AGENT_CONTROL_MOUSELOOK) )
- {
- mControlFlags |= AGENT_CONTROL_MOUSELOOK;
- }
- }
-*/
- return mControlFlags;
-}
-
-//-----------------------------------------------------------------------------
-// setControlFlags()
-//-----------------------------------------------------------------------------
-void LLAgent::setControlFlags(U32 mask)
-{
- mControlFlags |= mask;
- mbFlagsDirty = TRUE;
-}
-
-
-//-----------------------------------------------------------------------------
-// clearControlFlags()
-//-----------------------------------------------------------------------------
-void LLAgent::clearControlFlags(U32 mask)
-{
- U32 old_flags = mControlFlags;
- mControlFlags &= ~mask;
- if (old_flags != mControlFlags)
- {
- mbFlagsDirty = TRUE;
- }
-}
-
-//-----------------------------------------------------------------------------
-// controlFlagsDirty()
-//-----------------------------------------------------------------------------
-BOOL LLAgent::controlFlagsDirty() const
-{
- return mbFlagsDirty;
-}
-
-//-----------------------------------------------------------------------------
-// enableControlFlagReset()
-//-----------------------------------------------------------------------------
-void LLAgent::enableControlFlagReset()
-{
- mbFlagsNeedReset = TRUE;
-}
-
-//-----------------------------------------------------------------------------
-// resetControlFlags()
-//-----------------------------------------------------------------------------
-void LLAgent::resetControlFlags()
-{
- if (mbFlagsNeedReset)
- {
- mbFlagsNeedReset = FALSE;
- mbFlagsDirty = FALSE;
- // reset all of the ephemeral flags
- // some flags are managed elsewhere
- mControlFlags &= AGENT_CONTROL_AWAY | AGENT_CONTROL_FLY | AGENT_CONTROL_MOUSELOOK;
- }
-}
-
-//-----------------------------------------------------------------------------
-// setAFK()
-//-----------------------------------------------------------------------------
-void LLAgent::setAFK()
-{
- // Drones can't go AFK
- if (gNoRender)
- {
- return;
- }
-
- if (!gAgent.getRegion())
- {
- // Don't set AFK if we're not talking to a region yet.
- return;
- }
-
- if (!(mControlFlags & AGENT_CONTROL_AWAY))
- {
- sendAnimationRequest(ANIM_AGENT_AWAY, ANIM_REQUEST_START);
- setControlFlags(AGENT_CONTROL_AWAY | AGENT_CONTROL_STOP);
- gAwayTimer.start();
- if (gAFKMenu)
- {
- gAFKMenu->setLabel(LLTrans::getString("AvatarSetNotAway"));
- }
- }
-}
-
-//-----------------------------------------------------------------------------
-// clearAFK()
-//-----------------------------------------------------------------------------
-void LLAgent::clearAFK()
-{
- gAwayTriggerTimer.reset();
-
- // Gods can sometimes get into away state (via gestures)
- // without setting the appropriate control flag. JC
- LLVOAvatar* av = mAvatarObject;
- if (mControlFlags & AGENT_CONTROL_AWAY
- || (av
- && (av->mSignaledAnimations.find(ANIM_AGENT_AWAY) != av->mSignaledAnimations.end())))
- {
- sendAnimationRequest(ANIM_AGENT_AWAY, ANIM_REQUEST_STOP);
- clearControlFlags(AGENT_CONTROL_AWAY);
- if (gAFKMenu)
- {
- gAFKMenu->setLabel(LLTrans::getString("AvatarSetAway"));
- }
- }
-}
-
-//-----------------------------------------------------------------------------
-// getAFK()
-//-----------------------------------------------------------------------------
-BOOL LLAgent::getAFK() const
-{
- return (mControlFlags & AGENT_CONTROL_AWAY) != 0;
-}
-
-//-----------------------------------------------------------------------------
-// setBusy()
-//-----------------------------------------------------------------------------
-void LLAgent::setBusy()
-{
- sendAnimationRequest(ANIM_AGENT_BUSY, ANIM_REQUEST_START);
- mIsBusy = TRUE;
- if (gBusyMenu)
- {
- gBusyMenu->setLabel(LLTrans::getString("AvatarSetNotBusy"));
- }
- LLNotificationsUI::LLChannelManager::getInstance()->muteAllChannels(true);
-}
-
-//-----------------------------------------------------------------------------
-// clearBusy()
-//-----------------------------------------------------------------------------
-void LLAgent::clearBusy()
-{
- mIsBusy = FALSE;
- sendAnimationRequest(ANIM_AGENT_BUSY, ANIM_REQUEST_STOP);
- if (gBusyMenu)
- {
- gBusyMenu->setLabel(LLTrans::getString("AvatarSetBusy"));
- }
- LLNotificationsUI::LLChannelManager::getInstance()->muteAllChannels(false);
-}
-
-//-----------------------------------------------------------------------------
-// getBusy()
-//-----------------------------------------------------------------------------
-BOOL LLAgent::getBusy() const
-{
- return mIsBusy;
-}
-
-
-//-----------------------------------------------------------------------------
-// startAutoPilotGlobal()
-//-----------------------------------------------------------------------------
-void LLAgent::startAutoPilotGlobal(const LLVector3d &target_global, const std::string& behavior_name, const LLQuaternion *target_rotation, void (*finish_callback)(BOOL, void *), void *callback_data, F32 stop_distance, F32 rot_threshold)
-{
- if (!gAgent.getAvatarObject())
- {
- return;
- }
-
- mAutoPilotFinishedCallback = finish_callback;
- mAutoPilotCallbackData = callback_data;
- mAutoPilotRotationThreshold = rot_threshold;
- mAutoPilotBehaviorName = behavior_name;
-
- LLVector3d delta_pos( target_global );
- delta_pos -= getPositionGlobal();
- F64 distance = delta_pos.magVec();
- LLVector3d trace_target = target_global;
-
- trace_target.mdV[VZ] -= 10.f;
-
- LLVector3d intersection;
- LLVector3 normal;
- LLViewerObject *hit_obj;
- F32 heightDelta = LLWorld::getInstance()->resolveStepHeightGlobal(NULL, target_global, trace_target, intersection, normal, &hit_obj);
-
- if (stop_distance > 0.f)
- {
- mAutoPilotStopDistance = stop_distance;
- }
- else
- {
- // Guess at a reasonable stop distance.
- mAutoPilotStopDistance = fsqrtf( distance );
- if (mAutoPilotStopDistance < 0.5f)
- {
- mAutoPilotStopDistance = 0.5f;
- }
- }
-
- mAutoPilotFlyOnStop = getFlying();
-
- if (distance > 30.0)
- {
- setFlying(TRUE);
- }
-
- if ( distance > 1.f && heightDelta > (sqrtf(mAutoPilotStopDistance) + 1.f))
- {
- setFlying(TRUE);
- mAutoPilotFlyOnStop = TRUE;
- }
-
- mAutoPilot = TRUE;
- mAutoPilotTargetGlobal = target_global;
-
- // trace ray down to find height of destination from ground
- LLVector3d traceEndPt = target_global;
- traceEndPt.mdV[VZ] -= 20.f;
-
- LLVector3d targetOnGround;
- LLVector3 groundNorm;
- LLViewerObject *obj;
-
- LLWorld::getInstance()->resolveStepHeightGlobal(NULL, target_global, traceEndPt, targetOnGround, groundNorm, &obj);
- F64 target_height = llmax((F64)gAgent.getAvatarObject()->getPelvisToFoot(), target_global.mdV[VZ] - targetOnGround.mdV[VZ]);
-
- // clamp z value of target to minimum height above ground
- mAutoPilotTargetGlobal.mdV[VZ] = targetOnGround.mdV[VZ] + target_height;
- mAutoPilotTargetDist = (F32)dist_vec(gAgent.getPositionGlobal(), mAutoPilotTargetGlobal);
- if (target_rotation)
- {
- mAutoPilotUseRotation = TRUE;
- mAutoPilotTargetFacing = LLVector3::x_axis * *target_rotation;
- mAutoPilotTargetFacing.mV[VZ] = 0.f;
- mAutoPilotTargetFacing.normalize();
- }
- else
- {
- mAutoPilotUseRotation = FALSE;
- }
-
- mAutoPilotNoProgressFrameCount = 0;
-}
-
-
-//-----------------------------------------------------------------------------
-// startFollowPilot()
-//-----------------------------------------------------------------------------
-void LLAgent::startFollowPilot(const LLUUID &leader_id)
-{
- if (!mAutoPilot) return;
-
- mLeaderID = leader_id;
- if ( mLeaderID.isNull() ) return;
-
- LLViewerObject* object = gObjectList.findObject(mLeaderID);
- if (!object)
- {
- mLeaderID = LLUUID::null;
- return;
- }
-
- startAutoPilotGlobal(object->getPositionGlobal());
-}
-
-
-//-----------------------------------------------------------------------------
-// stopAutoPilot()
-//-----------------------------------------------------------------------------
-void LLAgent::stopAutoPilot(BOOL user_cancel)
-{
- if (mAutoPilot)
- {
- mAutoPilot = FALSE;
- if (mAutoPilotUseRotation && !user_cancel)
- {
- resetAxes(mAutoPilotTargetFacing);
- }
- //NB: auto pilot can terminate for a reason other than reaching the destination
- if (mAutoPilotFinishedCallback)
- {
- mAutoPilotFinishedCallback(!user_cancel && dist_vec(gAgent.getPositionGlobal(), mAutoPilotTargetGlobal) < mAutoPilotStopDistance, mAutoPilotCallbackData);
- }
- mLeaderID = LLUUID::null;
-
- // If the user cancelled, don't change the fly state
- if (!user_cancel)
- {
- setFlying(mAutoPilotFlyOnStop);
- }
- setControlFlags(AGENT_CONTROL_STOP);
-
- if (user_cancel && !mAutoPilotBehaviorName.empty())
- {
- if (mAutoPilotBehaviorName == "Sit")
- LLNotificationsUtil::add("CancelledSit");
- else if (mAutoPilotBehaviorName == "Attach")
- LLNotificationsUtil::add("CancelledAttach");
- else
- LLNotificationsUtil::add("Cancelled");
- }
- }
-}
-
-
-// Returns necessary agent pitch and yaw changes, radians.
-//-----------------------------------------------------------------------------
-// autoPilot()
-//-----------------------------------------------------------------------------
-void LLAgent::autoPilot(F32 *delta_yaw)
-{
- if (mAutoPilot)
- {
- if (!mLeaderID.isNull())
- {
- LLViewerObject* object = gObjectList.findObject(mLeaderID);
- if (!object)
- {
- stopAutoPilot();
- return;
- }
- mAutoPilotTargetGlobal = object->getPositionGlobal();
- }
-
- if (mAvatarObject.isNull())
- {
- return;
- }
-
- if (mAvatarObject->mInAir)
- {
- setFlying(TRUE);
- }
-
- LLVector3 at;
- at.setVec(mFrameAgent.getAtAxis());
- LLVector3 target_agent = getPosAgentFromGlobal(mAutoPilotTargetGlobal);
- LLVector3 direction = target_agent - getPositionAgent();
-
- F32 target_dist = direction.magVec();
-
- if (target_dist >= mAutoPilotTargetDist)
- {
- mAutoPilotNoProgressFrameCount++;
- if (mAutoPilotNoProgressFrameCount > AUTOPILOT_MAX_TIME_NO_PROGRESS * gFPSClamped)
- {
- stopAutoPilot();
- return;
- }
- }
-
- mAutoPilotTargetDist = target_dist;
-
- // Make this a two-dimensional solution
- at.mV[VZ] = 0.f;
- direction.mV[VZ] = 0.f;
-
- at.normalize();
- F32 xy_distance = direction.normalize();
-
- F32 yaw = 0.f;
- if (mAutoPilotTargetDist > mAutoPilotStopDistance)
- {
- yaw = angle_between(mFrameAgent.getAtAxis(), direction);
- }
- else if (mAutoPilotUseRotation)
- {
- // we're close now just aim at target facing
- yaw = angle_between(at, mAutoPilotTargetFacing);
- direction = mAutoPilotTargetFacing;
- }
-
- yaw = 4.f * yaw / gFPSClamped;
-
- // figure out which direction to turn
- LLVector3 scratch(at % direction);
-
- if (scratch.mV[VZ] > 0.f)
- {
- setControlFlags(AGENT_CONTROL_YAW_POS);
- }
- else
- {
- yaw = -yaw;
- setControlFlags(AGENT_CONTROL_YAW_NEG);
- }
-
- *delta_yaw = yaw;
-
- // Compute when to start slowing down and when to stop
- F32 stop_distance = mAutoPilotStopDistance;
- F32 slow_distance;
- if (getFlying())
- {
- slow_distance = llmax(6.f, mAutoPilotStopDistance + 5.f);
- stop_distance = llmax(2.f, mAutoPilotStopDistance);
- }
- else
- {
- slow_distance = llmax(3.f, mAutoPilotStopDistance + 2.f);
- }
-
- // If we're flying, handle autopilot points above or below you.
- if (getFlying() && xy_distance < AUTOPILOT_HEIGHT_ADJUST_DISTANCE)
- {
- if (mAvatarObject.notNull())
- {
- F64 current_height = mAvatarObject->getPositionGlobal().mdV[VZ];
- F32 delta_z = (F32)(mAutoPilotTargetGlobal.mdV[VZ] - current_height);
- F32 slope = delta_z / xy_distance;
- if (slope > 0.45f && delta_z > 6.f)
- {
- setControlFlags(AGENT_CONTROL_FAST_UP | AGENT_CONTROL_UP_POS);
- }
- else if (slope > 0.002f && delta_z > 0.5f)
- {
- setControlFlags(AGENT_CONTROL_UP_POS);
- }
- else if (slope < -0.45f && delta_z < -6.f && current_height > AUTOPILOT_MIN_TARGET_HEIGHT_OFF_GROUND)
- {
- setControlFlags(AGENT_CONTROL_FAST_UP | AGENT_CONTROL_UP_NEG);
- }
- else if (slope < -0.002f && delta_z < -0.5f && current_height > AUTOPILOT_MIN_TARGET_HEIGHT_OFF_GROUND)
- {
- setControlFlags(AGENT_CONTROL_UP_NEG);
- }
- }
- }
-
- // calculate delta rotation to target heading
- F32 delta_target_heading = angle_between(mFrameAgent.getAtAxis(), mAutoPilotTargetFacing);
-
- if (xy_distance > slow_distance && yaw < (F_PI / 10.f))
- {
- // walking/flying fast
- setControlFlags(AGENT_CONTROL_FAST_AT | AGENT_CONTROL_AT_POS);
- }
- else if (mAutoPilotTargetDist > mAutoPilotStopDistance)
- {
- // walking/flying slow
- if (at * direction > 0.9f)
- {
- setControlFlags(AGENT_CONTROL_AT_POS);
- }
- else if (at * direction < -0.9f)
- {
- setControlFlags(AGENT_CONTROL_AT_NEG);
- }
- }
-
- // check to see if we need to keep rotating to target orientation
- if (mAutoPilotTargetDist < mAutoPilotStopDistance)
- {
- setControlFlags(AGENT_CONTROL_STOP);
- if(!mAutoPilotUseRotation || (delta_target_heading < mAutoPilotRotationThreshold))
- {
- stopAutoPilot();
- }
- }
- }
-}
-
-
-//-----------------------------------------------------------------------------
-// propagate()
-//-----------------------------------------------------------------------------
-void LLAgent::propagate(const F32 dt)
-{
- // Update UI based on agent motion
- LLFloaterMove *floater_move = LLFloaterReg::findTypedInstance<LLFloaterMove>("moveview");
- if (floater_move)
- {
- floater_move->mForwardButton ->setToggleState( mAtKey > 0 || mWalkKey > 0 );
- floater_move->mBackwardButton ->setToggleState( mAtKey < 0 || mWalkKey < 0 );
- floater_move->mTurnLeftButton ->setToggleState( mYawKey > 0.f );
- floater_move->mTurnRightButton ->setToggleState( mYawKey < 0.f );
- floater_move->mMoveUpButton ->setToggleState( mUpKey > 0 );
- floater_move->mMoveDownButton ->setToggleState( mUpKey < 0 );
- }
-
- // handle rotation based on keyboard levels
- const F32 YAW_RATE = 90.f * DEG_TO_RAD; // radians per second
- yaw(YAW_RATE * mYawKey * dt);
-
- const F32 PITCH_RATE = 90.f * DEG_TO_RAD; // radians per second
- pitch(PITCH_RATE * mPitchKey * dt);
-
- // handle auto-land behavior
- if (mAvatarObject.notNull())
- {
- BOOL in_air = mAvatarObject->mInAir;
- LLVector3 land_vel = getVelocity();
- land_vel.mV[VZ] = 0.f;
-
- if (!in_air
- && mUpKey < 0
- && land_vel.magVecSquared() < MAX_VELOCITY_AUTO_LAND_SQUARED
- && gSavedSettings.getBOOL("AutomaticFly"))
- {
- // land automatically
- setFlying(FALSE);
- }
- }
-
- // clear keys
- mAtKey = 0;
- mWalkKey = 0;
- mLeftKey = 0;
- mUpKey = 0;
- mYawKey = 0.f;
- mPitchKey = 0.f;
-}
-
-//-----------------------------------------------------------------------------
-// updateAgentPosition()
-//-----------------------------------------------------------------------------
-void LLAgent::updateAgentPosition(const F32 dt, const F32 yaw_radians, const S32 mouse_x, const S32 mouse_y)
-{
- propagate(dt);
-
- // static S32 cameraUpdateCount = 0;
-
- rotate(yaw_radians, 0, 0, 1);
-
- //
- // Check for water and land collision, set underwater flag
- //
-
- gAgentCameraHACK.updateLookAt(mouse_x, mouse_y);
-}
-
-/*
-//-----------------------------------------------------------------------------
-// updateLookAt()
-//-----------------------------------------------------------------------------
-void LLAgent::updateLookAt(const S32 mouse_x, const S32 mouse_y)
-{
- static LLVector3 last_at_axis;
-
-
- if (mAvatarObject.isNull())
- {
- return;
- }
-
- LLQuaternion av_inv_rot = ~mAvatarObject->mRoot.getWorldRotation();
- LLVector3 root_at = LLVector3::x_axis * mAvatarObject->mRoot.getWorldRotation();
-
- if ((gViewerWindow->getMouseVelocityStat()->getCurrent() < 0.01f) &&
- (root_at * last_at_axis > 0.95f ))
- {
- LLVector3 vel = mAvatarObject->getVelocity();
- if (vel.magVecSquared() > 4.f)
- {
- setLookAt(LOOKAT_TARGET_IDLE, mAvatarObject, vel * av_inv_rot);
- }
- else
- {
- // *FIX: rotate mframeagent by sit object's rotation?
- LLQuaternion look_rotation = mAvatarObject->isSitting() ? mAvatarObject->getRenderRotation() : mFrameAgent.getQuaternion(); // use camera's current rotation
- LLVector3 look_offset = LLVector3(2.f, 0.f, 0.f) * look_rotation * av_inv_rot;
- setLookAt(LOOKAT_TARGET_IDLE, mAvatarObject, look_offset);
- }
- last_at_axis = root_at;
- return;
- }
-
- last_at_axis = root_at;
-
- if (CAMERA_MODE_CUSTOMIZE_AVATAR == getCameraMode())
- {
- setLookAt(LOOKAT_TARGET_NONE, mAvatarObject, LLVector3(-2.f, 0.f, 0.f));
- }
- else
- {
- // Move head based on cursor position
- ELookAtType lookAtType = LOOKAT_TARGET_NONE;
- LLVector3 headLookAxis;
- LLCoordFrame frameCamera = *((LLCoordFrame*)LLViewerCamera::getInstance());
-
- if (cameraMouselook())
- {
- lookAtType = LOOKAT_TARGET_MOUSELOOK;
- }
- else if (cameraThirdPerson())
- {
- // range from -.5 to .5
- F32 x_from_center =
- ((F32) mouse_x / (F32) gViewerWindow->getWindowWidthScaled() ) - 0.5f;
- F32 y_from_center =
- ((F32) mouse_y / (F32) gViewerWindow->getWindowHeightScaled() ) - 0.5f;
-
- frameCamera.yaw( - x_from_center * gSavedSettings.getF32("YawFromMousePosition") * DEG_TO_RAD);
- frameCamera.pitch( - y_from_center * gSavedSettings.getF32("PitchFromMousePosition") * DEG_TO_RAD);
- lookAtType = LOOKAT_TARGET_FREELOOK;
- }
-
- headLookAxis = frameCamera.getAtAxis();
- // RN: we use world-space offset for mouselook and freelook
- //headLookAxis = headLookAxis * av_inv_rot;
- setLookAt(lookAtType, mAvatarObject, headLookAxis);
- }
-}
-*/
-
-// friends and operators
-
-std::ostream& operator<<(std::ostream &s, const LLAgent &agent)
-{
- // This is unfinished, but might never be used.
- // We'll just leave it for now; we can always delete it.
- s << " { "
- << " Frame = " << agent.mFrameAgent << "\n"
- << " }";
- return s;
-}
-
-
-// ------------------- Beginning of legacy LLCamera hack ----------------------
-// This section is included for legacy LLCamera support until
-// it is no longer needed. Some legacy code must exist in
-// non-legacy functions, and is labeled with "// legacy" comments.
-
-//-----------------------------------------------------------------------------
-// setAvatarObject()
-//-----------------------------------------------------------------------------
-void LLAgent::setAvatarObject(LLVOAvatarSelf *avatar)
-{
- mAvatarObject = avatar;
-
- if (!avatar)
- {
- llinfos << "Setting LLAgent::mAvatarObject to NULL" << llendl;
- return;
- }
-
- if (!gAgentCameraHACK.mLookAt)
- {
- gAgentCameraHACK.mLookAt = (LLHUDEffectLookAt *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_LOOKAT);
- }
- if (!gAgentCameraHACK.mPointAt)
- {
- gAgentCameraHACK.mPointAt = (LLHUDEffectPointAt *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_POINTAT);
- }
-
- if (!gAgentCameraHACK.mLookAt.isNull())
- {
- gAgentCameraHACK.mLookAt->setSourceObject(avatar);
- }
- if (!gAgentCameraHACK.mPointAt.isNull())
- {
- gAgentCameraHACK.mPointAt->setSourceObject(avatar);
- }
-}
-
-// TRUE if your own avatar needs to be rendered. Usually only
-// in third person and build.
-//-----------------------------------------------------------------------------
-// needsRenderAvatar()
-//-----------------------------------------------------------------------------
-BOOL LLAgent::needsRenderAvatar()
-{
- if (gAgentCameraHACK.cameraMouselook() && !LLVOAvatar::sVisibleInFirstPerson)
- {
- return FALSE;
- }
-
- return mShowAvatar && mGenderChosen;
-}
-
-// TRUE if we need to render your own avatar's head.
-BOOL LLAgent::needsRenderHead()
-{
- return (LLVOAvatar::sVisibleInFirstPerson && LLPipeline::sReflectionRender) || (mShowAvatar && !gAgentCameraHACK.cameraMouselook());
-}
-
-//-----------------------------------------------------------------------------
-// startTyping()
-//-----------------------------------------------------------------------------
-void LLAgent::startTyping()
-{
- mTypingTimer.reset();
-
- if (getRenderState() & AGENT_STATE_TYPING)
- {
- // already typing, don't trigger a different animation
- return;
- }
- setRenderState(AGENT_STATE_TYPING);
-
- if (mChatTimer.getElapsedTimeF32() < 2.f)
- {
- LLViewerObject* chatter = gObjectList.findObject(mLastChatterID);
- if (chatter && chatter->isAvatar())
- {
- gAgentCameraHACK.setLookAt(LOOKAT_TARGET_RESPOND, chatter, LLVector3::zero);
- }
- }
-
- if (gSavedSettings.getBOOL("PlayTypingAnim"))
- {
- sendAnimationRequest(ANIM_AGENT_TYPE, ANIM_REQUEST_START);
- }
- LLNearbyChatBar::getInstance()->sendChatFromViewer("", CHAT_TYPE_START, FALSE);
-}
-
-//-----------------------------------------------------------------------------
-// stopTyping()
-//-----------------------------------------------------------------------------
-void LLAgent::stopTyping()
-{
- if (mRenderState & AGENT_STATE_TYPING)
- {
- clearRenderState(AGENT_STATE_TYPING);
- sendAnimationRequest(ANIM_AGENT_TYPE, ANIM_REQUEST_STOP);
- LLNearbyChatBar::getInstance()->sendChatFromViewer("", CHAT_TYPE_STOP, FALSE);
- }
-}
-
-//-----------------------------------------------------------------------------
-// setRenderState()
-//-----------------------------------------------------------------------------
-void LLAgent::setRenderState(U8 newstate)
-{
- mRenderState |= newstate;
-}
-
-//-----------------------------------------------------------------------------
-// clearRenderState()
-//-----------------------------------------------------------------------------
-void LLAgent::clearRenderState(U8 clearstate)
-{
- mRenderState &= ~clearstate;
-}
-
-
-//-----------------------------------------------------------------------------
-// getRenderState()
-//-----------------------------------------------------------------------------
-U8 LLAgent::getRenderState()
-{
- if (gNoRender || gKeyboard == NULL)
- {
- return 0;
- }
-
- // *FIX: don't do stuff in a getter! This is infinite loop city!
- if ((mTypingTimer.getElapsedTimeF32() > TYPING_TIMEOUT_SECS)
- && (mRenderState & AGENT_STATE_TYPING))
- {
- stopTyping();
- }
-
- if ((!LLSelectMgr::getInstance()->getSelection()->isEmpty() && LLSelectMgr::getInstance()->shouldShowSelection())
- || LLToolMgr::getInstance()->getCurrentTool()->isEditing() )
- {
- setRenderState(AGENT_STATE_EDITING);
- }
- else
- {
- clearRenderState(AGENT_STATE_EDITING);
- }
-
- return mRenderState;
-}
-
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-
-//-----------------------------------------------------------------------------
-// endAnimationUpdateUI()
-//-----------------------------------------------------------------------------
-void LLAgent::endAnimationUpdateUI()
-{
- if (gAgentCameraHACK.mCameraMode == gAgentCameraHACK.mLastCameraMode)
- {
- // We're already done endAnimationUpdateUI for this transition.
- return;
- }
-
- // clean up UI from mode we're leaving
- if (gAgentCameraHACK.mLastCameraMode == CAMERA_MODE_MOUSELOOK )
- {
- // show mouse cursor
- gViewerWindow->showCursor();
- // show menus
- gMenuBarView->setVisible(TRUE);
- LLNavigationBar::getInstance()->setVisible(TRUE);
- gStatusBar->setVisibleForMouselook(true);
-
- LLBottomTray::getInstance()->onMouselookModeOut();
-
- LLSideTray::getInstance()->getButtonsPanel()->setVisible(TRUE);
- LLSideTray::getInstance()->updateSidetrayVisibility();
-
- LLPanelStandStopFlying::getInstance()->setVisible(TRUE);
-
- LLToolMgr::getInstance()->setCurrentToolset(gBasicToolset);
-
- LLFloaterCamera::onLeavingMouseLook();
-
- // Only pop if we have pushed...
- if (TRUE == mViewsPushed)
- {
-#if 0 // Use this once all floaters are registered
- LLFloaterReg::restoreVisibleInstances();
-#else // Use this for now
- LLFloaterView::skip_list_t skip_list;
- if (LLFloaterReg::findInstance("mini_map"))
- {
- skip_list.insert(LLFloaterReg::findInstance("mini_map"));
- }
-
- gFloaterView->popVisibleAll(skip_list);
-#endif
- mViewsPushed = FALSE;
- }
-
-
- gAgentCameraHACK.setLookAt(LOOKAT_TARGET_CLEAR);
- if( gMorphView )
- {
- gMorphView->setVisible( FALSE );
- }
-
- // Disable mouselook-specific animations
- if (mAvatarObject.notNull())
- {
- if( mAvatarObject->isAnyAnimationSignaled(AGENT_GUN_AIM_ANIMS, NUM_AGENT_GUN_AIM_ANIMS) )
- {
- if (mAvatarObject->mSignaledAnimations.find(ANIM_AGENT_AIM_RIFLE_R) != mAvatarObject->mSignaledAnimations.end())
- {
- sendAnimationRequest(ANIM_AGENT_AIM_RIFLE_R, ANIM_REQUEST_STOP);
- sendAnimationRequest(ANIM_AGENT_HOLD_RIFLE_R, ANIM_REQUEST_START);
- }
- if (mAvatarObject->mSignaledAnimations.find(ANIM_AGENT_AIM_HANDGUN_R) != mAvatarObject->mSignaledAnimations.end())
- {
- sendAnimationRequest(ANIM_AGENT_AIM_HANDGUN_R, ANIM_REQUEST_STOP);
- sendAnimationRequest(ANIM_AGENT_HOLD_HANDGUN_R, ANIM_REQUEST_START);
- }
- if (mAvatarObject->mSignaledAnimations.find(ANIM_AGENT_AIM_BAZOOKA_R) != mAvatarObject->mSignaledAnimations.end())
- {
- sendAnimationRequest(ANIM_AGENT_AIM_BAZOOKA_R, ANIM_REQUEST_STOP);
- sendAnimationRequest(ANIM_AGENT_HOLD_BAZOOKA_R, ANIM_REQUEST_START);
- }
- if (mAvatarObject->mSignaledAnimations.find(ANIM_AGENT_AIM_BOW_L) != mAvatarObject->mSignaledAnimations.end())
- {
- sendAnimationRequest(ANIM_AGENT_AIM_BOW_L, ANIM_REQUEST_STOP);
- sendAnimationRequest(ANIM_AGENT_HOLD_BOW_L, ANIM_REQUEST_START);
- }
- }
- }
- }
- else
- if(gAgentCameraHACK.mLastCameraMode == CAMERA_MODE_CUSTOMIZE_AVATAR)
- {
- // make sure we ask to save changes
-
- LLToolMgr::getInstance()->setCurrentToolset(gBasicToolset);
-
- if( gMorphView )
- {
- gMorphView->setVisible( FALSE );
- }
-
- if (mAvatarObject.notNull())
- {
- if(mCustomAnim)
- {
- sendAnimationRequest(ANIM_AGENT_CUSTOMIZE, ANIM_REQUEST_STOP);
- sendAnimationRequest(ANIM_AGENT_CUSTOMIZE_DONE, ANIM_REQUEST_START);
-
- mCustomAnim = FALSE ;
- }
-
- }
- gAgentCameraHACK.setLookAt(LOOKAT_TARGET_CLEAR);
- }
-
- //---------------------------------------------------------------------
- // Set up UI for mode we're entering
- //---------------------------------------------------------------------
- if (gAgentCameraHACK.mCameraMode == CAMERA_MODE_MOUSELOOK)
- {
- // hide menus
- gMenuBarView->setVisible(FALSE);
- LLNavigationBar::getInstance()->setVisible(FALSE);
- gStatusBar->setVisibleForMouselook(false);
-
- LLBottomTray::getInstance()->onMouselookModeIn();
-
- LLSideTray::getInstance()->getButtonsPanel()->setVisible(FALSE);
- LLSideTray::getInstance()->updateSidetrayVisibility();
-
- LLPanelStandStopFlying::getInstance()->setVisible(FALSE);
-
- // clear out camera lag effect
- gAgentCameraHACK.mCameraLag.clearVec();
-
- // JC - Added for always chat in third person option
- gFocusMgr.setKeyboardFocus(NULL);
-
- LLToolMgr::getInstance()->setCurrentToolset(gMouselookToolset);
-
- mViewsPushed = TRUE;
-
- // hide all floaters except the mini map
-
-#if 0 // Use this once all floaters are registered
- std::set<std::string> exceptions;
- exceptions.insert("mini_map");
- LLFloaterReg::hideVisibleInstances(exceptions);
-#else // Use this for now
- LLFloaterView::skip_list_t skip_list;
- skip_list.insert(LLFloaterReg::findInstance("mini_map"));
- gFloaterView->pushVisibleAll(FALSE, skip_list);
-#endif
-
- if( gMorphView )
- {
- gMorphView->setVisible(FALSE);
- }
-
- gConsole->setVisible( TRUE );
-
- if (mAvatarObject.notNull())
- {
- // Trigger mouselook-specific animations
- if( mAvatarObject->isAnyAnimationSignaled(AGENT_GUN_HOLD_ANIMS, NUM_AGENT_GUN_HOLD_ANIMS) )
- {
- if (mAvatarObject->mSignaledAnimations.find(ANIM_AGENT_HOLD_RIFLE_R) != mAvatarObject->mSignaledAnimations.end())
- {
- sendAnimationRequest(ANIM_AGENT_HOLD_RIFLE_R, ANIM_REQUEST_STOP);
- sendAnimationRequest(ANIM_AGENT_AIM_RIFLE_R, ANIM_REQUEST_START);
- }
- if (mAvatarObject->mSignaledAnimations.find(ANIM_AGENT_HOLD_HANDGUN_R) != mAvatarObject->mSignaledAnimations.end())
- {
- sendAnimationRequest(ANIM_AGENT_HOLD_HANDGUN_R, ANIM_REQUEST_STOP);
- sendAnimationRequest(ANIM_AGENT_AIM_HANDGUN_R, ANIM_REQUEST_START);
- }
- if (mAvatarObject->mSignaledAnimations.find(ANIM_AGENT_HOLD_BAZOOKA_R) != mAvatarObject->mSignaledAnimations.end())
- {
- sendAnimationRequest(ANIM_AGENT_HOLD_BAZOOKA_R, ANIM_REQUEST_STOP);
- sendAnimationRequest(ANIM_AGENT_AIM_BAZOOKA_R, ANIM_REQUEST_START);
- }
- if (mAvatarObject->mSignaledAnimations.find(ANIM_AGENT_HOLD_BOW_L) != mAvatarObject->mSignaledAnimations.end())
- {
- sendAnimationRequest(ANIM_AGENT_HOLD_BOW_L, ANIM_REQUEST_STOP);
- sendAnimationRequest(ANIM_AGENT_AIM_BOW_L, ANIM_REQUEST_START);
- }
- }
- if (mAvatarObject->getParent())
- {
- LLVector3 at_axis = LLViewerCamera::getInstance()->getAtAxis();
- LLViewerObject* root_object = (LLViewerObject*)mAvatarObject->getRoot();
- if (root_object->flagCameraDecoupled())
- {
- resetAxes(at_axis);
- }
- else
- {
- resetAxes(at_axis * ~((LLViewerObject*)mAvatarObject->getParent())->getRenderRotation());
- }
- }
- }
-
- }
- else if (gAgentCameraHACK.mCameraMode == CAMERA_MODE_CUSTOMIZE_AVATAR)
- {
- LLToolMgr::getInstance()->setCurrentToolset(gFaceEditToolset);
-
- if( gMorphView )
- {
- gMorphView->setVisible( TRUE );
- }
-
- // freeze avatar
- if (mAvatarObject.notNull())
- {
- mPauseRequest = mAvatarObject->requestPause();
- }
- }
-
- if (getAvatarObject())
- {
- getAvatarObject()->updateAttachmentVisibility(gAgentCameraHACK.mCameraMode);
- }
-
- gFloaterTools->dirty();
-
- // Don't let this be called more than once if the camera
- // mode hasn't changed. --JC
- gAgentCameraHACK.mLastCameraMode = gAgentCameraHACK.mCameraMode;
-
-}
-
-/*
-//-----------------------------------------------------------------------------
-// updateCamera()
-//-----------------------------------------------------------------------------
-void LLAgent::updateCamera()
-{
- static LLFastTimer::DeclareTimer ftm("Camera");
- LLFastTimer t(ftm);
-
- //Ventrella - changed camera_skyward to the new global "mCameraUpVector"
- mCameraUpVector = LLVector3::z_axis;
- //LLVector3 camera_skyward(0.f, 0.f, 1.f);
- //end Ventrella
-
- U32 camera_mode = mCameraAnimating ? mLastCameraMode : mCameraMode;
-
- validateFocusObject();
-
- if (mAvatarObject.notNull() &&
- mAvatarObject->isSitting() &&
- camera_mode == CAMERA_MODE_MOUSELOOK)
- {
- //Ventrella
- //changed camera_skyward to the new global "mCameraUpVector"
- mCameraUpVector = mCameraUpVector * mAvatarObject->getRenderRotation();
- //end Ventrella
- }
-
- if (cameraThirdPerson() && mFocusOnAvatar && LLFollowCamMgr::getActiveFollowCamParams())
- {
- changeCameraToFollow();
- }
-
- //Ventrella
- //NOTE - this needs to be integrated into a general upVector system here within llAgent.
- if ( camera_mode == CAMERA_MODE_FOLLOW && mFocusOnAvatar )
- {
- mCameraUpVector = mFollowCam.getUpVector();
- }
- //end Ventrella
-
- if (mSitCameraEnabled)
- {
- if (mSitCameraReferenceObject->isDead())
- {
- setSitCamera(LLUUID::null);
- }
- }
-
- // Update UI with our camera inputs
- LLFloaterCamera* camera_floater = LLFloaterReg::findTypedInstance<LLFloaterCamera>("camera");
- if (camera_floater)
- {
- camera_floater->mRotate->setToggleState(
- mOrbitRightKey > 0.f, // left
- mOrbitUpKey > 0.f, // top
- mOrbitLeftKey > 0.f, // right
- mOrbitDownKey > 0.f); // bottom
-
- camera_floater->mTrack->setToggleState(
- mPanLeftKey > 0.f, // left
- mPanUpKey > 0.f, // top
- mPanRightKey > 0.f, // right
- mPanDownKey > 0.f); // bottom
- }
-
- // Handle camera movement based on keyboard.
- const F32 ORBIT_OVER_RATE = 90.f * DEG_TO_RAD; // radians per second
- const F32 ORBIT_AROUND_RATE = 90.f * DEG_TO_RAD; // radians per second
- const F32 PAN_RATE = 5.f; // meters per second
-
- if( mOrbitUpKey || mOrbitDownKey )
- {
- F32 input_rate = mOrbitUpKey - mOrbitDownKey;
- cameraOrbitOver( input_rate * ORBIT_OVER_RATE / gFPSClamped );
- }
-
- if( mOrbitLeftKey || mOrbitRightKey)
- {
- F32 input_rate = mOrbitLeftKey - mOrbitRightKey;
- cameraOrbitAround( input_rate * ORBIT_AROUND_RATE / gFPSClamped );
- }
-
- if( mOrbitInKey || mOrbitOutKey )
- {
- F32 input_rate = mOrbitInKey - mOrbitOutKey;
-
- LLVector3d to_focus = gAgent.getPosGlobalFromAgent(LLViewerCamera::getInstance()->getOrigin()) - calcFocusPositionTargetGlobal();
- F32 distance_to_focus = (F32)to_focus.magVec();
- // Move at distance (in meters) meters per second
- cameraOrbitIn( input_rate * distance_to_focus / gFPSClamped );
- }
-
- if( mPanInKey || mPanOutKey )
- {
- F32 input_rate = mPanInKey - mPanOutKey;
- cameraPanIn( input_rate * PAN_RATE / gFPSClamped );
- }
-
- if( mPanRightKey || mPanLeftKey )
- {
- F32 input_rate = mPanRightKey - mPanLeftKey;
- cameraPanLeft( input_rate * -PAN_RATE / gFPSClamped );
- }
-
- if( mPanUpKey || mPanDownKey )
- {
- F32 input_rate = mPanUpKey - mPanDownKey;
- cameraPanUp( input_rate * PAN_RATE / gFPSClamped );
- }
-
- // Clear camera keyboard keys.
- mOrbitLeftKey = 0.f;
- mOrbitRightKey = 0.f;
- mOrbitUpKey = 0.f;
- mOrbitDownKey = 0.f;
- mOrbitInKey = 0.f;
- mOrbitOutKey = 0.f;
-
- mPanRightKey = 0.f;
- mPanLeftKey = 0.f;
- mPanUpKey = 0.f;
- mPanDownKey = 0.f;
- mPanInKey = 0.f;
- mPanOutKey = 0.f;
-
- // lerp camera focus offset
- mCameraFocusOffset = lerp(mCameraFocusOffset, mCameraFocusOffsetTarget, LLCriticalDamp::getInterpolant(CAMERA_FOCUS_HALF_LIFE));
-
- //Ventrella
- if ( mCameraMode == CAMERA_MODE_FOLLOW )
- {
- if ( mAvatarObject.notNull() )
- {
- //--------------------------------------------------------------------------------
- // this is where the avatar's position and rotation are given to followCam, and
- // where it is updated. All three of its attributes are updated: (1) position,
- // (2) focus, and (3) upvector. They can then be queried elsewhere in llAgent.
- //--------------------------------------------------------------------------------
- // *TODO: use combined rotation of frameagent and sit object
- LLQuaternion avatarRotationForFollowCam = mAvatarObject->isSitting() ? mAvatarObject->getRenderRotation() : mFrameAgent.getQuaternion();
-
- LLFollowCamParams* current_cam = LLFollowCamMgr::getActiveFollowCamParams();
- if (current_cam)
- {
- mFollowCam.copyParams(*current_cam);
- mFollowCam.setSubjectPositionAndRotation( mAvatarObject->getRenderPosition(), avatarRotationForFollowCam );
- mFollowCam.update();
- LLViewerJoystick::getInstance()->setCameraNeedsUpdate(true);
- }
- else
- {
- changeCameraToThirdPerson(TRUE);
- }
- }
- }
- // end Ventrella
-
- BOOL hit_limit;
- LLVector3d camera_pos_global;
- LLVector3d camera_target_global = calcCameraPositionTargetGlobal(&hit_limit);
- mCameraVirtualPositionAgent = getPosAgentFromGlobal(camera_target_global);
- LLVector3d focus_target_global = calcFocusPositionTargetGlobal();
-
- // perform field of view correction
- mCameraFOVZoomFactor = calcCameraFOVZoomFactor();
- camera_target_global = focus_target_global + (camera_target_global - focus_target_global) * (1.f + mCameraFOVZoomFactor);
-
- mShowAvatar = TRUE; // can see avatar by default
-
- // Adjust position for animation
- if (mCameraAnimating)
- {
- F32 time = mAnimationTimer.getElapsedTimeF32();
-
- // yet another instance of critically damped motion, hooray!
- // F32 fraction_of_animation = 1.f - pow(2.f, -time / CAMERA_ZOOM_HALF_LIFE);
-
- // linear interpolation
- F32 fraction_of_animation = time / mAnimationDuration;
-
- BOOL isfirstPerson = mCameraMode == CAMERA_MODE_MOUSELOOK;
- BOOL wasfirstPerson = mLastCameraMode == CAMERA_MODE_MOUSELOOK;
- F32 fraction_animation_to_skip;
-
- if (mAnimationCameraStartGlobal == camera_target_global)
- {
- fraction_animation_to_skip = 0.f;
- }
- else
- {
- LLVector3d cam_delta = mAnimationCameraStartGlobal - camera_target_global;
- fraction_animation_to_skip = HEAD_BUFFER_SIZE / (F32)cam_delta.magVec();
- }
- F32 animation_start_fraction = (wasfirstPerson) ? fraction_animation_to_skip : 0.f;
- F32 animation_finish_fraction = (isfirstPerson) ? (1.f - fraction_animation_to_skip) : 1.f;
-
- if (fraction_of_animation < animation_finish_fraction)
- {
- if (fraction_of_animation < animation_start_fraction || fraction_of_animation > animation_finish_fraction )
- {
- mShowAvatar = FALSE;
- }
-
- // ...adjust position for animation
- F32 smooth_fraction_of_animation = llsmoothstep(0.0f, 1.0f, fraction_of_animation);
- camera_pos_global = lerp(mAnimationCameraStartGlobal, camera_target_global, smooth_fraction_of_animation);
- mFocusGlobal = lerp(mAnimationFocusStartGlobal, focus_target_global, smooth_fraction_of_animation);
- }
- else
- {
- // ...animation complete
- mCameraAnimating = FALSE;
-
- camera_pos_global = camera_target_global;
- mFocusGlobal = focus_target_global;
-
- endAnimationUpdateUI();
- mShowAvatar = TRUE;
- }
-
- if (getAvatarObject() && mCameraMode != CAMERA_MODE_MOUSELOOK)
- {
- getAvatarObject()->updateAttachmentVisibility(mCameraMode);
- }
- }
- else
- {
- camera_pos_global = camera_target_global;
- mFocusGlobal = focus_target_global;
- mShowAvatar = TRUE;
- }
-
- // smoothing
- if (TRUE)
- {
- LLVector3d agent_pos = getPositionGlobal();
- LLVector3d camera_pos_agent = camera_pos_global - agent_pos;
- // Sitting on what you're manipulating can cause camera jitter with smoothing.
- // This turns off smoothing while editing. -MG
- mCameraSmoothingStop |= (BOOL)LLToolMgr::getInstance()->inBuildMode();
-
- if (cameraThirdPerson() && !mCameraSmoothingStop)
- {
- const F32 SMOOTHING_HALF_LIFE = 0.02f;
-
- F32 smoothing = LLCriticalDamp::getInterpolant(gSavedSettings.getF32("CameraPositionSmoothing") * SMOOTHING_HALF_LIFE, FALSE);
-
- if (!mFocusObject) // we differentiate on avatar mode
- {
- // for avatar-relative focus, we smooth in avatar space -
- // the avatar moves too jerkily w/r/t global space to smooth there.
-
- LLVector3d delta = camera_pos_agent - mCameraSmoothingLastPositionAgent;
- if (delta.magVec() < MAX_CAMERA_SMOOTH_DISTANCE) // only smooth over short distances please
- {
- camera_pos_agent = lerp(mCameraSmoothingLastPositionAgent, camera_pos_agent, smoothing);
- camera_pos_global = camera_pos_agent + agent_pos;
- }
- }
- else
- {
- LLVector3d delta = camera_pos_global - mCameraSmoothingLastPositionGlobal;
- if (delta.magVec() < MAX_CAMERA_SMOOTH_DISTANCE) // only smooth over short distances please
- {
- camera_pos_global = lerp(mCameraSmoothingLastPositionGlobal, camera_pos_global, smoothing);
- }
- }
- }
-
- mCameraSmoothingLastPositionGlobal = camera_pos_global;
- mCameraSmoothingLastPositionAgent = camera_pos_agent;
- mCameraSmoothingStop = FALSE;
- }
-
-
- mCameraCurrentFOVZoomFactor = lerp(mCameraCurrentFOVZoomFactor, mCameraFOVZoomFactor, LLCriticalDamp::getInterpolant(FOV_ZOOM_HALF_LIFE));
-
-// llinfos << "Current FOV Zoom: " << mCameraCurrentFOVZoomFactor << " Target FOV Zoom: " << mCameraFOVZoomFactor << " Object penetration: " << mFocusObjectDist << llendl;
-
- F32 ui_offset = 0.f;
- if( CAMERA_MODE_CUSTOMIZE_AVATAR == mCameraMode )
- {
- ui_offset = calcCustomizeAvatarUIOffset( camera_pos_global );
- }
-
-
- LLVector3 focus_agent = getPosAgentFromGlobal(mFocusGlobal);
-
- mCameraPositionAgent = getPosAgentFromGlobal(camera_pos_global);
-
- // Move the camera
-
- //Ventrella
- LLViewerCamera::getInstance()->updateCameraLocation(mCameraPositionAgent, mCameraUpVector, focus_agent);
- //LLViewerCamera::getInstance()->updateCameraLocation(mCameraPositionAgent, camera_skyward, focus_agent);
- //end Ventrella
-
- //RN: translate UI offset after camera is oriented properly
- LLViewerCamera::getInstance()->translate(LLViewerCamera::getInstance()->getLeftAxis() * ui_offset);
-
- // Change FOV
- LLViewerCamera::getInstance()->setView(LLViewerCamera::getInstance()->getDefaultFOV() / (1.f + mCameraCurrentFOVZoomFactor));
-
- // follow camera when in customize mode
- if (cameraCustomizeAvatar())
- {
- setLookAt(LOOKAT_TARGET_FOCUS, NULL, mCameraPositionAgent);
- }
-
- // update the travel distance stat
- // this isn't directly related to the camera
- // but this seemed like the best place to do this
- LLVector3d global_pos = getPositionGlobal();
- if (! mLastPositionGlobal.isExactlyZero())
- {
- LLVector3d delta = global_pos - mLastPositionGlobal;
- mDistanceTraveled += delta.magVec();
- }
- mLastPositionGlobal = global_pos;
-
- if (LLVOAvatar::sVisibleInFirstPerson && mAvatarObject.notNull() && !mAvatarObject->isSitting() && cameraMouselook())
- {
- LLVector3 head_pos = mAvatarObject->mHeadp->getWorldPosition() +
- LLVector3(0.08f, 0.f, 0.05f) * mAvatarObject->mHeadp->getWorldRotation() +
- LLVector3(0.1f, 0.f, 0.f) * mAvatarObject->mPelvisp->getWorldRotation();
- LLVector3 diff = mCameraPositionAgent - head_pos;
- diff = diff * ~mAvatarObject->mRoot.getWorldRotation();
-
- LLJoint* torso_joint = mAvatarObject->mTorsop;
- LLJoint* chest_joint = mAvatarObject->mChestp;
- LLVector3 torso_scale = torso_joint->getScale();
- LLVector3 chest_scale = chest_joint->getScale();
-
- // shorten avatar skeleton to avoid foot interpenetration
- if (!mAvatarObject->mInAir)
- {
- LLVector3 chest_offset = LLVector3(0.f, 0.f, chest_joint->getPosition().mV[VZ]) * torso_joint->getWorldRotation();
- F32 z_compensate = llclamp(-diff.mV[VZ], -0.2f, 1.f);
- F32 scale_factor = llclamp(1.f - ((z_compensate * 0.5f) / chest_offset.mV[VZ]), 0.5f, 1.2f);
- torso_joint->setScale(LLVector3(1.f, 1.f, scale_factor));
-
- LLJoint* neck_joint = mAvatarObject->mNeckp;
- LLVector3 neck_offset = LLVector3(0.f, 0.f, neck_joint->getPosition().mV[VZ]) * chest_joint->getWorldRotation();
- scale_factor = llclamp(1.f - ((z_compensate * 0.5f) / neck_offset.mV[VZ]), 0.5f, 1.2f);
- chest_joint->setScale(LLVector3(1.f, 1.f, scale_factor));
- diff.mV[VZ] = 0.f;
- }
-
- mAvatarObject->mPelvisp->setPosition(mAvatarObject->mPelvisp->getPosition() + diff);
-
- mAvatarObject->mRoot.updateWorldMatrixChildren();
-
- for (LLVOAvatar::attachment_map_t::iterator iter = mAvatarObject->mAttachmentPoints.begin();
- iter != mAvatarObject->mAttachmentPoints.end(); )
- {
- LLVOAvatar::attachment_map_t::iterator curiter = iter++;
- LLViewerJointAttachment* attachment = curiter->second;
- for (LLViewerJointAttachment::attachedobjs_vec_t::iterator attachment_iter = attachment->mAttachedObjects.begin();
- attachment_iter != attachment->mAttachedObjects.end();
- ++attachment_iter)
- {
- LLViewerObject *attached_object = (*attachment_iter);
- if (attached_object && !attached_object->isDead() && attached_object->mDrawable.notNull())
- {
- // clear any existing "early" movements of attachment
- attached_object->mDrawable->clearState(LLDrawable::EARLY_MOVE);
- gPipeline.updateMoveNormalAsync(attached_object->mDrawable);
- attached_object->updateText();
- }
- }
- }
-
- torso_joint->setScale(torso_scale);
- chest_joint->setScale(chest_scale);
- }
-}
-
-void LLAgent::updateFocusOffset()
-{
- validateFocusObject();
- if (mFocusObject.notNull())
- {
- LLVector3d obj_pos = getPosGlobalFromAgent(mFocusObject->getRenderPosition());
- mFocusObjectOffset.setVec(mFocusTargetGlobal - obj_pos);
- }
-}
-
-void LLAgent::validateFocusObject()
-{
- if (mFocusObject.notNull() &&
- (mFocusObject->isDead()))
- {
- mFocusObjectOffset.clearVec();
- clearFocusObject();
- mCameraFOVZoomFactor = 0.f;
- }
-}
-
-//-----------------------------------------------------------------------------
-// calcCustomizeAvatarUIOffset()
-//-----------------------------------------------------------------------------
-F32 LLAgent::calcCustomizeAvatarUIOffset( const LLVector3d& camera_pos_global )
-{
- F32 ui_offset = 0.f;
+ mAutoPilotTargetDist = target_dist;
- if( gFloaterCustomize )
- {
- const LLRect& rect = gFloaterCustomize->getRect();
+ // Make this a two-dimensional solution
+ at.mV[VZ] = 0.f;
+ direction.mV[VZ] = 0.f;
- // Move the camera so that the avatar isn't covered up by this floater.
- F32 fraction_of_fov = 0.5f - (0.5f * (1.f - llmin(1.f, ((F32)rect.getWidth() / (F32)gViewerWindow->getWindowWidthScaled()))));
- F32 apparent_angle = fraction_of_fov * LLViewerCamera::getInstance()->getView() * LLViewerCamera::getInstance()->getAspect(); // radians
- F32 offset = tan(apparent_angle);
+ at.normalize();
+ F32 xy_distance = direction.normalize();
- if( rect.mLeft < (gViewerWindow->getWindowWidthScaled() - rect.mRight) )
+ F32 yaw = 0.f;
+ if (mAutoPilotTargetDist > mAutoPilotStopDistance)
{
- // Move the avatar to the right (camera to the left)
- ui_offset = offset;
+ yaw = angle_between(mFrameAgent.getAtAxis(), direction);
}
- else
+ else if (mAutoPilotUseRotation)
{
- // Move the avatar to the left (camera to the right)
- ui_offset = -offset;
+ // we're close now just aim at target facing
+ yaw = angle_between(at, mAutoPilotTargetFacing);
+ direction = mAutoPilotTargetFacing;
}
- }
- F32 range = (F32)dist_vec(camera_pos_global, gAgentCamera.getFocusGlobal());
- gAgentCameraHACK.mUIOffset = lerp(mUIOffset, ui_offset, LLCriticalDamp::getInterpolant(0.05f));
- return mUIOffset * range;
-}
-//-----------------------------------------------------------------------------
-// calcFocusPositionTargetGlobal()
-//-----------------------------------------------------------------------------
-LLVector3d LLAgent::calcFocusPositionTargetGlobal()
-{
- if (mFocusObject.notNull() && mFocusObject->isDead())
- {
- clearFocusObject();
- }
+ yaw = 4.f * yaw / gFPSClamped;
- // Ventrella
- if ( mCameraMode == CAMERA_MODE_FOLLOW && mFocusOnAvatar )
- {
- mFocusTargetGlobal = gAgent.getPosGlobalFromAgent(mFollowCam.getSimulatedFocus());
- return mFocusTargetGlobal;
- }// End Ventrella
- else if (mCameraMode == CAMERA_MODE_MOUSELOOK)
- {
- LLVector3d at_axis(1.0, 0.0, 0.0);
- LLQuaternion agent_rot = mFrameAgent.getQuaternion();
- if (mAvatarObject.notNull() && mAvatarObject->getParent())
+ // figure out which direction to turn
+ LLVector3 scratch(at % direction);
+
+ if (scratch.mV[VZ] > 0.f)
{
- LLViewerObject* root_object = (LLViewerObject*)mAvatarObject->getRoot();
- if (!root_object->flagCameraDecoupled())
- {
- agent_rot *= ((LLViewerObject*)(mAvatarObject->getParent()))->getRenderRotation();
- }
+ setControlFlags(AGENT_CONTROL_YAW_POS);
}
- at_axis = at_axis * agent_rot;
- mFocusTargetGlobal = calcCameraPositionTargetGlobal() + at_axis;
- return mFocusTargetGlobal;
- }
- else if (mCameraMode == CAMERA_MODE_CUSTOMIZE_AVATAR)
- {
- return mFocusTargetGlobal;
- }
- else if (!mFocusOnAvatar)
- {
- if (mFocusObject.notNull() && !mFocusObject->isDead() && mFocusObject->mDrawable.notNull())
+ else
{
- LLDrawable* drawablep = mFocusObject->mDrawable;
-
- if (mTrackFocusObject &&
- drawablep &&
- drawablep->isActive())
- {
- if (!mFocusObject->isAvatar())
- {
- if (mFocusObject->isSelected())
- {
- gPipeline.updateMoveNormalAsync(drawablep);
- }
- else
- {
- if (drawablep->isState(LLDrawable::MOVE_UNDAMPED))
- {
- gPipeline.updateMoveNormalAsync(drawablep);
- }
- else
- {
- gPipeline.updateMoveDampedAsync(drawablep);
- }
- }
- }
- }
- // if not tracking object, update offset based on new object position
- else
- {
- updateFocusOffset();
- }
- LLVector3 focus_agent = mFocusObject->getRenderPosition() + mFocusObjectOffset;
- mFocusTargetGlobal.setVec(getPosGlobalFromAgent(focus_agent));
+ yaw = -yaw;
+ setControlFlags(AGENT_CONTROL_YAW_NEG);
}
- return mFocusTargetGlobal;
- }
- else if (mSitCameraEnabled && mAvatarObject.notNull() && mAvatarObject->isSitting() && mSitCameraReferenceObject.notNull())
- {
- // sit camera
- LLVector3 object_pos = mSitCameraReferenceObject->getRenderPosition();
- LLQuaternion object_rot = mSitCameraReferenceObject->getRenderRotation();
- LLVector3 target_pos = object_pos + (mSitCameraFocus * object_rot);
- return getPosGlobalFromAgent(target_pos);
- }
- else
- {
- return getPositionGlobal() + calcThirdPersonFocusOffset();
- }
-}
-
-LLVector3d LLAgent::calcThirdPersonFocusOffset()
-{
- // ...offset from avatar
- LLVector3d focus_offset;
-
- LLQuaternion agent_rot = mFrameAgent.getQuaternion();
- if (!mAvatarObject.isNull() && mAvatarObject->getParent())
- {
- agent_rot *= ((LLViewerObject*)(mAvatarObject->getParent()))->getRenderRotation();
- }
-
- focus_offset = mFocusOffsetInitial[mCameraPreset] * agent_rot;
- return focus_offset;
-}
-
-void LLAgent::setupSitCamera()
-{
- // agent frame entering this function is in world coordinates
- if (mAvatarObject.notNull() && mAvatarObject->getParent())
- {
- LLQuaternion parent_rot = ((LLViewerObject*)mAvatarObject->getParent())->getRenderRotation();
- // slam agent coordinate frame to proper parent local version
- LLVector3 at_axis = mFrameAgent.getAtAxis();
- at_axis.mV[VZ] = 0.f;
- at_axis.normalize();
- resetAxes(at_axis * ~parent_rot);
- }
-}
-
-//-----------------------------------------------------------------------------
-// getCameraPositionAgent()
-//-----------------------------------------------------------------------------
-const LLVector3 &LLAgent::getCameraPositionAgent() const
-{
- return LLViewerCamera::getInstance()->getOrigin();
-}
-
-//-----------------------------------------------------------------------------
-// getCameraPositionGlobal()
-//-----------------------------------------------------------------------------
-LLVector3d LLAgent::getCameraPositionGlobal() const
-{
- return getPosGlobalFromAgent(LLViewerCamera::getInstance()->getOrigin());
-}
-
-//-----------------------------------------------------------------------------
-// calcCameraFOVZoomFactor()
-//-----------------------------------------------------------------------------
-F32 LLAgent::calcCameraFOVZoomFactor()
-{
- LLVector3 camera_offset_dir;
- camera_offset_dir.setVec(mCameraFocusOffset);
-
- if (mCameraMode == CAMERA_MODE_MOUSELOOK)
- {
- return 0.f;
- }
- else if (mFocusObject.notNull() && !mFocusObject->isAvatar() && !mFocusOnAvatar)
- {
- // don't FOV zoom on mostly transparent objects
- LLVector3 focus_offset = mFocusObjectOffset;
- F32 obj_min_dist = 0.f;
- calcCameraMinDistance(obj_min_dist);
- F32 current_distance = llmax(0.001f, camera_offset_dir.magVec());
-
- mFocusObjectDist = obj_min_dist - current_distance;
-
- F32 new_fov_zoom = llclamp(mFocusObjectDist / current_distance, 0.f, 1000.f);
- return new_fov_zoom;
- }
- else // focusing on land or avatar
- {
- // keep old field of view until user changes focus explicitly
- return mCameraFOVZoomFactor;
- //return 0.f;
- }
-}
-
-//-----------------------------------------------------------------------------
-// calcCameraPositionTargetGlobal()
-//-----------------------------------------------------------------------------
-LLVector3d LLAgent::calcCameraPositionTargetGlobal(BOOL *hit_limit)
-{
- // Compute base camera position and look-at points.
- F32 camera_land_height;
- LLVector3d frame_center_global = mAvatarObject.isNull() ? getPositionGlobal()
- : getPosGlobalFromAgent(mAvatarObject->mRoot.getWorldPosition());
-
- BOOL isConstrained = FALSE;
- LLVector3d head_offset;
- head_offset.setVec(mThirdPersonHeadOffset);
-
- LLVector3d camera_position_global;
+ *delta_yaw = yaw;
- // Ventrella
- if ( mCameraMode == CAMERA_MODE_FOLLOW && mFocusOnAvatar )
- {
- camera_position_global = gAgent.getPosGlobalFromAgent(mFollowCam.getSimulatedPosition());
- }// End Ventrella
- else if (mCameraMode == CAMERA_MODE_MOUSELOOK)
- {
- if (mAvatarObject.isNull() || mAvatarObject->mDrawable.isNull())
- {
- llwarns << "Null avatar drawable!" << llendl;
- return LLVector3d::zero;
- }
- head_offset.clearVec();
- if (mAvatarObject->isSitting() && mAvatarObject->getParent())
+ // Compute when to start slowing down and when to stop
+ F32 stop_distance = mAutoPilotStopDistance;
+ F32 slow_distance;
+ if (getFlying())
{
- mAvatarObject->updateHeadOffset();
- head_offset.mdV[VX] = mAvatarObject->mHeadOffset.mV[VX];
- head_offset.mdV[VY] = mAvatarObject->mHeadOffset.mV[VY];
- head_offset.mdV[VZ] = mAvatarObject->mHeadOffset.mV[VZ] + 0.1f;
- const LLMatrix4& mat = ((LLViewerObject*) mAvatarObject->getParent())->getRenderMatrix();
- camera_position_global = getPosGlobalFromAgent
- ((mAvatarObject->getPosition()+
- LLVector3(head_offset)*mAvatarObject->getRotation()) * mat);
+ slow_distance = llmax(6.f, mAutoPilotStopDistance + 5.f);
+ stop_distance = llmax(2.f, mAutoPilotStopDistance);
}
else
{
- head_offset.mdV[VZ] = mAvatarObject->mHeadOffset.mV[VZ];
- if (mAvatarObject->isSitting())
- {
- head_offset.mdV[VZ] += 0.1;
- }
- camera_position_global = getPosGlobalFromAgent(mAvatarObject->getRenderPosition());//frame_center_global;
- head_offset = head_offset * mAvatarObject->getRenderRotation();
- camera_position_global = camera_position_global + head_offset;
+ slow_distance = llmax(3.f, mAutoPilotStopDistance + 2.f);
}
- }
- else if (mCameraMode == CAMERA_MODE_THIRD_PERSON && mFocusOnAvatar)
- {
- LLVector3 local_camera_offset;
- F32 camera_distance = 0.f;
- if (mSitCameraEnabled
- && mAvatarObject.notNull()
- && mAvatarObject->isSitting()
- && mSitCameraReferenceObject.notNull())
- {
- // sit camera
- LLVector3 object_pos = mSitCameraReferenceObject->getRenderPosition();
- LLQuaternion object_rot = mSitCameraReferenceObject->getRenderRotation();
-
- LLVector3 target_pos = object_pos + (mSitCameraPos * object_rot);
-
- camera_position_global = getPosGlobalFromAgent(target_pos);
- }
- else
+ // If we're flying, handle autopilot points above or below you.
+ if (getFlying() && xy_distance < AUTOPILOT_HEIGHT_ADJUST_DISTANCE)
{
- local_camera_offset = mCameraZoomFraction * getCameraOffsetInitial() * gSavedSettings.getF32("CameraOffsetScale");
-
- // are we sitting down?
- if (mAvatarObject.notNull() && mAvatarObject->getParent())
- {
- LLQuaternion parent_rot = ((LLViewerObject*)mAvatarObject->getParent())->getRenderRotation();
- // slam agent coordinate frame to proper parent local version
- LLVector3 at_axis = mFrameAgent.getAtAxis() * parent_rot;
- at_axis.mV[VZ] = 0.f;
- at_axis.normalize();
- resetAxes(at_axis * ~parent_rot);
-
- local_camera_offset = local_camera_offset * mFrameAgent.getQuaternion() * parent_rot;
- }
- else
- {
- local_camera_offset = mFrameAgent.rotateToAbsolute( local_camera_offset );
- }
-
- if (!mCameraCollidePlane.isExactlyZero() && (mAvatarObject.isNull() || !mAvatarObject->isSitting()))
+ if (mAvatarObject.notNull())
{
- LLVector3 plane_normal;
- plane_normal.setVec(mCameraCollidePlane.mV);
-
- F32 offset_dot_norm = local_camera_offset * plane_normal;
- if (llabs(offset_dot_norm) < 0.001f)
- {
- offset_dot_norm = 0.001f;
- }
-
- camera_distance = local_camera_offset.normalize();
-
- F32 pos_dot_norm = getPosAgentFromGlobal(frame_center_global + head_offset) * plane_normal;
-
- // if agent is outside the colliding half-plane
- if (pos_dot_norm > mCameraCollidePlane.mV[VW])
+ F64 current_height = mAvatarObject->getPositionGlobal().mdV[VZ];
+ F32 delta_z = (F32)(mAutoPilotTargetGlobal.mdV[VZ] - current_height);
+ F32 slope = delta_z / xy_distance;
+ if (slope > 0.45f && delta_z > 6.f)
{
- // check to see if camera is on the opposite side (inside) the half-plane
- if (offset_dot_norm + pos_dot_norm < mCameraCollidePlane.mV[VW])
- {
- // diminish offset by factor to push it back outside the half-plane
- camera_distance *= (pos_dot_norm - mCameraCollidePlane.mV[VW] - CAMERA_COLLIDE_EPSILON) / -offset_dot_norm;
- }
+ setControlFlags(AGENT_CONTROL_FAST_UP | AGENT_CONTROL_UP_POS);
}
- else
+ else if (slope > 0.002f && delta_z > 0.5f)
{
- if (offset_dot_norm + pos_dot_norm > mCameraCollidePlane.mV[VW])
- {
- camera_distance *= (mCameraCollidePlane.mV[VW] - pos_dot_norm - CAMERA_COLLIDE_EPSILON) / offset_dot_norm;
- }
+ setControlFlags(AGENT_CONTROL_UP_POS);
}
- }
- else
- {
- camera_distance = local_camera_offset.normalize();
- }
-
- mTargetCameraDistance = llmax(camera_distance, MIN_CAMERA_DISTANCE);
-
- if (mTargetCameraDistance != mCurrentCameraDistance)
- {
- F32 camera_lerp_amt = LLCriticalDamp::getInterpolant(CAMERA_ZOOM_HALF_LIFE);
-
- mCurrentCameraDistance = lerp(mCurrentCameraDistance, mTargetCameraDistance, camera_lerp_amt);
- }
-
- // Make the camera distance current
- local_camera_offset *= mCurrentCameraDistance;
-
- // set the global camera position
- LLVector3d camera_offset;
-
- LLVector3 av_pos = mAvatarObject.isNull() ? LLVector3::zero : mAvatarObject->getRenderPosition();
- camera_offset.setVec( local_camera_offset );
- camera_position_global = frame_center_global + head_offset + camera_offset;
-
- if (mAvatarObject.notNull())
- {
- LLVector3d camera_lag_d;
- F32 lag_interp = LLCriticalDamp::getInterpolant(CAMERA_LAG_HALF_LIFE);
- LLVector3 target_lag;
- LLVector3 vel = getVelocity();
-
- // lag by appropriate amount for flying
- F32 time_in_air = mAvatarObject->mTimeInAir.getElapsedTimeF32();
- if(!mCameraAnimating && mAvatarObject->mInAir && time_in_air > GROUND_TO_AIR_CAMERA_TRANSITION_START_TIME)
+ else if (slope < -0.45f && delta_z < -6.f && current_height > AUTOPILOT_MIN_TARGET_HEIGHT_OFF_GROUND)
{
- LLVector3 frame_at_axis = mFrameAgent.getAtAxis();
- frame_at_axis -= projected_vec(frame_at_axis, getReferenceUpVector());
- frame_at_axis.normalize();
-
- //transition smoothly in air mode, to avoid camera pop
- F32 u = (time_in_air - GROUND_TO_AIR_CAMERA_TRANSITION_START_TIME) / GROUND_TO_AIR_CAMERA_TRANSITION_TIME;
- u = llclamp(u, 0.f, 1.f);
-
- lag_interp *= u;
-
- if (gViewerWindow->getLeftMouseDown() && gViewerWindow->getLastPick().mObjectID == mAvatarObject->getID())
- {
- // disable camera lag when using mouse-directed steering
- target_lag.clearVec();
- }
- else
- {
- target_lag = vel * gSavedSettings.getF32("DynamicCameraStrength") / 30.f;
- }
-
- mCameraLag = lerp(mCameraLag, target_lag, lag_interp);
-
- F32 lag_dist = mCameraLag.magVec();
- if (lag_dist > MAX_CAMERA_LAG)
- {
- mCameraLag = mCameraLag * MAX_CAMERA_LAG / lag_dist;
- }
-
- // clamp camera lag so that avatar is always in front
- F32 dot = (mCameraLag - (frame_at_axis * (MIN_CAMERA_LAG * u))) * frame_at_axis;
- if (dot < -(MIN_CAMERA_LAG * u))
- {
- mCameraLag -= (dot + (MIN_CAMERA_LAG * u)) * frame_at_axis;
- }
+ setControlFlags(AGENT_CONTROL_FAST_UP | AGENT_CONTROL_UP_NEG);
}
- else
+ else if (slope < -0.002f && delta_z < -0.5f && current_height > AUTOPILOT_MIN_TARGET_HEIGHT_OFF_GROUND)
{
- mCameraLag = lerp(mCameraLag, LLVector3::zero, LLCriticalDamp::getInterpolant(0.15f));
+ setControlFlags(AGENT_CONTROL_UP_NEG);
}
-
- camera_lag_d.setVec(mCameraLag);
- camera_position_global = camera_position_global - camera_lag_d;
}
}
- }
- else
- {
- LLVector3d focusPosGlobal = calcFocusPositionTargetGlobal();
- // camera gets pushed out later wrt mCameraFOVZoomFactor...this is "raw" value
- camera_position_global = focusPosGlobal + mCameraFocusOffset;
- }
-
- if (!gSavedSettings.getBOOL("DisableCameraConstraints") && !gAgent.isGodlike())
- {
- LLViewerRegion* regionp = LLWorld::getInstance()->getRegionFromPosGlobal(
- camera_position_global);
- bool constrain = true;
- if(regionp && regionp->canManageEstate())
- {
- constrain = false;
- }
- if(constrain)
- {
- F32 max_dist = ( CAMERA_MODE_CUSTOMIZE_AVATAR == mCameraMode ) ?
- APPEARANCE_MAX_ZOOM : mDrawDistance;
- LLVector3d camera_offset = camera_position_global
- - gAgent.getPositionGlobal();
- F32 camera_distance = (F32)camera_offset.magVec();
+ // calculate delta rotation to target heading
+ F32 delta_target_heading = angle_between(mFrameAgent.getAtAxis(), mAutoPilotTargetFacing);
- if(camera_distance > max_dist)
- {
- camera_position_global = gAgent.getPositionGlobal() +
- (max_dist / camera_distance) * camera_offset;
- isConstrained = TRUE;
- }
+ if (xy_distance > slow_distance && yaw < (F_PI / 10.f))
+ {
+ // walking/flying fast
+ setControlFlags(AGENT_CONTROL_FAST_AT | AGENT_CONTROL_AT_POS);
}
-
-// JC - Could constrain camera based on parcel stuff here.
-// LLViewerRegion *regionp = LLWorld::getInstance()->getRegionFromPosGlobal(camera_position_global);
-//
-// if (regionp && !regionp->mParcelOverlay->isBuildCameraAllowed(regionp->getPosRegionFromGlobal(camera_position_global)))
-// {
-// camera_position_global = last_position_global;
-//
-// isConstrained = TRUE;
-// }
- }
-
- // Don't let camera go underground
- F32 camera_min_off_ground = getCameraMinOffGround();
-
- camera_land_height = LLWorld::getInstance()->resolveLandHeightGlobal(camera_position_global);
-
- if (camera_position_global.mdV[VZ] < camera_land_height + camera_min_off_ground)
- {
- camera_position_global.mdV[VZ] = camera_land_height + camera_min_off_ground;
- isConstrained = TRUE;
- }
-
-
- if (hit_limit)
- {
- *hit_limit = isConstrained;
- }
-
- return camera_position_global;
-}
-
-
-LLVector3 LLAgent::getCameraOffsetInitial()
-{
- return mCameraOffsetInitial[mCameraPreset];
-}
-
-//-----------------------------------------------------------------------------
-// handleScrollWheel()
-//-----------------------------------------------------------------------------
-void LLAgent::handleScrollWheel(S32 clicks)
-{
- if ( mCameraMode == CAMERA_MODE_FOLLOW && gAgentCamera.getFocusOnAvatar())
- {
- if ( ! mFollowCam.getPositionLocked() ) // not if the followCam position is locked in place
+ else if (mAutoPilotTargetDist > mAutoPilotStopDistance)
{
- mFollowCam.zoom( clicks );
- if ( mFollowCam.isZoomedToMinimumDistance() )
+ // walking/flying slow
+ if (at * direction > 0.9f)
{
- changeCameraToMouselook(FALSE);
+ setControlFlags(AGENT_CONTROL_AT_POS);
+ }
+ else if (at * direction < -0.9f)
+ {
+ setControlFlags(AGENT_CONTROL_AT_NEG);
}
}
- }
- else
- {
- LLObjectSelectionHandle selection = LLSelectMgr::getInstance()->getSelection();
- const F32 ROOT_ROOT_TWO = sqrt(F_SQRT2);
-
- // Block if camera is animating
- if (mCameraAnimating)
- {
- return;
- }
-
- if (selection->getObjectCount() && selection->getSelectType() == SELECT_TYPE_HUD)
- {
- F32 zoom_factor = (F32)pow(0.8, -clicks);
- cameraZoomIn(zoom_factor);
- }
- else if (mFocusOnAvatar && mCameraMode == CAMERA_MODE_THIRD_PERSON)
- {
- F32 camera_offset_initial_mag = getCameraOffsetInitial().magVec();
-
- F32 current_zoom_fraction = mTargetCameraDistance / (camera_offset_initial_mag * gSavedSettings.getF32("CameraOffsetScale"));
- current_zoom_fraction *= 1.f - pow(ROOT_ROOT_TWO, clicks);
-
- cameraOrbitIn(current_zoom_fraction * camera_offset_initial_mag * gSavedSettings.getF32("CameraOffsetScale"));
- }
- else
+
+ // check to see if we need to keep rotating to target orientation
+ if (mAutoPilotTargetDist < mAutoPilotStopDistance)
{
- F32 current_zoom_fraction = (F32)mCameraFocusOffsetTarget.magVec();
- cameraOrbitIn(current_zoom_fraction * (1.f - pow(ROOT_ROOT_TWO, clicks)));
+ setControlFlags(AGENT_CONTROL_STOP);
+ if(!mAutoPilotUseRotation || (delta_target_heading < mAutoPilotRotationThreshold))
+ {
+ stopAutoPilot();
+ }
}
}
}
+
//-----------------------------------------------------------------------------
-// getCameraMinOffGround()
+// propagate()
//-----------------------------------------------------------------------------
-F32 LLAgent::getCameraMinOffGround()
+void LLAgent::propagate(const F32 dt)
{
- if (mCameraMode == CAMERA_MODE_MOUSELOOK)
+ // Update UI based on agent motion
+ LLFloaterMove *floater_move = LLFloaterReg::findTypedInstance<LLFloaterMove>("moveview");
+ if (floater_move)
{
- return 0.f;
+ floater_move->mForwardButton ->setToggleState( mAtKey > 0 || mWalkKey > 0 );
+ floater_move->mBackwardButton ->setToggleState( mAtKey < 0 || mWalkKey < 0 );
+ floater_move->mTurnLeftButton ->setToggleState( mYawKey > 0.f );
+ floater_move->mTurnRightButton ->setToggleState( mYawKey < 0.f );
+ floater_move->mMoveUpButton ->setToggleState( mUpKey > 0 );
+ floater_move->mMoveDownButton ->setToggleState( mUpKey < 0 );
}
- else
+
+ // handle rotation based on keyboard levels
+ const F32 YAW_RATE = 90.f * DEG_TO_RAD; // radians per second
+ yaw(YAW_RATE * mYawKey * dt);
+
+ const F32 PITCH_RATE = 90.f * DEG_TO_RAD; // radians per second
+ pitch(PITCH_RATE * mPitchKey * dt);
+
+ // handle auto-land behavior
+ if (mAvatarObject.notNull())
{
- if (gSavedSettings.getBOOL("DisableCameraConstraints"))
- {
- return -1000.f;
- }
- else
+ BOOL in_air = mAvatarObject->mInAir;
+ LLVector3 land_vel = getVelocity();
+ land_vel.mV[VZ] = 0.f;
+
+ if (!in_air
+ && mUpKey < 0
+ && land_vel.magVecSquared() < MAX_VELOCITY_AUTO_LAND_SQUARED
+ && gSavedSettings.getBOOL("AutomaticFly"))
{
- return 0.5f;
+ // land automatically
+ setFlying(FALSE);
}
}
-}
-
-
-//-----------------------------------------------------------------------------
-// resetCamera()
-//-----------------------------------------------------------------------------
-void LLAgent::resetCamera()
-{
- // Remove any pitch from the avatar
- LLVector3 at = mFrameAgent.getAtAxis();
- at.mV[VZ] = 0.f;
- at.normalize();
- gAgent.resetAxes(at);
- // have to explicitly clear field of view zoom now
- mCameraFOVZoomFactor = 0.f;
- updateCamera();
+ // clear keys
+ mAtKey = 0;
+ mWalkKey = 0;
+ mLeftKey = 0;
+ mUpKey = 0;
+ mYawKey = 0.f;
+ mPitchKey = 0.f;
}
//-----------------------------------------------------------------------------
-// changeCameraToMouselook()
+// updateAgentPosition()
//-----------------------------------------------------------------------------
-void LLAgent::changeCameraToMouselook(BOOL animate)
+void LLAgent::updateAgentPosition(const F32 dt, const F32 yaw_radians, const S32 mouse_x, const S32 mouse_y)
{
- if (LLViewerJoystick::getInstance()->getOverrideCamera())
- {
- return;
- }
-
- // visibility changes at end of animation
- gViewerWindow->getWindow()->resetBusyCount();
-
- // unpause avatar animation
- mPauseRequest = NULL;
+ propagate(dt);
- LLToolMgr::getInstance()->setCurrentToolset(gMouselookToolset);
+ // static S32 cameraUpdateCount = 0;
- if (mAvatarObject.notNull())
- {
- mAvatarObject->stopMotion( ANIM_AGENT_BODY_NOISE );
- mAvatarObject->stopMotion( ANIM_AGENT_BREATHE_ROT );
- }
+ rotate(yaw_radians, 0, 0, 1);
+
+ //
+ // Check for water and land collision, set underwater flag
+ //
- //gViewerWindow->stopGrab();
- LLSelectMgr::getInstance()->deselectAll();
- gViewerWindow->hideCursor();
- gViewerWindow->moveCursorToCenter();
+ gAgentCamera.updateLookAt(mouse_x, mouse_y);
+}
- if( mCameraMode != CAMERA_MODE_MOUSELOOK )
- {
- gFocusMgr.setKeyboardFocus( NULL );
-
- mLastCameraMode = mCameraMode;
- mCameraMode = CAMERA_MODE_MOUSELOOK;
- U32 old_flags = mControlFlags;
- setControlFlags(AGENT_CONTROL_MOUSELOOK);
- if (old_flags != mControlFlags)
- {
- mbFlagsDirty = TRUE;
- }
+// friends and operators
- if (animate)
- {
- startCameraAnimation();
- }
- else
- {
- mCameraAnimating = FALSE;
- endAnimationUpdateUI();
- }
- }
+std::ostream& operator<<(std::ostream &s, const LLAgent &agent)
+{
+ // This is unfinished, but might never be used.
+ // We'll just leave it for now; we can always delete it.
+ s << " { "
+ << " Frame = " << agent.mFrameAgent << "\n"
+ << " }";
+ return s;
}
+// ------------------- Beginning of legacy LLCamera hack ----------------------
+// This section is included for legacy LLCamera support until
+// it is no longer needed. Some legacy code must exist in
+// non-legacy functions, and is labeled with "// legacy" comments.
+
//-----------------------------------------------------------------------------
-// changeCameraToDefault()
+// setAvatarObject()
//-----------------------------------------------------------------------------
-void LLAgent::changeCameraToDefault()
-{
- if (LLViewerJoystick::getInstance()->getOverrideCamera())
+void LLAgent::setAvatarObject(LLVOAvatarSelf *avatar)
+{
+ mAvatarObject = avatar;
+
+ if (!avatar)
{
+ llinfos << "Setting LLAgent::mAvatarObject to NULL" << llendl;
return;
}
- if (LLFollowCamMgr::getActiveFollowCamParams())
+ if (!gAgentCamera.mLookAt)
{
- changeCameraToFollow();
+ gAgentCamera.mLookAt = (LLHUDEffectLookAt *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_LOOKAT);
}
- else
+ if (!gAgentCamera.mPointAt)
{
- changeCameraToThirdPerson();
+ gAgentCamera.mPointAt = (LLHUDEffectPointAt *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_POINTAT);
+ }
+
+ if (!gAgentCamera.mLookAt.isNull())
+ {
+ gAgentCamera.mLookAt->setSourceObject(avatar);
+ }
+ if (!gAgentCamera.mPointAt.isNull())
+ {
+ gAgentCamera.mPointAt->setSourceObject(avatar);
}
}
-
-// Ventrella
+// TRUE if your own avatar needs to be rendered. Usually only
+// in third person and build.
//-----------------------------------------------------------------------------
-// changeCameraToFollow()
+// needsRenderAvatar()
//-----------------------------------------------------------------------------
-void LLAgent::changeCameraToFollow(BOOL animate)
+BOOL LLAgent::needsRenderAvatar()
{
- if (LLViewerJoystick::getInstance()->getOverrideCamera())
+ if (gAgentCamera.cameraMouselook() && !LLVOAvatar::sVisibleInFirstPerson)
{
- return;
+ return FALSE;
}
- if( mCameraMode != CAMERA_MODE_FOLLOW )
- {
- if (mCameraMode == CAMERA_MODE_MOUSELOOK)
- {
- animate = FALSE;
- }
- startCameraAnimation();
-
- mLastCameraMode = mCameraMode;
- mCameraMode = CAMERA_MODE_FOLLOW;
-
- // bang-in the current focus, position, and up vector of the follow cam
- mFollowCam.reset( mCameraPositionAgent, LLViewerCamera::getInstance()->getPointOfInterest(), LLVector3::z_axis );
-
- if (gBasicToolset)
- {
- LLToolMgr::getInstance()->setCurrentToolset(gBasicToolset);
- }
-
- if (mAvatarObject.notNull())
- {
- mAvatarObject->mPelvisp->setPosition(LLVector3::zero);
- mAvatarObject->startMotion( ANIM_AGENT_BODY_NOISE );
- mAvatarObject->startMotion( ANIM_AGENT_BREATHE_ROT );
- }
-
- // unpause avatar animation
- mPauseRequest = NULL;
-
- U32 old_flags = mControlFlags;
- clearControlFlags(AGENT_CONTROL_MOUSELOOK);
- if (old_flags != mControlFlags)
- {
- mbFlagsDirty = TRUE;
- }
+ return mShowAvatar && mGenderChosen;
+}
- if (animate)
- {
- startCameraAnimation();
- }
- else
- {
- mCameraAnimating = FALSE;
- endAnimationUpdateUI();
- }
- }
+// TRUE if we need to render your own avatar's head.
+BOOL LLAgent::needsRenderHead()
+{
+ return (LLVOAvatar::sVisibleInFirstPerson && LLPipeline::sReflectionRender) || (mShowAvatar && !gAgentCamera.cameraMouselook());
}
//-----------------------------------------------------------------------------
-// changeCameraToThirdPerson()
+// startTyping()
//-----------------------------------------------------------------------------
-void LLAgent::changeCameraToThirdPerson(BOOL animate)
+void LLAgent::startTyping()
{
- if (LLViewerJoystick::getInstance()->getOverrideCamera())
- {
- return;
- }
-
- gViewerWindow->getWindow()->resetBusyCount();
-
- mCameraZoomFraction = INITIAL_ZOOM_FRACTION;
+ mTypingTimer.reset();
- if (mAvatarObject.notNull())
+ if (getRenderState() & AGENT_STATE_TYPING)
{
- if (!mAvatarObject->isSitting())
- {
- mAvatarObject->mPelvisp->setPosition(LLVector3::zero);
- }
- mAvatarObject->startMotion( ANIM_AGENT_BODY_NOISE );
- mAvatarObject->startMotion( ANIM_AGENT_BREATHE_ROT );
+ // already typing, don't trigger a different animation
+ return;
}
+ setRenderState(AGENT_STATE_TYPING);
- LLVector3 at_axis;
-
- // unpause avatar animation
- mPauseRequest = NULL;
-
- if( mCameraMode != CAMERA_MODE_THIRD_PERSON )
+ if (mChatTimer.getElapsedTimeF32() < 2.f)
{
- if (gBasicToolset)
- {
- LLToolMgr::getInstance()->setCurrentToolset(gBasicToolset);
- }
-
- mCameraLag.clearVec();
- if (mCameraMode == CAMERA_MODE_MOUSELOOK)
- {
- mCurrentCameraDistance = MIN_CAMERA_DISTANCE;
- mTargetCameraDistance = MIN_CAMERA_DISTANCE;
- animate = FALSE;
- }
- mLastCameraMode = mCameraMode;
- mCameraMode = CAMERA_MODE_THIRD_PERSON;
- U32 old_flags = mControlFlags;
- clearControlFlags(AGENT_CONTROL_MOUSELOOK);
- if (old_flags != mControlFlags)
+ LLViewerObject* chatter = gObjectList.findObject(mLastChatterID);
+ if (chatter && chatter->isAvatar())
{
- mbFlagsDirty = TRUE;
+ gAgentCamera.setLookAt(LOOKAT_TARGET_RESPOND, chatter, LLVector3::zero);
}
-
}
- // Remove any pitch from the avatar
- if (mAvatarObject.notNull() && mAvatarObject->getParent())
- {
- LLQuaternion obj_rot = ((LLViewerObject*)mAvatarObject->getParent())->getRenderRotation();
- at_axis = LLViewerCamera::getInstance()->getAtAxis();
- at_axis.mV[VZ] = 0.f;
- at_axis.normalize();
- resetAxes(at_axis * ~obj_rot);
- }
- else
+ if (gSavedSettings.getBOOL("PlayTypingAnim"))
{
- at_axis = mFrameAgent.getAtAxis();
- at_axis.mV[VZ] = 0.f;
- at_axis.normalize();
- resetAxes(at_axis);
+ sendAnimationRequest(ANIM_AGENT_TYPE, ANIM_REQUEST_START);
}
+ LLNearbyChatBar::getInstance()->sendChatFromViewer("", CHAT_TYPE_START, FALSE);
+}
-
- if (animate)
- {
- startCameraAnimation();
- }
- else
+//-----------------------------------------------------------------------------
+// stopTyping()
+//-----------------------------------------------------------------------------
+void LLAgent::stopTyping()
+{
+ if (mRenderState & AGENT_STATE_TYPING)
{
- mCameraAnimating = FALSE;
- endAnimationUpdateUI();
+ clearRenderState(AGENT_STATE_TYPING);
+ sendAnimationRequest(ANIM_AGENT_TYPE, ANIM_REQUEST_STOP);
+ LLNearbyChatBar::getInstance()->sendChatFromViewer("", CHAT_TYPE_STOP, FALSE);
}
}
//-----------------------------------------------------------------------------
-// changeCameraToCustomizeAvatar()
+// setRenderState()
//-----------------------------------------------------------------------------
-void LLAgent::changeCameraToCustomizeAvatar(BOOL avatar_animate, BOOL camera_animate)
+void LLAgent::setRenderState(U8 newstate)
{
- if (LLViewerJoystick::getInstance()->getOverrideCamera())
- {
- return;
- }
+ mRenderState |= newstate;
+}
- standUp(); // force stand up
- gViewerWindow->getWindow()->resetBusyCount();
+//-----------------------------------------------------------------------------
+// clearRenderState()
+//-----------------------------------------------------------------------------
+void LLAgent::clearRenderState(U8 clearstate)
+{
+ mRenderState &= ~clearstate;
+}
- if (gFaceEditToolset)
- {
- LLToolMgr::getInstance()->setCurrentToolset(gFaceEditToolset);
- }
- if (camera_animate)
+//-----------------------------------------------------------------------------
+// getRenderState()
+//-----------------------------------------------------------------------------
+U8 LLAgent::getRenderState()
+{
+ if (gNoRender || gKeyboard == NULL)
{
- startCameraAnimation();
+ return 0;
}
- // Remove any pitch from the avatar
- //LLVector3 at = mFrameAgent.getAtAxis();
- //at.mV[VZ] = 0.f;
- //at.normalize();
- //gAgent.resetAxes(at);
-
- if( mCameraMode != CAMERA_MODE_CUSTOMIZE_AVATAR )
+ // *FIX: don't do stuff in a getter! This is infinite loop city!
+ if ((mTypingTimer.getElapsedTimeF32() > TYPING_TIMEOUT_SECS)
+ && (mRenderState & AGENT_STATE_TYPING))
{
- mLastCameraMode = mCameraMode;
- mCameraMode = CAMERA_MODE_CUSTOMIZE_AVATAR;
- U32 old_flags = mControlFlags;
- clearControlFlags(AGENT_CONTROL_MOUSELOOK);
- if (old_flags != mControlFlags)
- {
- mbFlagsDirty = TRUE;
- }
-
- gFocusMgr.setKeyboardFocus( NULL );
- gFocusMgr.setMouseCapture( NULL );
-
- LLVOAvatarSelf::onCustomizeStart();
+ stopTyping();
}
-
- if (mAvatarObject.notNull())
+
+ if ((!LLSelectMgr::getInstance()->getSelection()->isEmpty() && LLSelectMgr::getInstance()->shouldShowSelection())
+ || LLToolMgr::getInstance()->getCurrentTool()->isEditing() )
{
- if(avatar_animate)
- {
- // Remove any pitch from the avatar
- LLVector3 at = mFrameAgent.getAtAxis();
- at.mV[VZ] = 0.f;
- at.normalize();
- gAgent.resetAxes(at);
-
- sendAnimationRequest(ANIM_AGENT_CUSTOMIZE, ANIM_REQUEST_START);
- mCustomAnim = TRUE ;
- mAvatarObject->startMotion(ANIM_AGENT_CUSTOMIZE);
- LLMotion* turn_motion = mAvatarObject->findMotion(ANIM_AGENT_CUSTOMIZE);
-
- if (turn_motion)
- {
- mAnimationDuration = turn_motion->getDuration() + CUSTOMIZE_AVATAR_CAMERA_ANIM_SLOP;
-
- }
- else
- {
- mAnimationDuration = gSavedSettings.getF32("ZoomTime");
- }
- }
-
-
-
- gAgentCamera.setFocusGlobal(LLVector3d::zero);
+ setRenderState(AGENT_STATE_EDITING);
}
else
{
- mCameraAnimating = FALSE;
- endAnimationUpdateUI();
- }
-
-}
-
-
-void LLAgent::switchCameraPreset(ECameraPreset preset)
-{
- //zoom is supposed to be reset for the front and group views
- mCameraZoomFraction = 1.f;
-
- //focusing on avatar in that case means following him on movements
- mFocusOnAvatar = TRUE;
-
- mCameraPreset = preset;
+ clearRenderState(AGENT_STATE_EDITING);
+ }
- gSavedSettings.setU32("CameraPreset", mCameraPreset);
+ return mRenderState;
}
-
-//
-// Focus point management
-//
-
//-----------------------------------------------------------------------------
-// startCameraAnimation()
//-----------------------------------------------------------------------------
-void LLAgent::startCameraAnimation()
-{
- mAnimationCameraStartGlobal = getCameraPositionGlobal();
- mAnimationFocusStartGlobal = mFocusGlobal;
- mAnimationTimer.reset();
- mCameraAnimating = TRUE;
- mAnimationDuration = gSavedSettings.getF32("ZoomTime");
-}
//-----------------------------------------------------------------------------
-// stopCameraAnimation()
+// endAnimationUpdateUI()
//-----------------------------------------------------------------------------
-void LLAgent::stopCameraAnimation()
-{
- mCameraAnimating = FALSE;
-}
-
-void LLAgent::clearFocusObject()
+void LLAgent::endAnimationUpdateUI()
{
- if (mFocusObject.notNull())
+ if (gAgentCamera.mCameraMode == gAgentCamera.mLastCameraMode)
{
- startCameraAnimation();
-
- setFocusObject(NULL);
- mFocusObjectOffset.clearVec();
+ // We're already done endAnimationUpdateUI for this transition.
+ return;
}
-}
-void LLAgent::setFocusObject(LLViewerObject* object)
-{
- mFocusObject = object;
-}
+ // clean up UI from mode we're leaving
+ if (gAgentCamera.mLastCameraMode == CAMERA_MODE_MOUSELOOK )
+ {
+ // show mouse cursor
+ gViewerWindow->showCursor();
+ // show menus
+ gMenuBarView->setVisible(TRUE);
+ LLNavigationBar::getInstance()->setVisible(TRUE);
+ gStatusBar->setVisibleForMouselook(true);
-// Focus on a point, but try to keep camera position stable.
-//-----------------------------------------------------------------------------
-// setFocusGlobal()
-//-----------------------------------------------------------------------------
-void LLAgent::setFocusGlobal(const LLPickInfo& pick)
-{
- LLViewerObject* objectp = gObjectList.findObject(pick.mObjectID);
+ LLBottomTray::getInstance()->onMouselookModeOut();
- if (objectp)
- {
- // focus on object plus designated offset
- // which may or may not be same as pick.mPosGlobal
- setFocusGlobal(objectp->getPositionGlobal() + LLVector3d(pick.mObjectOffset), pick.mObjectID);
- }
- else
- {
- // focus directly on point where user clicked
- setFocusGlobal(pick.mPosGlobal, pick.mObjectID);
- }
-}
+ LLSideTray::getInstance()->getButtonsPanel()->setVisible(TRUE);
+ LLSideTray::getInstance()->updateSidetrayVisibility();
+ LLPanelStandStopFlying::getInstance()->setVisible(TRUE);
-void LLAgent::setFocusGlobal(const LLVector3d& focus, const LLUUID &object_id)
-{
- setFocusObject(gObjectList.findObject(object_id));
- LLVector3d old_focus = mFocusTargetGlobal;
- LLViewerObject *focus_obj = mFocusObject;
+ LLToolMgr::getInstance()->setCurrentToolset(gBasicToolset);
- // if focus has changed
- if (old_focus != focus)
- {
- if (focus.isExactlyZero())
+ LLFloaterCamera::onLeavingMouseLook();
+
+ // Only pop if we have pushed...
+ if (TRUE == mViewsPushed)
{
- if (mAvatarObject.notNull())
- {
- mFocusTargetGlobal = getPosGlobalFromAgent(mAvatarObject->mHeadp->getWorldPosition());
- }
- else
+#if 0 // Use this once all floaters are registered
+ LLFloaterReg::restoreVisibleInstances();
+#else // Use this for now
+ LLFloaterView::skip_list_t skip_list;
+ if (LLFloaterReg::findInstance("mini_map"))
{
- mFocusTargetGlobal = getPositionGlobal();
+ skip_list.insert(LLFloaterReg::findInstance("mini_map"));
}
- mCameraFocusOffsetTarget = getCameraPositionGlobal() - mFocusTargetGlobal;
- mCameraFocusOffset = mCameraFocusOffsetTarget;
- setLookAt(LOOKAT_TARGET_CLEAR);
+
+ gFloaterView->popVisibleAll(skip_list);
+#endif
+ mViewsPushed = FALSE;
}
- else
- {
- mFocusTargetGlobal = focus;
- if (!focus_obj)
- {
- mCameraFOVZoomFactor = 0.f;
- }
- mCameraFocusOffsetTarget = gAgent.getPosGlobalFromAgent(mCameraVirtualPositionAgent) - mFocusTargetGlobal;
-
- startCameraAnimation();
+
+ gAgentCamera.setLookAt(LOOKAT_TARGET_CLEAR);
+ if( gMorphView )
+ {
+ gMorphView->setVisible( FALSE );
+ }
- if (focus_obj)
+ // Disable mouselook-specific animations
+ if (mAvatarObject.notNull())
+ {
+ if( mAvatarObject->isAnyAnimationSignaled(AGENT_GUN_AIM_ANIMS, NUM_AGENT_GUN_AIM_ANIMS) )
{
- if (focus_obj->isAvatar())
+ if (mAvatarObject->mSignaledAnimations.find(ANIM_AGENT_AIM_RIFLE_R) != mAvatarObject->mSignaledAnimations.end())
{
- setLookAt(LOOKAT_TARGET_FOCUS, focus_obj);
+ sendAnimationRequest(ANIM_AGENT_AIM_RIFLE_R, ANIM_REQUEST_STOP);
+ sendAnimationRequest(ANIM_AGENT_HOLD_RIFLE_R, ANIM_REQUEST_START);
}
- else
+ if (mAvatarObject->mSignaledAnimations.find(ANIM_AGENT_AIM_HANDGUN_R) != mAvatarObject->mSignaledAnimations.end())
{
- setLookAt(LOOKAT_TARGET_FOCUS, focus_obj, (getPosAgentFromGlobal(focus) - focus_obj->getRenderPosition()) * ~focus_obj->getRenderRotation());
+ sendAnimationRequest(ANIM_AGENT_AIM_HANDGUN_R, ANIM_REQUEST_STOP);
+ sendAnimationRequest(ANIM_AGENT_HOLD_HANDGUN_R, ANIM_REQUEST_START);
+ }
+ if (mAvatarObject->mSignaledAnimations.find(ANIM_AGENT_AIM_BAZOOKA_R) != mAvatarObject->mSignaledAnimations.end())
+ {
+ sendAnimationRequest(ANIM_AGENT_AIM_BAZOOKA_R, ANIM_REQUEST_STOP);
+ sendAnimationRequest(ANIM_AGENT_HOLD_BAZOOKA_R, ANIM_REQUEST_START);
+ }
+ if (mAvatarObject->mSignaledAnimations.find(ANIM_AGENT_AIM_BOW_L) != mAvatarObject->mSignaledAnimations.end())
+ {
+ sendAnimationRequest(ANIM_AGENT_AIM_BOW_L, ANIM_REQUEST_STOP);
+ sendAnimationRequest(ANIM_AGENT_HOLD_BOW_L, ANIM_REQUEST_START);
}
- }
- else
- {
- setLookAt(LOOKAT_TARGET_FOCUS, NULL, getPosAgentFromGlobal(mFocusTargetGlobal));
}
}
}
- else // focus == mFocusTargetGlobal
+ else
+ if(gAgentCamera.mLastCameraMode == CAMERA_MODE_CUSTOMIZE_AVATAR)
{
- if (focus.isExactlyZero())
+ // make sure we ask to save changes
+
+ LLToolMgr::getInstance()->setCurrentToolset(gBasicToolset);
+
+ if( gMorphView )
{
- if (mAvatarObject.notNull())
- {
- mFocusTargetGlobal = getPosGlobalFromAgent(mAvatarObject->mHeadp->getWorldPosition());
- }
- else
- {
- mFocusTargetGlobal = getPositionGlobal();
- }
+ gMorphView->setVisible( FALSE );
}
- mCameraFocusOffsetTarget = (getCameraPositionGlobal() - mFocusTargetGlobal) / (1.f + mCameraFOVZoomFactor);;
- mCameraFocusOffset = mCameraFocusOffsetTarget;
- }
- if (mFocusObject.notNull())
- {
- // for attachments, make offset relative to avatar, not the attachment
- if (mFocusObject->isAttachment())
+ if (mAvatarObject.notNull())
{
- while (mFocusObject.notNull() // DEV-29123 - can crash with a messed-up attachment
- && !mFocusObject->isAvatar())
+ if(mCustomAnim)
{
- mFocusObject = (LLViewerObject*) mFocusObject->getParent();
+ sendAnimationRequest(ANIM_AGENT_CUSTOMIZE, ANIM_REQUEST_STOP);
+ sendAnimationRequest(ANIM_AGENT_CUSTOMIZE_DONE, ANIM_REQUEST_START);
+
+ mCustomAnim = FALSE ;
}
- setFocusObject((LLViewerObject*)mFocusObject);
+
}
- updateFocusOffset();
+ gAgentCamera.setLookAt(LOOKAT_TARGET_CLEAR);
}
-}
-
-// Used for avatar customization
-//-----------------------------------------------------------------------------
-// setCameraPosAndFocusGlobal()
-//-----------------------------------------------------------------------------
-void LLAgent::setCameraPosAndFocusGlobal(const LLVector3d& camera_pos, const LLVector3d& focus, const LLUUID &object_id)
-{
- LLVector3d old_focus = mFocusTargetGlobal;
- F64 focus_delta_squared = (old_focus - focus).magVecSquared();
- const F64 ANIM_EPSILON_SQUARED = 0.0001;
- if( focus_delta_squared > ANIM_EPSILON_SQUARED )
+ //---------------------------------------------------------------------
+ // Set up UI for mode we're entering
+ //---------------------------------------------------------------------
+ if (gAgentCamera.mCameraMode == CAMERA_MODE_MOUSELOOK)
{
- startCameraAnimation();
+ // hide menus
+ gMenuBarView->setVisible(FALSE);
+ LLNavigationBar::getInstance()->setVisible(FALSE);
+ gStatusBar->setVisibleForMouselook(false);
- if( CAMERA_MODE_CUSTOMIZE_AVATAR == mCameraMode )
- {
- // Compensate for the fact that the camera has already been offset to make room for LLFloaterCustomize.
- mAnimationCameraStartGlobal -= LLVector3d(LLViewerCamera::getInstance()->getLeftAxis() * calcCustomizeAvatarUIOffset( mAnimationCameraStartGlobal ));
- }
- }
-
- //LLViewerCamera::getInstance()->setOrigin( gAgent.getPosAgentFromGlobal( camera_pos ) );
- setFocusObject(gObjectList.findObject(object_id));
- mFocusTargetGlobal = focus;
- mCameraFocusOffsetTarget = camera_pos - focus;
- mCameraFocusOffset = mCameraFocusOffsetTarget;
+ LLBottomTray::getInstance()->onMouselookModeIn();
- if (mFocusObject)
- {
- if (mFocusObject->isAvatar())
- {
- setLookAt(LOOKAT_TARGET_FOCUS, mFocusObject);
- }
- else
- {
- setLookAt(LOOKAT_TARGET_FOCUS, mFocusObject, (getPosAgentFromGlobal(focus) - mFocusObject->getRenderPosition()) * ~mFocusObject->getRenderRotation());
- }
- }
- else
- {
- setLookAt(LOOKAT_TARGET_FOCUS, NULL, getPosAgentFromGlobal(mFocusTargetGlobal));
- }
+ LLSideTray::getInstance()->getButtonsPanel()->setVisible(FALSE);
+ LLSideTray::getInstance()->updateSidetrayVisibility();
- if( mCameraAnimating )
- {
- const F64 ANIM_METERS_PER_SECOND = 10.0;
- const F64 MIN_ANIM_SECONDS = 0.5;
- const F64 MAX_ANIM_SECONDS = 10.0;
- F64 anim_duration = llmax( MIN_ANIM_SECONDS, sqrt(focus_delta_squared) / ANIM_METERS_PER_SECOND );
- anim_duration = llmin( anim_duration, MAX_ANIM_SECONDS );
- setAnimationDuration( (F32)anim_duration );
- }
+ LLPanelStandStopFlying::getInstance()->setVisible(FALSE);
- updateFocusOffset();
-}
+ // clear out camera lag effect
+ gAgentCamera.mCameraLag.clearVec();
-//-----------------------------------------------------------------------------
-// setSitCamera()
-//-----------------------------------------------------------------------------
-void LLAgent::setSitCamera(const LLUUID &object_id, const LLVector3 &camera_pos, const LLVector3 &camera_focus)
-{
- BOOL camera_enabled = !object_id.isNull();
+ // JC - Added for always chat in third person option
+ gFocusMgr.setKeyboardFocus(NULL);
- if (camera_enabled)
- {
- LLViewerObject *reference_object = gObjectList.findObject(object_id);
- if (reference_object)
- {
- //convert to root object relative?
- mSitCameraPos = camera_pos;
- mSitCameraFocus = camera_focus;
- mSitCameraReferenceObject = reference_object;
- mSitCameraEnabled = TRUE;
- }
- }
- else
- {
- mSitCameraPos.clearVec();
- mSitCameraFocus.clearVec();
- mSitCameraReferenceObject = NULL;
- mSitCameraEnabled = FALSE;
- }
-}
+ LLToolMgr::getInstance()->setCurrentToolset(gMouselookToolset);
-//-----------------------------------------------------------------------------
-// setFocusOnAvatar()
-//-----------------------------------------------------------------------------
-void LLAgent::setFocusOnAvatar(BOOL focus_on_avatar, BOOL animate)
-{
- if (focus_on_avatar != mFocusOnAvatar)
- {
- if (animate)
- {
- startCameraAnimation();
- }
- else
+ mViewsPushed = TRUE;
+
+ // hide all floaters except the mini map
+
+#if 0 // Use this once all floaters are registered
+ std::set<std::string> exceptions;
+ exceptions.insert("mini_map");
+ LLFloaterReg::hideVisibleInstances(exceptions);
+#else // Use this for now
+ LLFloaterView::skip_list_t skip_list;
+ skip_list.insert(LLFloaterReg::findInstance("mini_map"));
+ gFloaterView->pushVisibleAll(FALSE, skip_list);
+#endif
+
+ if( gMorphView )
{
- stopCameraAnimation();
+ gMorphView->setVisible(FALSE);
}
- }
-
- //RN: when focused on the avatar, we're not "looking" at it
- // looking implies intent while focusing on avatar means
- // you're just walking around with a camera on you...eesh.
- if (!mFocusOnAvatar && focus_on_avatar)
- {
- setFocusGlobal(LLVector3d::zero);
- mCameraFOVZoomFactor = 0.f;
- if (mCameraMode == CAMERA_MODE_THIRD_PERSON)
+
+ gConsole->setVisible( TRUE );
+
+ if (mAvatarObject.notNull())
{
- LLVector3 at_axis;
- if (mAvatarObject.notNull() && mAvatarObject->getParent())
+ // Trigger mouselook-specific animations
+ if( mAvatarObject->isAnyAnimationSignaled(AGENT_GUN_HOLD_ANIMS, NUM_AGENT_GUN_HOLD_ANIMS) )
{
- LLQuaternion obj_rot = ((LLViewerObject*)mAvatarObject->getParent())->getRenderRotation();
- at_axis = LLViewerCamera::getInstance()->getAtAxis();
- at_axis.mV[VZ] = 0.f;
- at_axis.normalize();
- resetAxes(at_axis * ~obj_rot);
+ if (mAvatarObject->mSignaledAnimations.find(ANIM_AGENT_HOLD_RIFLE_R) != mAvatarObject->mSignaledAnimations.end())
+ {
+ sendAnimationRequest(ANIM_AGENT_HOLD_RIFLE_R, ANIM_REQUEST_STOP);
+ sendAnimationRequest(ANIM_AGENT_AIM_RIFLE_R, ANIM_REQUEST_START);
+ }
+ if (mAvatarObject->mSignaledAnimations.find(ANIM_AGENT_HOLD_HANDGUN_R) != mAvatarObject->mSignaledAnimations.end())
+ {
+ sendAnimationRequest(ANIM_AGENT_HOLD_HANDGUN_R, ANIM_REQUEST_STOP);
+ sendAnimationRequest(ANIM_AGENT_AIM_HANDGUN_R, ANIM_REQUEST_START);
+ }
+ if (mAvatarObject->mSignaledAnimations.find(ANIM_AGENT_HOLD_BAZOOKA_R) != mAvatarObject->mSignaledAnimations.end())
+ {
+ sendAnimationRequest(ANIM_AGENT_HOLD_BAZOOKA_R, ANIM_REQUEST_STOP);
+ sendAnimationRequest(ANIM_AGENT_AIM_BAZOOKA_R, ANIM_REQUEST_START);
+ }
+ if (mAvatarObject->mSignaledAnimations.find(ANIM_AGENT_HOLD_BOW_L) != mAvatarObject->mSignaledAnimations.end())
+ {
+ sendAnimationRequest(ANIM_AGENT_HOLD_BOW_L, ANIM_REQUEST_STOP);
+ sendAnimationRequest(ANIM_AGENT_AIM_BOW_L, ANIM_REQUEST_START);
+ }
}
- else
+ if (mAvatarObject->getParent())
{
- at_axis = LLViewerCamera::getInstance()->getAtAxis();
- at_axis.mV[VZ] = 0.f;
- at_axis.normalize();
- resetAxes(at_axis);
+ LLVector3 at_axis = LLViewerCamera::getInstance()->getAtAxis();
+ LLViewerObject* root_object = (LLViewerObject*)mAvatarObject->getRoot();
+ if (root_object->flagCameraDecoupled())
+ {
+ resetAxes(at_axis);
+ }
+ else
+ {
+ resetAxes(at_axis * ~((LLViewerObject*)mAvatarObject->getParent())->getRenderRotation());
+ }
}
}
+
+ }
+ else if (gAgentCamera.mCameraMode == CAMERA_MODE_CUSTOMIZE_AVATAR)
+ {
+ LLToolMgr::getInstance()->setCurrentToolset(gFaceEditToolset);
+
+ if( gMorphView )
+ {
+ gMorphView->setVisible( TRUE );
+ }
+
+ // freeze avatar
+ if (mAvatarObject.notNull())
+ {
+ mPauseRequest = mAvatarObject->requestPause();
+ }
}
- // unlocking camera from avatar
- else if (mFocusOnAvatar && !focus_on_avatar)
+
+ if (getAvatarObject())
{
- // keep camera focus point consistent, even though it is now unlocked
- setFocusGlobal(getPositionGlobal() + calcThirdPersonFocusOffset(), gAgent.getID());
+ getAvatarObject()->updateAttachmentVisibility(gAgentCamera.mCameraMode);
}
-
- mFocusOnAvatar = focus_on_avatar;
+
+ gFloaterTools->dirty();
+
+ // Don't let this be called more than once if the camera
+ // mode hasn't changed. --JC
+ gAgentCamera.mLastCameraMode = gAgentCamera.mCameraMode;
+
}
-*/
//-----------------------------------------------------------------------------
// heardChat()
@@ -4600,7 +2021,7 @@ void LLAgent::heardChat(const LLUUID& id)
if (ll_rand(2) == 0)
{
LLViewerObject *chatter = gObjectList.findObject(mLastChatterID);
- gAgentCameraHACK.setLookAt(LOOKAT_TARGET_AUTO_LISTEN, chatter, LLVector3::zero);
+ gAgentCamera.setLookAt(LOOKAT_TARGET_AUTO_LISTEN, chatter, LLVector3::zero);
}
mLastChatterID = id;
@@ -4613,7 +2034,7 @@ void LLAgent::heardChat(const LLUUID& id)
void LLAgent::lookAtLastChat()
{
// Block if camera is animating or not in normal third person camera mode
- if (gAgentCameraHACK.mCameraAnimating || !gAgentCameraHACK.cameraThirdPerson())
+ if (gAgentCamera.mCameraAnimating || !gAgentCamera.cameraThirdPerson())
{
return;
}
@@ -4637,7 +2058,7 @@ void LLAgent::lookAtLastChat()
setControlFlags(AGENT_CONTROL_STOP);
- gAgentCameraHACK.changeCameraToThirdPerson();
+ gAgentCamera.changeCameraToThirdPerson();
LLVector3 new_camera_pos = mAvatarObject->mHeadp->getWorldPosition();
LLVector3 left = delta_pos % LLVector3::z_axis;
@@ -4649,15 +2070,15 @@ void LLAgent::lookAtLastChat()
new_camera_pos += up * 0.2f;
if (chatter_av->mHeadp)
{
- gAgentCameraHACK.setFocusGlobal(getPosGlobalFromAgent(chatter_av->mHeadp->getWorldPosition()), mLastChatterID);
- gAgentCameraHACK.mCameraFocusOffsetTarget = getPosGlobalFromAgent(new_camera_pos) - gAgent.getPosGlobalFromAgent(chatter_av->mHeadp->getWorldPosition());
+ gAgentCamera.setFocusGlobal(getPosGlobalFromAgent(chatter_av->mHeadp->getWorldPosition()), mLastChatterID);
+ gAgentCamera.mCameraFocusOffsetTarget = getPosGlobalFromAgent(new_camera_pos) - gAgent.getPosGlobalFromAgent(chatter_av->mHeadp->getWorldPosition());
}
else
{
- gAgentCameraHACK.setFocusGlobal(chatter->getPositionGlobal(), mLastChatterID);
- gAgentCameraHACK.mCameraFocusOffsetTarget = getPosGlobalFromAgent(new_camera_pos) - chatter->getPositionGlobal();
+ gAgentCamera.setFocusGlobal(chatter->getPositionGlobal(), mLastChatterID);
+ gAgentCamera.mCameraFocusOffsetTarget = getPosGlobalFromAgent(new_camera_pos) - chatter->getPositionGlobal();
}
- gAgentCameraHACK.setFocusOnAvatar(FALSE, TRUE);
+ gAgentCamera.setFocusOnAvatar(FALSE, TRUE);
}
else
{
@@ -4666,7 +2087,7 @@ void LLAgent::lookAtLastChat()
setControlFlags(AGENT_CONTROL_STOP);
- gAgentCameraHACK.changeCameraToThirdPerson();
+ gAgentCamera.changeCameraToThirdPerson();
LLVector3 new_camera_pos = mAvatarObject->mHeadp->getWorldPosition();
LLVector3 left = delta_pos % LLVector3::z_axis;
@@ -4677,9 +2098,9 @@ void LLAgent::lookAtLastChat()
new_camera_pos += left * 0.3f;
new_camera_pos += up * 0.2f;
- gAgentCameraHACK.setFocusGlobal(chatter->getPositionGlobal(), mLastChatterID);
- gAgentCameraHACK.mCameraFocusOffsetTarget = getPosGlobalFromAgent(new_camera_pos) - chatter->getPositionGlobal();
- gAgentCameraHACK.setFocusOnAvatar(FALSE, TRUE);
+ gAgentCamera.setFocusGlobal(chatter->getPositionGlobal(), mLastChatterID);
+ gAgentCamera.mCameraFocusOffsetTarget = getPosGlobalFromAgent(new_camera_pos) - chatter->getPositionGlobal();
+ gAgentCamera.setFocusOnAvatar(FALSE, TRUE);
}
}
}
@@ -5190,7 +2611,7 @@ LLQuaternion LLAgent::getHeadRotation()
return LLQuaternion::DEFAULT;
}
- if (!gAgentCameraHACK.cameraMouselook())
+ if (!gAgentCamera.cameraMouselook())
{
return mAvatarObject->getRotation();
}
@@ -5361,7 +2782,7 @@ void LLAgent::initOriginGlobal(const LLVector3d &origin_global)
BOOL LLAgent::leftButtonGrabbed() const
{
- const BOOL camera_mouse_look = gAgentCameraHACK.cameraMouselook();
+ const BOOL camera_mouse_look = gAgentCamera.cameraMouselook();
return (!camera_mouse_look && mControlsTakenCount[CONTROL_LBUTTON_DOWN_INDEX] > 0)
|| (camera_mouse_look && mControlsTakenCount[CONTROL_ML_LBUTTON_DOWN_INDEX] > 0)
|| (!camera_mouse_look && mControlsTakenPassedOnCount[CONTROL_LBUTTON_DOWN_INDEX] > 0)
@@ -5833,7 +3254,7 @@ void LLAgent::processAgentCachedTextureResponse(LLMessageSystem *mesgsys, void *
return;
}
- if (gAgentCameraHACK.cameraCustomizeAvatar())
+ if (gAgentCamera.cameraCustomizeAvatar())
{
// ignore baked textures when in customize mode
return;
@@ -5990,7 +3411,7 @@ bool LLAgent::teleportCore(bool is_local)
// Close all pie menus, deselect land, etc.
// Don't change the camera until we know teleport succeeded. JC
- gAgentCameraHACK.resetView(FALSE);
+ gAgentCamera.resetView(FALSE);
// local logic
LLViewerStats::getInstance()->incStat(LLViewerStats::ST_TELEPORT_COUNT);
@@ -6291,7 +3712,7 @@ void LLAgent::sendAgentSetAppearance()
{
if (mAvatarObject.isNull()) return;
- if (gAgentQueryManager.mNumPendingQueries > 0 && !gAgentCameraHACK.cameraCustomizeAvatar())
+ if (gAgentQueryManager.mNumPendingQueries > 0 && !gAgentCamera.cameraCustomizeAvatar())
{
return;
}
@@ -6540,9 +3961,7 @@ void LLAgent::renderAutoPilotTarget()
}
}
-/********************************************************************************
- *
- */
+/********************************************************************************/
LLAgentQueryManager gAgentQueryManager;
diff --git a/indra/newview/llagent.h b/indra/newview/llagent.h
index d196c1c1c1b877c8c19ffc3c76e21e1ccff310e8..1b378ef7b286a81571fbe156a098337f47d3882a 100644
--- a/indra/newview/llagent.h
+++ b/indra/newview/llagent.h
@@ -66,32 +66,6 @@ class LLAgentDropGroupViewerNode;
//--------------------------------------------------------------------
// Types
//--------------------------------------------------------------------
-//--------------------------------------------------------------------
-// Types
-//--------------------------------------------------------------------
-
-/*
-enum ECameraMode
-{
- CAMERA_MODE_THIRD_PERSON,
- CAMERA_MODE_MOUSELOOK,
- CAMERA_MODE_CUSTOMIZE_AVATAR,
- CAMERA_MODE_FOLLOW
-};
-
-// Camera Presets for CAMERA_MODE_THIRD_PERSON
-enum ECameraPreset
-{
- // Default preset, what the Third Person Mode actually was
- CAMERA_PRESET_REAR_VIEW,
-
- // "Looking at the Avatar from the front"
- CAMERA_PRESET_FRONT_VIEW,
-
- // "Above and to the left, over the shoulder, pulled back a little on the zoom"
- CAMERA_PRESET_GROUP_VIEW
-};
-*/
enum EAnimRequest
{
@@ -146,11 +120,12 @@ class LLAgent : public LLOldEvents::LLObservable
void setFirstLogin(BOOL b) { mFirstLogin = b; }
// Return TRUE if the database reported this login as the first for this particular user.
BOOL isFirstLogin() const { return mFirstLogin; }
+ BOOL isInitialized() const { return mInitialized; }
public:
- BOOL mInitialized;
- BOOL mFirstLogin;
std::string mMOTD; // Message of the day
private:
+ BOOL mInitialized;
+ BOOL mFirstLogin;
boost::shared_ptr<LLAgentListener> mListener;
//--------------------------------------------------------------------
@@ -455,8 +430,6 @@ class LLAgent : public LLOldEvents::LLObservable
void sendAnimationRequest(const LLUUID &anim_id, EAnimRequest request);
void endAnimationUpdateUI();
private:
- LLFrameTimer mAnimationTimer; // Seconds that transition animation has been active // SERAPH REMOVE
- F32 mAnimationDuration; // In seconds // SERAPH REMOVE
BOOL mCustomAnim; // Current animation is ANIM_AGENT_CUSTOMIZE ?
LLAnimPauseRequest mPauseRequest;
BOOL mViewsPushed; // Keep track of whether or not we have pushed views
@@ -498,44 +471,6 @@ class LLAgent : public LLOldEvents::LLObservable
void moveYaw(F32 mag, bool reset_view = true);
void movePitch(F32 mag);
- // SERAPH Remove this whole section
- //--------------------------------------------------------------------
- // Orbit
- //--------------------------------------------------------------------
-public:
- void setOrbitLeftKey(F32 mag) { mOrbitLeftKey = mag; }
- void setOrbitRightKey(F32 mag) { mOrbitRightKey = mag; }
- void setOrbitUpKey(F32 mag) { mOrbitUpKey = mag; }
- void setOrbitDownKey(F32 mag) { mOrbitDownKey = mag; }
- void setOrbitInKey(F32 mag) { mOrbitInKey = mag; }
- void setOrbitOutKey(F32 mag) { mOrbitOutKey = mag; }
-private:
- F32 mOrbitLeftKey;
- F32 mOrbitRightKey;
- F32 mOrbitUpKey;
- F32 mOrbitDownKey;
- F32 mOrbitInKey;
- F32 mOrbitOutKey;
-
- // SERAPH Remove this whole section
- //--------------------------------------------------------------------
- // Pan
- //--------------------------------------------------------------------
-public:
- void setPanLeftKey(F32 mag) { mPanLeftKey = mag; }
- void setPanRightKey(F32 mag) { mPanRightKey = mag; }
- void setPanUpKey(F32 mag) { mPanUpKey = mag; }
- void setPanDownKey(F32 mag) { mPanDownKey = mag; }
- void setPanInKey(F32 mag) { mPanInKey = mag; }
- void setPanOutKey(F32 mag) { mPanOutKey = mag; }
-private:
- F32 mPanUpKey;
- F32 mPanDownKey;
- F32 mPanLeftKey;
- F32 mPanRightKey;
- F32 mPanInKey;
- F32 mPanOutKey;
-
//--------------------------------------------------------------------
// Move the avatar's frame
//--------------------------------------------------------------------
@@ -647,220 +582,6 @@ class LLAgent : public LLOldEvents::LLObservable
** **
*******************************************************************************/
-/********************************************************************************
- ** **
- ** CAMERA
- **/
-
-/*
- //--------------------------------------------------------------------
- // Mode
- //--------------------------------------------------------------------
-public:
- void changeCameraToDefault();
- void changeCameraToMouselook(BOOL animate = TRUE);
- void changeCameraToThirdPerson(BOOL animate = TRUE);
- void changeCameraToCustomizeAvatar(BOOL avatar_animate = TRUE, BOOL camera_animate = TRUE); // Trigger transition animation
- void changeCameraToFollow(BOOL animate = TRUE); // Ventrella
- BOOL cameraThirdPerson() const { return (mCameraMode == CAMERA_MODE_THIRD_PERSON && mLastCameraMode == CAMERA_MODE_THIRD_PERSON); }
- BOOL cameraMouselook() const { return (mCameraMode == CAMERA_MODE_MOUSELOOK && mLastCameraMode == CAMERA_MODE_MOUSELOOK); }
- BOOL cameraCustomizeAvatar() const { return (mCameraMode == CAMERA_MODE_CUSTOMIZE_AVATAR); }
- BOOL cameraFollow() const { return (mCameraMode == CAMERA_MODE_FOLLOW && mLastCameraMode == CAMERA_MODE_FOLLOW); }
- ECameraMode getCameraMode() const { return mCameraMode; }
- void updateCamera(); // Call once per frame to update camera location/orientation
- void resetCamera(); // Slam camera into its default position
-private:
- ECameraMode mCameraMode; // Target mode after transition animation is done
- ECameraMode mLastCameraMode;
-
- //--------------------------------------------------------------------
- // Preset
- //--------------------------------------------------------------------
-public:
- void switchCameraPreset(ECameraPreset preset);
-
-private:
-
- // Determines default camera offset depending on the current camera preset
- LLVector3 getCameraOffsetInitial();
-
- // Camera preset in Third Person Mode
- ECameraPreset mCameraPreset;
-
- // Initial camera offsets
- std::map<ECameraPreset, LLVector3> mCameraOffsetInitial;
-
- // Initial focus offsets
- std::map<ECameraPreset, LLVector3d> mFocusOffsetInitial;
-
- //--------------------------------------------------------------------
- // Position
- //--------------------------------------------------------------------
-public:
- LLVector3d getCameraPositionGlobal() const;
- const LLVector3 &getCameraPositionAgent() const;
- LLVector3d calcCameraPositionTargetGlobal(BOOL *hit_limit = NULL); // Calculate the camera position target
- F32 getCameraMinOffGround(); // Minimum height off ground for this mode, meters
- void setCameraCollidePlane(const LLVector4 &plane) { mCameraCollidePlane = plane; }
- BOOL calcCameraMinDistance(F32 &obj_min_distance);
- F32 calcCustomizeAvatarUIOffset(const LLVector3d& camera_pos_global);
- F32 getCurrentCameraBuildOffset() { return (F32)mCameraFocusOffset.length(); }
-private:
- F32 mCurrentCameraDistance; // Current camera offset from avatar
- F32 mTargetCameraDistance; // Target camera offset from avatar
- F32 mCameraFOVZoomFactor; // Amount of fov zoom applied to camera when zeroing in on an object
- F32 mCameraCurrentFOVZoomFactor; // Interpolated fov zoom
- F32 mCameraFOVDefault; // Default field of view that is basis for FOV zoom effect
- LLVector4 mCameraCollidePlane; // Colliding plane for camera
- F32 mCameraZoomFraction; // Mousewheel driven fraction of zoom
- LLVector3 mCameraPositionAgent; // Camera position in agent coordinates
- LLVector3 mCameraVirtualPositionAgent; // Camera virtual position (target) before performing FOV zoom
- LLVector3d mCameraSmoothingLastPositionGlobal;
- LLVector3d mCameraSmoothingLastPositionAgent;
- BOOL mCameraSmoothingStop;
- LLVector3 mCameraLag; // Third person camera lag
- LLVector3 mCameraUpVector; // Camera's up direction in world coordinates (determines the 'roll' of the view)
-
- //--------------------------------------------------------------------
- // Follow
- //--------------------------------------------------------------------
-public:
- void setUsingFollowCam(bool using_follow_cam);
-private:
- LLFollowCam mFollowCam; // Ventrella
-
- //--------------------------------------------------------------------
- // Sit
- //--------------------------------------------------------------------
-public:
- void setupSitCamera();
- BOOL sitCameraEnabled() { return mSitCameraEnabled; }
- void setSitCamera(const LLUUID &object_id,
- const LLVector3 &camera_pos = LLVector3::zero, const LLVector3 &camera_focus = LLVector3::zero);
-private:
- LLPointer<LLViewerObject> mSitCameraReferenceObject; // Object to which camera is related when sitting
- BOOL mSitCameraEnabled; // Use provided camera information when sitting?
- LLVector3 mSitCameraPos; // Root relative camera pos when sitting
- LLVector3 mSitCameraFocus; // Root relative camera target when sitting
-#endif
-
- //--------------------------------------------------------------------
- // Animation
- //--------------------------------------------------------------------
-public:
- void setCameraAnimating(BOOL b) { mCameraAnimating = b; }
- BOOL getCameraAnimating() { return mCameraAnimating; }
- void setAnimationDuration(F32 seconds) { mAnimationDuration = seconds; }
- void startCameraAnimation();
- void stopCameraAnimation();
-private:
- BOOL mCameraAnimating; // Camera is transitioning from one mode to another
- LLVector3d mAnimationCameraStartGlobal; // Camera start position, global coords
- LLVector3d mAnimationFocusStartGlobal; // Camera focus point, global coords
-
- //--------------------------------------------------------------------
- // Focus
- //--------------------------------------------------------------------
-public:
- LLVector3d calcFocusPositionTargetGlobal();
- LLVector3 calcFocusOffset(LLViewerObject *object, LLVector3 pos_agent, S32 x, S32 y);
- BOOL getFocusOnAvatar() const { return mFocusOnAvatar; }
- LLPointer<LLViewerObject>& getFocusObject() { return mFocusObject; }
- F32 getFocusObjectDist() const { return mFocusObjectDist; }
- void updateFocusOffset();
- void validateFocusObject();
- void setFocusGlobal(const LLPickInfo& pick);
- void setFocusGlobal(const LLVector3d &focus, const LLUUID &object_id = LLUUID::null);
- void setFocusOnAvatar(BOOL focus, BOOL animate);
- void setCameraPosAndFocusGlobal(const LLVector3d& pos, const LLVector3d& focus, const LLUUID &object_id);
- void clearFocusObject();
- void setFocusObject(LLViewerObject* object);
- void setObjectTracking(BOOL track) { mTrackFocusObject = track; }
- const LLVector3d &getFocusGlobal() const { return mFocusGlobal; }
- const LLVector3d &getFocusTargetGlobal() const { return mFocusTargetGlobal; }
-private:
- LLVector3d mCameraFocusOffset; // Offset from focus point in build mode
- LLVector3d mCameraFocusOffsetTarget; // Target towards which we are lerping the camera's focus offset
- BOOL mFocusOnAvatar;
- LLVector3d mFocusGlobal;
- LLVector3d mFocusTargetGlobal;
- LLPointer<LLViewerObject> mFocusObject;
- F32 mFocusObjectDist;
- LLVector3 mFocusObjectOffset;
- F32 mFocusDotRadius; // Meters
- BOOL mTrackFocusObject;
- F32 mUIOffset;
-
- //--------------------------------------------------------------------
- // Third person
- //--------------------------------------------------------------------
-public:
- LLVector3d calcThirdPersonFocusOffset();
- void setThirdPersonHeadOffset(LLVector3 offset) { mThirdPersonHeadOffset = offset; }
-private:
- LLVector3 mThirdPersonHeadOffset; // Head offset for third person camera position
-
- //--------------------------------------------------------------------
- // Orbit
- //--------------------------------------------------------------------
-public:
- void cameraOrbitAround(const F32 radians); // Rotate camera CCW radians about build focus point
- void cameraOrbitOver(const F32 radians); // Rotate camera forward radians over build focus point
- void cameraOrbitIn(const F32 meters); // Move camera in toward build focus point
-
- //--------------------------------------------------------------------
- // Zoom
- //--------------------------------------------------------------------
-public:
- void handleScrollWheel(S32 clicks); // Mousewheel driven zoom
- void cameraZoomIn(const F32 factor); // Zoom in by fraction of current distance
- F32 getCameraZoomFraction(); // Get camera zoom as fraction of minimum and maximum zoom
- void setCameraZoomFraction(F32 fraction); // Set camera zoom as fraction of minimum and maximum zoom
- F32 calcCameraFOVZoomFactor();
-
- //--------------------------------------------------------------------
- // Pan
- //--------------------------------------------------------------------
-public:
- void cameraPanIn(const F32 meters);
- void cameraPanLeft(const F32 meters);
- void cameraPanUp(const F32 meters);
-
- //--------------------------------------------------------------------
- // View
- //--------------------------------------------------------------------
-public:
- // Called whenever the agent moves. Puts camera back in default position, deselects items, etc.
- void resetView(BOOL reset_camera = TRUE, BOOL change_camera = FALSE);
- // Called on camera movement. Unlocks camera from the default position behind the avatar.
- void unlockView();
-
- //--------------------------------------------------------------------
- // Mouselook
- //--------------------------------------------------------------------
-public:
- BOOL getForceMouselook() const { return mForceMouselook; }
- void setForceMouselook(BOOL mouselook) { mForceMouselook = mouselook; }
-private:
- BOOL mForceMouselook;
-
-*/
-
- //--------------------------------------------------------------------
- // HUD
- //--------------------------------------------------------------------
-public:
- const LLColor4 &getEffectColor();
- void setEffectColor(const LLColor4 &color);
-private:
- LLUIColor mEffectColor;
-
-/** Camera
- ** **
- *******************************************************************************/
-
-
-
/********************************************************************************
** **
** ACCESS
@@ -935,8 +656,6 @@ class LLAgent : public LLOldEvents::LLObservable
LLQuaternion getHeadRotation();
BOOL needsRenderAvatar(); // TRUE when camera mode is such that your own avatar should draw
BOOL needsRenderHead();
-public:
- F32 mDrawDistance; // SERAPH REMOVE
private:
BOOL mShowAvatar; // Should we render the avatar?
U32 mAppearanceSerialNum;
@@ -951,6 +670,15 @@ class LLAgent : public LLOldEvents::LLObservable
private:
U8 mRenderState; // Current behavior state of agent
+ //--------------------------------------------------------------------
+ // HUD
+ //--------------------------------------------------------------------
+public:
+ const LLColor4 &getEffectColor();
+ void setEffectColor(const LLColor4 &color);
+private:
+ LLUIColor mEffectColor;
+
/** Rendering
** **
*******************************************************************************/
diff --git a/indra/newview/llagentcamera.cpp b/indra/newview/llagentcamera.cpp
index f1422e24422ba09424099966eaaa5a99dd68251c..c51edbaf4b3d0b386ec290ed5a8489b8f6ce3ee5 100644
--- a/indra/newview/llagentcamera.cpp
+++ b/indra/newview/llagentcamera.cpp
@@ -80,47 +80,15 @@
#include "llworld.h"
#include "llworldmap.h"
-static LLAgent gAgentHACK = gAgent;
-
using namespace LLVOAvatarDefines;
extern LLMenuBarGL* gMenuBarView;
-/*
-const BOOL ANIMATE = TRUE;
-const U8 AGENT_STATE_TYPING = 0x04;
-const U8 AGENT_STATE_EDITING = 0x10;
-
-//drone wandering constants
-const F32 MAX_WANDER_TIME = 20.f; // seconds
-const F32 MAX_HEADING_HALF_ERROR = 0.2f; // radians
-const F32 WANDER_MAX_SLEW_RATE = 2.f * DEG_TO_RAD; // radians / frame
-const F32 WANDER_TARGET_MIN_DISTANCE = 10.f; // meters
-
-// Autopilot constants
-const F32 AUTOPILOT_HEADING_HALF_ERROR = 10.f * DEG_TO_RAD; // radians
-const F32 AUTOPILOT_MAX_SLEW_RATE = 1.f * DEG_TO_RAD; // radians / frame
-const F32 AUTOPILOT_STOP_DISTANCE = 2.f; // meters
-const F32 AUTOPILOT_HEIGHT_ADJUST_DISTANCE = 8.f; // meters
-const F32 AUTOPILOT_MIN_TARGET_HEIGHT_OFF_GROUND = 1.f; // meters
-const F32 AUTOPILOT_MAX_TIME_NO_PROGRESS = 1.5f; // seconds
-
-// face editing constants
-const LLVector3d FACE_EDIT_CAMERA_OFFSET(0.4f, -0.05f, 0.07f);
-const LLVector3d FACE_EDIT_TARGET_OFFSET(0.f, 0.f, 0.05f);
-*/
-
// Mousewheel camera zoom
const F32 MIN_ZOOM_FRACTION = 0.25f;
const F32 INITIAL_ZOOM_FRACTION = 1.f;
const F32 MAX_ZOOM_FRACTION = 8.f;
-/*
-const F32 METERS_PER_WHEEL_CLICK = 1.f;
-
-const F32 MAX_TIME_DELTA = 1.f;
-*/
-
const F32 CAMERA_ZOOM_HALF_LIFE = 0.07f; // seconds
const F32 FOV_ZOOM_HALF_LIFE = 0.07f; // seconds
@@ -152,28 +120,10 @@ const F32 OBJECT_MIN_ZOOM = 0.02f;
const F32 APPEARANCE_MIN_ZOOM = 0.39f;
const F32 APPEARANCE_MAX_ZOOM = 8.f;
-/*
-// fidget constants
-const F32 MIN_FIDGET_TIME = 8.f; // seconds
-const F32 MAX_FIDGET_TIME = 20.f; // seconds
-
-const S32 MAX_NUM_CHAT_POSITIONS = 10;
-*/
-
const F32 GROUND_TO_AIR_CAMERA_TRANSITION_TIME = 0.5f;
const F32 GROUND_TO_AIR_CAMERA_TRANSITION_START_TIME = 0.5f;
-/*
-const F32 MAX_VELOCITY_AUTO_LAND_SQUARED = 4.f * 4.f;
-
-const F32 MAX_FOCUS_OFFSET = 20.f;
-*/
const F32 OBJECT_EXTENTS_PADDING = 0.5f;
-/*
-const F32 MIN_RADIUS_ALPHA_SIZZLE = 0.5f;
-
-const F64 CHAT_AGE_FAST_RATE = 3.0;
-*/
// The agent instance.
LLAgentCamera gAgentCamera;
@@ -182,9 +132,16 @@ LLAgentCamera gAgentCamera;
// LLAgentCamera()
//-----------------------------------------------------------------------------
LLAgentCamera::LLAgentCamera() :
+ mDrawDistance( DEFAULT_FAR_PLANE ),
+
mLookAt(NULL),
mPointAt(NULL),
+ mHUDTargetZoom(1.f),
+ mHUDCurZoom(1.f),
+
+ mForceMouselook(FALSE),
+
mCameraMode( CAMERA_MODE_THIRD_PERSON ),
mLastCameraMode( CAMERA_MODE_THIRD_PERSON ),
@@ -238,6 +195,7 @@ LLAgentCamera::LLAgentCamera() :
mPanInKey(0.f),
mPanOutKey(0.f)
{
+ mFollowCam.setMaxCameraDistantFromSubject( MAX_CAMERA_DISTANCE_FROM_AGENT );
}
// Requires gSavedSettings to be initialized.
@@ -248,6 +206,8 @@ void LLAgentCamera::init()
{
// *Note: this is where LLViewerCamera::getInstance() used to be constructed.
+ mDrawDistance = gSavedSettings.getF32("RenderFarClip");
+
LLViewerCamera::getInstance()->setView(DEFAULT_FIELD_OF_VIEW);
// Leave at 0.1 meters until we have real near clip management
LLViewerCamera::getInstance()->setNear(0.1f);
@@ -313,9 +273,9 @@ LLAgentCamera::~LLAgentCamera()
//-----------------------------------------------------------------------------
void LLAgentCamera::resetView(BOOL reset_camera, BOOL change_camera)
{
- if (gAgentHACK.mAutoPilot)
+ if (gAgent.mAutoPilot)
{
- gAgentHACK.stopAutoPilot(TRUE);
+ gAgent.stopAutoPilot(TRUE);
}
if (!gNoRender)
@@ -369,10 +329,10 @@ void LLAgentCamera::resetView(BOOL reset_camera, BOOL change_camera)
if (!gViewerWindow->getLeftMouseDown() && cameraThirdPerson())
{
// leaving mouse-steer mode
- LLVector3 agent_at_axis = gAgentHACK.getAtAxis();
- agent_at_axis -= projected_vec(agent_at_axis, gAgentHACK.getReferenceUpVector());
+ LLVector3 agent_at_axis = gAgent.getAtAxis();
+ agent_at_axis -= projected_vec(agent_at_axis, gAgent.getReferenceUpVector());
agent_at_axis.normalize();
- gAgentHACK.resetAxes(lerp(gAgentHACK.getAtAxis(), agent_at_axis, LLCriticalDamp::getInterpolant(0.3f)));
+ gAgent.resetAxes(lerp(gAgent.getAtAxis(), agent_at_axis, LLCriticalDamp::getInterpolant(0.3f)));
}
setFocusOnAvatar(TRUE, ANIMATE);
@@ -391,9 +351,9 @@ void LLAgentCamera::unlockView()
{
if (getFocusOnAvatar())
{
- if (gAgentHACK.mAvatarObject.notNull())
+ if (gAgent.mAvatarObject.notNull())
{
- setFocusGlobal( LLVector3d::zero, gAgentHACK.mAvatarObject->mID );
+ setFocusGlobal( LLVector3d::zero, gAgent.mAvatarObject->mID );
}
setFocusOnAvatar(FALSE, FALSE); // no animation
}
@@ -407,7 +367,7 @@ void LLAgentCamera::slamLookAt(const LLVector3 &look_at)
LLVector3 look_at_norm = look_at;
look_at_norm.mV[VZ] = 0.f;
look_at_norm.normalize();
- gAgentHACK.resetAxes(look_at_norm);
+ gAgent.resetAxes(look_at_norm);
}
//-----------------------------------------------------------------------------
@@ -607,7 +567,7 @@ BOOL LLAgentCamera::calcCameraMinDistance(F32 &obj_min_distance)
LLQuaternion inv_object_rot = ~mFocusObject->getRenderRotation();
LLVector3 target_offset_origin = mFocusObjectOffset;
- LLVector3 camera_offset_target(getCameraPositionAgent() - gAgentHACK.getPosAgentFromGlobal(mFocusTargetGlobal));
+ LLVector3 camera_offset_target(getCameraPositionAgent() - gAgent.getPosAgentFromGlobal(mFocusTargetGlobal));
// convert offsets into object local space
camera_offset_target.rotVec(inv_object_rot);
@@ -870,7 +830,7 @@ void LLAgentCamera::cameraOrbitAround(const F32 radians)
}
else if (mFocusOnAvatar && (mCameraMode == CAMERA_MODE_THIRD_PERSON || mCameraMode == CAMERA_MODE_FOLLOW))
{
- gAgentHACK.mFrameAgent.rotate(radians, gAgentHACK.getReferenceUpVector());
+ gAgent.mFrameAgent.rotate(radians, gAgent.getReferenceUpVector());
}
else
{
@@ -893,14 +853,14 @@ void LLAgentCamera::cameraOrbitOver(const F32 angle)
}
else if (mFocusOnAvatar && mCameraMode == CAMERA_MODE_THIRD_PERSON)
{
- gAgentHACK.pitch(angle);
+ gAgent.pitch(angle);
}
else
{
LLVector3 camera_offset_unit(mCameraFocusOffsetTarget);
camera_offset_unit.normalize();
- F32 angle_from_up = acos( camera_offset_unit * gAgentHACK.getReferenceUpVector() );
+ F32 angle_from_up = acos( camera_offset_unit * gAgent.getReferenceUpVector() );
LLVector3d left_axis;
left_axis.setVec(LLViewerCamera::getInstance()->getLeftAxis());
@@ -1111,28 +1071,28 @@ void LLAgentCamera::updateLookAt(const S32 mouse_x, const S32 mouse_y)
static LLVector3 last_at_axis;
- if (gAgentHACK.mAvatarObject.isNull())
+ if (gAgent.mAvatarObject.isNull())
{
return;
}
- LLQuaternion av_inv_rot = ~gAgentHACK.mAvatarObject->mRoot.getWorldRotation();
- LLVector3 root_at = LLVector3::x_axis * gAgentHACK.mAvatarObject->mRoot.getWorldRotation();
+ LLQuaternion av_inv_rot = ~gAgent.mAvatarObject->mRoot.getWorldRotation();
+ LLVector3 root_at = LLVector3::x_axis * gAgent.mAvatarObject->mRoot.getWorldRotation();
if ((gViewerWindow->getMouseVelocityStat()->getCurrent() < 0.01f) &&
(root_at * last_at_axis > 0.95f ))
{
- LLVector3 vel = gAgentHACK.mAvatarObject->getVelocity();
+ LLVector3 vel = gAgent.mAvatarObject->getVelocity();
if (vel.magVecSquared() > 4.f)
{
- setLookAt(LOOKAT_TARGET_IDLE, gAgentHACK.mAvatarObject, vel * av_inv_rot);
+ setLookAt(LOOKAT_TARGET_IDLE, gAgent.mAvatarObject, vel * av_inv_rot);
}
else
{
// *FIX: rotate mframeagent by sit object's rotation?
- LLQuaternion look_rotation = gAgentHACK.mAvatarObject->isSitting() ? gAgentHACK.mAvatarObject->getRenderRotation() : gAgentHACK.mFrameAgent.getQuaternion(); // use camera's current rotation
+ LLQuaternion look_rotation = gAgent.mAvatarObject->isSitting() ? gAgent.mAvatarObject->getRenderRotation() : gAgent.mFrameAgent.getQuaternion(); // use camera's current rotation
LLVector3 look_offset = LLVector3(2.f, 0.f, 0.f) * look_rotation * av_inv_rot;
- setLookAt(LOOKAT_TARGET_IDLE, gAgentHACK.mAvatarObject, look_offset);
+ setLookAt(LOOKAT_TARGET_IDLE, gAgent.mAvatarObject, look_offset);
}
last_at_axis = root_at;
return;
@@ -1142,7 +1102,7 @@ void LLAgentCamera::updateLookAt(const S32 mouse_x, const S32 mouse_y)
if (CAMERA_MODE_CUSTOMIZE_AVATAR == getCameraMode())
{
- setLookAt(LOOKAT_TARGET_NONE, gAgentHACK.mAvatarObject, LLVector3(-2.f, 0.f, 0.f));
+ setLookAt(LOOKAT_TARGET_NONE, gAgent.mAvatarObject, LLVector3(-2.f, 0.f, 0.f));
}
else
{
@@ -1171,7 +1131,7 @@ void LLAgentCamera::updateLookAt(const S32 mouse_x, const S32 mouse_y)
headLookAxis = frameCamera.getAtAxis();
// RN: we use world-space offset for mouselook and freelook
//headLookAxis = headLookAxis * av_inv_rot;
- setLookAt(lookAtType, gAgentHACK.mAvatarObject, headLookAxis);
+ setLookAt(lookAtType, gAgent.mAvatarObject, headLookAxis);
}
}
@@ -1192,13 +1152,13 @@ void LLAgentCamera::updateCamera()
validateFocusObject();
- if (gAgentHACK.mAvatarObject.notNull() &&
- gAgentHACK.mAvatarObject->isSitting() &&
+ if (gAgent.mAvatarObject.notNull() &&
+ gAgent.mAvatarObject->isSitting() &&
camera_mode == CAMERA_MODE_MOUSELOOK)
{
//Ventrella
//changed camera_skyward to the new global "mCameraUpVector"
- mCameraUpVector = mCameraUpVector * gAgentHACK.mAvatarObject->getRenderRotation();
+ mCameraUpVector = mCameraUpVector * gAgent.mAvatarObject->getRenderRotation();
//end Ventrella
}
@@ -1306,7 +1266,7 @@ void LLAgentCamera::updateCamera()
//Ventrella
if ( mCameraMode == CAMERA_MODE_FOLLOW )
{
- if ( gAgentHACK.mAvatarObject.notNull() )
+ if ( gAgent.mAvatarObject.notNull() )
{
//--------------------------------------------------------------------------------
// this is where the avatar's position and rotation are given to followCam, and
@@ -1314,13 +1274,13 @@ void LLAgentCamera::updateCamera()
// (2) focus, and (3) upvector. They can then be queried elsewhere in llAgent.
//--------------------------------------------------------------------------------
// *TODO: use combined rotation of frameagent and sit object
- LLQuaternion avatarRotationForFollowCam = gAgentHACK.mAvatarObject->isSitting() ? gAgentHACK.mAvatarObject->getRenderRotation() : gAgentHACK.mFrameAgent.getQuaternion();
+ LLQuaternion avatarRotationForFollowCam = gAgent.mAvatarObject->isSitting() ? gAgent.mAvatarObject->getRenderRotation() : gAgent.mFrameAgent.getQuaternion();
LLFollowCamParams* current_cam = LLFollowCamMgr::getActiveFollowCamParams();
if (current_cam)
{
mFollowCam.copyParams(*current_cam);
- mFollowCam.setSubjectPositionAndRotation( gAgentHACK.mAvatarObject->getRenderPosition(), avatarRotationForFollowCam );
+ mFollowCam.setSubjectPositionAndRotation( gAgent.mAvatarObject->getRenderPosition(), avatarRotationForFollowCam );
mFollowCam.update();
LLViewerJoystick::getInstance()->setCameraNeedsUpdate(true);
}
@@ -1335,14 +1295,14 @@ void LLAgentCamera::updateCamera()
BOOL hit_limit;
LLVector3d camera_pos_global;
LLVector3d camera_target_global = calcCameraPositionTargetGlobal(&hit_limit);
- mCameraVirtualPositionAgent = gAgentHACK.getPosAgentFromGlobal(camera_target_global);
+ mCameraVirtualPositionAgent = gAgent.getPosAgentFromGlobal(camera_target_global);
LLVector3d focus_target_global = calcFocusPositionTargetGlobal();
// perform field of view correction
mCameraFOVZoomFactor = calcCameraFOVZoomFactor();
camera_target_global = focus_target_global + (camera_target_global - focus_target_global) * (1.f + mCameraFOVZoomFactor);
- gAgentHACK.mShowAvatar = TRUE; // can see avatar by default
+ gAgent.mShowAvatar = TRUE; // can see avatar by default
// Adjust position for animation
if (mCameraAnimating)
@@ -1375,7 +1335,7 @@ void LLAgentCamera::updateCamera()
{
if (fraction_of_animation < animation_start_fraction || fraction_of_animation > animation_finish_fraction )
{
- gAgentHACK.mShowAvatar = FALSE;
+ gAgent.mShowAvatar = FALSE;
}
// ...adjust position for animation
@@ -1391,26 +1351,26 @@ void LLAgentCamera::updateCamera()
camera_pos_global = camera_target_global;
mFocusGlobal = focus_target_global;
- gAgentHACK.endAnimationUpdateUI();
- gAgentHACK.mShowAvatar = TRUE;
+ gAgent.endAnimationUpdateUI();
+ gAgent.mShowAvatar = TRUE;
}
- if (gAgentHACK.getAvatarObject() && mCameraMode != CAMERA_MODE_MOUSELOOK)
+ if (gAgent.getAvatarObject() && mCameraMode != CAMERA_MODE_MOUSELOOK)
{
- gAgentHACK.getAvatarObject()->updateAttachmentVisibility(mCameraMode);
+ gAgent.getAvatarObject()->updateAttachmentVisibility(mCameraMode);
}
}
else
{
camera_pos_global = camera_target_global;
mFocusGlobal = focus_target_global;
- gAgentHACK.mShowAvatar = TRUE;
+ gAgent.mShowAvatar = TRUE;
}
// smoothing
if (TRUE)
{
- LLVector3d agent_pos = gAgentHACK.getPositionGlobal();
+ LLVector3d agent_pos = gAgent.getPositionGlobal();
LLVector3d camera_pos_agent = camera_pos_global - agent_pos;
// Sitting on what you're manipulating can cause camera jitter with smoothing.
// This turns off smoothing while editing. -MG
@@ -1461,9 +1421,9 @@ void LLAgentCamera::updateCamera()
}
- LLVector3 focus_agent = gAgentHACK.getPosAgentFromGlobal(mFocusGlobal);
+ LLVector3 focus_agent = gAgent.getPosAgentFromGlobal(mFocusGlobal);
- mCameraPositionAgent = gAgentHACK.getPosAgentFromGlobal(camera_pos_global);
+ mCameraPositionAgent = gAgent.getPosAgentFromGlobal(camera_pos_global);
// Move the camera
@@ -1487,48 +1447,48 @@ void LLAgentCamera::updateCamera()
// update the travel distance stat
// this isn't directly related to the camera
// but this seemed like the best place to do this
- LLVector3d global_pos = gAgentHACK.getPositionGlobal();
- if (! gAgentHACK.mLastPositionGlobal.isExactlyZero())
+ LLVector3d global_pos = gAgent.getPositionGlobal();
+ if (! gAgent.mLastPositionGlobal.isExactlyZero())
{
- LLVector3d delta = global_pos - gAgentHACK.mLastPositionGlobal;
- gAgentHACK.mDistanceTraveled += delta.magVec();
+ LLVector3d delta = global_pos - gAgent.mLastPositionGlobal;
+ gAgent.mDistanceTraveled += delta.magVec();
}
- gAgentHACK.mLastPositionGlobal = global_pos;
+ gAgent.mLastPositionGlobal = global_pos;
- if (LLVOAvatar::sVisibleInFirstPerson && gAgentHACK.mAvatarObject.notNull() && !gAgentHACK.mAvatarObject->isSitting() && cameraMouselook())
+ if (LLVOAvatar::sVisibleInFirstPerson && gAgent.mAvatarObject.notNull() && !gAgent.mAvatarObject->isSitting() && cameraMouselook())
{
- LLVector3 head_pos = gAgentHACK.mAvatarObject->mHeadp->getWorldPosition() +
- LLVector3(0.08f, 0.f, 0.05f) * gAgentHACK.mAvatarObject->mHeadp->getWorldRotation() +
- LLVector3(0.1f, 0.f, 0.f) * gAgentHACK.mAvatarObject->mPelvisp->getWorldRotation();
+ LLVector3 head_pos = gAgent.mAvatarObject->mHeadp->getWorldPosition() +
+ LLVector3(0.08f, 0.f, 0.05f) * gAgent.mAvatarObject->mHeadp->getWorldRotation() +
+ LLVector3(0.1f, 0.f, 0.f) * gAgent.mAvatarObject->mPelvisp->getWorldRotation();
LLVector3 diff = mCameraPositionAgent - head_pos;
- diff = diff * ~gAgentHACK.mAvatarObject->mRoot.getWorldRotation();
+ diff = diff * ~gAgent.mAvatarObject->mRoot.getWorldRotation();
- LLJoint* torso_joint = gAgentHACK.mAvatarObject->mTorsop;
- LLJoint* chest_joint = gAgentHACK.mAvatarObject->mChestp;
+ LLJoint* torso_joint = gAgent.mAvatarObject->mTorsop;
+ LLJoint* chest_joint = gAgent.mAvatarObject->mChestp;
LLVector3 torso_scale = torso_joint->getScale();
LLVector3 chest_scale = chest_joint->getScale();
// shorten avatar skeleton to avoid foot interpenetration
- if (!gAgentHACK.mAvatarObject->mInAir)
+ if (!gAgent.mAvatarObject->mInAir)
{
LLVector3 chest_offset = LLVector3(0.f, 0.f, chest_joint->getPosition().mV[VZ]) * torso_joint->getWorldRotation();
F32 z_compensate = llclamp(-diff.mV[VZ], -0.2f, 1.f);
F32 scale_factor = llclamp(1.f - ((z_compensate * 0.5f) / chest_offset.mV[VZ]), 0.5f, 1.2f);
torso_joint->setScale(LLVector3(1.f, 1.f, scale_factor));
- LLJoint* neck_joint = gAgentHACK.mAvatarObject->mNeckp;
+ LLJoint* neck_joint = gAgent.mAvatarObject->mNeckp;
LLVector3 neck_offset = LLVector3(0.f, 0.f, neck_joint->getPosition().mV[VZ]) * chest_joint->getWorldRotation();
scale_factor = llclamp(1.f - ((z_compensate * 0.5f) / neck_offset.mV[VZ]), 0.5f, 1.2f);
chest_joint->setScale(LLVector3(1.f, 1.f, scale_factor));
diff.mV[VZ] = 0.f;
}
- gAgentHACK.mAvatarObject->mPelvisp->setPosition(gAgentHACK.mAvatarObject->mPelvisp->getPosition() + diff);
+ gAgent.mAvatarObject->mPelvisp->setPosition(gAgent.mAvatarObject->mPelvisp->getPosition() + diff);
- gAgentHACK.mAvatarObject->mRoot.updateWorldMatrixChildren();
+ gAgent.mAvatarObject->mRoot.updateWorldMatrixChildren();
- for (LLVOAvatar::attachment_map_t::iterator iter = gAgentHACK.mAvatarObject->mAttachmentPoints.begin();
- iter != gAgentHACK.mAvatarObject->mAttachmentPoints.end(); )
+ for (LLVOAvatar::attachment_map_t::iterator iter = gAgent.mAvatarObject->mAttachmentPoints.begin();
+ iter != gAgent.mAvatarObject->mAttachmentPoints.end(); )
{
LLVOAvatar::attachment_map_t::iterator curiter = iter++;
LLViewerJointAttachment* attachment = curiter->second;
@@ -1557,7 +1517,7 @@ void LLAgentCamera::updateFocusOffset()
validateFocusObject();
if (mFocusObject.notNull())
{
- LLVector3d obj_pos = gAgentHACK.getPosGlobalFromAgent(mFocusObject->getRenderPosition());
+ LLVector3d obj_pos = gAgent.getPosGlobalFromAgent(mFocusObject->getRenderPosition());
mFocusObjectOffset.setVec(mFocusTargetGlobal - obj_pos);
}
}
@@ -1624,13 +1584,13 @@ LLVector3d LLAgentCamera::calcFocusPositionTargetGlobal()
else if (mCameraMode == CAMERA_MODE_MOUSELOOK)
{
LLVector3d at_axis(1.0, 0.0, 0.0);
- LLQuaternion agent_rot = gAgentHACK.mFrameAgent.getQuaternion();
- if (gAgentHACK.mAvatarObject.notNull() && gAgentHACK.mAvatarObject->getParent())
+ LLQuaternion agent_rot = gAgent.mFrameAgent.getQuaternion();
+ if (gAgent.mAvatarObject.notNull() && gAgent.mAvatarObject->getParent())
{
- LLViewerObject* root_object = (LLViewerObject*)gAgentHACK.mAvatarObject->getRoot();
+ LLViewerObject* root_object = (LLViewerObject*)gAgent.mAvatarObject->getRoot();
if (!root_object->flagCameraDecoupled())
{
- agent_rot *= ((LLViewerObject*)(gAgentHACK.mAvatarObject->getParent()))->getRenderRotation();
+ agent_rot *= ((LLViewerObject*)(gAgent.mAvatarObject->getParent()))->getRenderRotation();
}
}
at_axis = at_axis * agent_rot;
@@ -1676,22 +1636,22 @@ LLVector3d LLAgentCamera::calcFocusPositionTargetGlobal()
updateFocusOffset();
}
LLVector3 focus_agent = mFocusObject->getRenderPosition() + mFocusObjectOffset;
- mFocusTargetGlobal.setVec(gAgentHACK.getPosGlobalFromAgent(focus_agent));
+ mFocusTargetGlobal.setVec(gAgent.getPosGlobalFromAgent(focus_agent));
}
return mFocusTargetGlobal;
}
- else if (mSitCameraEnabled && gAgentHACK.mAvatarObject.notNull() && gAgentHACK.mAvatarObject->isSitting() && mSitCameraReferenceObject.notNull())
+ else if (mSitCameraEnabled && gAgent.mAvatarObject.notNull() && gAgent.mAvatarObject->isSitting() && mSitCameraReferenceObject.notNull())
{
// sit camera
LLVector3 object_pos = mSitCameraReferenceObject->getRenderPosition();
LLQuaternion object_rot = mSitCameraReferenceObject->getRenderRotation();
LLVector3 target_pos = object_pos + (mSitCameraFocus * object_rot);
- return gAgentHACK.getPosGlobalFromAgent(target_pos);
+ return gAgent.getPosGlobalFromAgent(target_pos);
}
else
{
- return gAgentHACK.getPositionGlobal() + calcThirdPersonFocusOffset();
+ return gAgent.getPositionGlobal() + calcThirdPersonFocusOffset();
}
}
@@ -1700,10 +1660,10 @@ LLVector3d LLAgentCamera::calcThirdPersonFocusOffset()
// ...offset from avatar
LLVector3d focus_offset;
- LLQuaternion agent_rot = gAgentHACK.mFrameAgent.getQuaternion();
- if (!gAgentHACK.mAvatarObject.isNull() && gAgentHACK.mAvatarObject->getParent())
+ LLQuaternion agent_rot = gAgent.mFrameAgent.getQuaternion();
+ if (!gAgent.mAvatarObject.isNull() && gAgent.mAvatarObject->getParent())
{
- agent_rot *= ((LLViewerObject*)(gAgentHACK.mAvatarObject->getParent()))->getRenderRotation();
+ agent_rot *= ((LLViewerObject*)(gAgent.mAvatarObject->getParent()))->getRenderRotation();
}
focus_offset = mFocusOffsetInitial[mCameraPreset] * agent_rot;
@@ -1713,14 +1673,14 @@ LLVector3d LLAgentCamera::calcThirdPersonFocusOffset()
void LLAgentCamera::setupSitCamera()
{
// agent frame entering this function is in world coordinates
- if (gAgentHACK.mAvatarObject.notNull() && gAgentHACK.mAvatarObject->getParent())
+ if (gAgent.mAvatarObject.notNull() && gAgent.mAvatarObject->getParent())
{
- LLQuaternion parent_rot = ((LLViewerObject*)gAgentHACK.mAvatarObject->getParent())->getRenderRotation();
+ LLQuaternion parent_rot = ((LLViewerObject*)gAgent.mAvatarObject->getParent())->getRenderRotation();
// slam agent coordinate frame to proper parent local version
- LLVector3 at_axis = gAgentHACK.mFrameAgent.getAtAxis();
+ LLVector3 at_axis = gAgent.mFrameAgent.getAtAxis();
at_axis.mV[VZ] = 0.f;
at_axis.normalize();
- gAgentHACK.resetAxes(at_axis * ~parent_rot);
+ gAgent.resetAxes(at_axis * ~parent_rot);
}
}
@@ -1737,7 +1697,7 @@ const LLVector3 &LLAgentCamera::getCameraPositionAgent() const
//-----------------------------------------------------------------------------
LLVector3d LLAgentCamera::getCameraPositionGlobal() const
{
- return gAgentHACK.getPosGlobalFromAgent(LLViewerCamera::getInstance()->getOrigin());
+ return gAgent.getPosGlobalFromAgent(LLViewerCamera::getInstance()->getOrigin());
}
//-----------------------------------------------------------------------------
@@ -1780,8 +1740,8 @@ LLVector3d LLAgentCamera::calcCameraPositionTargetGlobal(BOOL *hit_limit)
{
// Compute base camera position and look-at points.
F32 camera_land_height;
- LLVector3d frame_center_global = gAgentHACK.mAvatarObject.isNull() ? gAgentHACK.getPositionGlobal()
- : gAgentHACK.getPosGlobalFromAgent(gAgentHACK.mAvatarObject->mRoot.getWorldPosition());
+ LLVector3d frame_center_global = gAgent.mAvatarObject.isNull() ? gAgent.getPositionGlobal()
+ : gAgent.getPosGlobalFromAgent(gAgent.mAvatarObject->mRoot.getWorldPosition());
BOOL isConstrained = FALSE;
LLVector3d head_offset;
@@ -1796,32 +1756,32 @@ LLVector3d LLAgentCamera::calcCameraPositionTargetGlobal(BOOL *hit_limit)
}// End Ventrella
else if (mCameraMode == CAMERA_MODE_MOUSELOOK)
{
- if (gAgentHACK.mAvatarObject.isNull() || gAgentHACK.mAvatarObject->mDrawable.isNull())
+ if (gAgent.mAvatarObject.isNull() || gAgent.mAvatarObject->mDrawable.isNull())
{
llwarns << "Null avatar drawable!" << llendl;
return LLVector3d::zero;
}
head_offset.clearVec();
- if (gAgentHACK.mAvatarObject->isSitting() && gAgentHACK.mAvatarObject->getParent())
+ if (gAgent.mAvatarObject->isSitting() && gAgent.mAvatarObject->getParent())
{
- gAgentHACK.mAvatarObject->updateHeadOffset();
- head_offset.mdV[VX] = gAgentHACK.mAvatarObject->mHeadOffset.mV[VX];
- head_offset.mdV[VY] = gAgentHACK.mAvatarObject->mHeadOffset.mV[VY];
- head_offset.mdV[VZ] = gAgentHACK.mAvatarObject->mHeadOffset.mV[VZ] + 0.1f;
- const LLMatrix4& mat = ((LLViewerObject*) gAgentHACK.mAvatarObject->getParent())->getRenderMatrix();
- camera_position_global = gAgentHACK.getPosGlobalFromAgent
- ((gAgentHACK.mAvatarObject->getPosition()+
- LLVector3(head_offset)*gAgentHACK.mAvatarObject->getRotation()) * mat);
+ gAgent.mAvatarObject->updateHeadOffset();
+ head_offset.mdV[VX] = gAgent.mAvatarObject->mHeadOffset.mV[VX];
+ head_offset.mdV[VY] = gAgent.mAvatarObject->mHeadOffset.mV[VY];
+ head_offset.mdV[VZ] = gAgent.mAvatarObject->mHeadOffset.mV[VZ] + 0.1f;
+ const LLMatrix4& mat = ((LLViewerObject*) gAgent.mAvatarObject->getParent())->getRenderMatrix();
+ camera_position_global = gAgent.getPosGlobalFromAgent
+ ((gAgent.mAvatarObject->getPosition()+
+ LLVector3(head_offset)*gAgent.mAvatarObject->getRotation()) * mat);
}
else
{
- head_offset.mdV[VZ] = gAgentHACK.mAvatarObject->mHeadOffset.mV[VZ];
- if (gAgentHACK.mAvatarObject->isSitting())
+ head_offset.mdV[VZ] = gAgent.mAvatarObject->mHeadOffset.mV[VZ];
+ if (gAgent.mAvatarObject->isSitting())
{
head_offset.mdV[VZ] += 0.1;
}
- camera_position_global = gAgentHACK.getPosGlobalFromAgent(gAgentHACK.mAvatarObject->getRenderPosition());//frame_center_global;
- head_offset = head_offset * gAgentHACK.mAvatarObject->getRenderRotation();
+ camera_position_global = gAgent.getPosGlobalFromAgent(gAgent.mAvatarObject->getRenderPosition());//frame_center_global;
+ head_offset = head_offset * gAgent.mAvatarObject->getRenderRotation();
camera_position_global = camera_position_global + head_offset;
}
}
@@ -1831,8 +1791,8 @@ LLVector3d LLAgentCamera::calcCameraPositionTargetGlobal(BOOL *hit_limit)
F32 camera_distance = 0.f;
if (mSitCameraEnabled
- && gAgentHACK.mAvatarObject.notNull()
- && gAgentHACK.mAvatarObject->isSitting()
+ && gAgent.mAvatarObject.notNull()
+ && gAgent.mAvatarObject->isSitting()
&& mSitCameraReferenceObject.notNull())
{
// sit camera
@@ -1841,30 +1801,30 @@ LLVector3d LLAgentCamera::calcCameraPositionTargetGlobal(BOOL *hit_limit)
LLVector3 target_pos = object_pos + (mSitCameraPos * object_rot);
- camera_position_global = gAgentHACK.getPosGlobalFromAgent(target_pos);
+ camera_position_global = gAgent.getPosGlobalFromAgent(target_pos);
}
else
{
local_camera_offset = mCameraZoomFraction * getCameraOffsetInitial() * gSavedSettings.getF32("CameraOffsetScale");
// are we sitting down?
- if (gAgentHACK.mAvatarObject.notNull() && gAgentHACK.mAvatarObject->getParent())
+ if (gAgent.mAvatarObject.notNull() && gAgent.mAvatarObject->getParent())
{
- LLQuaternion parent_rot = ((LLViewerObject*)gAgentHACK.mAvatarObject->getParent())->getRenderRotation();
+ LLQuaternion parent_rot = ((LLViewerObject*)gAgent.mAvatarObject->getParent())->getRenderRotation();
// slam agent coordinate frame to proper parent local version
- LLVector3 at_axis = gAgentHACK.mFrameAgent.getAtAxis() * parent_rot;
+ LLVector3 at_axis = gAgent.mFrameAgent.getAtAxis() * parent_rot;
at_axis.mV[VZ] = 0.f;
at_axis.normalize();
- gAgentHACK.resetAxes(at_axis * ~parent_rot);
+ gAgent.resetAxes(at_axis * ~parent_rot);
- local_camera_offset = local_camera_offset * gAgentHACK.mFrameAgent.getQuaternion() * parent_rot;
+ local_camera_offset = local_camera_offset * gAgent.mFrameAgent.getQuaternion() * parent_rot;
}
else
{
- local_camera_offset = gAgentHACK.mFrameAgent.rotateToAbsolute( local_camera_offset );
+ local_camera_offset = gAgent.mFrameAgent.rotateToAbsolute( local_camera_offset );
}
- if (!mCameraCollidePlane.isExactlyZero() && (gAgentHACK.mAvatarObject.isNull() || !gAgentHACK.mAvatarObject->isSitting()))
+ if (!mCameraCollidePlane.isExactlyZero() && (gAgent.mAvatarObject.isNull() || !gAgent.mAvatarObject->isSitting()))
{
LLVector3 plane_normal;
plane_normal.setVec(mCameraCollidePlane.mV);
@@ -1877,7 +1837,7 @@ LLVector3d LLAgentCamera::calcCameraPositionTargetGlobal(BOOL *hit_limit)
camera_distance = local_camera_offset.normalize();
- F32 pos_dot_norm = gAgentHACK.getPosAgentFromGlobal(frame_center_global + head_offset) * plane_normal;
+ F32 pos_dot_norm = gAgent.getPosAgentFromGlobal(frame_center_global + head_offset) * plane_normal;
// if agent is outside the colliding half-plane
if (pos_dot_norm > mCameraCollidePlane.mV[VW])
@@ -1917,23 +1877,23 @@ LLVector3d LLAgentCamera::calcCameraPositionTargetGlobal(BOOL *hit_limit)
// set the global camera position
LLVector3d camera_offset;
- LLVector3 av_pos = gAgentHACK.mAvatarObject.isNull() ? LLVector3::zero : gAgentHACK.mAvatarObject->getRenderPosition();
+ LLVector3 av_pos = gAgent.mAvatarObject.isNull() ? LLVector3::zero : gAgent.mAvatarObject->getRenderPosition();
camera_offset.setVec( local_camera_offset );
camera_position_global = frame_center_global + head_offset + camera_offset;
- if (gAgentHACK.mAvatarObject.notNull())
+ if (gAgent.mAvatarObject.notNull())
{
LLVector3d camera_lag_d;
F32 lag_interp = LLCriticalDamp::getInterpolant(CAMERA_LAG_HALF_LIFE);
LLVector3 target_lag;
- LLVector3 vel = gAgentHACK.getVelocity();
+ LLVector3 vel = gAgent.getVelocity();
// lag by appropriate amount for flying
- F32 time_in_air = gAgentHACK.mAvatarObject->mTimeInAir.getElapsedTimeF32();
- if(!mCameraAnimating && gAgentHACK.mAvatarObject->mInAir && time_in_air > GROUND_TO_AIR_CAMERA_TRANSITION_START_TIME)
+ F32 time_in_air = gAgent.mAvatarObject->mTimeInAir.getElapsedTimeF32();
+ if(!mCameraAnimating && gAgent.mAvatarObject->mInAir && time_in_air > GROUND_TO_AIR_CAMERA_TRANSITION_START_TIME)
{
- LLVector3 frame_at_axis = gAgentHACK.mFrameAgent.getAtAxis();
- frame_at_axis -= projected_vec(frame_at_axis, gAgentHACK.getReferenceUpVector());
+ LLVector3 frame_at_axis = gAgent.mFrameAgent.getAtAxis();
+ frame_at_axis -= projected_vec(frame_at_axis, gAgent.getReferenceUpVector());
frame_at_axis.normalize();
//transition smoothly in air mode, to avoid camera pop
@@ -1942,7 +1902,7 @@ LLVector3d LLAgentCamera::calcCameraPositionTargetGlobal(BOOL *hit_limit)
lag_interp *= u;
- if (gViewerWindow->getLeftMouseDown() && gViewerWindow->getLastPick().mObjectID == gAgentHACK.mAvatarObject->getID())
+ if (gViewerWindow->getLeftMouseDown() && gViewerWindow->getLastPick().mObjectID == gAgent.mAvatarObject->getID())
{
// disable camera lag when using mouse-directed steering
target_lag.clearVec();
@@ -2127,7 +2087,7 @@ F32 LLAgentCamera::getCameraMinOffGround()
void LLAgentCamera::resetCamera()
{
// Remove any pitch from the avatar
- LLVector3 at = gAgentHACK.mFrameAgent.getAtAxis();
+ LLVector3 at = gAgent.mFrameAgent.getAtAxis();
at.mV[VZ] = 0.f;
at.normalize();
gAgent.resetAxes(at);
@@ -2151,14 +2111,14 @@ void LLAgentCamera::changeCameraToMouselook(BOOL animate)
gViewerWindow->getWindow()->resetBusyCount();
// unpause avatar animation
- gAgentHACK.mPauseRequest = NULL;
+ gAgent.mPauseRequest = NULL;
LLToolMgr::getInstance()->setCurrentToolset(gMouselookToolset);
- if (gAgentHACK.mAvatarObject.notNull())
+ if (gAgent.mAvatarObject.notNull())
{
- gAgentHACK.mAvatarObject->stopMotion( ANIM_AGENT_BODY_NOISE );
- gAgentHACK.mAvatarObject->stopMotion( ANIM_AGENT_BREATHE_ROT );
+ gAgent.mAvatarObject->stopMotion( ANIM_AGENT_BODY_NOISE );
+ gAgent.mAvatarObject->stopMotion( ANIM_AGENT_BREATHE_ROT );
}
//gViewerWindow->stopGrab();
@@ -2172,11 +2132,11 @@ void LLAgentCamera::changeCameraToMouselook(BOOL animate)
mLastCameraMode = mCameraMode;
mCameraMode = CAMERA_MODE_MOUSELOOK;
- U32 old_flags = gAgentHACK.mControlFlags;
- gAgentHACK.setControlFlags(AGENT_CONTROL_MOUSELOOK);
- if (old_flags != gAgentHACK.mControlFlags)
+ U32 old_flags = gAgent.mControlFlags;
+ gAgent.setControlFlags(AGENT_CONTROL_MOUSELOOK);
+ if (old_flags != gAgent.mControlFlags)
{
- gAgentHACK.mbFlagsDirty = TRUE;
+ gAgent.mbFlagsDirty = TRUE;
}
if (animate)
@@ -2186,7 +2146,7 @@ void LLAgentCamera::changeCameraToMouselook(BOOL animate)
else
{
mCameraAnimating = FALSE;
- gAgentHACK.endAnimationUpdateUI();
+ gAgent.endAnimationUpdateUI();
}
}
}
@@ -2243,21 +2203,21 @@ void LLAgentCamera::changeCameraToFollow(BOOL animate)
LLToolMgr::getInstance()->setCurrentToolset(gBasicToolset);
}
- if (gAgentHACK.mAvatarObject.notNull())
+ if (gAgent.mAvatarObject.notNull())
{
- gAgentHACK.mAvatarObject->mPelvisp->setPosition(LLVector3::zero);
- gAgentHACK.mAvatarObject->startMotion( ANIM_AGENT_BODY_NOISE );
- gAgentHACK.mAvatarObject->startMotion( ANIM_AGENT_BREATHE_ROT );
+ gAgent.mAvatarObject->mPelvisp->setPosition(LLVector3::zero);
+ gAgent.mAvatarObject->startMotion( ANIM_AGENT_BODY_NOISE );
+ gAgent.mAvatarObject->startMotion( ANIM_AGENT_BREATHE_ROT );
}
// unpause avatar animation
- gAgentHACK.mPauseRequest = NULL;
+ gAgent.mPauseRequest = NULL;
- U32 old_flags = gAgentHACK.mControlFlags;
- gAgentHACK.clearControlFlags(AGENT_CONTROL_MOUSELOOK);
- if (old_flags != gAgentHACK.mControlFlags)
+ U32 old_flags = gAgent.mControlFlags;
+ gAgent.clearControlFlags(AGENT_CONTROL_MOUSELOOK);
+ if (old_flags != gAgent.mControlFlags)
{
- gAgentHACK.mbFlagsDirty = TRUE;
+ gAgent.mbFlagsDirty = TRUE;
}
if (animate)
@@ -2267,7 +2227,7 @@ void LLAgentCamera::changeCameraToFollow(BOOL animate)
else
{
mCameraAnimating = FALSE;
- gAgentHACK.endAnimationUpdateUI();
+ gAgent.endAnimationUpdateUI();
}
}
}
@@ -2286,20 +2246,20 @@ void LLAgentCamera::changeCameraToThirdPerson(BOOL animate)
mCameraZoomFraction = INITIAL_ZOOM_FRACTION;
- if (gAgentHACK.mAvatarObject.notNull())
+ if (gAgent.mAvatarObject.notNull())
{
- if (!gAgentHACK.mAvatarObject->isSitting())
+ if (!gAgent.mAvatarObject->isSitting())
{
- gAgentHACK.mAvatarObject->mPelvisp->setPosition(LLVector3::zero);
+ gAgent.mAvatarObject->mPelvisp->setPosition(LLVector3::zero);
}
- gAgentHACK.mAvatarObject->startMotion( ANIM_AGENT_BODY_NOISE );
- gAgentHACK.mAvatarObject->startMotion( ANIM_AGENT_BREATHE_ROT );
+ gAgent.mAvatarObject->startMotion( ANIM_AGENT_BODY_NOISE );
+ gAgent.mAvatarObject->startMotion( ANIM_AGENT_BREATHE_ROT );
}
LLVector3 at_axis;
// unpause avatar animation
- gAgentHACK.mPauseRequest = NULL;
+ gAgent.mPauseRequest = NULL;
if( mCameraMode != CAMERA_MODE_THIRD_PERSON )
{
@@ -2317,30 +2277,30 @@ void LLAgentCamera::changeCameraToThirdPerson(BOOL animate)
}
mLastCameraMode = mCameraMode;
mCameraMode = CAMERA_MODE_THIRD_PERSON;
- U32 old_flags = gAgentHACK.mControlFlags;
- gAgentHACK.clearControlFlags(AGENT_CONTROL_MOUSELOOK);
- if (old_flags != gAgentHACK.mControlFlags)
+ U32 old_flags = gAgent.mControlFlags;
+ gAgent.clearControlFlags(AGENT_CONTROL_MOUSELOOK);
+ if (old_flags != gAgent.mControlFlags)
{
- gAgentHACK.mbFlagsDirty = TRUE;
+ gAgent.mbFlagsDirty = TRUE;
}
}
// Remove any pitch from the avatar
- if (gAgentHACK.mAvatarObject.notNull() && gAgentHACK.mAvatarObject->getParent())
+ if (gAgent.mAvatarObject.notNull() && gAgent.mAvatarObject->getParent())
{
- LLQuaternion obj_rot = ((LLViewerObject*)gAgentHACK.mAvatarObject->getParent())->getRenderRotation();
+ LLQuaternion obj_rot = ((LLViewerObject*)gAgent.mAvatarObject->getParent())->getRenderRotation();
at_axis = LLViewerCamera::getInstance()->getAtAxis();
at_axis.mV[VZ] = 0.f;
at_axis.normalize();
- gAgentHACK.resetAxes(at_axis * ~obj_rot);
+ gAgent.resetAxes(at_axis * ~obj_rot);
}
else
{
- at_axis = gAgentHACK.mFrameAgent.getAtAxis();
+ at_axis = gAgent.mFrameAgent.getAtAxis();
at_axis.mV[VZ] = 0.f;
at_axis.normalize();
- gAgentHACK.resetAxes(at_axis);
+ gAgent.resetAxes(at_axis);
}
@@ -2351,7 +2311,7 @@ void LLAgentCamera::changeCameraToThirdPerson(BOOL animate)
else
{
mCameraAnimating = FALSE;
- gAgentHACK.endAnimationUpdateUI();
+ gAgent.endAnimationUpdateUI();
}
}
@@ -2365,7 +2325,7 @@ void LLAgentCamera::changeCameraToCustomizeAvatar(BOOL avatar_animate, BOOL came
return;
}
- gAgentHACK.standUp(); // force stand up
+ gAgent.standUp(); // force stand up
gViewerWindow->getWindow()->resetBusyCount();
if (gFaceEditToolset)
@@ -2379,7 +2339,7 @@ void LLAgentCamera::changeCameraToCustomizeAvatar(BOOL avatar_animate, BOOL came
}
// Remove any pitch from the avatar
- //LLVector3 at = gAgentHACK.mFrameAgent.getAtAxis();
+ //LLVector3 at = gAgent.mFrameAgent.getAtAxis();
//at.mV[VZ] = 0.f;
//at.normalize();
//gAgent.resetAxes(at);
@@ -2388,11 +2348,11 @@ void LLAgentCamera::changeCameraToCustomizeAvatar(BOOL avatar_animate, BOOL came
{
mLastCameraMode = mCameraMode;
mCameraMode = CAMERA_MODE_CUSTOMIZE_AVATAR;
- U32 old_flags = gAgentHACK.mControlFlags;
- gAgentHACK.clearControlFlags(AGENT_CONTROL_MOUSELOOK);
- if (old_flags != gAgentHACK.mControlFlags)
+ U32 old_flags = gAgent.mControlFlags;
+ gAgent.clearControlFlags(AGENT_CONTROL_MOUSELOOK);
+ if (old_flags != gAgent.mControlFlags)
{
- gAgentHACK.mbFlagsDirty = TRUE;
+ gAgent.mbFlagsDirty = TRUE;
}
gFocusMgr.setKeyboardFocus( NULL );
@@ -2401,20 +2361,20 @@ void LLAgentCamera::changeCameraToCustomizeAvatar(BOOL avatar_animate, BOOL came
LLVOAvatarSelf::onCustomizeStart();
}
- if (gAgentHACK.mAvatarObject.notNull())
+ if (gAgent.mAvatarObject.notNull())
{
if(avatar_animate)
{
// Remove any pitch from the avatar
- LLVector3 at = gAgentHACK.mFrameAgent.getAtAxis();
+ LLVector3 at = gAgent.mFrameAgent.getAtAxis();
at.mV[VZ] = 0.f;
at.normalize();
gAgent.resetAxes(at);
- gAgentHACK.sendAnimationRequest(ANIM_AGENT_CUSTOMIZE, ANIM_REQUEST_START);
- gAgentHACK.mCustomAnim = TRUE;
- gAgentHACK.mAvatarObject->startMotion(ANIM_AGENT_CUSTOMIZE);
- LLMotion* turn_motion = gAgentHACK.mAvatarObject->findMotion(ANIM_AGENT_CUSTOMIZE);
+ gAgent.sendAnimationRequest(ANIM_AGENT_CUSTOMIZE, ANIM_REQUEST_START);
+ gAgent.mCustomAnim = TRUE;
+ gAgent.mAvatarObject->startMotion(ANIM_AGENT_CUSTOMIZE);
+ LLMotion* turn_motion = gAgent.mAvatarObject->findMotion(ANIM_AGENT_CUSTOMIZE);
if (turn_motion)
{
@@ -2434,7 +2394,7 @@ void LLAgentCamera::changeCameraToCustomizeAvatar(BOOL avatar_animate, BOOL came
else
{
mCameraAnimating = FALSE;
- gAgentHACK.endAnimationUpdateUI();
+ gAgent.endAnimationUpdateUI();
}
}
@@ -2527,13 +2487,13 @@ void LLAgentCamera::setFocusGlobal(const LLVector3d& focus, const LLUUID &object
{
if (focus.isExactlyZero())
{
- if (gAgentHACK.mAvatarObject.notNull())
+ if (gAgent.mAvatarObject.notNull())
{
- mFocusTargetGlobal = gAgentHACK.getPosGlobalFromAgent(gAgentHACK.mAvatarObject->mHeadp->getWorldPosition());
+ mFocusTargetGlobal = gAgent.getPosGlobalFromAgent(gAgent.mAvatarObject->mHeadp->getWorldPosition());
}
else
{
- mFocusTargetGlobal = gAgentHACK.getPositionGlobal();
+ mFocusTargetGlobal = gAgent.getPositionGlobal();
}
mCameraFocusOffsetTarget = getCameraPositionGlobal() - mFocusTargetGlobal;
mCameraFocusOffset = mCameraFocusOffsetTarget;
@@ -2559,12 +2519,12 @@ void LLAgentCamera::setFocusGlobal(const LLVector3d& focus, const LLUUID &object
}
else
{
- setLookAt(LOOKAT_TARGET_FOCUS, focus_obj, (gAgentHACK.getPosAgentFromGlobal(focus) - focus_obj->getRenderPosition()) * ~focus_obj->getRenderRotation());
+ setLookAt(LOOKAT_TARGET_FOCUS, focus_obj, (gAgent.getPosAgentFromGlobal(focus) - focus_obj->getRenderPosition()) * ~focus_obj->getRenderRotation());
}
}
else
{
- setLookAt(LOOKAT_TARGET_FOCUS, NULL, gAgentHACK.getPosAgentFromGlobal(mFocusTargetGlobal));
+ setLookAt(LOOKAT_TARGET_FOCUS, NULL, gAgent.getPosAgentFromGlobal(mFocusTargetGlobal));
}
}
}
@@ -2572,13 +2532,13 @@ void LLAgentCamera::setFocusGlobal(const LLVector3d& focus, const LLUUID &object
{
if (focus.isExactlyZero())
{
- if (gAgentHACK.mAvatarObject.notNull())
+ if (gAgent.mAvatarObject.notNull())
{
- mFocusTargetGlobal = gAgentHACK.getPosGlobalFromAgent(gAgentHACK.mAvatarObject->mHeadp->getWorldPosition());
+ mFocusTargetGlobal = gAgent.getPosGlobalFromAgent(gAgent.mAvatarObject->mHeadp->getWorldPosition());
}
else
{
- mFocusTargetGlobal = gAgentHACK.getPositionGlobal();
+ mFocusTargetGlobal = gAgent.getPositionGlobal();
}
}
mCameraFocusOffsetTarget = (getCameraPositionGlobal() - mFocusTargetGlobal) / (1.f + mCameraFOVZoomFactor);;
@@ -2636,12 +2596,12 @@ void LLAgentCamera::setCameraPosAndFocusGlobal(const LLVector3d& camera_pos, con
}
else
{
- setLookAt(LOOKAT_TARGET_FOCUS, mFocusObject, (gAgentHACK.getPosAgentFromGlobal(focus) - mFocusObject->getRenderPosition()) * ~mFocusObject->getRenderRotation());
+ setLookAt(LOOKAT_TARGET_FOCUS, mFocusObject, (gAgent.getPosAgentFromGlobal(focus) - mFocusObject->getRenderPosition()) * ~mFocusObject->getRenderRotation());
}
}
else
{
- setLookAt(LOOKAT_TARGET_FOCUS, NULL, gAgentHACK.getPosAgentFromGlobal(mFocusTargetGlobal));
+ setLookAt(LOOKAT_TARGET_FOCUS, NULL, gAgent.getPosAgentFromGlobal(mFocusTargetGlobal));
}
if( mCameraAnimating )
@@ -2712,20 +2672,20 @@ void LLAgentCamera::setFocusOnAvatar(BOOL focus_on_avatar, BOOL animate)
if (mCameraMode == CAMERA_MODE_THIRD_PERSON)
{
LLVector3 at_axis;
- if (gAgentHACK.mAvatarObject.notNull() && gAgentHACK.mAvatarObject->getParent())
+ if (gAgent.mAvatarObject.notNull() && gAgent.mAvatarObject->getParent())
{
- LLQuaternion obj_rot = ((LLViewerObject*)gAgentHACK.mAvatarObject->getParent())->getRenderRotation();
+ LLQuaternion obj_rot = ((LLViewerObject*)gAgent.mAvatarObject->getParent())->getRenderRotation();
at_axis = LLViewerCamera::getInstance()->getAtAxis();
at_axis.mV[VZ] = 0.f;
at_axis.normalize();
- gAgentHACK.resetAxes(at_axis * ~obj_rot);
+ gAgent.resetAxes(at_axis * ~obj_rot);
}
else
{
at_axis = LLViewerCamera::getInstance()->getAtAxis();
at_axis.mV[VZ] = 0.f;
at_axis.normalize();
- gAgentHACK.resetAxes(at_axis);
+ gAgent.resetAxes(at_axis);
}
}
}
@@ -2733,7 +2693,7 @@ void LLAgentCamera::setFocusOnAvatar(BOOL focus_on_avatar, BOOL animate)
else if (mFocusOnAvatar && !focus_on_avatar)
{
// keep camera focus point consistent, even though it is now unlocked
- setFocusGlobal(gAgentHACK.getPositionGlobal() + calcThirdPersonFocusOffset(), gAgent.getID());
+ setFocusGlobal(gAgent.getPositionGlobal() + calcThirdPersonFocusOffset(), gAgent.getID());
}
mFocusOnAvatar = focus_on_avatar;
@@ -2747,10 +2707,10 @@ BOOL LLAgentCamera::setLookAt(ELookAtType target_type, LLViewerObject *object, L
LLViewerObject* parent = object;
while(parent)
{
- if (parent == gAgentHACK.mAvatarObject)
+ if (parent == gAgent.mAvatarObject)
{
// looking at an attachment on ourselves, which we don't want to do
- object = gAgentHACK.mAvatarObject;
+ object = gAgent.mAvatarObject;
position.clearVec();
}
parent = (LLViewerObject*)parent->getParent();
@@ -2759,7 +2719,7 @@ BOOL LLAgentCamera::setLookAt(ELookAtType target_type, LLViewerObject *object, L
if(!mLookAt || mLookAt->isDead())
{
mLookAt = (LLHUDEffectLookAt *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_LOOKAT);
- mLookAt->setSourceObject(gAgentHACK.mAvatarObject);
+ mLookAt->setSourceObject(gAgent.mAvatarObject);
}
return mLookAt->setLookAt(target_type, object, position);
@@ -2776,7 +2736,7 @@ BOOL LLAgentCamera::setPointAt(EPointAtType target_type, LLViewerObject *object,
if(!mPointAt || mPointAt->isDead())
{
mPointAt = (LLHUDEffectPointAt *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_POINTAT);
- mPointAt->setSourceObject(gAgentHACK.mAvatarObject);
+ mPointAt->setSourceObject(gAgent.mAvatarObject);
}
return mPointAt->setPointAt(target_type, object, position);
diff --git a/indra/newview/llagentcamera.h b/indra/newview/llagentcamera.h
index 6a0e8d372eafd645e1d2264ee96f6afcb3b0d152..0b55b917d01f48d03d2c0d7cfe6d0c993f5e3353 100644
--- a/indra/newview/llagentcamera.h
+++ b/indra/newview/llagentcamera.h
@@ -99,10 +99,6 @@ class LLAgentCamera
** INITIALIZATION
**/
- // SERAPH UNFILED
-public:
- F32 mDrawDistance;
-
//--------------------------------------------------------------------
// Constructors / Destructors
//--------------------------------------------------------------------
@@ -139,9 +135,7 @@ class LLAgentCamera
//--------------------------------------------------------------------
public:
void switchCameraPreset(ECameraPreset preset);
-
private:
-
/** Determines default camera offset depending on the current camera preset */
LLVector3 getCameraOffsetInitial();
@@ -251,7 +245,7 @@ class LLAgentCamera
void startCameraAnimation();
void stopCameraAnimation();
private:
- LLFrameTimer mAnimationTimer; // Seconds that transition animation has been active // SERAPH agentCamera
+ LLFrameTimer mAnimationTimer; // Seconds that transition animation has been active
F32 mAnimationDuration; // In seconds
BOOL mCameraAnimating; // Camera is transitioning from one mode to another
LLVector3d mAnimationCameraStartGlobal; // Camera start position, global coords
@@ -347,6 +341,8 @@ class LLAgentCamera
void resetView(BOOL reset_camera = TRUE, BOOL change_camera = FALSE);
// Called on camera movement. Unlocks camera from the default position behind the avatar.
void unlockView();
+public:
+ F32 mDrawDistance;
//--------------------------------------------------------------------
// Mouselook
diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index aaac36d5577d3d9a79b5f744181e369678c7a5b4..80c32399ce481fc3a8c9d788948d9e67bf4f7af9 100644
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -2509,9 +2509,9 @@ void LLAppViewer::cleanupSavedSettings()
gSavedSettings.setF32("MapScale", LLWorldMapView::sMapScale );
// Some things are cached in LLAgent.
- if (gAgent.mInitialized)
+ if (gAgent.isInitialized())
{
- gSavedSettings.setF32("RenderFarClip", gAgent.mDrawDistance);
+ gSavedSettings.setF32("RenderFarClip", gAgentCamera.mDrawDistance);
}
}
diff --git a/indra/newview/lljoystickbutton.cpp b/indra/newview/lljoystickbutton.cpp
index 33f651284bbcc4b96f60148cd4dc1d1779a7a655..9e1dc3a4b0aee90174789ac1d10fc59ee9e38660 100644
--- a/indra/newview/lljoystickbutton.cpp
+++ b/indra/newview/lljoystickbutton.cpp
@@ -627,24 +627,24 @@ void LLJoystickCameraTrack::onHeldDown()
if (dx > mVertSlopNear)
{
gAgentCamera.unlockView();
- gAgent.setPanRightKey(getOrbitRate());
+ gAgentCamera.setPanRightKey(getOrbitRate());
}
else if (dx < -mVertSlopNear)
{
gAgentCamera.unlockView();
- gAgent.setPanLeftKey(getOrbitRate());
+ gAgentCamera.setPanLeftKey(getOrbitRate());
}
// over/under rotation
if (dy > mVertSlopNear)
{
gAgentCamera.unlockView();
- gAgent.setPanUpKey(getOrbitRate());
+ gAgentCamera.setPanUpKey(getOrbitRate());
}
else if (dy < -mVertSlopNear)
{
gAgentCamera.unlockView();
- gAgent.setPanDownKey(getOrbitRate());
+ gAgentCamera.setPanDownKey(getOrbitRate());
}
}
@@ -694,25 +694,25 @@ void LLJoystickCameraZoom::onHeldDown()
{
// Zoom in fast
gAgentCamera.unlockView();
- gAgent.setOrbitInKey(FAST_RATE);
+ gAgentCamera.setOrbitInKey(FAST_RATE);
}
else if (dy > mVertSlopNear)
{
// Zoom in slow
gAgentCamera.unlockView();
- gAgent.setOrbitInKey(getOrbitRate());
+ gAgentCamera.setOrbitInKey(getOrbitRate());
}
else if (dy < -mVertSlopFar)
{
// Zoom out fast
gAgentCamera.unlockView();
- gAgent.setOrbitOutKey(FAST_RATE);
+ gAgentCamera.setOrbitOutKey(FAST_RATE);
}
else if (dy < -mVertSlopNear)
{
// Zoom out slow
gAgentCamera.unlockView();
- gAgent.setOrbitOutKey(getOrbitRate());
+ gAgentCamera.setOrbitOutKey(getOrbitRate());
}
}
diff --git a/indra/newview/llstartup.cpp b/indra/newview/llstartup.cpp
index 559cd624f7f60636d641622ce360c3ca2aa834e9..c440a1b285e457ff234e9f439fe7ec1218de0d08 100644
--- a/indra/newview/llstartup.cpp
+++ b/indra/newview/llstartup.cpp
@@ -1174,7 +1174,7 @@ bool idle_startup()
// World initialization must be done after above window init
// User might have overridden far clip
- LLWorld::getInstance()->setLandFarClip( gAgent.mDrawDistance );
+ LLWorld::getInstance()->setLandFarClip(gAgentCamera.mDrawDistance);
// Before we create the first region, we need to set the agent's mOriginGlobal
// This is necessary because creating objects before this is set will result in a
diff --git a/indra/newview/llviewercamera.cpp b/indra/newview/llviewercamera.cpp
index 0051f467162f497ffebef6be9d0e38906b8f4487..aa82c216d91e5fed05c0ac4ccb8cc4aaeb8bf92a 100644
--- a/indra/newview/llviewercamera.cpp
+++ b/indra/newview/llviewercamera.cpp
@@ -37,6 +37,7 @@
// Viewer includes
#include "llagent.h"
+#include "llagentcamera.h"
#include "llviewercontrol.h"
#include "llviewerobjectlist.h"
#include "llviewerregion.h"
@@ -354,7 +355,7 @@ void LLViewerCamera::setPerspective(BOOL for_selection,
}
else
{
- z_far = gAgent.mDrawDistance;
+ z_far = gAgentCamera.mDrawDistance;
}
}
else
diff --git a/indra/newview/llviewercontrol.cpp b/indra/newview/llviewercontrol.cpp
index 5daea96123f383e678b673d805f9978d2b53c944..23349ab9161bc11c37948fda68c91b01d87e330f 100644
--- a/indra/newview/llviewercontrol.cpp
+++ b/indra/newview/llviewercontrol.cpp
@@ -41,6 +41,7 @@
// For Listeners
#include "llaudioengine.h"
#include "llagent.h"
+#include "llagentcamera.h"
#include "llconsole.h"
#include "lldrawpoolterrain.h"
#include "llflexibleobject.h"
@@ -102,7 +103,7 @@ static bool handleRenderAvatarMouselookChanged(const LLSD& newvalue)
static bool handleRenderFarClipChanged(const LLSD& newvalue)
{
F32 draw_distance = (F32) newvalue.asReal();
- gAgent.mDrawDistance = draw_distance;
+ gAgentCamera.mDrawDistance = draw_distance;
LLWorld::getInstance()->setLandFarClip(draw_distance);
return true;
}
diff --git a/indra/newview/llviewerdisplay.cpp b/indra/newview/llviewerdisplay.cpp
index 17816bc81875225b6c7a26324bb6a3953f337ea6..5a2b901bd7ad147b12eb5a0fe16726bf3b974131 100644
--- a/indra/newview/llviewerdisplay.cpp
+++ b/indra/newview/llviewerdisplay.cpp
@@ -175,7 +175,7 @@ void display_update_camera()
// Cut draw distance in half when customizing avatar,
// but on the viewer only.
- F32 final_far = gAgent.mDrawDistance;
+ F32 final_far = gAgentCamera.mDrawDistance;
if (CAMERA_MODE_CUSTOMIZE_AVATAR == gAgentCamera.getCameraMode())
{
final_far *= 0.5f;
diff --git a/indra/newview/llviewerkeyboard.cpp b/indra/newview/llviewerkeyboard.cpp
index 4034d8c57df8c9760bc66b657baa025873c147f0..cbec2c890f6075e5e488f9236329dc9a20029966 100644
--- a/indra/newview/llviewerkeyboard.cpp
+++ b/indra/newview/llviewerkeyboard.cpp
@@ -281,7 +281,7 @@ void camera_spin_around_ccw( EKeystate s )
{
if( KEYSTATE_UP == s ) return;
gAgentCamera.unlockView();
- gAgent.setOrbitLeftKey( get_orbit_rate() );
+ gAgentCamera.setOrbitLeftKey( get_orbit_rate() );
}
@@ -289,7 +289,7 @@ void camera_spin_around_cw( EKeystate s )
{
if( KEYSTATE_UP == s ) return;
gAgentCamera.unlockView();
- gAgent.setOrbitRightKey( get_orbit_rate() );
+ gAgentCamera.setOrbitRightKey( get_orbit_rate() );
}
void camera_spin_around_ccw_sitting( EKeystate s )
@@ -303,7 +303,7 @@ void camera_spin_around_ccw_sitting( EKeystate s )
else
{
//change camera but do not send keystrokes
- gAgent.setOrbitLeftKey( get_orbit_rate() );
+ gAgentCamera.setOrbitLeftKey( get_orbit_rate() );
}
}
@@ -319,7 +319,7 @@ void camera_spin_around_cw_sitting( EKeystate s )
else
{
//change camera but do not send keystrokes
- gAgent.setOrbitRightKey( get_orbit_rate() );
+ gAgentCamera.setOrbitRightKey( get_orbit_rate() );
}
}
@@ -328,7 +328,7 @@ void camera_spin_over( EKeystate s )
{
if( KEYSTATE_UP == s ) return;
gAgentCamera.unlockView();
- gAgent.setOrbitUpKey( get_orbit_rate() );
+ gAgentCamera.setOrbitUpKey( get_orbit_rate() );
}
@@ -336,7 +336,7 @@ void camera_spin_under( EKeystate s )
{
if( KEYSTATE_UP == s ) return;
gAgentCamera.unlockView();
- gAgent.setOrbitDownKey( get_orbit_rate() );
+ gAgentCamera.setOrbitDownKey( get_orbit_rate() );
}
void camera_spin_over_sitting( EKeystate s )
@@ -350,7 +350,7 @@ void camera_spin_over_sitting( EKeystate s )
else
{
//change camera but do not send keystrokes
- gAgent.setOrbitUpKey( get_orbit_rate() );
+ gAgentCamera.setOrbitUpKey( get_orbit_rate() );
}
}
@@ -366,7 +366,7 @@ void camera_spin_under_sitting( EKeystate s )
else
{
//change camera but do not send keystrokes
- gAgent.setOrbitDownKey( get_orbit_rate() );
+ gAgentCamera.setOrbitDownKey( get_orbit_rate() );
}
}
@@ -374,7 +374,7 @@ void camera_move_forward( EKeystate s )
{
if( KEYSTATE_UP == s ) return;
gAgentCamera.unlockView();
- gAgent.setOrbitInKey( get_orbit_rate() );
+ gAgentCamera.setOrbitInKey( get_orbit_rate() );
}
@@ -382,7 +382,7 @@ void camera_move_backward( EKeystate s )
{
if( KEYSTATE_UP == s ) return;
gAgentCamera.unlockView();
- gAgent.setOrbitOutKey( get_orbit_rate() );
+ gAgentCamera.setOrbitOutKey( get_orbit_rate() );
}
void camera_move_forward_sitting( EKeystate s )
@@ -394,7 +394,7 @@ void camera_move_forward_sitting( EKeystate s )
}
else
{
- gAgent.setOrbitInKey( get_orbit_rate() );
+ gAgentCamera.setOrbitInKey( get_orbit_rate() );
}
}
@@ -409,7 +409,7 @@ void camera_move_backward_sitting( EKeystate s )
}
else
{
- gAgent.setOrbitOutKey( get_orbit_rate() );
+ gAgentCamera.setOrbitOutKey( get_orbit_rate() );
}
}
@@ -417,56 +417,56 @@ void camera_pan_up( EKeystate s )
{
if( KEYSTATE_UP == s ) return;
gAgentCamera.unlockView();
- gAgent.setPanUpKey( get_orbit_rate() );
+ gAgentCamera.setPanUpKey( get_orbit_rate() );
}
void camera_pan_down( EKeystate s )
{
if( KEYSTATE_UP == s ) return;
gAgentCamera.unlockView();
- gAgent.setPanDownKey( get_orbit_rate() );
+ gAgentCamera.setPanDownKey( get_orbit_rate() );
}
void camera_pan_left( EKeystate s )
{
if( KEYSTATE_UP == s ) return;
gAgentCamera.unlockView();
- gAgent.setPanLeftKey( get_orbit_rate() );
+ gAgentCamera.setPanLeftKey( get_orbit_rate() );
}
void camera_pan_right( EKeystate s )
{
if( KEYSTATE_UP == s ) return;
gAgentCamera.unlockView();
- gAgent.setPanRightKey( get_orbit_rate() );
+ gAgentCamera.setPanRightKey( get_orbit_rate() );
}
void camera_pan_in( EKeystate s )
{
if( KEYSTATE_UP == s ) return;
gAgentCamera.unlockView();
- gAgent.setPanInKey( get_orbit_rate() );
+ gAgentCamera.setPanInKey( get_orbit_rate() );
}
void camera_pan_out( EKeystate s )
{
if( KEYSTATE_UP == s ) return;
gAgentCamera.unlockView();
- gAgent.setPanOutKey( get_orbit_rate() );
+ gAgentCamera.setPanOutKey( get_orbit_rate() );
}
void camera_move_forward_fast( EKeystate s )
{
if( KEYSTATE_UP == s ) return;
gAgentCamera.unlockView();
- gAgent.setOrbitInKey(2.5f);
+ gAgentCamera.setOrbitInKey(2.5f);
}
void camera_move_backward_fast( EKeystate s )
{
if( KEYSTATE_UP == s ) return;
gAgentCamera.unlockView();
- gAgent.setOrbitOutKey(2.5f);
+ gAgentCamera.setOrbitOutKey(2.5f);
}
@@ -474,7 +474,7 @@ void edit_avatar_spin_ccw( EKeystate s )
{
if( KEYSTATE_UP == s ) return;
gMorphView->setCameraDrivenByKeys( TRUE );
- gAgent.setOrbitLeftKey( get_orbit_rate() );
+ gAgentCamera.setOrbitLeftKey( get_orbit_rate() );
//gMorphView->orbitLeft( get_orbit_rate() );
}
@@ -483,7 +483,7 @@ void edit_avatar_spin_cw( EKeystate s )
{
if( KEYSTATE_UP == s ) return;
gMorphView->setCameraDrivenByKeys( TRUE );
- gAgent.setOrbitRightKey( get_orbit_rate() );
+ gAgentCamera.setOrbitRightKey( get_orbit_rate() );
//gMorphView->orbitRight( get_orbit_rate() );
}
@@ -491,7 +491,7 @@ void edit_avatar_spin_over( EKeystate s )
{
if( KEYSTATE_UP == s ) return;
gMorphView->setCameraDrivenByKeys( TRUE );
- gAgent.setOrbitUpKey( get_orbit_rate() );
+ gAgentCamera.setOrbitUpKey( get_orbit_rate() );
//gMorphView->orbitUp( get_orbit_rate() );
}
@@ -500,7 +500,7 @@ void edit_avatar_spin_under( EKeystate s )
{
if( KEYSTATE_UP == s ) return;
gMorphView->setCameraDrivenByKeys( TRUE );
- gAgent.setOrbitDownKey( get_orbit_rate() );
+ gAgentCamera.setOrbitDownKey( get_orbit_rate() );
//gMorphView->orbitDown( get_orbit_rate() );
}
@@ -508,7 +508,7 @@ void edit_avatar_move_forward( EKeystate s )
{
if( KEYSTATE_UP == s ) return;
gMorphView->setCameraDrivenByKeys( TRUE );
- gAgent.setOrbitInKey( get_orbit_rate() );
+ gAgentCamera.setOrbitInKey( get_orbit_rate() );
//gMorphView->orbitIn();
}
@@ -517,7 +517,7 @@ void edit_avatar_move_backward( EKeystate s )
{
if( KEYSTATE_UP == s ) return;
gMorphView->setCameraDrivenByKeys( TRUE );
- gAgent.setOrbitOutKey( get_orbit_rate() );
+ gAgentCamera.setOrbitOutKey( get_orbit_rate() );
//gMorphView->orbitOut();
}
diff --git a/indra/newview/llviewermessage.cpp b/indra/newview/llviewermessage.cpp
index ea80dee05cf11b22f6735803e7a00eec956d1366..05dffb810720aaf7599f1b4f720d6d12f42eaed6 100644
--- a/indra/newview/llviewermessage.cpp
+++ b/indra/newview/llviewermessage.cpp
@@ -3458,7 +3458,7 @@ void send_agent_update(BOOL force_send, BOOL send_reliable)
msg->addVector3Fast(_PREHASH_CameraAtAxis, LLViewerCamera::getInstance()->getAtAxis());
msg->addVector3Fast(_PREHASH_CameraLeftAxis, LLViewerCamera::getInstance()->getLeftAxis());
msg->addVector3Fast(_PREHASH_CameraUpAxis, LLViewerCamera::getInstance()->getUpAxis());
- msg->addF32Fast(_PREHASH_Far, gAgent.mDrawDistance);
+ msg->addF32Fast(_PREHASH_Far, gAgentCamera.mDrawDistance);
msg->addU32Fast(_PREHASH_ControlFlags, control_flags);
diff --git a/indra/newview/llviewerwindow.cpp b/indra/newview/llviewerwindow.cpp
index 8c6571aaf77d48ebd9d0933859a2089f697dc7a2..00c89457dedafba0f7edd44f68d50c41b36089b9 100644
--- a/indra/newview/llviewerwindow.cpp
+++ b/indra/newview/llviewerwindow.cpp
@@ -3656,7 +3656,7 @@ BOOL LLViewerWindow::mousePointOnLandGlobal(const S32 x, const S32 y, LLVector3d
LLVector3 probe_point_region;
// walk forwards to find the point
- for (mouse_dir_scale = FIRST_PASS_STEP; mouse_dir_scale < gAgent.mDrawDistance; mouse_dir_scale += FIRST_PASS_STEP)
+ for (mouse_dir_scale = FIRST_PASS_STEP; mouse_dir_scale < gAgentCamera.mDrawDistance; mouse_dir_scale += FIRST_PASS_STEP)
{
LLVector3d mouse_direction_global_d;
mouse_direction_global_d.setVec(mouse_direction_global * mouse_dir_scale);