272 Source/Core/VideoCommon/FreeLookCamera.cpp
View file
@@ -0,0 +1,272 @@
// Copyright 2020 Dolphin Emulator Project
// Licensed under GPLv2+
// Refer to the license.txt file included.

#include "VideoCommon/FreeLookCamera.h"

#include <algorithm>
#include <math.h>

#include <fmt/format.h>

#include "Common/MathUtil.h"

#include "Common/ChunkFile.h"
#include "Core/Config/GraphicsSettings.h"
#include "Core/ConfigManager.h"
#include "Core/Core.h"
#include "VideoCommon/VideoCommon.h"
#include "VideoCommon/VideoConfig.h"

FreeLookCamera g_freelook_camera;

namespace
{
std::string to_string(FreelookControlType type)
{
switch (type)
{
case FreelookControlType::SixAxis:
return "Six Axis";
case FreelookControlType::FPS:
return "First Person";
case FreelookControlType::Orbital:
return "Orbital";
}

return "";
}

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

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

void MoveVertical(float amt) override
{
m_mat = Common::Matrix44::Translate(Common::Vec3{0, amt, 0}) * m_mat;
}

void MoveHorizontal(float amt) override
{
m_mat = Common::Matrix44::Translate(Common::Vec3{amt, 0, 0}) * m_mat;
}

void Zoom(float amt) override
{
m_mat = Common::Matrix44::Translate(Common::Vec3{0, 0, amt}) * m_mat;
}

void Rotate(const Common::Vec3& amt) override
{
using Common::Matrix33;
m_mat = Common::Matrix44::FromMatrix33(Matrix33::RotateX(amt.x) * Matrix33::RotateY(amt.y) *
Matrix33::RotateZ(amt.z)) *
m_mat;
}

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

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

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

constexpr double HalfPI = MathUtil::PI / 2;

class FPSController : public CameraController
{
public:
Common::Matrix44 GetView() override
{
return m_rotate_mat * Common::Matrix44::Translate(m_position);
}

void MoveVertical(float amt) override
{
Common::Vec3 up{m_rotate_mat.data[4], m_rotate_mat.data[5], m_rotate_mat.data[6]};
m_position += up * amt;
}

void MoveHorizontal(float amt) override
{
Common::Vec3 right{m_rotate_mat.data[0], m_rotate_mat.data[1], m_rotate_mat.data[2]};
m_position += right * amt;
}

void Zoom(float amt) override
{
Common::Vec3 forward{m_rotate_mat.data[8], m_rotate_mat.data[9], m_rotate_mat.data[10]};
m_position += forward * amt;
}

void Rotate(const Common::Vec3& amt) override
{
m_rotation += amt;

using Common::Matrix33;
using Common::Matrix44;
m_rotate_mat =
Matrix44::FromMatrix33(Matrix33::RotateX(m_rotation.x) * Matrix33::RotateY(m_rotation.y));
}

void Reset() override
{
m_position = Common::Vec3{};
m_rotation = Common::Vec3{};
m_rotate_mat = Common::Matrix44::Identity();
}

void DoState(PointerWrap& p)
{
p.Do(m_rotation);
p.Do(m_rotate_mat);
p.Do(m_position);
}

private:
Common::Vec3 m_rotation = Common::Vec3{};
Common::Matrix44 m_rotate_mat = Common::Matrix44::Identity();
Common::Vec3 m_position = Common::Vec3{};
};

class OrbitalController : public CameraController
{
public:
Common::Matrix44 GetView() override
{
Common::Matrix44 result = Common::Matrix44::Identity();
result *= Common::Matrix44::Translate(Common::Vec3{0, 0, -m_distance});
result *= Common::Matrix44::FromMatrix33(Common::Matrix33::RotateX(m_rotation.x));
result *= Common::Matrix44::FromMatrix33(Common::Matrix33::RotateY(m_rotation.y));

return result;
}

void MoveVertical(float) override {}

void MoveHorizontal(float) override {}

void Zoom(float amt) override
{
m_distance += -1 * amt;
m_distance = std::clamp(m_distance, 0.0f, m_distance);
}

void Rotate(const Common::Vec3& amt) override { m_rotation += amt; }

void Reset() override
{
m_rotation = Common::Vec3{};
m_distance = 0;
}

void DoState(PointerWrap& p)
{
p.Do(m_rotation);
p.Do(m_distance);
}

private:
float m_distance = 0;
Common::Vec3 m_rotation = Common::Vec3{};
};
} // namespace

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

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

m_current_type = type;
}

Common::Matrix44 FreeLookCamera::GetView()
{
return m_camera_controller->GetView();
}

void FreeLookCamera::MoveVertical(float amt)
{
m_camera_controller->MoveVertical(amt);
m_dirty = true;
}

void FreeLookCamera::MoveHorizontal(float amt)
{
m_camera_controller->MoveHorizontal(amt);
m_dirty = true;
}

void FreeLookCamera::Zoom(float amt)
{
m_camera_controller->Zoom(amt);
m_dirty = true;
}

void FreeLookCamera::Rotate(const Common::Vec3& amt)
{
m_camera_controller->Rotate(amt);
m_dirty = true;
}

void FreeLookCamera::Reset()
{
m_camera_controller->Reset();
m_dirty = true;
}

void FreeLookCamera::DoState(PointerWrap& p)
{
if (p.mode == PointerWrap::MODE_WRITE || p.mode == PointerWrap::MODE_MEASURE)
{
p.Do(m_current_type);
if (m_camera_controller)
{
m_camera_controller->DoState(p);
}
}
else
{
const auto old_type = m_current_type;
p.Do(m_current_type);
if (old_type == m_current_type)
{
m_camera_controller->DoState(p);
}
else if (p.GetMode() == PointerWrap::MODE_READ)
{
const std::string old_type_name = old_type ? to_string(*old_type) : "";
const std::string loaded_type_name = m_current_type ? to_string(*m_current_type) : "";
const std::string message =
fmt::format("State needs same free look camera type. Settings value '{}', loaded value "
"'{}'. Aborting load state",
old_type_name, loaded_type_name);
Core::DisplayMessage(message, 5000);
p.SetMode(PointerWrap::MODE_VERIFY);
}
}
}

bool FreeLookCamera::IsDirty() const
{
return m_dirty;
}
66 Source/Core/VideoCommon/FreeLookCamera.h
View file
@@ -0,0 +1,66 @@
// Copyright 2020 Dolphin Emulator Project
// Licensed under GPLv2+
// Refer to the license.txt file included.

#pragma once

#include <memory>
#include <optional>

#include "Common/Matrix.h"
#include "VideoCommon/VideoConfig.h"

class PointerWrap;

class CameraController
{
public:
CameraController() = default;
virtual ~CameraController() = default;

CameraController(const CameraController&) = delete;
CameraController& operator=(const CameraController&) = delete;

CameraController(CameraController&&) = delete;
CameraController& operator=(CameraController&&) = delete;

virtual Common::Matrix44 GetView() = 0;

virtual void MoveVertical(float amt) = 0;
virtual void MoveHorizontal(float amt) = 0;

virtual void Zoom(float amt) = 0;

virtual void Rotate(const Common::Vec3& amt) = 0;

virtual void Reset() = 0;

virtual void DoState(PointerWrap& p) = 0;
};

class FreeLookCamera
{
public:
void SetControlType(FreelookControlType type);
Common::Matrix44 GetView();

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

void Zoom(float amt);

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

void Reset();

void DoState(PointerWrap& p);

bool IsDirty() const;

private:
bool m_dirty = false;
std::optional<FreelookControlType> m_current_type;
std::unique_ptr<CameraController> m_camera_controller;
};

extern FreeLookCamera g_freelook_camera;
40 Source/Core/VideoCommon/VertexShaderManager.cpp
View file
@@ -12,13 +12,16 @@
#include "Common/BitSet.h"
#include "Common/ChunkFile.h"
#include "Common/CommonTypes.h"
#include "Common/Config/Config.h"
#include "Common/Logging/Log.h"
#include "Common/Matrix.h"
#include "Core/Config/GraphicsSettings.h"
#include "Core/ConfigManager.h"
#include "Core/Core.h"
#include "VideoCommon/BPFunctions.h"
#include "VideoCommon/BPMemory.h"
#include "VideoCommon/CPMemory.h"
#include "VideoCommon/FreeLookCamera.h"
#include "VideoCommon/RenderBase.h"
#include "VideoCommon/Statistics.h"
#include "VideoCommon/VertexManagerBase.h"
@@ -42,7 +45,6 @@ static std::array<int, 2> nPostTransformMatricesChanged; // min,max
static std::array<int, 2> nLightsChanged; // min,max

static Common::Matrix44 s_viewportCorrection;
static Common::Matrix44 s_freelook_matrix;

VertexShaderConstants VertexShaderManager::constants;
bool VertexShaderManager::dirty;
@@ -110,10 +112,10 @@ void VertexShaderManager::Init()
bViewportChanged = false;
bTexMtxInfoChanged = false;
bLightingConfigChanged = false;
g_freelook_camera.SetControlType(Config::Get(Config::GFX_FREE_LOOK_CONTROL_TYPE));

std::memset(static_cast<void*>(&xfmem), 0, sizeof(xfmem));
constants = {};
ResetView();

// TODO: should these go inside ResetView()?
s_viewportCorrection = Common::Matrix44::Identity();
@@ -344,7 +346,7 @@ void VertexShaderManager::SetConstants()
}
}

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

@@ -413,7 +415,7 @@ void VertexShaderManager::SetConstants()
auto corrected_matrix = s_viewportCorrection * Common::Matrix44::FromArray(g_fProjectionMatrix);

if (g_ActiveConfig.bFreeLook && xfmem.projection.type == GX_PERSPECTIVE)
corrected_matrix *= s_freelook_matrix;
corrected_matrix *= g_freelook_camera.GetView();

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

@@ -445,6 +447,9 @@ void VertexShaderManager::SetConstants()

dirty = true;
}

// Handle a potential config change
g_freelook_camera.SetControlType(Config::Get(Config::GFX_FREE_LOOK_CONTROL_TYPE));
}

void VertexShaderManager::InvalidateXFRange(int start, int end)
@@ -600,31 +605,6 @@ void VertexShaderManager::SetMaterialColorChanged(int index)
nMaterialsChanged[index] = true;
}

void VertexShaderManager::TranslateView(float x, float y, float z)
{
s_freelook_matrix = Common::Matrix44::Translate({x, z, y}) * s_freelook_matrix;

bProjectionChanged = true;
}

void VertexShaderManager::RotateView(float x, float y, float z)
{
using Common::Matrix33;

s_freelook_matrix = Common::Matrix44::FromMatrix33(Matrix33::RotateX(x) * Matrix33::RotateY(y) *
Matrix33::RotateZ(z)) *
s_freelook_matrix;

bProjectionChanged = true;
}

void VertexShaderManager::ResetView()
{
s_freelook_matrix = Common::Matrix44::Identity();

bProjectionChanged = true;
}

void VertexShaderManager::SetVertexFormat(u32 components)
{
if (components != constants.components)
@@ -673,7 +653,7 @@ void VertexShaderManager::DoState(PointerWrap& p)
{
p.DoArray(g_fProjectionMatrix);
p.Do(s_viewportCorrection);
p.Do(s_freelook_matrix);
g_freelook_camera.DoState(p);

p.DoArray(nTransformMatricesChanged);
p.DoArray(nNormalMatricesChanged);
4 Source/Core/VideoCommon/VertexShaderManager.h
View file
@@ -29,10 +29,6 @@ class VertexShaderManager
static void SetProjectionChanged();
static void SetMaterialColorChanged(int index);

static void TranslateView(float x, float y, float z = 0.0f);
static void RotateView(float x, float y, float z);
static void ResetView();

static void SetVertexFormat(u32 components);
static void SetTexMatrixInfoChanged(int index);
static void SetLightingConfigChanged();
2 Source/Core/VideoCommon/VideoCommon.vcxproj
View file
@@ -63,6 +63,7 @@
<ClCompile Include="FPSCounter.cpp" />
<ClCompile Include="FramebufferManager.cpp" />
<ClCompile Include="FramebufferShaderGen.cpp" />
<ClCompile Include="FreeLookCamera.cpp" />
<ClCompile Include="HiresTextures.cpp" />
<ClCompile Include="HiresTextures_DDSLoader.cpp" />
<ClCompile Include="ImageWrite.cpp" />
@@ -141,6 +142,7 @@
<ClInclude Include="FPSCounter.h" />
<ClInclude Include="FramebufferManager.h" />
<ClInclude Include="FramebufferShaderGen.h" />
<ClInclude Include="FreeLookCamera.h" />
<ClInclude Include="GXPipelineTypes.h" />
<ClInclude Include="NetPlayChatUI.h" />
<ClInclude Include="NetPlayGolfUI.h" />
8 Source/Core/VideoCommon/VideoConfig.h
View file
@@ -51,6 +51,13 @@ enum class ShaderCompilationMode : int
AsynchronousSkipRendering
};

enum class FreelookControlType : int
{
SixAxis,
FPS,
Orbital
};

// NEVER inherit from this class.
struct VideoConfig final
{
@@ -107,6 +114,7 @@ struct VideoConfig final
std::string sDumpPath;
bool bInternalResolutionFrameDumps;
bool bFreeLook;
FreelookControlType iFreelookControlType;
bool bBorderlessFullscreen;
bool bEnableGPUTextureDecoding;
int iBitrateKbps;