DirectX 12 integration with nvrhi

EppoEngine/Source/Platform/ComPtr.h

@@ -0,0 +1,39 @@
+#pragma once
+
+// clang-format off
+#if defined(EP_PLATFORM_WINDOWS)
+    #include <wrl/client.h>
+    template<typename T>
+    using ComPtr = Microsoft::WRL::ComPtr<T>;
+#else
+    #include <dxc/WinAdapter.h>
+    template<typename T>
+    class ComPtr : public CComPtr<T>
+    {
+        using Base = CComPtr<T>;
+    public:
+        using Base::Base;
+        using Base::operator=;
+
+        ComPtr() noexcept = default;
+
+        T* Get() const noexcept { return this->p; }
+
+        T* const* GetAddressOf() const noexcept { return &this->p; }
+        T** GetAddressOf() noexcept
+        {
+            assert(this->p == nullptr);
+            return &this->p;
+        }
+
+        T** ReleaseAndGetAddressOf() noexcept
+        {
+            this->Release();
+            return &this->p;
+        }
+
+        void Reset() noexcept { this->Release(); }
+        explicit operator bool() const noexcept { return this->p != nullptr; }
+    };
+#endif
+// clang-format on

EppoEngine/Source/Platform/Vulkan/DeviceManagerVK.cpp

@@ -42,20 +42,12 @@ namespace Eppo
         m_LogicalDevice = nullptr;
         m_PhysicalDevice = nullptr;
 
-        if (g_EnableValidationLayers)
+        if (s_EnableValidationLayers)
             DestroyDebugUtilsMessengerEXT(m_Instance, m_DebugMessenger, nullptr);
 
         vkDestroyInstance(m_Instance, nullptr);
     }
 
-    auto DeviceManagerVK::GetDevice() const -> nvrhi::IDevice*
-    {
-        if (m_ValidationLayer)
-            return m_ValidationLayer;
-
-        return m_Device;
-    }
-
     auto DeviceManagerVK::BeginFrame() -> bool
     {
         return m_Swapchain->BeginFrame();
@@ -66,6 +58,14 @@ namespace Eppo
         return m_Swapchain->Present();
     }
 
+    auto DeviceManagerVK::GetDevice() const -> nvrhi::IDevice*
+    {
+        if (m_ValidationLayer)
+            return m_ValidationLayer;
+
+        return m_Device;
+    }
+
     auto DeviceManagerVK::CreateVulkanInstance() -> void
     {
         // Create instance
@@ -84,9 +84,8 @@ namespace Eppo
 
         const std::vector extensions(glfwExtensions, glfwExtensions + glfwExtensionCount);
 
-#if !defined(EP_DIST)
-        m_Params.RequiredVulkanInstanceExtensions.emplace_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
-#endif
+        if (s_EnableValidationLayers)
+            m_Params.RequiredVulkanInstanceExtensions.emplace_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
 
         for (const auto& extension : extensions)
             m_Params.RequiredVulkanInstanceExtensions.emplace_back(extension);
@@ -106,7 +105,7 @@ namespace Eppo
         };
 
         VkDebugUtilsMessengerCreateInfoEXT debugMessengerInfo{};
-        if (g_EnableValidationLayers)
+        if (s_EnableValidationLayers)
         {
             instanceInfo.enabledLayerCount = static_cast<uint32_t>(g_ValidationLayers.size());
             instanceInfo.ppEnabledLayerNames = g_ValidationLayers.data();
@@ -127,7 +126,7 @@ namespace Eppo
         VK_CHECK(vkCreateInstance(&instanceInfo, nullptr, &m_Instance), "Failed to create vulkan instance!");
         EP_ASSERT(m_Instance);
 
-        if (g_EnableValidationLayers)
+        if (s_EnableValidationLayers)
         {
             VK_CHECK(
                 CreateDebugUtilsMessengerEXT(m_Instance, &debugMessengerInfo, nullptr, &m_DebugMessenger),
@@ -162,7 +161,7 @@ namespace Eppo
 
         m_Device = nvrhi::vulkan::createDevice(deviceDesc);
 
-        if (g_EnableValidationLayers)
+        if (s_EnableValidationLayers)
             m_ValidationLayer = nvrhi::validation::createValidationLayer(m_Device);
     }
 }

EppoEngine/Source/Platform/Vulkan/DeviceManagerVK.h

@@ -15,14 +15,12 @@ namespace Eppo
     class DeviceManagerVK : public DeviceManager
     {
     public:
-        DeviceManagerVK(const Ref<Window>& window, const DeviceParams& params);
+        explicit DeviceManagerVK(const Ref<Window>& window, const DeviceParams& params);
         ~DeviceManagerVK() override = default;
 
         auto Init() -> void override;
         auto Shutdown() -> void override;
 
-        [[nodiscard]] auto GetDevice() const -> nvrhi::IDevice* override;
-
         auto BeginFrame() -> bool override;
         auto Present() -> bool override;
 
@@ -31,6 +29,7 @@ namespace Eppo
         [[nodiscard]] auto GetCurrentBackBufferIndex() const -> uint32_t override { return m_Swapchain->GetCurrentBackBufferIndex(); }
         [[nodiscard]] auto GetBackBufferCount() const -> uint32_t override { return m_Swapchain->GetImageCount(); }
         auto GetCurrentSwapchainImage() -> const SwapchainImage& override { return m_Swapchain->GetCurrentSwapchainImage(); }
+        [[nodiscard]] auto GetDevice() const -> nvrhi::IDevice* override;
 
         [[nodiscard]] constexpr auto GetVulkanInstance() const -> VkInstance { return m_Instance; }
         [[nodiscard]] constexpr auto GetPhysicalDevice() const -> const ScopedPtr<PhysicalDevice>& { return m_PhysicalDevice; }

EppoEngine/Source/Platform/Vulkan/LogicalDevice.cpp

@@ -1,6 +1,8 @@
 #include "pch.h"
 #include "Platform/Vulkan/LogicalDevice.h"
 
+#include "Renderer/DeviceManager.h"
+
 namespace Eppo
 {
     LogicalDevice::LogicalDevice(const ScopedPtr<PhysicalDevice>& physicalDevice)
@@ -89,7 +91,7 @@ namespace Eppo
             .ppEnabledExtensionNames = g_DeviceExtensions.data(),
         };
 
-        if (g_EnableValidationLayers)
+        if (s_EnableValidationLayers)
         {
             deviceInfo.enabledLayerCount = static_cast<uint32_t>(g_ValidationLayers.size());
             deviceInfo.ppEnabledLayerNames = g_ValidationLayers.data();

EppoEngine/Source/Platform/Vulkan/Vulkan.h

@@ -8,12 +8,6 @@ namespace Eppo
     if (fn != VK_SUCCESS)                                                                                                                  \
         Log::Error(LogSource::Vulkan, msg);
 
-#if !defined(EP_DIST)
-    constexpr bool g_EnableValidationLayers = true;
-#else
-    constexpr bool g_EnableValidationLayers = false;
-#endif
-
     constexpr std::array g_ValidationLayers = { "VK_LAYER_KHRONOS_validation" };
     constexpr std::array g_DeviceExtensions = { VK_KHR_SWAPCHAIN_EXTENSION_NAME, VK_KHR_MAINTENANCE_1_EXTENSION_NAME,
                                                 VK_GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME, VK_GOOGLE_USER_TYPE_EXTENSION_NAME,

EppoEngine/Source/Platform/Vulkan/VulkanShader.cpp

@@ -1,17 +1,11 @@
 #include "pch.h"
 #include "Platform/Vulkan/VulkanShader.h"
 
+#include "Platform/ComPtr.h"
 #include "Renderer/DeviceManager.h"
 
-#if defined(EP_PLATFORM_WINDOWS)
-    #include <atlbase.h>
-#else
-    #include <dxc/WinAdapter.h>
-#endif
-
 #include <dxc/dxcapi.h>
 
-#include <ranges>
 #include <nvrhi/utils.h>
 #include <spirv_cross/spirv_cross.hpp>
 
@@ -74,7 +68,7 @@ namespace Eppo
                     return E_FAIL;
                 }
 
-                CComPtr<IDxcBlobEncoding> blob;
+                ComPtr<IDxcBlobEncoding> blob;
                 if (FAILED(m_Utils->CreateBlob(source->data(), static_cast<uint32_t>(source->size()), DXC_CP_UTF8, &blob)))
                     return E_FAIL;
 
@@ -298,8 +292,8 @@ namespace Eppo
     auto VulkanShader::Compile(const nvrhi::ShaderType type) -> bool
     {
         // Create compiler
-        CComPtr<IDxcUtils> utils;
-        CComPtr<IDxcCompiler3> compiler;
+        ComPtr<IDxcUtils> utils;
+        ComPtr<IDxcCompiler3> compiler;
         if (FAILED(DxcCreateInstance(CLSID_DxcUtils, IID_PPV_ARGS(&utils))) ||
             FAILED(DxcCreateInstance(CLSID_DxcCompiler, IID_PPV_ARGS(&compiler))))
         {
@@ -310,11 +304,11 @@ namespace Eppo
         // Create include handler. A packed shader gets the pack-backed one and never the default:
         // the default reads from disk, which a deployed game has none of.
         const bool packed = !m_Specification.Source.empty();
-        PackedIncludeHandler packedIncludeHandler(utils, m_Specification.Includes);
-        CComPtr<IDxcIncludeHandler> diskIncludeHandler;
+        PackedIncludeHandler packedIncludeHandler(utils.Get(), m_Specification.Includes);
+        ComPtr<IDxcIncludeHandler> diskIncludeHandler;
         if (!packed)
             utils->CreateDefaultIncludeHandler(&diskIncludeHandler);
-        IDxcIncludeHandler* includeHandler = packed ? static_cast<IDxcIncludeHandler*>(&packedIncludeHandler) : diskIncludeHandler.p;
+        IDxcIncludeHandler* includeHandler = packed ? static_cast<IDxcIncludeHandler*>(&packedIncludeHandler) : diskIncludeHandler.Get();
 
         // Command line args for compiler. A packed shader is named relative to the virtual Resources/Shaders
         // root, so DXC hands its #include paths to the handler the way the pack keys them.
@@ -365,14 +359,14 @@ namespace Eppo
         };
 
         // Execute compiler
-        CComPtr<IDxcResult> result;
+        ComPtr<IDxcResult> result;
         if (FAILED(compiler->Compile(&srcBuffer, args, _countof(args), includeHandler, IID_PPV_ARGS(&result))) || !result)
         {
             Log::Error("Invoking the compiler for shader '{}' failed!", m_Specification.Name);
             return false;
         }
 
-        CComPtr<IDxcBlobUtf8> errors = nullptr;
+        ComPtr<IDxcBlobUtf8> errors;
         result->GetOutput(DXC_OUT_ERRORS, IID_PPV_ARGS(&errors), nullptr);
 
         if (errors != nullptr && errors->GetStringLength() != 0)
@@ -389,8 +383,8 @@ namespace Eppo
         }
 
         // Save shader binary
-        CComPtr<IDxcBlob> binary = nullptr;
-        CComPtr<IDxcBlobWide> binaryName = nullptr;
+        ComPtr<IDxcBlob> binary;
+        ComPtr<IDxcBlobWide> binaryName;
         result->GetOutput(DXC_OUT_OBJECT, IID_PPV_ARGS(&binary), &binaryName);
 
         if (binary == nullptr)

EppoEngine/Source/Renderer/IndexBuffer.cpp → EppoEngine/Source/Renderer/Buffer/IndexBuffer.cpp

@@ -1,5 +1,5 @@
 #include "pch.h"
-#include "Renderer/IndexBuffer.h"
+#include "Renderer/Buffer/IndexBuffer.h"
 
 #include "Renderer/DeviceManager.h"
 #include "Renderer/Mesh.h"
@@ -240,4 +240,4 @@ namespace Eppo
             }
         }
     }
-}
+}

EppoEngine/Source/Renderer/StorageBuffer.cpp → EppoEngine/Source/Renderer/Buffer/StorageBuffer.cpp

@@ -1,5 +1,5 @@
 #include "pch.h"
-#include "Renderer/StorageBuffer.h"
+#include "Renderer/Buffer/StorageBuffer.h"
 
 #include "Renderer/DeviceManager.h"
 

EppoEngine/Source/Renderer/UniformBuffer.cpp → EppoEngine/Source/Renderer/Buffer/UniformBuffer.cpp

@@ -1,5 +1,5 @@
 #include "pch.h"
-#include "Renderer/UniformBuffer.h"
+#include "Renderer/Buffer/UniformBuffer.h"
 
 #include "Renderer/DeviceManager.h"
 

EppoEngine/Source/Renderer/VertexBuffer.cpp → EppoEngine/Source/Renderer/Buffer/VertexBuffer.cpp

@@ -1,5 +1,5 @@
 #include "pch.h"
-#include "Renderer/VertexBuffer.h"
+#include "Renderer/Buffer/VertexBuffer.h"
 
 #include "Renderer/DeviceManager.h"
 #include "Renderer/Mesh.h"
@@ -328,4 +328,4 @@ namespace Eppo
             }
         }
     }
-}
+}

EppoEngine/Source/Renderer/DescriptorManager.h

@@ -1,9 +1,9 @@
 #pragma once
 
+#include "Renderer/Buffer/StorageBuffer.h"
+#include "Renderer/Buffer/UniformBuffer.h"
 #include "Renderer/DeviceManager.h"
 #include "Renderer/Image.h"
-#include "Renderer/StorageBuffer.h"
-#include "Renderer/UniformBuffer.h"
 
 #include <nvrhi/nvrhi.h>
 

EppoEngine/Source/Renderer/DeviceManager.cpp

@@ -16,20 +16,13 @@ namespace Eppo
     {
         EP_ASSERT(params.API != RendererAPI::None, "No renderer api selected!");
 #if !defined(EP_PLATFORM_WINDOWS)
-        EP_ASSERT(params.API != RendererAPI::DX11, "DX11 renderer api selected on a non windows target!");
         EP_ASSERT(params.API != RendererAPI::DX12, "DX12 renderer api selected on a non windows target!");
 #endif
         EP_ASSERT(params.MaxFramesInFlight >= 2);
 
         switch (params.API)
         {
 #if defined(EP_PLATFORM_WINDOWS)
-            case RendererAPI::DX11:
-            {
-                EP_ASSERT(false, "Currently we do not support DX11!");
-                break;
-            }
-
             case RendererAPI::DX12:
             {
                 EP_ASSERT(false, "Currently we do not support DX12!");

EppoEngine/Source/Renderer/DeviceManager.h

@@ -10,10 +10,15 @@ namespace Eppo
 {
     class DeviceManagerVK;
 
+#if !defined(EP_DIST)
+    constexpr bool s_EnableValidationLayers = true;
+#else
+    constexpr bool s_EnableValidationLayers = false;
+#endif
+
     enum class RendererAPI
     {
         None,
-        DX11,
         DX12,
         Vulkan,
     };

EppoEngine/Source/Renderer/Mesh.h

@@ -1,11 +1,11 @@
 #pragma once
 
 #include "Asset/Asset.h"
+#include "Renderer/Buffer/IndexBuffer.h"
+#include "Renderer/Buffer/VertexBuffer.h"
 #include "Renderer/Image.h"
-#include "Renderer/IndexBuffer.h"
 #include "Renderer/Material.h"
 #include "Renderer/Sampler.h"
-#include "Renderer/VertexBuffer.h"
 
 #include <glm/glm.hpp>
 

EppoEngine/Source/Renderer/RenderPass.cpp

@@ -1,13 +1,13 @@
 #include "pch.h"
 #include "Renderer/RenderPass.h"
 
+#include "Renderer/Buffer/StorageBuffer.h"
+#include "Renderer/Buffer/UniformBuffer.h"
 #include "Renderer/DescriptorManager.h"
 #include "Renderer/DeviceManager.h"
 #include "Renderer/Image.h"
 #include "Renderer/Renderer.h"
 #include "Renderer/Sampler.h"
-#include "Renderer/StorageBuffer.h"
-#include "Renderer/UniformBuffer.h"
 
 namespace Eppo
 {

EppoEngine/Source/Renderer/SceneRenderer.h

@@ -1,13 +1,13 @@
 #pragma once
 
+#include "Renderer/Buffer/StorageBuffer.h"
+#include "Renderer/Buffer/UniformBuffer.h"
 #include "Renderer/Camera/EditorCamera.h"
 #include "Renderer/Camera/SceneCamera.h"
 #include "Renderer/Mesh.h"
 #include "Renderer/RenderCommandBuffer.h"
 #include "Renderer/RenderPass.h"
 #include "Renderer/Sampler.h"
-#include "Renderer/StorageBuffer.h"
-#include "Renderer/UniformBuffer.h"
 #include "Scene/Entity.h"
 #include "Scene/Scene.h"