nvapi: Rename Vulkan → Vk and rework its construction

Existence of src/nvapi/vulkan.cpp prevents introduction of src/nvapi_vulkan.cpp that would contain Vulkan Reflex entrypoints due to Meson/Ninja confusing both paths as if they refered to the same target/file.
jp7677 · Dec 26, 2024 · 8c4c9a6 · 8c4c9a6
1 parent 9bce572
commit 8c4c9a6
Show file tree

Hide file tree

Showing 21 changed files with 231 additions and 205 deletions.
diff --git a/src/meson.build b/src/meson.build
@@ -11,7 +11,7 @@ nvapi_src = files([
   'nvapi/nvapi_adapter_registry.cpp',
   'nvapi/nvapi_adapter.cpp',
   'nvapi/nvapi_output.cpp',
-  'nvapi/vulkan.cpp',
+  'nvapi/vk.cpp',
   'nvapi/nvml.cpp',
   'nvapi_globals.cpp',
   'nvapi.cpp',

diff --git a/src/nvapi/nvapi_adapter.cpp b/src/nvapi/nvapi_adapter.cpp
@@ -6,8 +6,8 @@
 #include "../util/util_version.h"
 
 namespace dxvk {
-    NvapiAdapter::NvapiAdapter(Vulkan& vulkan, Nvml& nvml, Com<IDXGIAdapter3> dxgiAdapter)
-        : m_vulkan(vulkan), m_nvml(nvml), m_dxgiAdapter(std::move(dxgiAdapter)) {}
+    NvapiAdapter::NvapiAdapter(Vk& vk, Nvml& nvml, Com<IDXGIAdapter3> dxgiAdapter)
+        : m_vk(vk), m_nvml(nvml), m_dxgiAdapter(std::move(dxgiAdapter)) {}
 
     NvapiAdapter::~NvapiAdapter() = default;
 
@@ -36,7 +36,7 @@ namespace dxvk {
         VkPhysicalDevice vkDevice = VK_NULL_HANDLE;
         dxgiVkInteropAdapter->GetVulkanHandles(&vkInstance, &vkDevice);
 
-        m_vkExtensions = m_vulkan.GetDeviceExtensions(vkInstance, vkDevice);
+        m_vkExtensions = m_vk.GetDeviceExtensions(vkInstance, vkDevice);
         if (m_vkExtensions.empty())
             return false;
 
@@ -70,7 +70,7 @@ namespace dxvk {
         m_vkIdProperties.pNext = deviceProperties2.pNext;
         deviceProperties2.pNext = &m_vkIdProperties;
 
-        m_vulkan.GetPhysicalDeviceProperties2(vkInstance, vkDevice, &deviceProperties2);
+        m_vk.GetPhysicalDeviceProperties2(vkInstance, vkDevice, &deviceProperties2);
         m_vkProperties = deviceProperties2.properties;
 
         auto allowOtherDrivers = env::getEnvVariable(allowOtherDriversEnvName);
@@ -183,7 +183,7 @@ namespace dxvk {
     }
 
     NV_GPU_TYPE NvapiAdapter::GetGpuType() const {
-        return Vulkan::ToNvGpuType(m_vkProperties.deviceType);
+        return Vk::ToNvGpuType(m_vkProperties.deviceType);
     }
 
     uint32_t NvapiAdapter::GetPciBusId() const {

diff --git a/src/nvapi/nvapi_adapter.h b/src/nvapi/nvapi_adapter.h
@@ -2,15 +2,15 @@
 
 #include "../nvapi_private.h"
 #include "../util/com_pointer.h"
-#include "vulkan.h"
+#include "vk.h"
 #include "nvml.h"
 #include "nvapi_output.h"
 
 namespace dxvk {
     class NvapiAdapter {
 
       public:
-        explicit NvapiAdapter(Vulkan& vulkan, Nvml& nvml, Com<IDXGIAdapter3> dxgiAdapter);
+        explicit NvapiAdapter(Vk& vk, Nvml& nvml, Com<IDXGIAdapter3> dxgiAdapter);
         ~NvapiAdapter();
 
         struct MemoryInfo {
@@ -57,7 +57,7 @@ namespace dxvk {
         [[nodiscard]] nvmlReturn_t GetNvmlDeviceDynamicPstatesInfo(nvmlGpuDynamicPstatesInfo_t* pDynamicPstatesInfo) const;
 
       private:
-        Vulkan& m_vulkan;
+        Vk& m_vk;
         Nvml& m_nvml;
         Com<IDXGIAdapter3> m_dxgiAdapter;
 

diff --git a/src/nvapi/nvapi_adapter_registry.cpp b/src/nvapi/nvapi_adapter_registry.cpp
@@ -29,8 +29,8 @@ namespace dxvk {
         if (m_dxgiFactory == nullptr)
             return false;
 
-        m_vulkan = m_resourceFactory.CreateVulkan(m_dxgiFactory);
-        if (m_vulkan == nullptr || !m_vulkan->IsAvailable())
+        m_vk = m_resourceFactory.CreateVulkan(m_dxgiFactory);
+        if (m_vk == nullptr || !m_vk->IsAvailable())
             return false;
 
         m_nvml = m_resourceFactory.CreateNvml();
@@ -48,7 +48,7 @@ namespace dxvk {
             if (FAILED(dxgiAdapter->QueryInterface(IID_PPV_ARGS(&dxgiAdapter3))))
                 continue;
 
-            auto nvapiAdapter = new NvapiAdapter(*m_vulkan, *m_nvml, dxgiAdapter3);
+            auto nvapiAdapter = new NvapiAdapter(*m_vk, *m_nvml, dxgiAdapter3);
             if (nvapiAdapter->Initialize(i, m_nvapiOutputs))
                 m_nvapiAdapters.push_back(nvapiAdapter);
             else

diff --git a/src/nvapi/nvapi_adapter_registry.h b/src/nvapi/nvapi_adapter_registry.h
@@ -4,7 +4,7 @@
 #include "resource_factory.h"
 #include "nvapi_adapter.h"
 #include "nvapi_output.h"
-#include "vulkan.h"
+#include "vk.h"
 #include "nvml.h"
 #include "../interfaces/dxvk_interfaces.h"
 
@@ -37,7 +37,7 @@ namespace dxvk {
         ResourceFactory& m_resourceFactory;
         Com<IDXGIFactory1> m_dxgiFactory;
         Com<IDXGIVkInteropFactory1> m_dxgiVkInterop;
-        std::unique_ptr<Vulkan> m_vulkan;
+        std::unique_ptr<Vk> m_vk;
         std::unique_ptr<Nvml> m_nvml;
         std::vector<NvapiAdapter*> m_nvapiAdapters;
         std::vector<NvapiOutput*> m_nvapiOutputs;

diff --git a/src/nvapi/resource_factory.cpp b/src/nvapi/resource_factory.cpp
@@ -18,19 +18,29 @@ namespace dxvk {
         return dxgiFactory;
     }
 
-    std::unique_ptr<Vulkan> ResourceFactory::CreateVulkan(Com<IDXGIFactory1>& dxgiFactory) {
+    std::unique_ptr<Vk> ResourceFactory::CreateVulkan(Com<IDXGIFactory1>& dxgiFactory) {
         Com<IDXGIVkInteropFactory> dxgiVkFactory;
         if (FAILED(dxgiFactory->QueryInterface(IID_PPV_ARGS(&dxgiVkFactory)))) {
             log::info("Querying Vulkan entry point from DXGI factory failed, please ensure that DXVK's dxgi.dll (version 2.1 or newer) is present");
             return nullptr;
         }
 
-        VkInstance vkInstance = VK_NULL_HANDLE;
-        PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr{};
-        dxgiVkFactory->GetVulkanInstance(&vkInstance, &vkGetInstanceProcAddr);
+        return std::make_unique<Vk>(std::move(dxgiVkFactory));
+    }
+
+    std::unique_ptr<Vk> ResourceFactory::CreateVulkan(const char* moduleName) {
+        auto module = GetModuleHandleA(moduleName);
+        if (!module) {
+            log::info(str::format("Module ", moduleName, " not loaded into current process"));
+            return nullptr;
+        }
+
+#define GET_PROC_ADDRESS(proc) auto proc = reinterpret_cast<PFN_##proc>(reinterpret_cast<void*>(GetProcAddress(module, #proc)));
+
+        GET_PROC_ADDRESS(vkGetInstanceProcAddr);
+        GET_PROC_ADDRESS(vkGetDeviceProcAddr);
 
-        log::info(str::format("Successfully acquired Vulkan vkGetInstanceProcAddr @ 0x", std::hex, reinterpret_cast<uintptr_t>(vkGetInstanceProcAddr)));
-        return std::make_unique<Vulkan>(dxgiFactory, vkGetInstanceProcAddr);
+        return std::make_unique<Vk>(vkGetInstanceProcAddr, vkGetDeviceProcAddr);
     }
 
     std::unique_ptr<Nvml> ResourceFactory::CreateNvml() {

diff --git a/src/nvapi/resource_factory.h b/src/nvapi/resource_factory.h
@@ -2,7 +2,7 @@
 
 #include "../nvapi_private.h"
 #include "../util/com_pointer.h"
-#include "vulkan.h"
+#include "vk.h"
 #include "nvml.h"
 #include "lfx.h"
 
@@ -14,7 +14,8 @@ namespace dxvk {
         virtual ~ResourceFactory();
 
         virtual Com<IDXGIFactory1> CreateDXGIFactory1();
-        virtual std::unique_ptr<Vulkan> CreateVulkan(Com<IDXGIFactory1>& dxgiFactory);
+        virtual std::unique_ptr<Vk> CreateVulkan(Com<IDXGIFactory1>& dxgiFactory);
+        virtual std::unique_ptr<Vk> CreateVulkan(const char* moduleName);
         virtual std::unique_ptr<Nvml> CreateNvml();
         virtual std::unique_ptr<Lfx> CreateLfx();
     };

diff --git a/src/nvapi/vulkan.cpp → src/nvapi/vk.cpp b/src/nvapi/vulkan.cpp → src/nvapi/vk.cpp
@@ -1,17 +1,31 @@
-#include "vulkan.h"
+#include "vk.h"
+#include "../util/util_log.h"
 
 namespace dxvk {
-    Vulkan::Vulkan() = default;
-    Vulkan::Vulkan(Com<IDXGIFactory1> dxgiFactory, PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr)
-        : m_dxgiFactory(std::move(dxgiFactory)), m_vkGetInstanceProcAddr(vkGetInstanceProcAddr) {}
+    Vk::Vk() = default;
 
-    Vulkan::~Vulkan() = default;
+    Vk::Vk(Com<IDXGIVkInteropFactory>&& dxgiVkInteropFactory)
+        : m_dxgiVkInteropFactory(dxgiVkInteropFactory) {
+        VkInstance vkInstance;
+        m_dxgiVkInteropFactory->GetVulkanInstance(&vkInstance, &m_vkGetInstanceProcAddr);
 
-    bool Vulkan::IsAvailable() const {
-        return m_vkGetInstanceProcAddr != nullptr;
+        if (vkInstance && m_vkGetInstanceProcAddr) {
+            log::info(str::format("Successfully acquired Vulkan vkGetInstanceProcAddr @ 0x", std::hex, reinterpret_cast<uintptr_t>(m_vkGetInstanceProcAddr)));
+
+            m_vkGetDeviceProcAddr = GetInstanceProcAddress<PFN_vkGetDeviceProcAddr>(vkInstance, "vkGetDeviceProcAddr");
+        }
+    }
+
+    Vk::Vk(PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr, PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr)
+        : m_vkGetInstanceProcAddr(vkGetInstanceProcAddr), m_vkGetDeviceProcAddr(vkGetDeviceProcAddr) {}
+
+    Vk::~Vk() = default;
+
+    bool Vk::IsAvailable() const {
+        return m_vkGetInstanceProcAddr != nullptr && m_vkGetDeviceProcAddr != nullptr;
     }
 
-    std::set<std::string> Vulkan::GetDeviceExtensions(VkInstance vkInstance, VkPhysicalDevice vkDevice) const {
+    std::set<std::string> Vk::GetDeviceExtensions(VkInstance vkInstance, VkPhysicalDevice vkDevice) const {
         auto vkEnumerateDeviceExtensionProperties =
             GetInstanceProcAddress<PFN_vkEnumerateDeviceExtensionProperties>(
                 vkInstance, "vkEnumerateDeviceExtensionProperties");
@@ -33,15 +47,15 @@ namespace dxvk {
         return deviceExtensions;
     }
 
-    void Vulkan::GetPhysicalDeviceProperties2(VkInstance vkInstance, VkPhysicalDevice vkDevice, VkPhysicalDeviceProperties2* deviceProperties2) const {
+    void Vk::GetPhysicalDeviceProperties2(VkInstance vkInstance, VkPhysicalDevice vkDevice, VkPhysicalDeviceProperties2* deviceProperties2) const {
         auto vkGetPhysicalDeviceProperties2 =
             GetInstanceProcAddress<PFN_vkGetPhysicalDeviceProperties2>(
                 vkInstance, "vkGetPhysicalDeviceProperties2");
 
         vkGetPhysicalDeviceProperties2(vkDevice, deviceProperties2);
     }
 
-    NV_GPU_TYPE Vulkan::ToNvGpuType(VkPhysicalDeviceType vkDeviceType) {
+    NV_GPU_TYPE Vk::ToNvGpuType(VkPhysicalDeviceType vkDeviceType) {
         // Assert enum value equality between Vulkan and NVAPI at compile time
         static_assert(static_cast<int>(VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) == static_cast<int>(NV_SYSTEM_TYPE_DGPU));
         static_assert(static_cast<int>(VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU) == static_cast<int>(NV_SYSTEM_TYPE_IGPU));
@@ -53,7 +67,7 @@ namespace dxvk {
     }
 
     template <typename T>
-    T Vulkan::GetInstanceProcAddress(VkInstance vkInstance, const char* name) const {
+    T Vk::GetInstanceProcAddress(VkInstance vkInstance, const char* name) const {
         return reinterpret_cast<T>(m_vkGetInstanceProcAddr(vkInstance, name));
     }
 }
diff --git a/src/nvapi/vulkan.h → src/nvapi/vk.h b/src/nvapi/vulkan.h → src/nvapi/vk.h
@@ -1,15 +1,17 @@
 #pragma once
 
 #include "../nvapi_private.h"
+#include "../interfaces/dxvk_interfaces.h"
 #include "../util/com_pointer.h"
 
 namespace dxvk {
-    class Vulkan {
+    class Vk {
 
       public:
-        Vulkan();
-        explicit Vulkan(Com<IDXGIFactory1> dxgiFactory, PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr);
-        virtual ~Vulkan();
+        Vk();
+        explicit Vk(Com<IDXGIVkInteropFactory>&& dxgiVkInteropFactory);
+        explicit Vk(PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr, PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr);
+        virtual ~Vk();
 
         [[nodiscard]] virtual bool IsAvailable() const;
         [[nodiscard]] virtual std::set<std::string> GetDeviceExtensions(VkInstance vkInstance, VkPhysicalDevice vkDevice) const;
@@ -18,8 +20,9 @@ namespace dxvk {
         [[nodiscard]] static NV_GPU_TYPE ToNvGpuType(VkPhysicalDeviceType vkDeviceType);
 
       private:
-        Com<IDXGIFactory1> m_dxgiFactory;
+        Com<IDXGIVkInteropFactory> m_dxgiVkInteropFactory;
         PFN_vkGetInstanceProcAddr m_vkGetInstanceProcAddr{};
+        PFN_vkGetDeviceProcAddr m_vkGetDeviceProcAddr{};
 
         template <typename T>
         T GetInstanceProcAddress(VkInstance vkInstance, const char* name) const;

diff --git a/tests/meson.build b/tests/meson.build
@@ -3,7 +3,7 @@ nvapi_src = files([
   '../src/util/util_env.cpp',
   '../src/util/util_log.cpp',
   '../src/nvapi/resource_factory.cpp',
-  '../src/nvapi/vulkan.cpp',
+  '../src/nvapi/vk.cpp',
   '../src/nvapi/nvml.cpp',
   '../src/nvapi/lfx.cpp',
   '../src/nvapi/nvapi_d3d_instance.cpp',

diff --git a/tests/mock_factory.h b/tests/mock_factory.h
@@ -1,6 +1,8 @@
 #pragma once
 
 #include "nvapi_tests_private.h"
+#include "nvapi_d3d_mocks.h"
+#include "nvapi_sysinfo_mocks.h"
 #include "../src/nvapi/resource_factory.h"
 
 using namespace trompeloeil;
@@ -10,20 +12,20 @@ class MockFactory : public dxvk::ResourceFactory {
   public:
     MockFactory(
         std::unique_ptr<DXGIDxvkFactoryMock> dxgiFactory1Mock,
-        std::unique_ptr<VulkanMock> vulkanMock,
+        std::unique_ptr<VkMock> vkMock,
         std::unique_ptr<NvmlMock> nvmlMock,
         std::unique_ptr<LfxMock> lfxMock)
         : m_dxgiFactoryMock(std::move(dxgiFactory1Mock)),
-          m_vulkanMock(std::move(vulkanMock)),
+          m_vkMock(std::move(vkMock)),
           m_nvmlMock(std::move(nvmlMock)),
           m_lfxMock(std::move(lfxMock)) {};
 
     dxvk::Com<IDXGIFactory1> CreateDXGIFactory1() override {
         return m_dxgiFactoryMock.get();
     };
 
-    std::unique_ptr<dxvk::Vulkan> CreateVulkan(dxvk::Com<IDXGIFactory1>& dxgiFactory) override {
-        return std::move(m_vulkanMock);
+    std::unique_ptr<dxvk::Vk> CreateVulkan(dxvk::Com<IDXGIFactory1>& dxgiFactory) override {
+        return std::move(m_vkMock);
     }
 
     std::unique_ptr<dxvk::Nvml> CreateNvml() override {
@@ -40,7 +42,7 @@ class MockFactory : public dxvk::ResourceFactory {
 
   private:
     std::unique_ptr<DXGIDxvkFactoryMock> m_dxgiFactoryMock;
-    std::unique_ptr<VulkanMock> m_vulkanMock;
+    std::unique_ptr<VkMock> m_vkMock;
     std::unique_ptr<NvmlMock> m_nvmlMock;
     std::unique_ptr<LfxMock> m_lfxMock;
 };