169 changes: 76 additions & 93 deletions Source/Core/VideoCommon/FreeLookCamera.cpp
View file
Expand Up @@ -35,12 +35,12 @@ std::string to_string(FreeLook::ControlType type)
return "";
}

class SixAxisController final : public CameraController
class SixAxisController final : public CameraControllerInput
{
public:
SixAxisController() = default;

Common::Matrix44 GetView() override { return m_mat; }
Common::Matrix44 GetView() const override { return m_mat; }

void MoveVertical(float amt) override
{
Expand All @@ -64,18 +64,26 @@ class SixAxisController final : public CameraController
m_mat = Common::Matrix44::FromQuaternion(quat) * m_mat;
}

void Reset() override { m_mat = Common::Matrix44::Identity(); }
void Reset() override
{
CameraControllerInput::Reset();
m_mat = Common::Matrix44::Identity();
}

void DoState(PointerWrap& p) override { p.Do(m_mat); }
void DoState(PointerWrap& p) override
{
CameraControllerInput::DoState(p);
p.Do(m_mat);
}

private:
Common::Matrix44 m_mat = Common::Matrix44::Identity();
};

class FPSController final : public CameraController
class FPSController final : public CameraControllerInput
{
public:
Common::Matrix44 GetView() override
Common::Matrix44 GetView() const override
{
return Common::Matrix44::FromQuaternion(m_rotate_quat) *
Common::Matrix44::Translate(m_position);
Expand Down Expand Up @@ -118,13 +126,15 @@ class FPSController final : public CameraController

void Reset() override
{
CameraControllerInput::Reset();
m_position = Common::Vec3{};
m_rotation = Common::Vec3{};
m_rotate_quat = Common::Quaternion::Identity();
}

void DoState(PointerWrap& p) override
{
CameraControllerInput::DoState(p);
p.Do(m_rotation);
p.Do(m_rotate_quat);
p.Do(m_position);
Expand All @@ -136,10 +146,10 @@ class FPSController final : public CameraController
Common::Vec3 m_position = Common::Vec3{};
};

class OrbitalController final : public CameraController
class OrbitalController final : public CameraControllerInput
{
public:
Common::Matrix44 GetView() override
Common::Matrix44 GetView() const override
{
return Common::Matrix44::Translate(Common::Vec3{0, 0, -m_distance}) *
Common::Matrix44::FromQuaternion(m_rotate_quat);
Expand All @@ -152,7 +162,7 @@ class OrbitalController final : public CameraController
void MoveForward(float amt) override
{
m_distance += -1 * amt;
m_distance = std::clamp(m_distance, 0.0f, m_distance);
m_distance = std::max(m_distance, MIN_DISTANCE);
}

void Rotate(const Common::Vec3& amt) override
Expand All @@ -174,142 +184,123 @@ class OrbitalController final : public CameraController

void Reset() override
{
CameraControllerInput::Reset();
m_rotation = Common::Vec3{};
m_rotate_quat = Common::Quaternion::Identity();
m_distance = 0;
m_distance = MIN_DISTANCE;
}

void DoState(PointerWrap& p) override
{
CameraControllerInput::DoState(p);
p.Do(m_rotation);
p.Do(m_rotate_quat);
p.Do(m_distance);
}

private:
float m_distance = 0;
static constexpr float MIN_DISTANCE = 0.0f;
float m_distance = MIN_DISTANCE;
Common::Vec3 m_rotation = Common::Vec3{};
Common::Quaternion m_rotate_quat = Common::Quaternion::Identity();
};
} // namespace

FreeLookCamera::FreeLookCamera()
Common::Vec2 CameraControllerInput::GetFieldOfViewMultiplier() const
{
SetControlType(FreeLook::ControlType::SixAxis);
}

void FreeLookCamera::SetControlType(FreeLook::ControlType type)
{
if (m_current_type && *m_current_type == type)
{
return;
}

if (type == FreeLook::ControlType::SixAxis)
{
m_camera_controller = std::make_unique<SixAxisController>();
}
else if (type == FreeLook::ControlType::Orbital)
{
m_camera_controller = std::make_unique<OrbitalController>();
}
else if (type == FreeLook::ControlType::FPS)
{
m_camera_controller = std::make_unique<FPSController>();
}

m_current_type = type;
return Common::Vec2{m_fov_x_multiplier, m_fov_y_multiplier};
}

Common::Matrix44 FreeLookCamera::GetView()
void CameraControllerInput::DoState(PointerWrap& p)
{
return m_camera_controller->GetView();
p.Do(m_speed);
p.Do(m_fov_x_multiplier);
p.Do(m_fov_y_multiplier);
}

Common::Vec2 FreeLookCamera::GetFieldOfView() const
void CameraControllerInput::IncreaseFovX(float fov)
{
return Common::Vec2{m_fov_x, m_fov_y};
m_fov_x_multiplier += fov;
m_fov_x_multiplier = std::max(m_fov_x_multiplier, MIN_FOV_MULTIPLIER);
}

void FreeLookCamera::MoveVertical(float amt)
void CameraControllerInput::IncreaseFovY(float fov)
{
m_camera_controller->MoveVertical(amt);
m_dirty = true;
m_fov_y_multiplier += fov;
m_fov_y_multiplier = std::max(m_fov_y_multiplier, MIN_FOV_MULTIPLIER);
}

void FreeLookCamera::MoveHorizontal(float amt)
float CameraControllerInput::GetFovStepSize() const
{
m_camera_controller->MoveHorizontal(amt);
m_dirty = true;
return 1.5f;
}

void FreeLookCamera::MoveForward(float amt)
void CameraControllerInput::Reset()
{
m_camera_controller->MoveForward(amt);
m_fov_x_multiplier = DEFAULT_FOV_MULTIPLIER;
m_fov_y_multiplier = DEFAULT_FOV_MULTIPLIER;
m_dirty = true;
}

void FreeLookCamera::Rotate(const Common::Vec3& amt)
void CameraControllerInput::ModifySpeed(float amt)
{
m_camera_controller->Rotate(amt);
m_dirty = true;
m_speed += amt;
m_speed = std::max(m_speed, 0.0f);
}

void FreeLookCamera::Rotate(const Common::Quaternion& amt)
void CameraControllerInput::ResetSpeed()
{
m_camera_controller->Rotate(amt);
m_dirty = true;
m_speed = DEFAULT_SPEED;
}

void FreeLookCamera::IncreaseFovX(float fov)
float CameraControllerInput::GetSpeed() const
{
m_fov_x += fov;
m_fov_x = std::clamp(m_fov_x, m_min_fov_multiplier, m_fov_x);
return m_speed;
}

void FreeLookCamera::IncreaseFovY(float fov)
FreeLookCamera::FreeLookCamera()
{
m_fov_y += fov;
m_fov_y = std::clamp(m_fov_y, m_min_fov_multiplier, m_fov_y);
SetControlType(FreeLook::ControlType::SixAxis);
}

float FreeLookCamera::GetFovStepSize() const
void FreeLookCamera::SetControlType(FreeLook::ControlType type)
{
return 1.5f;
}
if (m_current_type && *m_current_type == type)
{
return;
}

void FreeLookCamera::Reset()
{
m_camera_controller->Reset();
m_fov_x = 1.0f;
m_fov_y = 1.0f;
m_dirty = true;
}
if (type == FreeLook::ControlType::SixAxis)
{
m_camera_controller = std::make_unique<SixAxisController>();
}
else if (type == FreeLook::ControlType::Orbital)
{
m_camera_controller = std::make_unique<OrbitalController>();
}
else if (type == FreeLook::ControlType::FPS)
{
m_camera_controller = std::make_unique<FPSController>();
}

void FreeLookCamera::ModifySpeed(float amt)
{
m_speed += amt;
m_speed = std::clamp(m_speed, 0.0f, m_speed);
m_current_type = type;
}

void FreeLookCamera::ResetSpeed()
Common::Matrix44 FreeLookCamera::GetView() const
{
m_speed = 60.0f;
return m_camera_controller->GetView();
}

float FreeLookCamera::GetSpeed() const
Common::Vec2 FreeLookCamera::GetFieldOfViewMultiplier() const
{
return m_speed;
return m_camera_controller->GetFieldOfViewMultiplier();
}

void FreeLookCamera::DoState(PointerWrap& p)
{
if (p.mode == PointerWrap::MODE_WRITE || p.mode == PointerWrap::MODE_MEASURE)
{
p.Do(m_speed);
p.Do(m_current_type);
p.Do(m_fov_x);
p.Do(m_fov_y);
if (m_camera_controller)
{
m_camera_controller->DoState(p);
Expand All @@ -318,10 +309,7 @@ void FreeLookCamera::DoState(PointerWrap& p)
else
{
const auto old_type = m_current_type;
p.Do(m_speed);
p.Do(m_current_type);
p.Do(m_fov_x);
p.Do(m_fov_y);
if (old_type == m_current_type)
{
m_camera_controller->DoState(p);
Expand All @@ -340,17 +328,12 @@ void FreeLookCamera::DoState(PointerWrap& p)
}
}

bool FreeLookCamera::IsDirty() const
{
return m_dirty;
}

void FreeLookCamera::SetClean()
bool FreeLookCamera::IsActive() const
{
m_dirty = false;
return FreeLook::GetActiveConfig().enabled;
}

bool FreeLookCamera::IsActive() const
CameraController* FreeLookCamera::GetController() const
{
return FreeLook::GetActiveConfig().enabled;
return m_camera_controller.get();
}
73 changes: 43 additions & 30 deletions Source/Core/VideoCommon/FreeLookCamera.h
View file
Expand Up @@ -23,7 +23,28 @@ class CameraController
CameraController(CameraController&&) = delete;
CameraController& operator=(CameraController&&) = delete;

virtual Common::Matrix44 GetView() = 0;
virtual Common::Matrix44 GetView() const = 0;
virtual Common::Vec2 GetFieldOfViewMultiplier() const = 0;

virtual void DoState(PointerWrap& p) = 0;

virtual bool IsDirty() const = 0;
virtual void SetClean() = 0;

virtual bool SupportsInput() const = 0;
};

class CameraControllerInput : public CameraController
{
public:
Common::Vec2 GetFieldOfViewMultiplier() const final override;

void DoState(PointerWrap& p) override;

bool IsDirty() const final override { return m_dirty; }
void SetClean() final override { m_dirty = false; }

bool SupportsInput() const final override { return true; }

virtual void MoveVertical(float amt) = 0;
virtual void MoveHorizontal(float amt) = 0;
Expand All @@ -35,50 +56,42 @@ class CameraController

virtual void Reset() = 0;

virtual void DoState(PointerWrap& p) = 0;
void IncreaseFovX(float fov);
void IncreaseFovY(float fov);
float GetFovStepSize() const;

void ModifySpeed(float multiplier);
void ResetSpeed();
float GetSpeed() const;

private:
static constexpr float MIN_FOV_MULTIPLIER = 0.025f;
static constexpr float DEFAULT_SPEED = 60.0f;
static constexpr float DEFAULT_FOV_MULTIPLIER = 1.0f;

float m_fov_x_multiplier = DEFAULT_FOV_MULTIPLIER;
float m_fov_y_multiplier = DEFAULT_FOV_MULTIPLIER;
float m_speed = DEFAULT_SPEED;
bool m_dirty = false;
};

class FreeLookCamera
{
public:
FreeLookCamera();
void SetControlType(FreeLook::ControlType type);
Common::Matrix44 GetView();
Common::Vec2 GetFieldOfView() const;

void MoveVertical(float amt);
void MoveHorizontal(float amt);
void MoveForward(float amt);

void Rotate(const Common::Vec3& amt);
void Rotate(const Common::Quaternion& amt);

void IncreaseFovX(float fov);
void IncreaseFovY(float fov);
float GetFovStepSize() const;

void Reset();
Common::Matrix44 GetView() const;
Common::Vec2 GetFieldOfViewMultiplier() const;

void DoState(PointerWrap& p);

bool IsDirty() const;
void SetClean();

void ModifySpeed(float multiplier);
void ResetSpeed();
float GetSpeed() const;

bool IsActive() const;

CameraController* GetController() const;

private:
bool m_dirty = false;
float m_fov_x = 1.0f;
float m_fov_y = 1.0f;
std::optional<FreeLook::ControlType> m_current_type;
std::unique_ptr<CameraController> m_camera_controller;

float m_min_fov_multiplier = 0.025f;
float m_speed = 60.0f;
};

extern FreeLookCamera g_freelook_camera;
21 changes: 13 additions & 8 deletions Source/Core/VideoCommon/VertexShaderManager.cpp
View file
Expand Up @@ -356,7 +356,7 @@ void VertexShaderManager::SetConstants()
}
}

if (bProjectionChanged || g_freelook_camera.IsDirty())
if (bProjectionChanged || g_freelook_camera.GetController()->IsDirty())
{
bProjectionChanged = false;

Expand All @@ -366,16 +366,21 @@ void VertexShaderManager::SetConstants()
{
case ProjectionType::Perspective:
{
const Common::Vec2 fov =
g_freelook_camera.IsActive() ? g_freelook_camera.GetFieldOfView() : Common::Vec2{1, 1};
g_fProjectionMatrix[0] = rawProjection[0] * g_ActiveConfig.fAspectRatioHackW * fov.x;
const Common::Vec2 fov_multiplier = g_freelook_camera.IsActive() ?
g_freelook_camera.GetFieldOfViewMultiplier() :
Common::Vec2{1, 1};
g_fProjectionMatrix[0] =
rawProjection[0] * g_ActiveConfig.fAspectRatioHackW * fov_multiplier.x;
g_fProjectionMatrix[1] = 0.0f;
g_fProjectionMatrix[2] = rawProjection[1] * g_ActiveConfig.fAspectRatioHackW * fov.x;
g_fProjectionMatrix[2] =
rawProjection[1] * g_ActiveConfig.fAspectRatioHackW * fov_multiplier.x;
g_fProjectionMatrix[3] = 0.0f;

g_fProjectionMatrix[4] = 0.0f;
g_fProjectionMatrix[5] = rawProjection[2] * g_ActiveConfig.fAspectRatioHackH * fov.y;
g_fProjectionMatrix[6] = rawProjection[3] * g_ActiveConfig.fAspectRatioHackH * fov.y;
g_fProjectionMatrix[5] =
rawProjection[2] * g_ActiveConfig.fAspectRatioHackH * fov_multiplier.y;
g_fProjectionMatrix[6] =
rawProjection[3] * g_ActiveConfig.fAspectRatioHackH * fov_multiplier.y;
g_fProjectionMatrix[7] = 0.0f;

g_fProjectionMatrix[8] = 0.0f;
Expand Down Expand Up @@ -435,7 +440,7 @@ void VertexShaderManager::SetConstants()

memcpy(constants.projection.data(), corrected_matrix.data.data(), 4 * sizeof(float4));

g_freelook_camera.SetClean();
g_freelook_camera.GetController()->SetClean();

dirty = true;
}
Expand Down