Working on Camera

Author: deccer

src/Cpp/1-getting-started/1-3-6-Camera/1-3-6-Camera.vcxproj

@@ -118,6 +118,7 @@ xcopy /Y $(ProjectDir)Assets\Textures\*.* $(OutDir)Assets\Textures\</Command>
     <ClCompile Include="..\..\..\..\lib\imgui\include\imgui\imgui_tables.cpp" />
     <ClCompile Include="..\..\..\..\lib\imgui\include\imgui\imgui_widgets.cpp" />
     <ClCompile Include="Application.cpp" />
+    <ClCompile Include="Camera.cpp" />
     <ClCompile Include="DeviceContext.cpp" />
     <ClCompile Include="Main.cpp" />
     <ClCompile Include="CameraApplication.cpp" />
@@ -128,6 +129,7 @@ xcopy /Y $(ProjectDir)Assets\Textures\*.* $(OutDir)Assets\Textures\</Command>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Application.hpp" />
+    <ClInclude Include="Camera.hpp" />
     <ClInclude Include="Definitions.hpp" />
     <ClInclude Include="DeviceContext.hpp" />
     <ClInclude Include="CameraApplication.hpp" />

src/Cpp/1-getting-started/1-3-6-Camera/1-3-6-Camera.vcxproj.filters

@@ -60,6 +60,9 @@
     <ClCompile Include="..\..\..\..\lib\imgui\include\imgui\backend\imgui_impl_glfw.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="Camera.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Application.hpp">
@@ -92,6 +95,9 @@
     <ClInclude Include="DeviceContext.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="Camera.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <Image Include="Assets\Textures\T_Good_Froge.dds" />

src/Cpp/1-getting-started/1-3-6-Camera/Assets/Shaders/Main.vs.hlsl

@@ -12,20 +12,16 @@ struct VSOutput
     float2 Uv: TEXCOORD0;
 };
 
-cbuffer PerApplication
+cbuffer CameraBuffer
 {
     matrix ProjectionMatrix;
-}
-
-cbuffer PerFrame
-{
     matrix ViewMatrix;
 }
 
-cbuffer PerObject
+cbuffer Object
 {
     matrix WorldMatrix;
-}
+};
 
 VSOutput Main(VSInput input)
 {

src/Cpp/1-getting-started/1-3-6-Camera/Camera.cpp

@@ -0,0 +1,115 @@
+#include "Camera.hpp"
+
+Camera::Camera(
+    const float nearPlane,
+    const float farPlane)
+{
+    _nearPlane = nearPlane;
+    _farPlane = farPlane;
+}
+
+DirectX::XMFLOAT4X4 Camera::GetViewMatrix()
+{
+    return _viewMatrix;
+}
+
+DirectX::XMFLOAT4X4 Camera::GetProjectionMatrix()
+{
+    return _projectionMatrix;
+}
+
+CameraConstants& Camera::GetCameraConstants()
+{
+    return _cameraConstants;
+}
+
+void Camera::Update()
+{
+    UpdateVectors();
+    UpdateProjectionMatrix();
+    UpdateViewMatrix();
+
+    _cameraConstants.ProjectionMatrix = _projectionMatrix;
+    _cameraConstants.ViewMatrix = _viewMatrix;
+}
+
+void Camera::UpdateViewMatrix()
+{
+    DirectX::XMMATRIX viewMatrix = DirectX::XMMatrixLookToLH(
+        DirectX::XMLoadFloat3(&_position),
+        DirectX::XMLoadFloat3(&_direction),
+        DirectX::XMLoadFloat3(&_up));
+    DirectX::XMStoreFloat4x4(&_viewMatrix, viewMatrix);
+}
+
+void Camera::UpdateVectors()
+{
+    float pitchSine;
+    float pitchCosine;
+    float yawSine;
+    float yawCosine;
+
+    DirectX::XMScalarSinCos(&pitchSine, &pitchCosine, _pitch);
+    DirectX::XMScalarSinCos(&yawSine, &yawCosine, _yaw);
+
+    float x = pitchCosine * yawCosine;
+    float y = pitchSine;
+    float z = pitchCosine * yawSine;
+
+    DirectX::XMFLOAT3 rotation = DirectX::XMFLOAT3(x, y, z);
+    DirectX::XMFLOAT3 unitY = DirectX::XMFLOAT3(0.0f, 1.0f, 0.0f);
+    DirectX::XMVECTOR unitYVector = DirectX::XMLoadFloat3(&unitY);
+
+    DirectX::XMVECTOR direction = DirectX::XMVector3Normalize(DirectX::XMLoadFloat3(&rotation));
+    DirectX::XMVECTOR right = DirectX::XMVector3Normalize(DirectX::XMVector3Cross(direction, unitYVector));
+    DirectX::XMVECTOR up = DirectX::XMVector3Normalize(DirectX::XMVector3Cross(right, direction));
+
+    DirectX::XMStoreFloat3(&_direction, direction);
+    DirectX::XMStoreFloat3(&_right, right);
+    DirectX::XMStoreFloat3(&_up, up);
+}
+
+void Camera::SetPosition(const DirectX::XMFLOAT3& position)
+{
+    _position = position;
+}
+
+void Camera::SetDirection(const DirectX::XMFLOAT3& direction)
+{
+    _direction = _direction;
+}
+
+void Camera::SetUp(const DirectX::XMFLOAT3& up)
+{
+    _up = _up;
+}
+
+PerspectiveCamera::PerspectiveCamera(
+    const float fieldOfView,
+    const int32_t width,
+    const int32_t height,
+    const float nearPlane,
+    const float farPlane) : Camera(nearPlane, farPlane)
+{
+    _aspectRatio = static_cast<float>(width) / static_cast<float>(height);
+    _fieldOfView = DirectX::XMConvertToRadians(fieldOfView);
+}
+
+void PerspectiveCamera::Resize(
+    const int32_t width,
+    const int32_t height)
+{
+    _aspectRatio = static_cast<float>(width) / static_cast<float>(height);
+
+    UpdateProjectionMatrix();
+}
+
+void PerspectiveCamera::UpdateProjectionMatrix()
+{
+    DirectX::XMMATRIX projectionMatrix = DirectX::XMMatrixPerspectiveFovLH(
+        _fieldOfView,
+        _aspectRatio,
+        _nearPlane,
+        _farPlane);
+    DirectX::XMStoreFloat4x4(&_projectionMatrix, projectionMatrix);
+}

src/Cpp/1-getting-started/1-3-6-Camera/Camera.hpp

@@ -0,0 +1,75 @@
+#pragma once
+
+#include <DirectXMath.h>
+
+struct CameraConstants
+{
+    DirectX::XMFLOAT4X4 ProjectionMatrix;
+    DirectX::XMFLOAT4X4 ViewMatrix;
+};
+
+class Camera
+{
+public:
+    virtual void Resize(
+        const int32_t width,
+        const int32_t height) = 0;
+
+    void Update();
+
+    void SetPosition(const DirectX::XMFLOAT3& position);
+    void SetDirection(const DirectX::XMFLOAT3& direction);
+    void SetUp(const DirectX::XMFLOAT3& up);
+
+    [[nodiscard]] DirectX::XMFLOAT4X4 GetViewMatrix();
+    [[nodiscard]] DirectX::XMFLOAT4X4 GetProjectionMatrix();
+    [[nodiscard]] CameraConstants& GetCameraConstants();
+
+protected:
+    Camera(
+        const float nearPlane,
+        const float farPlane);
+
+    virtual void UpdateProjectionMatrix() = 0;
+
+    float _nearPlane = 0.0f;
+    float _farPlane = 0.0f;
+
+    DirectX::XMFLOAT4X4 _projectionMatrix = DirectX::XMFLOAT4X4();
+    DirectX::XMFLOAT4X4 _viewMatrix = DirectX::XMFLOAT4X4();
+    CameraConstants _cameraConstants = {};
+
+private:
+    void UpdateVectors();
+    void UpdateViewMatrix();
+
+    DirectX::XMFLOAT3 _position = {};
+    DirectX::XMFLOAT3 _direction = {};
+    DirectX::XMFLOAT3 _up = {};
+    DirectX::XMFLOAT3 _right = {};
+    float _pitch = 0.0f;
+    float _yaw = 0.0f;
+};
+
+class PerspectiveCamera final : public Camera
+{
+public:
+    PerspectiveCamera(
+        const float fieldOfView,
+        const int32_t width,
+        const int32_t height,
+        const float nearPlane,
+        const float farPlane);
+
+    void Resize(
+        const int32_t width,
+        const int32_t height) override;
+
+protected:
+    void UpdateProjectionMatrix() override;
+
+private:
+    float _fieldOfView = 0.0f;
+    float _aspectRatio = 0.0f;
+
+};

src/Cpp/1-getting-started/1-3-6-Camera/CameraApplication.cpp

@@ -4,6 +4,7 @@
 #include "Pipeline.hpp"
 #include "TextureFactory.hpp"
 #include "ModelFactory.hpp"
+#include "Camera.hpp"
 
 #include <GLFW/glfw3.h>
 #define GLFW_EXPOSE_NATIVE_WIN32
@@ -56,9 +57,7 @@ CameraApplication::~CameraApplication()
     _solidFrameCullNoneRasterizerState.Reset();
 
     _depthStencilView.Reset();
-    _constantBuffers[ConstantBufferType::PerApplication].Reset();
-    _constantBuffers[ConstantBufferType::PerFrame].Reset();
-    _constantBuffers[ConstantBufferType::PerObject].Reset();
+    _cameraConstantBuffer.Reset();
     _textureSrv.Reset();
     _pipeline.reset();
     _pipelineFactory.reset();
@@ -165,6 +164,7 @@ bool CameraApplication::Initialize()
     _pipelineFactory = std::make_unique<PipelineFactory>(_device);
     _textureFactory = std::make_unique<TextureFactory>(_device);
     _modelFactory = std::make_unique<ModelFactory>(_device);
+    _camera = std::make_unique<PerspectiveCamera>(60.0f, GetWindowWidth(), GetWindowHeight(), 0.1f, 2048.0f);
 
     return true;
 }
@@ -213,36 +213,30 @@ bool CameraApplication::Load()
         return false;
     }
 
-    const D3D11_BUFFER_DESC constantBufferDescriptor = CD3D11_BUFFER_DESC(
-        sizeof(DirectX::XMMATRIX),
+    const D3D11_BUFFER_DESC cameraConstantBufferDescriptor = CD3D11_BUFFER_DESC(
+        sizeof(CameraConstants),
         D3D11_BIND_FLAG::D3D11_BIND_CONSTANT_BUFFER);
 
-    if (FAILED(_device->CreateBuffer(&constantBufferDescriptor, nullptr, &_constantBuffers[ConstantBufferType::PerApplication])))
-    {
-        std::cout << "D3D11: Unable to create constant buffer PerApplication\n";
-        return false;
-    }
-    if (FAILED(_device->CreateBuffer(&constantBufferDescriptor, nullptr, &_constantBuffers[ConstantBufferType::PerFrame])))
+    if (FAILED(_device->CreateBuffer(&cameraConstantBufferDescriptor, nullptr, &_cameraConstantBuffer)))
     {
-        std::cout << "D3D11: Unable to create constant buffer PerFrame\n";
+        std::cout << "D3D11: Unable to create CameraConstants buffer\n";
         return false;
     }
-    if (FAILED(_device->CreateBuffer(&constantBufferDescriptor, nullptr, &_constantBuffers[ConstantBufferType::PerObject])))
+    SetDebugName(_cameraConstantBuffer.Get(), "CB_Camera");
+
+    const D3D11_BUFFER_DESC objectConstantBufferDescriptor = CD3D11_BUFFER_DESC(
+        sizeof(DirectX::XMMATRIX),
+        D3D11_BIND_FLAG::D3D11_BIND_CONSTANT_BUFFER);
+
+    if (FAILED(_device->CreateBuffer(&objectConstantBufferDescriptor, nullptr, &_objectConstantBuffer)))
     {
-        std::cout << "D3D11: Unable to create constant buffer PerObject\n";
+        std::cout << "D3D11: Unable to create ObjectConstants buffer\n";
         return false;
     }
+    SetDebugName(_objectConstantBuffer.Get(), "CB_Object");
 
-    _pipeline->BindVertexStageConstantBuffer(0, _constantBuffers[ConstantBufferType::PerApplication].Get());
-    _pipeline->BindVertexStageConstantBuffer(1, _constantBuffers[ConstantBufferType::PerFrame].Get());
-    _pipeline->BindVertexStageConstantBuffer(2, _constantBuffers[ConstantBufferType::PerObject].Get());
-
-    _projectionMatrix = DirectX::XMMatrixPerspectiveFovLH(
-        DirectX::XMConvertToRadians(45.0f),
-        GetWindowWidth() / static_cast<float>(GetWindowHeight()),
-        0.1f,
-        512.0f);
-    _deviceContext->UpdateSubresource(_constantBuffers[PerApplication].Get(), &_projectionMatrix);
+    _pipeline->BindVertexStageConstantBuffer(0, _cameraConstantBuffer.Get());
+    _pipeline->BindVertexStageConstantBuffer(1, _objectConstantBuffer.Get());
 
     if (!CreateDepthStencilStates())
     {
@@ -339,15 +333,10 @@ void CameraApplication::OnResize(
 
     CreateSwapchainResources();
 
-    //ImGuiIO& io = ImGui::GetIO();
-    //io.DisplaySize = ImVec2(GetWindowWidth(), GetWindowHeight());
+    _camera->Resize(width, height);
 
-    _projectionMatrix = DirectX::XMMatrixPerspectiveFovLH(
-        DirectX::XMConvertToRadians(45.0f),
-        GetWindowWidth() / static_cast<float>(GetWindowHeight()),
-        0.1f,
-        512);
-    _deviceContext->UpdateSubresource(_constantBuffers[PerApplication].Get(), &_projectionMatrix);
+    ImGuiIO& io = ImGui::GetIO();
+    io.DisplaySize = ImVec2(width, height);
 }
 
 void CameraApplication::Update()
@@ -357,11 +346,9 @@ void CameraApplication::Update()
         Close();
     }
 
-    const auto eyePosition = DirectX::XMVectorSet(0, 50, 200, 1);
-    const auto focusPoint = DirectX::XMVectorSet(0, 0, 0, 1);
-    const auto upDirection = DirectX::XMVectorSet(0, 1, 0, 0);
-    _viewMatrix = DirectX::XMMatrixLookAtLH(eyePosition, focusPoint, upDirection);
-    _deviceContext->UpdateSubresource(_constantBuffers[PerFrame].Get(), &_viewMatrix);
+    _camera->SetPosition(DirectX::XMFLOAT3{ 0.0f, 50.0f, -200.0f });
+    _camera->SetDirection(DirectX::XMFLOAT3{ 0.0f, 0.0f, 1.0f });
+    _camera->SetUp(DirectX::XMFLOAT3{ 0.0f, 1.0f, 0.0f });
 
     static float angle = 0.0f;
     if (_toggledRotation)
@@ -375,12 +362,21 @@ void CameraApplication::Update()
 
     const auto rotationAxis = DirectX::XMVectorSet(0, 1, 0, 0);
 
-    _worldMatrix = DirectX::XMMatrixRotationAxis(rotationAxis, DirectX::XMConvertToRadians(angle));
-    _deviceContext->UpdateSubresource(_constantBuffers[PerObject].Get(), &_worldMatrix);
+    _worldMatrix = DirectX::XMMatrixRotationAxis(
+        rotationAxis,
+        DirectX::XMConvertToRadians(angle));
+
+    DirectX::XMFLOAT4X4 worldMatrix;
+    DirectX::XMStoreFloat4x4(&worldMatrix, _worldMatrix);
+    _deviceContext->UpdateSubresource(_objectConstantBuffer.Get(), &worldMatrix);
 }
 
 void CameraApplication::Render()
 {
+    _camera->Update();
+    CameraConstants& cameraConstants = _camera->GetCameraConstants();
+    _deviceContext->UpdateSubresource(_cameraConstantBuffer.Get(), &cameraConstants);
+
     constexpr float clearColor[] = { 0.1f, 0.1f, 0.1f, 1.0f };
 
     _deviceContext->Clear(
@@ -394,7 +390,7 @@ void CameraApplication::Render()
 
     _deviceContext->DrawIndexed();
 
-    //RenderUi();
+    RenderUi();
     _swapChain->Present(1, 0);
 }