diff options
Diffstat (limited to 'indra/newview/llagentcamera.cpp')
| -rw-r--r-- | indra/newview/llagentcamera.cpp | 551 |
1 files changed, 535 insertions, 16 deletions
diff --git a/indra/newview/llagentcamera.cpp b/indra/newview/llagentcamera.cpp index 0fe5f622e3..13878f9448 100644 --- a/indra/newview/llagentcamera.cpp +++ b/indra/newview/llagentcamera.cpp @@ -185,7 +185,9 @@ LLAgentCamera::LLAgentCamera() : mPanLeftKey(0.f), mPanRightKey(0.f), mPanInKey(0.f), - mPanOutKey(0.f) + mPanOutKey(0.f), + mRollLeftKey(0.f), + mRollRightKey(0.f) { mFollowCam.setMaxCameraDistantFromSubject( MAX_CAMERA_DISTANCE_FROM_AGENT ); @@ -195,6 +197,7 @@ LLAgentCamera::LLAgentCamera() : resetPanDiff(); resetOrbitDiff(); + resetCameraRoll(); } // Requires gSavedSettings to be initialized. @@ -331,7 +334,8 @@ void LLAgentCamera::resetView(bool reset_camera, bool change_camera) //Camera Tool is needed for Free Camera Control Mode if (!LLFloaterCamera::inFreeCameraMode()) { - LLFloaterReg::hideInstance("build"); + if (LLFloaterReg::instanceVisible("build")) + LLFloaterReg::hideInstance("build"); // Switch back to basic toolset LLToolMgr::getInstance()->setCurrentToolset(gBasicToolset); @@ -355,6 +359,8 @@ void LLAgentCamera::resetView(bool reset_camera, bool change_camera) setFocusOnAvatar(true, ANIMATE); mCameraFOVZoomFactor = 0.f; + + resetCameraRoll(); } resetPanDiff(); resetOrbitDiff(); @@ -905,6 +911,19 @@ void LLAgentCamera::cameraOrbitOver(const F32 angle) } } +//----------------------------------------------------------------------------- +// cameraRollOver() +//----------------------------------------------------------------------------- +void LLAgentCamera::cameraRollOver(const F32 angle) +{ + mRollAngle += fmod(angle, F_TWO_PI); +} + +void LLAgentCamera::resetCameraRoll() +{ + mRollAngle = 0.f; +} + void LLAgentCamera::resetCameraOrbit() { LLVector3 camera_offset_unit(mCameraFocusOffsetTarget); @@ -918,6 +937,7 @@ void LLAgentCamera::resetCameraOrbit() cameraZoomIn(1.f); resetOrbitDiff(); + resetCameraRoll(); } void LLAgentCamera::resetOrbitDiff() @@ -1282,6 +1302,7 @@ void LLAgentCamera::updateCamera() 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 + const F32 ROLL_RATE = 45.f * DEG_TO_RAD; // radians per second if (gAgentCamera.getOrbitUpKey() || gAgentCamera.getOrbitDownKey()) { @@ -1323,6 +1344,12 @@ void LLAgentCamera::updateCamera() cameraPanUp(input_rate * PAN_RATE / gFPSClamped ); } + if (getRollLeftKey() || getRollRightKey()) + { + F32 input_rate = getRollRightKey() - getRollLeftKey(); + cameraRollOver(input_rate * ROLL_RATE / gFPSClamped); + } + // Clear camera keyboard keys. gAgentCamera.clearOrbitKeys(); gAgentCamera.clearPanKeys(); @@ -1552,6 +1579,7 @@ void LLAgentCamera::updateCamera() LLVector3 chest_scale = chest_joint->getScale(); // shorten avatar skeleton to avoid foot interpenetration +#if 0 // This screws up mouselook attachments if (!gAgentAvatarp->mInAir) { LLVector3 chest_offset = LLVector3(0.f, 0.f, chest_joint->getPosition().mV[VZ]) * torso_joint->getWorldRotation(); @@ -1565,9 +1593,37 @@ void LLAgentCamera::updateCamera() chest_joint->setScale(LLVector3(1.f, 1.f, scale_factor)); diff.mV[VZ] = 0.f; } +#endif + static LLCachedControl<bool> useRealisticMouselook(gSavedSettings, "AlchemyRealisticMouselook", false); + if (useRealisticMouselook) + { + auto frame_agent = gAgent.getFrameAgent(); + LLQuaternion agent_rot(frame_agent.getQuaternion()); + auto avatarp_parent = (LLViewerObject*)gAgentAvatarp->getParent(); + if(avatarp_parent) + { + auto avatarp_root = (LLViewerObject*)gAgentAvatarp->getRoot(); + if(avatarp_root) + { + auto decoupled = avatarp_root->flagCameraDecoupled(); + if(decoupled) + { + agent_rot *= avatarp_parent->getRenderRotation(); + } - // SL-315 - gAgentAvatarp->mPelvisp->setPosition(gAgentAvatarp->mPelvisp->getPosition() + diff); + } + } + + LLViewerCamera::getInstance()->updateCameraLocation(head_pos, + mCameraUpVector, + gAgentAvatarp->mHeadp->getWorldPosition() + + LLVector3(1.0, 0.0, 0.0) * agent_rot); + } + else + { + // SL-315 + gAgentAvatarp->mPelvisp->setPosition(gAgentAvatarp->mPelvisp->getPosition() + diff); + } gAgentAvatarp->mRoot->updateWorldMatrixChildren(); @@ -1594,6 +1650,18 @@ void LLAgentCamera::updateCamera() torso_joint->setScale(torso_scale); chest_joint->setScale(chest_scale); } + + // We have do this at the very end to make sure it takes all previous calculations into + // account and then applies our roll on top of it, besides it wouldn't even work otherwise. + LLQuaternion rot_quat = LLViewerCamera::instance().getQuaternion(); + LLMatrix3 rot_mat(mRollAngle, 0.f, 0.f); + rot_quat = LLQuaternion(rot_mat)*rot_quat; + + LLMatrix3 mat(rot_quat); + + LLViewerCamera::instance().mXAxis = LLVector3(mat.mMatrix[0]); + LLViewerCamera::instance().mYAxis = LLVector3(mat.mMatrix[1]); + LLViewerCamera::instance().mZAxis = LLVector3(mat.mMatrix[2]); } void LLAgentCamera::updateLastCamera() @@ -1697,7 +1765,6 @@ LLVector3d LLAgentCamera::calcFocusPositionTargetGlobal() LLVector3d LLAgentCamera::calcThirdPersonFocusOffset() { // ...offset from avatar - LLVector3d focus_offset; LLQuaternion agent_rot = gAgent.getFrameAgent().getQuaternion(); if (isAgentAvatarValid() && gAgentAvatarp->getParent()) { @@ -2095,14 +2162,67 @@ LLVector3 LLAgentCamera::getAvatarRootPosition() //----------------------------------------------------------------------------- void LLAgentCamera::handleScrollWheel(S32 clicks) { + if (isUsingFlycam()) + { + // Flycam preempts updateCamera() entirely (see the comment on + // mUsingFlycam in llagentcamera.h), so none of the mCameraMode-based + // zoom logic below applies to it; drive the flycam's own FOV-based + // "zoom" (LLFlycam::mView, also fed by the FLYCAM_ZOOM game-control + // channel in updateFlycam()) instead. + // Negative 'clicks' (forward/up scroll) narrows the FOV to zoom in, + // matching the sign convention used by the non-flycam paths below. + constexpr F32 FLYCAM_SCROLL_ZOOM_FACTOR_PER_CLICK = 0.9f; + F32 zoom_factor = (F32)pow(FLYCAM_SCROLL_ZOOM_FACTOR_PER_CLICK, -clicks); + mFlycam.setView(mFlycam.getView() * zoom_factor); + return; + } + + // The Shift/Ctrl offset tweaks are wheel-only; everything else is shared with + // gamepad "Scroll" input via scrollCamera(). + if (mFocusOnAvatar && mCameraMode == CAMERA_MODE_THIRD_PERSON && !mCameraAnimating) + { + LLObjectSelectionHandle selection = LLSelectMgr::getInstance()->getSelection(); + if (!(selection->getObjectCount() && selection->getSelectType() == SELECT_TYPE_HUD)) + { + MASK mask = gKeyboard->currentMask(true); + if (mask & MASK_SHIFT) + { + LLVector3d offset = gSavedSettings.getVector3d("FocusOffsetRearView"); + offset.mdV[VZ] += 0.1f * (F32)clicks; + gSavedSettings.setVector3d("FocusOffsetRearView", offset); + return; + } + else if (mask & MASK_CONTROL) + { + LLVector3 offset = gSavedSettings.getVector3("CameraOffsetRearView"); + offset.mV[VZ] += 0.1f * (F32)clicks; + gSavedSettings.setVector3("CameraOffsetRearView", offset); + return; + } + } + } + + scrollCamera((F32)clicks); +} + +void LLAgentCamera::scrollCamera(F32 clicks) +{ if (mCameraMode == CAMERA_MODE_FOLLOW && getFocusOnAvatar()) { if (!mFollowCam.getPositionLocked()) // not if the followCam position is locked in place { - mFollowCam.zoom(clicks); - if (mFollowCam.isZoomedToMinimumDistance()) + // LLFollowCam::zoom() only takes whole clicks (and enforces a minimum + // step per call), so accumulate fractional ones until a click is due. + mFollowCamScrollClicks += clicks; + S32 whole_clicks = (S32)mFollowCamScrollClicks; + if (whole_clicks != 0) { - changeCameraToMouselook(false); + mFollowCamScrollClicks -= (F32)whole_clicks; + mFollowCam.zoom(whole_clicks); + if (mFollowCam.isZoomedToMinimumDistance()) + { + changeCameraToMouselook(false); + } } } } @@ -2181,7 +2301,7 @@ void LLAgentCamera::resetCamera() void LLAgentCamera::changeCameraToMouselook(bool animate) { if (!gSavedSettings.getBOOL("EnableMouselook") - || LLViewerJoystick::getInstance()->getOverrideCamera()) + || gAgent.isCameraExternallyDriven()) { return; } @@ -2216,7 +2336,6 @@ void LLAgentCamera::changeCameraToMouselook(bool animate) updateLastCamera(); mCameraMode = CAMERA_MODE_MOUSELOOK; - const U32 old_flags = gAgent.getControlFlags(); gAgent.setControlFlags(AGENT_CONTROL_MOUSELOOK); if (animate) @@ -2237,7 +2356,7 @@ void LLAgentCamera::changeCameraToMouselook(bool animate) //----------------------------------------------------------------------------- void LLAgentCamera::changeCameraToDefault() { - if (LLViewerJoystick::getInstance()->getOverrideCamera()) + if (gAgent.isCameraExternallyDriven()) { return; } @@ -2263,7 +2382,7 @@ void LLAgentCamera::changeCameraToDefault() //----------------------------------------------------------------------------- void LLAgentCamera::changeCameraToFollow(bool animate) { - if (LLViewerJoystick::getInstance()->getOverrideCamera()) + if (gAgent.isCameraExternallyDriven()) { return; } @@ -2319,7 +2438,7 @@ void LLAgentCamera::changeCameraToFollow(bool animate) //----------------------------------------------------------------------------- void LLAgentCamera::changeCameraToThirdPerson(bool animate) { - if (LLViewerJoystick::getInstance()->getOverrideCamera()) + if (gAgent.isCameraExternallyDriven()) { return; } @@ -2390,7 +2509,7 @@ void LLAgentCamera::changeCameraToThirdPerson(bool animate) //----------------------------------------------------------------------------- void LLAgentCamera::changeCameraToCustomizeAvatar() { - if (LLViewerJoystick::getInstance()->getOverrideCamera() || !isAgentAvatarValid()) + if (gAgent.isCameraExternallyDriven() || !isAgentAvatarValid()) { return; } @@ -2471,6 +2590,7 @@ void LLAgentCamera::switchCameraPreset(ECameraPreset preset) resetPanDiff(); resetOrbitDiff(); + resetCameraRoll(); gSavedSettings.setU32("CameraPresetType", mCameraPreset); } @@ -2675,9 +2795,9 @@ void LLAgentCamera::setCameraPosAndFocusGlobal(const LLVector3d& camera_pos, con if (mCameraAnimating) { - const F64 ANIM_METERS_PER_SECOND = 10.0; + const F64 ANIM_METERS_PER_SECOND = 25.0; const F64 MIN_ANIM_SECONDS = 0.5; - const F64 MAX_ANIM_SECONDS = 10.0; + const F64 MAX_ANIM_SECONDS = 1.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 ); @@ -2888,6 +3008,403 @@ void LLAgentCamera::notifyFollowCamParamsCleared() mLastValidFollowCamParamsTime = 0.0; } +//----------------------------------------------------------------------------- +// resetFlycamToCurrentView() +//----------------------------------------------------------------------------- +void LLAgentCamera::resetFlycamToCurrentView() +{ + LLViewerCamera* camera = LLViewerCamera::getInstance(); + mFlycam.setTransform(gAgent.getPosGlobalFromAgent(camera->getOrigin()), camera->getQuaternion()); + mFlycam.setView(camera->getView()); +} + +//----------------------------------------------------------------------------- +// toggleFlycam() +//----------------------------------------------------------------------------- +void LLAgentCamera::toggleFlycam() +{ + mUsingFlycam = !mUsingFlycam; + if (mUsingFlycam) + { + resetFlycamToCurrentView(); + // Flycam starts from the current view, which in mouselook is inside the + // avatar's head: keep the avatar hidden until it's out of view. + mFlycamHidingAvatar = cameraMouselook(); + } + else + { + bool was_revealed = !mFlycamHidingAvatar; + mFlycamHidingAvatar = false; + if (was_revealed && cameraMouselook() && isAgentAvatarValid()) + { + // Back to the mouselook view: re-hide the attachments + // updateFlycamAvatarVisibility() revealed. + gAgentAvatarp->updateAttachmentVisibility(CAMERA_MODE_MOUSELOOK); + } + } +} + +void LLAgentCamera::updateFlycamCursorVisibility(LLGameControl::AgentControlMode mode) +{ + // Seconds until the cursor hides again after the mouse moves... + constexpr F64 FLYCAM_CURSOR_MOUSE_TIMEOUT = 5.0; + // ...shortened to at most this while the flycam camera itself is moving. + constexpr F64 FLYCAM_CURSOR_CAMERA_TIMEOUT = 1.0; + // Tolerance when comparing mouse-move timestamps reconstructed from + // LLUI's F32 mouse idle time. + constexpr F64 MOUSE_MOVE_EPSILON = 0.005; + + if (!gViewerWindow) + { + return; + } + + // Mouselook (which flycam can be engaged from) manages its own hidden + // cursor, so leave the cursor alone while it is active. + bool mouselook = cameraMouselook(); + bool want_hiding = mode == LLGameControl::CONTROL_MODE_FLYCAM + && LLGameControl::isFlycamHideCursorEnabled() + && !mouselook; + + if (!want_hiding) + { + if (mFlycamCursorHidden && !mouselook) + { + gViewerWindow->showCursor(); + } + mFlycamCursorHiding = false; + mFlycamCursorHidden = false; + return; + } + + F64 now = LLFrameTimer::getElapsedSeconds(); + // LLViewerWindow::handleMouseMove() resets LLUI's mouse idle timer + // whenever the mouse moves, so this is when it last moved. + F64 mouse_move_time = now - (F64)LLUI::getInstance()->getMouseIdleTime(); + + // Detect flycam camera motion by comparing its transform (global, so + // unaffected by region-origin rebases) and view angle against the + // previous frame's. + LLVector3d flycam_position; + LLQuaternion flycam_rotation; + mFlycam.getTransform(flycam_position, flycam_rotation); + F32 flycam_view = mFlycam.getView(); + bool flycam_moved = flycam_position != mFlycamCursorLastPosition + || flycam_rotation != mFlycamCursorLastRotation + || flycam_view != mFlycamCursorLastView; + mFlycamCursorLastPosition = flycam_position; + mFlycamCursorLastRotation = flycam_rotation; + mFlycamCursorLastView = flycam_view; + + if (!mFlycamCursorHiding) + { + // Just entered FlyCam mode: hide immediately. + mFlycamCursorHiding = true; + mFlycamCursorHidden = true; + mFlycamCursorMouseMoveTime = mouse_move_time; + gViewerWindow->hideCursor(); + return; + } + + if (mFlycamCursorHidden && !gViewerWindow->getCursorHidden()) + { + // Something else re-showed the cursor behind our back: treat it as + // visible, with a fresh timeout. + mFlycamCursorHidden = false; + mFlycamCursorHideTime = now + FLYCAM_CURSOR_MOUSE_TIMEOUT; + } + + if (mouse_move_time > mFlycamCursorMouseMoveTime + MOUSE_MOVE_EPSILON) + { + // The mouse moved: show the cursor (if hidden) and restart the timeout. + mFlycamCursorMouseMoveTime = mouse_move_time; + mFlycamCursorHideTime = mouse_move_time + FLYCAM_CURSOR_MOUSE_TIMEOUT; + if (mFlycamCursorHidden) + { + mFlycamCursorHidden = false; + gViewerWindow->showCursor(); + } + } + + if (mFlycamCursorHidden) + { + return; + } + + if (flycam_moved) + { + mFlycamCursorHideTime = llmin(mFlycamCursorHideTime, now + FLYCAM_CURSOR_CAMERA_TIMEOUT); + } + + if (now >= mFlycamCursorHideTime) + { + mFlycamCursorHidden = true; + gViewerWindow->hideCursor(); + } +} + +bool LLAgentCamera::isHidingAvatarForFirstPerson() const +{ + return cameraMouselook() && (!mUsingFlycam || mFlycamHidingAvatar); +} + +//----------------------------------------------------------------------------- +// updateFlycamAvatarVisibility() +//----------------------------------------------------------------------------- +void LLAgentCamera::updateFlycamAvatarVisibility() +{ + if (!mFlycamHidingAvatar) + { + return; + } + if (!cameraMouselook() || !isAgentAvatarValid()) + { + // Nothing left to hide from (e.g. the camera mode changed underneath). + mFlycamHidingAvatar = false; + return; + } + + // Bounding sphere of the avatar, including its attachments. + LLVector3 center = gAgentAvatarp->getRenderPosition(); + F32 radius = 0.f; + if (gAgentAvatarp->mDrawable.notNull()) + { + const LLVector4a* extents = gAgentAvatarp->mDrawable->getSpatialExtents(); + LLVector3 min(extents[0].getF32ptr()); + LLVector3 max(extents[1].getF32ptr()); + center = (min + max) * 0.5f; + radius = (max - min).magVec() * 0.5f; + } + // Pad for stale extents and animation beyond the bounds. + constexpr F32 MIN_AVATAR_RADIUS = 1.f; // meters + constexpr F32 AVATAR_RADIUS_PADDING = 1.25f; + radius = llmax(radius * AVATAR_RADIUS_PADDING, MIN_AVATAR_RADIUS); + + // Conservative test: the avatar is out of view if its bounding sphere lies + // entirely outside the cone that encloses the view frustum (half-angle to + // the frustum's corners). + const LLViewerCamera* camera = LLViewerCamera::getInstance(); + LLVector3 to_avatar = center - camera->getOrigin(); + F32 distance = to_avatar.normVec(); + if (distance <= radius) + { + return; // camera is inside the bounds + } + F32 tan_half_view = tanf(0.5f * camera->getView()); + F32 frustum_half_angle = atanf(tan_half_view * sqrtf(1.f + camera->getAspect() * camera->getAspect())); + F32 avatar_half_angle = asinf(radius / distance); + F32 angle_to_avatar = acosf(llclamp(to_avatar * camera->getAtAxis(), -1.f, 1.f)); + if (angle_to_avatar > frustum_half_angle + avatar_half_angle) + { + mFlycamHidingAvatar = false; + gAgentAvatarp->updateAttachmentVisibility(getCameraMode()); + } +} + +//----------------------------------------------------------------------------- +// applyNdofFlycamFrameDelta() +//----------------------------------------------------------------------------- +void LLAgentCamera::applyNdofFlycamFrameDelta(const F32 local_delta[7], + bool auto_level, F32 auto_level_fraction, + bool direct_view, F32 direct_view_value) +{ + mFlycam.applyFrameDelta(local_delta, auto_level, auto_level_fraction, direct_view, direct_view_value); + + LLVector3d pos_global; + LLQuaternion rot; + mFlycam.getTransform(pos_global, rot); + LLVector3 pos = gAgent.getPosAgentFromGlobal(pos_global); + LLMatrix3 mat(rot); + LLViewerCamera::getInstance()->setOrigin(pos); + LLViewerCamera::getInstance()->mXAxis = LLVector3(mat.mMatrix[0]); + LLViewerCamera::getInstance()->mYAxis = LLVector3(mat.mMatrix[1]); + LLViewerCamera::getInstance()->mZAxis = LLVector3(mat.mMatrix[2]); + + LLViewerCamera::getInstance()->setView(mFlycam.getView()); + + updateFlycamAvatarVisibility(); +} + +//----------------------------------------------------------------------------- +// updateFlycam() +//----------------------------------------------------------------------------- +void LLAgentCamera::updateFlycam(F32 delta_time) +{ + // Note: flycam_inputs arrive in range [-1,1] + std::vector<F32> flycam_inputs; + U32 flycam_misc_actions = 0; + U32 flycam_modifiers = 0; + LLGameControl::getFlycamInputs(flycam_inputs, flycam_misc_actions, flycam_modifiers); + + // The channel order is defined by LLGameControl::FlycamChannel. + + // Defensive: getFlycamInputs() should return one value per channel. + if ((S32)flycam_inputs.size() < LLGameControl::FLYCAM_NUM_CHANNELS) + { + return; + } + + if (flycam_misc_actions & LLGameControl::FLYCAM_ACTION_ESCAPE) + { + // Bail out of FlyCam mode immediately; no point applying this frame's + // (about to be abandoned) flycam deltas below. + gAgent.resetToAvatarMode(); + return; + } + + // Blend in keyboard-driven flycam input (independent of LLGameControl, + // which only sees a physical controller). mFlycamKeyboardInput is + // level-triggered by flycam_axis_key<> in llviewerinput.cpp -- it must be + // re-set every frame a key is held, so clear it here once consumed. + for (U8 i = 0; i < LLGameControl::FLYCAM_NUM_CHANNELS; ++i) + { + flycam_inputs[i] = llclamp(flycam_inputs[i] + mFlycamKeyboardInput[i], -1.f, 1.f); + } + mFlycamKeyboardInput.fill(0.f); + bool flycam_key_unroll_requested = mFlycamKeyboardUnrollRequested; + mFlycamKeyboardUnrollRequested = false; + + // Unroll only undoes roll, and roll is already kept at zero every frame + // (LLFlycam::setRollRate()/integrate()) whenever roll is disallowed, so + // treat an Unroll request as a no-op rather than kicking off a pointless + // startReset() lerp while "Allow Roll" is unchecked. + if (LLGameControl::isFlycamRollAllowed() + && ((flycam_misc_actions & LLGameControl::FLYCAM_ACTION_UNROLL) || flycam_key_unroll_requested)) + { + // Re-orient the flycam in place: keep its current position and + // forward (local X) axis unchanged, but unroll it so its local vertical + // axis lies on the plane defined by forward axis and world-up, with positive + // dot-product with world-up. + // mFlycam.startReset() smoothly lerps into this transform (see + // LLFlycam::integrate()); flycam input has no effect until the lerp + // completes. + constexpr F32 FLYCAM_UNROLL_DURATION = 1.0f; // seconds; may be tuned later + + LLVector3d current_position; + LLQuaternion current_rotation; + mFlycam.getTransform(current_position, current_rotation); + + LLMatrix3 level(current_rotation); + LLVector3 forward(level.getFwdRow()); + forward.normVec(); + + LLVector3 world_up = LLVector3::z_axis; + LLVector3 new_up = world_up - (world_up * forward) * forward; + constexpr F32 MIN_UNROLL_SIN = 0.01f; // ~0.6 degrees off vertical + if (new_up.lengthSquared() > MIN_UNROLL_SIN * MIN_UNROLL_SIN) + { + new_up.normVec(); + // Right-handed (forward, left, up) basis, per + // LLMatrix3::orthogonalize()'s up = forward % left: up % forward == left. + LLVector3 new_left = new_up % forward; + level.setRows(forward, new_left, new_up); + level.orthogonalize(); // numerical cleanup only; rows are already orthonormal by construction + + mFlycam.startReset(current_position, LLQuaternion(level), FLYCAM_UNROLL_DURATION); + } + } + + // Orbit modifier: while held, Truck stops meaning strafe and instead adds + // into Pan's yaw (both sweep the camera left/right around the focal + // point), and Dolly stops meaning advance and instead adjusts the radius + // (see LLFlycam::setOrbitRadialRate()/integrate()). Tilt, Roll, Boom, + // and Zoom keep their normal meaning either way: Tilt already rotates the + // camera about its own local left axis, which is exactly what swings it + // up/down around the focal point once position is derived from + // orientation; Roll still passes straight through (it just changes which + // region-frame axis Tilt's local axis happens to be next frame). + bool flycam_orbit_held = (flycam_modifiers & LLGameControl::FLYCAM_MODIFIER_ORBIT) != 0; + constexpr F32 FLYCAM_ORBIT_DEFAULT_FOCAL_DISTANCE = 20.0f; // meters; hard-coded for now, may be tuned later + constexpr F32 FLYCAM_ORBIT_MAX_TRACE_DISTANCE = 512.0f; // meters; matches the general world-raycast convention used elsewhere (e.g. LLViewerWindow::cursorIntersect) + F32 flycam_orbit_focal_distance = FLYCAM_ORBIT_DEFAULT_FOCAL_DISTANCE; + if (flycam_orbit_held && !mFlycam.isOrbitEngaged()) + { + // Rising edge: ray-trace forward from the flycam to see what it's + // pointing at, so Orbit pivots around that instead of an arbitrary + // fixed distance whenever there's something in view; falls back to + // the default distance if nothing is hit within range. + LLVector3d camera_pos_global; + LLQuaternion camera_rot; + mFlycam.getTransform(camera_pos_global, camera_rot); + LLVector3 camera_pos = gAgent.getPosAgentFromGlobal(camera_pos_global); + LLVector3 forward(LLMatrix3(camera_rot).getFwdRow()); + LLVector3 trace_end = camera_pos + forward * FLYCAM_ORBIT_MAX_TRACE_DISTANCE; + + LLVector4a start, end; + start.load3(camera_pos.mV); + end.load3(trace_end.mV); + + LLVector4a intersection; + S32 face_hit = -1; + LLViewerObject* hit_object = gPipeline.lineSegmentIntersectInWorld( + start, end, + /*pick_transparent=*/ false, + /*pick_rigged=*/ true, + /*pick_unselectable=*/ true, + /*pick_reflection_probe=*/ false, + &face_hit, nullptr, nullptr, + &intersection); + if (hit_object) + { + LLVector3 hit_pos; + hit_pos.set(intersection.getF32ptr()); + flycam_orbit_focal_distance = (hit_pos - camera_pos).length(); + } + } + mFlycam.setOrbitEngaged(flycam_orbit_held, flycam_orbit_focal_distance); + + F32 yaw_input = flycam_inputs[LLGameControl::FLYCAM_PAN]; + F32 truck_input = flycam_inputs[LLGameControl::FLYCAM_TRUCK]; + F32 dolly_input = flycam_inputs[LLGameControl::FLYCAM_DOLLY]; + if (flycam_orbit_held) + { + // Truck/Dolly are negated here (Pan/Tilt/Roll/Boom/Zoom are not) -- + // determined empirically to match the expected orbit sweep/radial + // directions. + truck_input = -truck_input; + dolly_input = -dolly_input; + yaw_input = llclamp(yaw_input + truck_input, -1.f, 1.f); + truck_input = 0.f; + mFlycam.setOrbitRadialRate(dolly_input); + dolly_input = 0.f; + } + else + { + mFlycam.setOrbitRadialRate(0.f); + } + + // Must precede setLinearVelocity()/setPitchRate()/setYawRate()/setRollRate(): + // those setters apply mSpeedFactor/mAllowRoll immediately rather than at + // integrate() time. + mFlycam.setSpeedFactor(LLGameControl::getSpeedFactor(LLGameControl::getModeName(LLGameControl::CONTROL_MODE_FLYCAM))); + mFlycam.setAllowRoll(LLGameControl::isFlycamRollAllowed()); + + LLVector3 linear_velocity(dolly_input, truck_input, flycam_inputs[LLGameControl::FLYCAM_BOOM]); + constexpr F32 MAX_FLYCAM_SPEED = 10.0f; + mFlycam.setLinearVelocity(MAX_FLYCAM_SPEED * linear_velocity); + + mFlycam.setPitchRate(flycam_inputs[LLGameControl::FLYCAM_TILT]); + mFlycam.setYawRate(yaw_input); + mFlycam.setRollRate(flycam_inputs[LLGameControl::FLYCAM_ROLL]); + mFlycam.setZoomRate(flycam_inputs[LLGameControl::FLYCAM_ZOOM]); + + mFlycam.integrate(delta_time); + + LLVector3d pos_global; + LLQuaternion rot; + mFlycam.getTransform(pos_global, rot); + LLVector3 pos = gAgent.getPosAgentFromGlobal(pos_global); + LLMatrix3 mat(rot); + LLViewerCamera::getInstance()->setOrigin(pos); + LLViewerCamera::getInstance()->mXAxis = LLVector3(mat.mMatrix[0]); + LLViewerCamera::getInstance()->mYAxis = LLVector3(mat.mMatrix[1]); + LLViewerCamera::getInstance()->mZAxis = LLVector3(mat.mMatrix[2]); + + LLViewerCamera::getInstance()->setView(mFlycam.getView()); + + updateFlycamAvatarVisibility(); +} + bool LLAgentCamera::setPointAt(EPointAtType target_type, LLViewerObject *object, LLVector3 position) { // disallow pointing at attachments and avatars @@ -2950,6 +3467,8 @@ void LLAgentCamera::clearOrbitKeys() mOrbitDownKey = 0.f; mOrbitInKey = 0.f; mOrbitOutKey = 0.f; + mRollLeftKey = 0.f; + mRollRightKey = 0.f; } void LLAgentCamera::clearPanKeys() |