birkeh/o3de
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Move new camera settings to the Settings Registry and connect them to viewport border elements (#1267)

Browse Source 
* ensure the new camera respects changing ui values and move camera settings to the settings registry

* factor out creation of modular camera controller

* small updates before posting PR

* updates following review feedback

* updates following review feedback
This commit is contained in:
Tom Hulton-Harrop
2021-06-14 12:32:35 +01:00
committed by GitHub
parent 259542b3ca
commit 0f09a6d8bf
15 changed files with 562 additions and 290 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Code/Framework/AzFramework/AzFramework/Viewport/CameraInput.cpp
+80 -31
View File
@@ -28,19 +28,8 @@ namespace AzFramework
nullptr,
AZ::ConsoleFunctorFlags::Null,
"The default height of the ground plane to do intersection tests against when orbiting");
AZ_CVAR(float, ed_cameraSystemBoostMultiplier, 3.0f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
AZ_CVAR(float, ed_cameraSystemTranslateSpeed, 10.0f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
AZ_CVAR(float, ed_cameraSystemOrbitDollyScrollSpeed, 0.02f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
AZ_CVAR(float, ed_cameraSystemOrbitDollyCursorSpeed, 0.01f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
AZ_CVAR(float, ed_cameraSystemScrollTranslateSpeed, 0.02f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
AZ_CVAR(float, ed_cameraSystemMinOrbitDistance, 10.0f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
AZ_CVAR(float, ed_cameraSystemMaxOrbitDistance, 50.0f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
AZ_CVAR(float, ed_cameraSystemLookSmoothness, 5.0f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
AZ_CVAR(float, ed_cameraSystemTranslateSmoothness, 5.0f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
AZ_CVAR(float, ed_cameraSystemRotateSpeed, 0.005f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
AZ_CVAR(float, ed_cameraSystemPanSpeed, 0.01f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
AZ_CVAR(bool, ed_cameraSystemPanInvertX, true, nullptr, AZ::ConsoleFunctorFlags::Null, "");
AZ_CVAR(bool, ed_cameraSystemPanInvertY, true, nullptr, AZ::ConsoleFunctorFlags::Null, "");
AZ_CVAR(
AZ::CVarFixedString, ed_cameraSystemTranslateForwardKey, "keyboard_key_alphanumeric_W", nullptr, AZ::ConsoleFunctorFlags::Null, "");
@@ -121,6 +110,13 @@ namespace AzFramework
AZ_CONSOLEFREEFUNC(ReloadCameraKeyBindingsConsole, AZ::ConsoleFunctorFlags::Null, "Reload keybindings for the modern camera system");
//! return -1.0f if inverted, 1.0f otherwise
constexpr static float Invert(const bool invert)
{
constexpr float Dir[] = { 1.0f, -1.0f };
return Dir[aznumeric_cast<int>(invert)];
};
// Based on paper by David Eberly - https://www.geometrictools.com/Documentation/EulerAngles.pdf
AZ::Vector3 EulerAngles(const AZ::Matrix3x3& orientation)
{
@@ -291,6 +287,20 @@ namespace AzFramework
RotateCameraInput::RotateCameraInput(const InputChannelId rotateChannelId)
: m_rotateChannelId(rotateChannelId)
{
m_rotateSpeedFn = []() constexpr
{
return 0.005f;
};
m_invertPitchFn = []() constexpr
{
return false;
};
m_invertYawFn = []() constexpr
{
return false;
};
}
bool RotateCameraInput::HandleEvents(const InputEvent& event, const ScreenVector& cursorDelta, [[maybe_unused]] float scrollDelta)
@@ -341,8 +351,9 @@ namespace AzFramework
{
Camera nextCamera = targetCamera;
nextCamera.m_pitch -= float(cursorDelta.m_y) * ed_cameraSystemRotateSpeed;
nextCamera.m_yaw -= float(cursorDelta.m_x) * ed_cameraSystemRotateSpeed;
const float rotateSpeed = m_rotateSpeedFn();
nextCamera.m_pitch -= float(cursorDelta.m_y) * rotateSpeed * Invert(m_invertPitchFn());
nextCamera.m_yaw -= float(cursorDelta.m_x) * rotateSpeed * Invert(m_invertYawFn());
const auto clampRotation = [](const float angle)
{
@@ -360,6 +371,20 @@ namespace AzFramework
: m_panAxesFn(AZStd::move(panAxesFn))
, m_panChannelId(panChannelId)
{
m_panSpeedFn = []() constexpr
{
return 0.01f;
};
m_invertPanXFn = []() constexpr
{
return true;
};
m_invertPanYFn = []() constexpr
{
return true;
};
}
bool PanCameraInput::HandleEvents(
@@ -393,17 +418,12 @@ namespace AzFramework
const auto panAxes = m_panAxesFn(nextCamera);
const auto deltaPanX = float(cursorDelta.m_x) * panAxes.m_horizontalAxis * ed_cameraSystemPanSpeed;
const auto deltaPanY = float(cursorDelta.m_y) * panAxes.m_verticalAxis * ed_cameraSystemPanSpeed;
const float panSpeed = m_panSpeedFn();
const auto deltaPanX = float(cursorDelta.m_x) * panAxes.m_horizontalAxis * panSpeed;
const auto deltaPanY = float(cursorDelta.m_y) * panAxes.m_verticalAxis * panSpeed;
const auto inv = [](const bool invert)
{
constexpr float Dir[] = { 1.0f, -1.0f };
return Dir[aznumeric_cast<int>(invert)];
};
nextCamera.m_lookAt += deltaPanX * inv(ed_cameraSystemPanInvertX);
nextCamera.m_lookAt += deltaPanY * -inv(ed_cameraSystemPanInvertY);
nextCamera.m_lookAt += deltaPanX * Invert(m_invertPanXFn());
nextCamera.m_lookAt += deltaPanY * -Invert(m_invertPanYFn());
return nextCamera;
}
@@ -446,6 +466,15 @@ namespace AzFramework
TranslateCameraInput::TranslateCameraInput(TranslationAxesFn translationAxesFn)
: m_translationAxesFn(AZStd::move(translationAxesFn))
{
m_translateSpeedFn = []() constexpr
{
return 10.0f;
};
m_boostMultiplierFn = []() constexpr
{
return 3.0f;
};
}
bool TranslateCameraInput::HandleEvents(
@@ -497,9 +526,9 @@ namespace AzFramework
const auto axisY = translationBasis.GetBasisY();
const auto axisZ = translationBasis.GetBasisZ();
const float speed = [boost = m_boost]()
const float speed = [boost = m_boost, &translateSpeedFn = m_translateSpeedFn, &boostMultiplierFn = m_boostMultiplierFn]()
{
return ed_cameraSystemTranslateSpeed * (boost ? ed_cameraSystemBoostMultiplier : 1.0f);
return translateSpeedFn() * (boost ? boostMultiplierFn() : 1.0f);
}();
if ((m_translation & TranslationType::Forward) == TranslationType::Forward)
@@ -632,6 +661,14 @@ namespace AzFramework
return nextCamera;
}
OrbitDollyScrollCameraInput::OrbitDollyScrollCameraInput()
{
m_scrollSpeedFn = []() constexpr
{
return 0.03f;
};
}
bool OrbitDollyScrollCameraInput::HandleEvents(
const InputEvent& event, [[maybe_unused]] const ScreenVector& cursorDelta, [[maybe_unused]] float scrollDelta)
{
@@ -650,7 +687,7 @@ namespace AzFramework
[[maybe_unused]] const float deltaTime)
{
Camera nextCamera = targetCamera;
nextCamera.m_lookDist = AZ::GetMin(nextCamera.m_lookDist + scrollDelta * ed_cameraSystemOrbitDollyScrollSpeed, 0.0f);
nextCamera.m_lookDist = AZ::GetMin(nextCamera.m_lookDist + scrollDelta * m_scrollSpeedFn(), 0.0f);
EndActivation();
return nextCamera;
}
@@ -658,6 +695,10 @@ namespace AzFramework
OrbitDollyCursorMoveCameraInput::OrbitDollyCursorMoveCameraInput(const InputChannelId dollyChannelId)
: m_dollyChannelId(dollyChannelId)
{
m_cursorSpeedFn = []() constexpr
{
return 0.01f;
};
}
bool OrbitDollyCursorMoveCameraInput::HandleEvents(
@@ -688,10 +729,18 @@ namespace AzFramework
[[maybe_unused]] const float deltaTime)
{
Camera nextCamera = targetCamera;
nextCamera.m_lookDist = AZ::GetMin(nextCamera.m_lookDist + float(cursorDelta.m_y) * ed_cameraSystemOrbitDollyCursorSpeed, 0.0f);
nextCamera.m_lookDist = AZ::GetMin(nextCamera.m_lookDist + float(cursorDelta.m_y) * m_cursorSpeedFn(), 0.0f);
return nextCamera;
}
ScrollTranslationCameraInput::ScrollTranslationCameraInput()
{
m_scrollSpeedFn = []() constexpr
{
return 0.02f;
};
}
bool ScrollTranslationCameraInput::HandleEvents(
const InputEvent& event, [[maybe_unused]] const ScreenVector& cursorDelta, [[maybe_unused]] float scrollDelta)
{
@@ -714,14 +763,14 @@ namespace AzFramework
const auto translation_basis = LookTranslation(nextCamera);
const auto axisY = translation_basis.GetBasisY();
nextCamera.m_lookAt += axisY * scrollDelta * ed_cameraSystemScrollTranslateSpeed;
nextCamera.m_lookAt += axisY * scrollDelta * m_scrollSpeedFn();
EndActivation();
return nextCamera;
}
Camera SmoothCamera(const Camera& currentCamera, const Camera& targetCamera, const float deltaTime)
Camera SmoothCamera(const Camera& currentCamera, const Camera& targetCamera, const CameraProps& cameraProps, const float deltaTime)
{
const auto clamp_rotation = [](const float angle)
{
@@ -748,11 +797,11 @@ namespace AzFramework
Camera camera;
// note: the math for the lerp smoothing implementation for camera rotation and translation was inspired by this excellent
// article by Scott Lembcke: https://www.gamasutra.com/blogs/ScottLembcke/20180404/316046/Improved_Lerp_Smoothing.php
const float lookRate = AZStd::exp2(ed_cameraSystemLookSmoothness);
const float lookRate = AZStd::exp2(cameraProps.m_rotateSmoothnessFn());
const float lookT = AZStd::exp2(-lookRate * deltaTime);
camera.m_pitch = AZ::Lerp(targetCamera.m_pitch, currentCamera.m_pitch, lookT);
camera.m_yaw = AZ::Lerp(targetYaw, currentYaw, lookT);
const float moveRate = AZStd::exp2(ed_cameraSystemTranslateSmoothness);
const float moveRate = AZStd::exp2(cameraProps.m_translateSmoothnessFn());
const float moveT = AZStd::exp2(-moveRate * deltaTime);
camera.m_lookDist = AZ::Lerp(targetCamera.m_lookDist, currentCamera.m_lookDist, moveT);
camera.m_lookAt = targetCamera.m_lookAt.Lerp(currentCamera.m_lookAt, moveT);
Code/Framework/AzFramework/AzFramework/Viewport/CameraInput.h
+29 -1
View File
@@ -170,7 +170,14 @@ namespace AzFramework
Activation m_activation = Activation::Idle;
};
Camera SmoothCamera(const Camera& currentCamera, const Camera& targetCamera, float deltaTime);
//! Properties to use to configure behavior across all types of camera.
struct CameraProps
{
AZStd::function<float()> m_rotateSmoothnessFn; //!< Rotate smoothing value (useful approx range 3-6, higher values give sharper feel).
AZStd::function<float()> m_translateSmoothnessFn; //!< Translate smoothing value (useful approx range 3-6, higher values give sharper feel).
};
Camera SmoothCamera(const Camera& currentCamera, const Camera& targetCamera, const CameraProps& cameraProps, float deltaTime);
class Cameras
{
@@ -225,6 +232,10 @@ namespace AzFramework
bool HandleEvents(const InputEvent& event, const ScreenVector& cursorDelta, float scrollDelta) override;
Camera StepCamera(const Camera& targetCamera, const ScreenVector& cursorDelta, float scrollDelta, float deltaTime) override;
AZStd::function<float()> m_rotateSpeedFn;
AZStd::function<bool()> m_invertPitchFn;
AZStd::function<bool()> m_invertYawFn;
private:
InputChannelId m_rotateChannelId;
ClickDetector m_clickDetector;
@@ -267,6 +278,10 @@ namespace AzFramework
bool HandleEvents(const InputEvent& event, const ScreenVector& cursorDelta, float scrollDelta) override;
Camera StepCamera(const Camera& targetCamera, const ScreenVector& cursorDelta, float scrollDelta, float deltaTime) override;
AZStd::function<float()> m_panSpeedFn;
AZStd::function<bool()> m_invertPanXFn;
AZStd::function<bool()> m_invertPanYFn;
private:
PanAxesFn m_panAxesFn;
InputChannelId m_panChannelId;
@@ -310,6 +325,9 @@ namespace AzFramework
Camera StepCamera(const Camera& targetCamera, const ScreenVector& cursorDelta, float scrollDelta, float deltaTime) override;
void ResetImpl() override;
AZStd::function<float()> m_translateSpeedFn;
AZStd::function<float()> m_boostMultiplierFn;
private:
enum class TranslationType
{
@@ -375,9 +393,13 @@ namespace AzFramework
class OrbitDollyScrollCameraInput : public CameraInput
{
public:
OrbitDollyScrollCameraInput();
// CameraInput overrides ...
bool HandleEvents(const InputEvent& event, const ScreenVector& cursorDelta, float scrollDelta) override;
Camera StepCamera(const Camera& targetCamera, const ScreenVector& cursorDelta, float scrollDelta, float deltaTime) override;
AZStd::function<float()> m_scrollSpeedFn;
};
class OrbitDollyCursorMoveCameraInput : public CameraInput
@@ -389,6 +411,8 @@ namespace AzFramework
bool HandleEvents(const InputEvent& event, const ScreenVector& cursorDelta, float scrollDelta) override;
Camera StepCamera(const Camera& targetCamera, const ScreenVector& cursorDelta, float scrollDelta, float deltaTime) override;
AZStd::function<float()> m_cursorSpeedFn;
private:
InputChannelId m_dollyChannelId;
};
@@ -396,9 +420,13 @@ namespace AzFramework
class ScrollTranslationCameraInput : public CameraInput
{
public:
ScrollTranslationCameraInput();
// CameraInput overrides ...
bool HandleEvents(const InputEvent& event, const ScreenVector& cursorDelta, float scrollDelta) override;
Camera StepCamera(const Camera& targetCamera, const ScreenVector& cursorDelta, float scrollDelta, float deltaTime) override;
AZStd::function<float()> m_scrollSpeedFn;
};
class OrbitCameraInput : public CameraInput
Code/Sandbox/Editor/Core/LevelEditorMenuHandler.cpp
-5
View File
@@ -759,11 +759,6 @@ QMenu* LevelEditorMenuHandler::CreateViewMenu()
viewportViewsMenuWrapper.AddSeparator();
auto changeMoveSpeedMenu = viewportViewsMenuWrapper.AddMenu(tr("Change Move Speed"));
changeMoveSpeedMenu.AddAction(ID_CHANGEMOVESPEED_INCREASE);
changeMoveSpeedMenu.AddAction(ID_CHANGEMOVESPEED_DECREASE);
changeMoveSpeedMenu.AddAction(ID_CHANGEMOVESPEED_CHANGESTEP);
auto switchCameraMenu = viewportViewsMenuWrapper.AddMenu(tr("Switch Camera"));
switchCameraMenu.AddAction(ID_SWITCHCAMERA_DEFAULTCAMERA);
switchCameraMenu.AddAction(ID_SWITCHCAMERA_SEQUENCECAMERA);
Code/Sandbox/Editor/CryEdit.cpp
-35
View File
@@ -441,9 +441,6 @@ void CCryEditApp::RegisterActionHandlers()
ON_COMMAND(ID_VIEW_CYCLE2DVIEWPORT, OnViewCycle2dviewport)
#endif
ON_COMMAND(ID_DISPLAY_GOTOPOSITION, OnDisplayGotoPosition)
ON_COMMAND(ID_CHANGEMOVESPEED_INCREASE, OnChangemovespeedIncrease)
ON_COMMAND(ID_CHANGEMOVESPEED_DECREASE, OnChangemovespeedDecrease)
ON_COMMAND(ID_CHANGEMOVESPEED_CHANGESTEP, OnChangemovespeedChangestep)
ON_COMMAND(ID_FILE_SAVELEVELRESOURCES, OnFileSavelevelresources)
ON_COMMAND(ID_CLEAR_REGISTRY, OnClearRegistryData)
ON_COMMAND(ID_VALIDATELEVEL, OnValidatelevel)
@@ -3706,38 +3703,6 @@ void CCryEditApp::OnDisplayGotoPosition()
dialog.exec();
}
//////////////////////////////////////////////////////////////////////////
void CCryEditApp::OnChangemovespeedIncrease()
{
gSettings.cameraMoveSpeed += m_moveSpeedStep;
if (gSettings.cameraMoveSpeed < 0.01f)
{
gSettings.cameraMoveSpeed = 0.01f;
}
}
//////////////////////////////////////////////////////////////////////////
void CCryEditApp::OnChangemovespeedDecrease()
{
gSettings.cameraMoveSpeed -= m_moveSpeedStep;
if (gSettings.cameraMoveSpeed < 0.01f)
{
gSettings.cameraMoveSpeed = 0.01f;
}
}
//////////////////////////////////////////////////////////////////////////
void CCryEditApp::OnChangemovespeedChangestep()
{
bool ok = false;
int fractionalDigitCount = 5;
float step = aznumeric_caster(QInputDialog::getDouble(AzToolsFramework::GetActiveWindow(), QObject::tr("Change Move Increase/Decrease Step"), QStringLiteral(""), m_moveSpeedStep, std::numeric_limits<float>::lowest(), std::numeric_limits<float>::max(), fractionalDigitCount, &ok));
if (ok)
{
m_moveSpeedStep = step;
}
}
//////////////////////////////////////////////////////////////////////////
void CCryEditApp::OnFileSavelevelresources()
{
Code/Sandbox/Editor/CryEdit.h
-3
View File
@@ -408,9 +408,6 @@ private:
void OnToolsScriptHelp();
void OnViewCycle2dviewport();
void OnDisplayGotoPosition();
void OnChangemovespeedIncrease();
void OnChangemovespeedDecrease();
void OnChangemovespeedChangestep();
void OnFileSavelevelresources();
void OnClearRegistryData();
void OnValidatelevel();
Code/Sandbox/Editor/EditorPreferencesPageViewportMovement.cpp
+38 -13
View File
@@ -17,7 +17,7 @@
// Editor
#include "Settings.h"
#include "EditorViewportSettings.h"
void CEditorPreferencesPage_ViewportMovement::Reflect(AZ::SerializeContext& serialize)
{
@@ -72,20 +72,45 @@ QIcon& CEditorPreferencesPage_ViewportMovement::GetIcon()
void CEditorPreferencesPage_ViewportMovement::OnApply()
{
gSettings.cameraMoveSpeed = m_cameraMovementSettings.m_moveSpeed;
gSettings.cameraRotateSpeed = m_cameraMovementSettings.m_rotateSpeed;
gSettings.cameraFastMoveSpeed = m_cameraMovementSettings.m_fastMoveSpeed;
gSettings.wheelZoomSpeed = m_cameraMovementSettings.m_wheelZoomSpeed;
gSettings.invertYRotation = m_cameraMovementSettings.m_invertYRotation;
gSettings.invertPan = m_cameraMovementSettings.m_invertPan;
if (SandboxEditor::UsingNewCameraSystem())
{
SandboxEditor::SetCameraTranslateSpeed(m_cameraMovementSettings.m_moveSpeed);
SandboxEditor::SetCameraRotateSpeed(m_cameraMovementSettings.m_rotateSpeed);
SandboxEditor::SetCameraBoostMultiplier(m_cameraMovementSettings.m_fastMoveSpeed);
SandboxEditor::SetCameraScrollSpeed(m_cameraMovementSettings.m_wheelZoomSpeed);
SandboxEditor::SetCameraOrbitYawRotationInverted(m_cameraMovementSettings.m_invertYRotation);
SandboxEditor::SetCameraPanInvertedX(m_cameraMovementSettings.m_invertPan);
SandboxEditor::SetCameraPanInvertedY(m_cameraMovementSettings.m_invertPan);
}
else
{
gSettings.cameraMoveSpeed = m_cameraMovementSettings.m_moveSpeed;
gSettings.cameraRotateSpeed = m_cameraMovementSettings.m_rotateSpeed;
gSettings.cameraFastMoveSpeed = m_cameraMovementSettings.m_fastMoveSpeed;
gSettings.wheelZoomSpeed = m_cameraMovementSettings.m_wheelZoomSpeed;
gSettings.invertYRotation = m_cameraMovementSettings.m_invertYRotation;
gSettings.invertPan = m_cameraMovementSettings.m_invertPan;
}
}
void CEditorPreferencesPage_ViewportMovement::InitializeSettings()
{
m_cameraMovementSettings.m_moveSpeed = gSettings.cameraMoveSpeed;
m_cameraMovementSettings.m_rotateSpeed = gSettings.cameraRotateSpeed;
m_cameraMovementSettings.m_fastMoveSpeed = gSettings.cameraFastMoveSpeed;
m_cameraMovementSettings.m_wheelZoomSpeed = gSettings.wheelZoomSpeed;
m_cameraMovementSettings.m_invertYRotation = gSettings.invertYRotation;
m_cameraMovementSettings.m_invertPan = gSettings.invertPan;
if (SandboxEditor::UsingNewCameraSystem())
{
m_cameraMovementSettings.m_moveSpeed = SandboxEditor::CameraTranslateSpeed();
m_cameraMovementSettings.m_rotateSpeed = SandboxEditor::CameraRotateSpeed();
m_cameraMovementSettings.m_fastMoveSpeed = SandboxEditor::CameraBoostMultiplier();
m_cameraMovementSettings.m_wheelZoomSpeed = SandboxEditor::CameraScrollSpeed();
m_cameraMovementSettings.m_invertYRotation = SandboxEditor::CameraOrbitYawRotationInverted();
m_cameraMovementSettings.m_invertPan = SandboxEditor::CameraPanInvertedX() && SandboxEditor::CameraPanInvertedY();
}
else
{
m_cameraMovementSettings.m_moveSpeed = gSettings.cameraMoveSpeed;
m_cameraMovementSettings.m_rotateSpeed = gSettings.cameraRotateSpeed;
m_cameraMovementSettings.m_fastMoveSpeed = gSettings.cameraFastMoveSpeed;
m_cameraMovementSettings.m_wheelZoomSpeed = gSettings.wheelZoomSpeed;
m_cameraMovementSettings.m_invertYRotation = gSettings.invertYRotation;
m_cameraMovementSettings.m_invertPan = gSettings.invertPan;
}
}
Code/Sandbox/Editor/EditorViewportSettings.cpp
+168 -66
View File
@@ -23,94 +23,196 @@ namespace SandboxEditor
constexpr AZStd::string_view AngleSnappingSetting = "/Amazon/Preferences/Editor/AngleSnapping";
constexpr AZStd::string_view AngleSizeSetting = "/Amazon/Preferences/Editor/AngleSize";
constexpr AZStd::string_view ShowGridSetting = "/Amazon/Preferences/Editor/ShowGrid";
constexpr AZStd::string_view CameraTranslateSpeedSetting = "/Amazon/Preferences/Editor/Camera/TranslateSpeed";
constexpr AZStd::string_view CameraBoostMultiplierSetting = "/Amazon/Preferences/Editor/Camera/BoostMultiplier";
constexpr AZStd::string_view CameraRotateSpeedSetting = "/Amazon/Preferences/Editor/Camera/RotateSpeed";
constexpr AZStd::string_view CameraScrollSpeedSetting = "/Amazon/Preferences/Editor/Camera/DollyScrollSpeed";
constexpr AZStd::string_view CameraDollyMotionSpeedSetting = "/Amazon/Preferences/Editor/Camera/DollyMotionSpeed";
constexpr AZStd::string_view CameraOrbitYawRotationInvertedSetting = "/Amazon/Preferences/Editor/Camera/YawRotationInverted";
constexpr AZStd::string_view CameraPanInvertedXSetting = "/Amazon/Preferences/Editor/Camera/PanInvertedX";
constexpr AZStd::string_view CameraPanInvertedYSetting = "/Amazon/Preferences/Editor/Camera/PanInvertedY";
constexpr AZStd::string_view CameraPanSpeedSetting = "/Amazon/Preferences/Editor/Camera/PanSpeed";
constexpr AZStd::string_view CameraRotateSmoothnessSetting = "/Amazon/Preferences/Editor/Camera/RotateSmoothness";
constexpr AZStd::string_view CameraTranslateSmoothnessSetting = "/Amazon/Preferences/Editor/Camera/TranslateSmoothness";
template<typename T>
void SetRegistry(const AZStd::string_view setting, T&& value)
{
if (auto* registry = AZ::SettingsRegistry::Get())
{
registry->Set(setting, AZStd::forward<T>(value));
}
}
template<typename T>
AZStd::remove_cvref_t<T> GetRegistry(const AZStd::string_view setting, T&& defaultValue)
{
AZStd::remove_cvref_t<T> value = AZStd::forward<T>(defaultValue);
if (auto* registry = AZ::SettingsRegistry::Get())
{
registry->Get(value, setting);
}
return value;
}
bool GridSnappingEnabled()
{
bool enabled = false;
if (auto* registry = AZ::SettingsRegistry::Get())
{
registry->Get(enabled, GridSnappingSetting);
}
return enabled;
}
float GridSnappingSize()
{
double gridSize = 0.1;
if (auto* registry = AZ::SettingsRegistry::Get())
{
registry->Get(gridSize, GridSizeSetting);
}
return aznumeric_cast<float>(gridSize);
}
bool AngleSnappingEnabled()
{
bool enabled = false;
if (auto* registry = AZ::SettingsRegistry::Get())
{
registry->Get(enabled, AngleSnappingSetting);
}
return enabled;
}
float AngleSnappingSize()
{
double angleSize = 5.0;
if (auto* registry = AZ::SettingsRegistry::Get())
{
registry->Get(angleSize, AngleSizeSetting);
}
return aznumeric_cast<float>(angleSize);
}
bool ShowingGrid()
{
bool enabled = false;
if (auto* registry = AZ::SettingsRegistry::Get())
{
registry->Get(enabled, ShowGridSetting);
}
return enabled;
return GetRegistry(GridSnappingSetting, false);
}
void SetGridSnapping(const bool enabled)
{
if (auto* registry = AZ::SettingsRegistry::Get())
{
registry->Set(GridSnappingSetting, enabled);
}
SetRegistry(GridSnappingSetting, enabled);
}
float GridSnappingSize()
{
return aznumeric_cast<float>(GetRegistry(GridSizeSetting, 0.1));
}
void SetGridSnappingSize(const float size)
{
if (auto* registry = AZ::SettingsRegistry::Get())
{
registry->Set(GridSizeSetting, size);
}
SetRegistry(GridSizeSetting, size);
}
bool AngleSnappingEnabled()
{
return GetRegistry(AngleSnappingSetting, false);
}
void SetAngleSnapping(const bool enabled)
{
if (auto* registry = AZ::SettingsRegistry::Get())
{
registry->Set(AngleSnappingSetting, enabled);
}
SetRegistry(AngleSnappingSetting, enabled);
}
float AngleSnappingSize()
{
return aznumeric_cast<float>(GetRegistry(AngleSizeSetting, 5.0));
}
void SetAngleSnappingSize(const float size)
{
if (auto* registry = AZ::SettingsRegistry::Get())
{
registry->Set(AngleSizeSetting, size);
}
SetRegistry(AngleSizeSetting, size);
}
bool ShowingGrid()
{
return GetRegistry(ShowGridSetting, false);
}
void SetShowingGrid(const bool showing)
{
if (auto* registry = AZ::SettingsRegistry::Get())
{
registry->Set(ShowGridSetting, showing);
}
SetRegistry(ShowGridSetting, showing);
}
float CameraTranslateSpeed()
{
return aznumeric_cast<float>(GetRegistry(CameraTranslateSpeedSetting, 10.0));
}
void SetCameraTranslateSpeed(const float speed)
{
SetRegistry(CameraTranslateSpeedSetting, speed);
}
float CameraBoostMultiplier()
{
return aznumeric_cast<float>(GetRegistry(CameraBoostMultiplierSetting, 3.0));
}
void SetCameraBoostMultiplier(const float multiplier)
{
SetRegistry(CameraBoostMultiplierSetting, multiplier);
}
float CameraRotateSpeed()
{
return aznumeric_cast<float>(GetRegistry(CameraRotateSpeedSetting, 0.005));
}
void SetCameraRotateSpeed(const float speed)
{
SetRegistry(CameraRotateSpeedSetting, speed);
}
float CameraScrollSpeed()
{
return aznumeric_cast<float>(GetRegistry(CameraScrollSpeedSetting, 0.02));
}
void SetCameraScrollSpeed(const float speed)
{
SetRegistry(CameraScrollSpeedSetting, speed);
}
float CameraDollyMotionSpeed()
{
return aznumeric_cast<float>(GetRegistry(CameraDollyMotionSpeedSetting, 0.01));
}
void SetCameraDollyMotionSpeed(const float speed)
{
SetRegistry(CameraDollyMotionSpeedSetting, speed);
}
bool CameraOrbitYawRotationInverted()
{
return GetRegistry(CameraOrbitYawRotationInvertedSetting, false);
}
void SetCameraOrbitYawRotationInverted(const bool inverted)
{
SetRegistry(CameraOrbitYawRotationInvertedSetting, inverted);
}
bool CameraPanInvertedX()
{
return GetRegistry(CameraPanInvertedXSetting, true);
}
void SetCameraPanInvertedX(const bool inverted)
{
SetRegistry(CameraPanInvertedXSetting, inverted);
}
bool CameraPanInvertedY()
{
return GetRegistry(CameraPanInvertedYSetting, true);
}
void SetCameraPanInvertedY(const bool inverted)
{
SetRegistry(CameraPanInvertedYSetting, inverted);
}
float CameraPanSpeed()
{
return aznumeric_cast<float>(GetRegistry(CameraPanSpeedSetting, 0.01));
}
void SetCameraPanSpeed(float speed)
{
SetRegistry(CameraPanSpeedSetting, speed);
}
float CameraRotateSmoothness()
{
return aznumeric_cast<float>(GetRegistry(CameraRotateSmoothnessSetting, 5.0));
}
void SetCameraRotateSmoothness(const float smoothness)
{
SetRegistry(CameraRotateSmoothnessSetting, smoothness);
}
float CameraTranslateSmoothness()
{
return aznumeric_cast<float>(GetRegistry(CameraTranslateSmoothnessSetting, 5.0));
}
void SetCameraTranslateSmoothness(const float smoothness)
{
SetRegistry(CameraTranslateSmoothnessSetting, smoothness);
}
} // namespace SandboxEditor
Code/Sandbox/Editor/EditorViewportSettings.h
+37 -9
View File
@@ -17,25 +17,53 @@
namespace SandboxEditor
{
SANDBOX_API bool GridSnappingEnabled();
SANDBOX_API float GridSnappingSize();
SANDBOX_API bool AngleSnappingEnabled();
SANDBOX_API float AngleSnappingSize();
SANDBOX_API bool ShowingGrid();
SANDBOX_API void SetGridSnapping(bool enabled);
SANDBOX_API float GridSnappingSize();
SANDBOX_API void SetGridSnappingSize(float size);
SANDBOX_API bool AngleSnappingEnabled();
SANDBOX_API void SetAngleSnapping(bool enabled);
SANDBOX_API float AngleSnappingSize();
SANDBOX_API void SetAngleSnappingSize(float size);
SANDBOX_API bool ShowingGrid();
SANDBOX_API void SetShowingGrid(bool showing);
SANDBOX_API float CameraTranslateSpeed();
SANDBOX_API void SetCameraTranslateSpeed(float speed);
SANDBOX_API float CameraBoostMultiplier();
SANDBOX_API void SetCameraBoostMultiplier(float multiplier);
SANDBOX_API float CameraRotateSpeed();
SANDBOX_API void SetCameraRotateSpeed(float speed);
SANDBOX_API float CameraScrollSpeed();
SANDBOX_API void SetCameraScrollSpeed(float speed);
SANDBOX_API float CameraDollyMotionSpeed();
SANDBOX_API void SetCameraDollyMotionSpeed(float speed);
SANDBOX_API bool CameraOrbitYawRotationInverted();
SANDBOX_API void SetCameraOrbitYawRotationInverted(bool inverted);
SANDBOX_API bool CameraPanInvertedX();
SANDBOX_API void SetCameraPanInvertedX(bool inverted);
SANDBOX_API bool CameraPanInvertedY();
SANDBOX_API void SetCameraPanInvertedY(bool inverted);
SANDBOX_API float CameraPanSpeed();
SANDBOX_API void SetCameraPanSpeed(float speed);
SANDBOX_API float CameraRotateSmoothness();
SANDBOX_API void SetCameraRotateSmoothness(float smoothness);
SANDBOX_API float CameraTranslateSmoothness();
SANDBOX_API void SetCameraTranslateSmoothness(float smoothness);
//! Return if the new editor camera system is enabled or not.
//! @note This is implemented in EditorViewportWidget.cpp
SANDBOX_API bool UsingNewCameraSystem();
Code/Sandbox/Editor/EditorViewportWidget.cpp
+169 -106
View File
@@ -13,7 +13,6 @@
// Description : implementation filefov
#include "EditorDefs.h"
#include "EditorViewportWidget.h"
@@ -173,6 +172,7 @@ namespace AZ::ViewportHelpers
{
m_renderViewport.OnStopPlayInEditor();
}
private:
EditorViewportWidget& m_renderViewport;
};
@@ -402,7 +402,7 @@ void EditorViewportWidget::InjectFakeMouseMove(int deltaX, int deltaY, Qt::Mouse
}
//////////////////////////////////////////////////////////////////////////
bool EditorViewportWidget::event(QEvent* event)
bool EditorViewportWidget::event(QEvent* event)
{
switch (event->type())
{
@@ -479,7 +479,6 @@ void EditorViewportWidget::Update()
}
m_updatingCameraPosition = false;
// Don't wait for changes to update the focused viewport.
if (CheckRespondToInput())
{
@@ -1205,6 +1204,166 @@ bool EditorViewportWidget::ShowingWorldSpace()
return BuildKeyboardModifiers(QGuiApplication::queryKeyboardModifiers()).Shift();
}
AZStd::shared_ptr<AtomToolsFramework::ModularViewportCameraController> CreateModularViewportCameraController(
AzFramework::ViewportId viewportId)
{
AzFramework::ReloadCameraKeyBindings();
auto controller = AZStd::make_shared<AtomToolsFramework::ModularViewportCameraController>();
controller->SetCameraPropsBuilderCallback(
[](AzFramework::CameraProps& cameraProps)
{
cameraProps.m_rotateSmoothnessFn = []
{
return SandboxEditor::CameraRotateSmoothness();
};
cameraProps.m_translateSmoothnessFn = []
{
return SandboxEditor::CameraTranslateSmoothness();
};
});
controller->SetCameraListBuilderCallback(
[viewportId](AzFramework::Cameras& cameras)
{
auto firstPersonRotateCamera = AZStd::make_shared<AzFramework::RotateCameraInput>(AzFramework::CameraFreeLookButton);
firstPersonRotateCamera->m_rotateSpeedFn = []
{
return SandboxEditor::CameraRotateSpeed();
};
auto firstPersonPanCamera =
AZStd::make_shared<AzFramework::PanCameraInput>(AzFramework::CameraFreePanButton, AzFramework::LookPan);
firstPersonPanCamera->m_panSpeedFn = []
{
return SandboxEditor::CameraPanSpeed();
};
firstPersonPanCamera->m_invertPanXFn = []
{
return SandboxEditor::CameraPanInvertedX();
};
firstPersonPanCamera->m_invertPanYFn = []
{
return SandboxEditor::CameraPanInvertedY();
};
auto firstPersonTranslateCamera = AZStd::make_shared<AzFramework::TranslateCameraInput>(AzFramework::LookTranslation);
firstPersonTranslateCamera->m_translateSpeedFn = []
{
return SandboxEditor::CameraTranslateSpeed();
};
firstPersonTranslateCamera->m_boostMultiplierFn = []
{
return SandboxEditor::CameraBoostMultiplier();
};
auto firstPersonWheelCamera = AZStd::make_shared<AzFramework::ScrollTranslationCameraInput>();
firstPersonWheelCamera->m_scrollSpeedFn = []
{
return SandboxEditor::CameraScrollSpeed();
};
auto orbitCamera = AZStd::make_shared<AzFramework::OrbitCameraInput>();
orbitCamera->SetLookAtFn(
[viewportId](const AZ::Vector3& position, const AZ::Vector3& direction) -> AZStd::optional<AZ::Vector3>
{
AZStd::optional<AZ::Vector3> lookAtAfterInterpolation;
AtomToolsFramework::ModularViewportCameraControllerRequestBus::EventResult(
lookAtAfterInterpolation, viewportId,
&AtomToolsFramework::ModularViewportCameraControllerRequestBus::Events::LookAtAfterInterpolation);
// initially attempt to use the last set look at point after an interpolation has finished
if (lookAtAfterInterpolation.has_value())
{
return *lookAtAfterInterpolation;
}
const float RayDistance = 1000.0f;
AzFramework::RenderGeometry::RayRequest ray;
ray.m_startWorldPosition = position;
ray.m_endWorldPosition = position + direction * RayDistance;
ray.m_onlyVisible = true;
AzFramework::RenderGeometry::RayResult renderGeometryIntersectionResult;
AzFramework::RenderGeometry::IntersectorBus::EventResult(
renderGeometryIntersectionResult, AzToolsFramework::GetEntityContextId(),
&AzFramework::RenderGeometry::IntersectorBus::Events::RayIntersect, ray);
// attempt a ray intersection with any visible mesh and return the intersection position if successful
if (renderGeometryIntersectionResult)
{
return renderGeometryIntersectionResult.m_worldPosition;
}
// if there is no selection or no intersection, fallback to default camera orbit behavior (ground plane
// intersection)
return {};
});
auto orbitRotateCamera = AZStd::make_shared<AzFramework::RotateCameraInput>(AzFramework::CameraOrbitLookButton);
orbitRotateCamera->m_rotateSpeedFn = []
{
return SandboxEditor::CameraRotateSpeed();
};
orbitRotateCamera->m_invertYawFn = []
{
return SandboxEditor::CameraOrbitYawRotationInverted();
};
auto orbitTranslateCamera = AZStd::make_shared<AzFramework::TranslateCameraInput>(AzFramework::OrbitTranslation);
orbitTranslateCamera->m_translateSpeedFn = []
{
return SandboxEditor::CameraTranslateSpeed();
};
orbitTranslateCamera->m_boostMultiplierFn = []
{
return SandboxEditor::CameraBoostMultiplier();
};
auto orbitDollyWheelCamera = AZStd::make_shared<AzFramework::OrbitDollyScrollCameraInput>();
orbitDollyWheelCamera->m_scrollSpeedFn = []
{
return SandboxEditor::CameraScrollSpeed();
};
auto orbitDollyMoveCamera =
AZStd::make_shared<AzFramework::OrbitDollyCursorMoveCameraInput>(AzFramework::CameraOrbitDollyButton);
orbitDollyMoveCamera->m_cursorSpeedFn = []
{
return SandboxEditor::CameraDollyMotionSpeed();
};
auto orbitPanCamera = AZStd::make_shared<AzFramework::PanCameraInput>(AzFramework::CameraOrbitPanButton, AzFramework::OrbitPan);
orbitPanCamera->m_panSpeedFn = []
{
return SandboxEditor::CameraPanSpeed();
};
orbitPanCamera->m_invertPanXFn = []
{
return SandboxEditor::CameraPanInvertedX();
};
orbitPanCamera->m_invertPanYFn = []
{
return SandboxEditor::CameraPanInvertedY();
};
orbitCamera->m_orbitCameras.AddCamera(orbitRotateCamera);
orbitCamera->m_orbitCameras.AddCamera(orbitTranslateCamera);
orbitCamera->m_orbitCameras.AddCamera(orbitDollyWheelCamera);
orbitCamera->m_orbitCameras.AddCamera(orbitDollyMoveCamera);
orbitCamera->m_orbitCameras.AddCamera(orbitPanCamera);
cameras.AddCamera(firstPersonRotateCamera);
cameras.AddCamera(firstPersonPanCamera);
cameras.AddCamera(firstPersonTranslateCamera);
cameras.AddCamera(firstPersonWheelCamera);
cameras.AddCamera(orbitCamera);
});
return controller;
}
void EditorViewportWidget::SetViewportId(int id)
{
CViewport::SetViewportId(id);
@@ -1229,77 +1388,7 @@ void EditorViewportWidget::SetViewportId(int id)
if (ed_useNewCameraSystem)
{
AzFramework::ReloadCameraKeyBindings();
auto controller = AZStd::make_shared<AtomToolsFramework::ModularViewportCameraController>();
controller->SetCameraListBuilderCallback(
[id](AzFramework::Cameras& cameras)
{
auto firstPersonRotateCamera = AZStd::make_shared<AzFramework::RotateCameraInput>(AzFramework::CameraFreeLookButton);
auto firstPersonPanCamera =
AZStd::make_shared<AzFramework::PanCameraInput>(AzFramework::CameraFreePanButton, AzFramework::LookPan);
auto firstPersonTranslateCamera = AZStd::make_shared<AzFramework::TranslateCameraInput>(AzFramework::LookTranslation);
auto firstPersonWheelCamera = AZStd::make_shared<AzFramework::ScrollTranslationCameraInput>();
auto orbitCamera = AZStd::make_shared<AzFramework::OrbitCameraInput>();
orbitCamera->SetLookAtFn(
[id](const AZ::Vector3& position, const AZ::Vector3& direction) -> AZStd::optional<AZ::Vector3>
{
AZStd::optional<AZ::Vector3> lookAtAfterInterpolation;
AtomToolsFramework::ModularViewportCameraControllerRequestBus::EventResult(
lookAtAfterInterpolation, id,
&AtomToolsFramework::ModularViewportCameraControllerRequestBus::Events::LookAtAfterInterpolation);
// initially attempt to use the last set look at point after an interpolation has finished
if (lookAtAfterInterpolation.has_value())
{
return *lookAtAfterInterpolation;
}
const float RayDistance = 1000.0f;
AzFramework::RenderGeometry::RayRequest ray;
ray.m_startWorldPosition = position;
ray.m_endWorldPosition = position + direction * RayDistance;
ray.m_onlyVisible = true;
AzFramework::RenderGeometry::RayResult renderGeometryIntersectionResult;
AzFramework::RenderGeometry::IntersectorBus::EventResult(
renderGeometryIntersectionResult, AzToolsFramework::GetEntityContextId(),
&AzFramework::RenderGeometry::IntersectorBus::Events::RayIntersect, ray);
// attempt a ray intersection with any visible mesh and return the intersection position if successful
if (renderGeometryIntersectionResult)
{
return renderGeometryIntersectionResult.m_worldPosition;
}
// if there is no selection or no intersection, fallback to default camera orbit behavior (ground plane
// intersection)
return {};
});
auto orbitRotateCamera = AZStd::make_shared<AzFramework::RotateCameraInput>(AzFramework::CameraOrbitLookButton);
auto orbitTranslateCamera = AZStd::make_shared<AzFramework::TranslateCameraInput>(AzFramework::OrbitTranslation);
auto orbitDollyWheelCamera = AZStd::make_shared<AzFramework::OrbitDollyScrollCameraInput>();
auto orbitDollyMoveCamera =
AZStd::make_shared<AzFramework::OrbitDollyCursorMoveCameraInput>(AzFramework::CameraOrbitDollyButton);
auto orbitPanCamera =
AZStd::make_shared<AzFramework::PanCameraInput>(AzFramework::CameraOrbitPanButton, AzFramework::OrbitPan);
orbitCamera->m_orbitCameras.AddCamera(orbitRotateCamera);
orbitCamera->m_orbitCameras.AddCamera(orbitTranslateCamera);
orbitCamera->m_orbitCameras.AddCamera(orbitDollyWheelCamera);
orbitCamera->m_orbitCameras.AddCamera(orbitDollyMoveCamera);
orbitCamera->m_orbitCameras.AddCamera(orbitPanCamera);
cameras.AddCamera(firstPersonRotateCamera);
cameras.AddCamera(firstPersonPanCamera);
cameras.AddCamera(firstPersonTranslateCamera);
cameras.AddCamera(firstPersonWheelCamera);
cameras.AddCamera(orbitCamera);
});
m_renderViewport->GetControllerList()->Add(controller);
m_renderViewport->GetControllerList()->Add(CreateModularViewportCameraController(AzFramework::ViewportId(id)));
}
else
{
@@ -1367,7 +1456,7 @@ namespace AZ::ViewportHelpers
action->setCheckable(true);
action->setChecked(*variable);
}
}
} // namespace AZ::ViewportHelpers
//////////////////////////////////////////////////////////////////////////
void EditorViewportWidget::OnTitleMenu(QMenu* menu)
@@ -1615,7 +1704,6 @@ void EditorViewportWidget::ToggleCameraObject()
GetIEditor()->GetAnimation()->ForceAnimation();
}
//////////////////////////////////////////////////////////////////////////
void EditorViewportWidget::SetCamera(const CCamera& camera)
{
@@ -1623,30 +1711,6 @@ void EditorViewportWidget::SetCamera(const CCamera& camera)
SetViewTM(m_Camera.GetMatrix());
}
//////////////////////////////////////////////////////////////////////////
float EditorViewportWidget::GetCameraMoveSpeed() const
{
return gSettings.cameraMoveSpeed;
}
//////////////////////////////////////////////////////////////////////////
float EditorViewportWidget::GetCameraRotateSpeed() const
{
return gSettings.cameraRotateSpeed;
}
//////////////////////////////////////////////////////////////////////////
bool EditorViewportWidget::GetCameraInvertYRotation() const
{
return gSettings.invertYRotation;
}
//////////////////////////////////////////////////////////////////////////
float EditorViewportWidget::GetCameraInvertPan() const
{
return gSettings.invertPan;
}
//////////////////////////////////////////////////////////////////////////
EditorViewportWidget* EditorViewportWidget::GetPrimaryViewport()
{
@@ -1946,7 +2010,6 @@ void EditorViewportWidget::RenderSelectedRegion()
Vec3(x1, y2, fMinZ)
};
// Generate vertices
static AABB boxPrev(AABB::RESET);
static std::vector<Vec3> verts;
@@ -2508,14 +2571,14 @@ void EditorViewportWidget::SetSequenceCamera()
}
//////////////////////////////////////////////////////////////////////////
void EditorViewportWidget::SetComponentCamera(const AZ::EntityId& entityId)
void EditorViewportWidget::SetComponentCamera(const AZ::EntityId& entityId)
{
ResetToViewSourceType(ViewSourceType::CameraComponent);
SetViewEntity(entityId);
}
//////////////////////////////////////////////////////////////////////////
void EditorViewportWidget::SetEntityAsCamera(const AZ::EntityId& entityId, bool lockCameraMovement)
void EditorViewportWidget::SetEntityAsCamera(const AZ::EntityId& entityId, bool lockCameraMovement)
{
ResetToViewSourceType(ViewSourceType::AZ_Entity);
SetViewEntity(entityId, lockCameraMovement);
@@ -2764,18 +2827,18 @@ bool EditorViewportWidget::IsRenderingDisabled() const
}
//////////////////////////////////////////////////////////////////////////
QPoint EditorViewportWidget::WidgetToViewport(const QPoint &point) const
QPoint EditorViewportWidget::WidgetToViewport(const QPoint& point) const
{
return point * WidgetToViewportFactor();
}
QPoint EditorViewportWidget::ViewportToWidget(const QPoint &point) const
QPoint EditorViewportWidget::ViewportToWidget(const QPoint& point) const
{
return point / WidgetToViewportFactor();
}
//////////////////////////////////////////////////////////////////////////
QSize EditorViewportWidget::WidgetToViewport(const QSize &size) const
QSize EditorViewportWidget::WidgetToViewport(const QSize& size) const
{
return size * WidgetToViewportFactor();
}
Code/Sandbox/Editor/EditorViewportWidget.h
-5
View File
@@ -328,11 +328,6 @@ protected:
void SetViewTM(const Matrix34& tm, bool bMoveOnly);
virtual float GetCameraMoveSpeed() const;
virtual float GetCameraRotateSpeed() const;
virtual bool GetCameraInvertYRotation() const;
virtual float GetCameraInvertPan() const;
// Called to render stuff.
virtual void OnRender();
Code/Sandbox/Editor/MainWindow.cpp
-6
View File
@@ -842,12 +842,6 @@ void MainWindow::InitActions()
am->AddAction(ID_SWITCHCAMERA_NEXT, tr("Cycle Camera"))
.SetShortcut(tr("Ctrl+`"))
.SetToolTip(tr("Cycle Camera (Ctrl+`)"));
am->AddAction(ID_CHANGEMOVESPEED_INCREASE, tr("Increase"))
.SetStatusTip(tr("Increase Flycam Movement Speed"));
am->AddAction(ID_CHANGEMOVESPEED_DECREASE, tr("Decrease"))
.SetStatusTip(tr("Decrease Flycam Movement Speed"));
am->AddAction(ID_CHANGEMOVESPEED_CHANGESTEP, tr("Change Step"))
.SetStatusTip(tr("Change Flycam Movement Step"));
am->AddAction(ID_DISPLAY_GOTOPOSITION, tr("Go to Position..."));
am->AddAction(ID_MODIFY_GOTO_SELECTION, tr("Center on Selection"))
.SetShortcut(tr("Z"))
Code/Sandbox/Editor/Resource.h
-3
View File
@@ -89,9 +89,6 @@
#define ID_EXPORT_INDOORS 32915
#define ID_VIEW_CYCLE2DVIEWPORT 32916
#define ID_SNAPANGLE 32917
#define ID_CHANGEMOVESPEED_INCREASE 32928
#define ID_CHANGEMOVESPEED_DECREASE 32929
#define ID_CHANGEMOVESPEED_CHANGESTEP 32930
#define ID_PHYSICS_GETPHYSICSSTATE 32937
#define ID_PHYSICS_RESETPHYSICSSTATE 32938
#define ID_GAME_SYNCPLAYER 32941
Code/Sandbox/Editor/ViewportTitleDlg.cpp
+14 -5
View File
@@ -170,7 +170,7 @@ void CViewportTitleDlg::SetupCameraDropdownMenu()
cameraSpeedActionWidget->setDefaultWidget(cameraSpeedContainer);
// Save off the move speed here since setting up the combo box can cause it to update values in the background.
float cameraMoveSpeed = gSettings.cameraMoveSpeed;
const float cameraMoveSpeed = SandboxEditor::UsingNewCameraSystem() ? SandboxEditor::CameraTranslateSpeed() : gSettings.cameraMoveSpeed;
// Populate the presets in the ComboBox
for (float presetValue : m_speedPresetValues)
@@ -901,15 +901,24 @@ void CViewportTitleDlg::OnSpeedComboBoxEnter()
void CViewportTitleDlg::OnUpdateMoveSpeedText(const QString& text)
{
gSettings.cameraMoveSpeed = aznumeric_cast<float>(Round(text.toDouble(), m_speedStep));
if (SandboxEditor::UsingNewCameraSystem())
{
SandboxEditor::SetCameraTranslateSpeed(aznumeric_cast<float>(Round(text.toDouble(), m_speedStep)));
}
else
{
gSettings.cameraMoveSpeed = aznumeric_cast<float>(Round(text.toDouble(), m_speedStep));
}
}
void CViewportTitleDlg::CheckForCameraSpeedUpdate()
{
if (gSettings.cameraMoveSpeed != m_prevMoveSpeed && !m_cameraSpeed->lineEdit()->hasFocus())
if (const float currentCameraMoveSpeed =
SandboxEditor::UsingNewCameraSystem() ? SandboxEditor::CameraTranslateSpeed() : gSettings.cameraMoveSpeed;
currentCameraMoveSpeed != m_prevMoveSpeed && !m_cameraSpeed->lineEdit()->hasFocus())
{
m_prevMoveSpeed = gSettings.cameraMoveSpeed;
SetSpeedComboBox(gSettings.cameraMoveSpeed);
m_prevMoveSpeed = currentCameraMoveSpeed;
SetSpeedComboBox(currentCameraMoveSpeed);
}
}
Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Viewport/ModularViewportCameraController.h
+7
View File
@@ -27,14 +27,20 @@ namespace AtomToolsFramework
{
public:
using CameraListBuilder = AZStd::function<void(AzFramework::Cameras&)>;
using CameraPropsBuilder = AZStd::function<void(AzFramework::CameraProps&)>;
//! Sets the camera list builder callback used to populate new ModernViewportCameraControllerInstances
void SetCameraListBuilderCallback(const CameraListBuilder& builder);
//! Sets the camera props builder callback used to populate new ModernViewportCameraControllerInstances
void SetCameraPropsBuilderCallback(const CameraPropsBuilder& builder);
//! Sets up a camera list based on this controller's CameraListBuilderCallback
void SetupCameras(AzFramework::Cameras& cameras);
//! Sets up properties shared across all cameras
void SetupCameraProperies(AzFramework::CameraProps& cameraProps);
private:
CameraListBuilder m_cameraListBuilder;
CameraPropsBuilder m_cameraPropsBuilder;
};
class ModernViewportCameraControllerInstance final
@@ -67,6 +73,7 @@ namespace AtomToolsFramework
AzFramework::Camera m_camera;
AzFramework::Camera m_targetCamera;
AzFramework::CameraSystem m_cameraSystem;
AzFramework::CameraProps m_cameraProps;
AZ::Transform m_transformStart = AZ::Transform::CreateIdentity();
AZ::Transform m_transformEnd = AZ::Transform::CreateIdentity();
Gems/Atom/Tools/AtomToolsFramework/Code/Source/Viewport/ModularViewportCameraController.cpp
+20 -2
View File
@@ -26,7 +26,11 @@
namespace AtomToolsFramework
{
AZ_CVAR(
AZ::Color, ed_cameraSystemOrbitPointColor, AZ::Color::CreateFromRgba(255, 255, 255, 255), nullptr, AZ::ConsoleFunctorFlags::Null,
AZ::Color,
ed_cameraSystemOrbitPointColor,
AZ::Color::CreateFromRgba(255, 255, 255, 255),
nullptr,
AZ::ConsoleFunctorFlags::Null,
"");
AZ_CVAR(float, ed_cameraSystemOrbitPointSize, 0.5f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
@@ -63,6 +67,11 @@ namespace AtomToolsFramework
m_cameraListBuilder = builder;
}
void ModularViewportCameraController::SetCameraPropsBuilderCallback(const CameraPropsBuilder& builder)
{
m_cameraPropsBuilder = builder;
}
void ModularViewportCameraController::SetupCameras(AzFramework::Cameras& cameras)
{
if (m_cameraListBuilder)
@@ -71,11 +80,20 @@ namespace AtomToolsFramework
}
}
void ModularViewportCameraController::SetupCameraProperies(AzFramework::CameraProps& cameraProps)
{
if (m_cameraPropsBuilder)
{
m_cameraPropsBuilder(cameraProps);
}
}
ModernViewportCameraControllerInstance::ModernViewportCameraControllerInstance(
const AzFramework::ViewportId viewportId, ModularViewportCameraController* controller)
: MultiViewportControllerInstanceInterface<ModularViewportCameraController>(viewportId, controller)
{
controller->SetupCameras(m_cameraSystem.m_cameras);
controller->SetupCameraProperies(m_cameraProps);
if (auto viewportContext = RetrieveViewportContext(GetViewportId()))
{
@@ -138,7 +156,7 @@ namespace AtomToolsFramework
if (m_cameraMode == CameraMode::Control)
{
m_targetCamera = m_cameraSystem.StepCamera(m_targetCamera, event.m_deltaTime.count());
m_camera = AzFramework::SmoothCamera(m_camera, m_targetCamera, event.m_deltaTime.count());
m_camera = AzFramework::SmoothCamera(m_camera, m_targetCamera, m_cameraProps, event.m_deltaTime.count());
// if there has been an interpolation, only clear the look at point if it is no longer
// centered in the view (the camera has looked away from it)