stash

OptiScaler/hooks/Dxgi_Hooks.cpp

@@ -21,9 +21,9 @@ static PFN_CreateSwapChainForHwnd o_CreateSwapChainForHwnd = nullptr;
 static PFN_CreateSwapChainForComposition o_CreateSwapChainForComposition = nullptr;
 static PFN_CreateSwapChainForCoreWindow o_CreateSwapChainForCoreWindow = nullptr;
 
-static PFN_PresentCallback presentCallback[2] = { nullptr, nullptr };
-static PFN_CleanCallback cleanCallback[2] = { nullptr, nullptr };
-static PFN_ReleaseCallback releaseCallback[2] = { nullptr, nullptr };
+static PFN_DxgiPresentCallback presentCallback[2] = { nullptr, nullptr };
+static PFN_DxgiCleanCallback cleanCallback[2] = { nullptr, nullptr };
+static PFN_DxgiReleaseCallback releaseCallback[2] = { nullptr, nullptr };
 
 static IUnknown* device = nullptr;
 static IDXGIAdapter* adapters[8] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
@@ -283,7 +283,7 @@ void Hooks::AttachDxgiSwapchainHooks(IDXGIFactory* InFactory)
     DetourTransactionCommit();
 }
 
-void Hooks::SetDxgiClean(PFN_CleanCallback InCallback)
+void Hooks::SetDxgiClean(PFN_DxgiCleanCallback InCallback)
 {
     if(cleanCallback == nullptr)
         cleanCallback[0] = InCallback;
@@ -291,7 +291,7 @@ void Hooks::SetDxgiClean(PFN_CleanCallback InCallback)
         cleanCallback[1] = InCallback;
 }
 
-void Hooks::SetDxgiPresent(PFN_PresentCallback InCallback)
+void Hooks::SetDxgiPresent(PFN_DxgiPresentCallback InCallback)
 {
     if (presentCallback == nullptr)
         presentCallback[0] = InCallback;
@@ -299,7 +299,7 @@ void Hooks::SetDxgiPresent(PFN_PresentCallback InCallback)
         presentCallback[1] = InCallback;
 }
 
-void Hooks::SetDxgiRelease(PFN_ReleaseCallback InCallback)
+void Hooks::SetDxgiRelease(PFN_DxgiReleaseCallback InCallback)
 {
     if (releaseCallback == nullptr)
         releaseCallback[0] = InCallback;
@@ -312,7 +312,10 @@ IUnknown* Hooks::DxgiDevice()
     return device;
 }
 
-IDXGIAdapter* Hooks::GetDXGIAdapter(uint32_t no)
+IDXGIAdapter* Hooks::GetDXGIAdapter(uint32_t index)
 {
+    if (index >= 0 && index < 8)
+        return adapters[index];
+
     return nullptr;
 }

OptiScaler/hooks/Dxgi_Hooks.h

@@ -3,9 +3,9 @@
 
 #include <dxgi1_6.h>
 
-typedef void(*PFN_CleanCallback)(bool);
-typedef void(*PFN_PresentCallback)(IDXGISwapChain*);
-typedef void(*PFN_ReleaseCallback)(HWND);
+typedef void(*PFN_DxgiCleanCallback)(bool);
+typedef void(*PFN_DxgiPresentCallback)(IDXGISwapChain*);
+typedef void(*PFN_DxgiReleaseCallback)(HWND);
 
 namespace Hooks
 {
@@ -13,9 +13,9 @@ namespace Hooks
     void DetachDxgiHooks();
     void AttachDxgiSwapchainHooks(IDXGIFactory* InFactory);
 
-    void SetDxgiClean(PFN_CleanCallback);
-    void SetDxgiPresent(PFN_PresentCallback);
-    void SetDxgiRelease(PFN_ReleaseCallback);
+    void SetDxgiClean(PFN_DxgiCleanCallback);
+    void SetDxgiPresent(PFN_DxgiPresentCallback);
+    void SetDxgiRelease(PFN_DxgiReleaseCallback);
 
     IUnknown* DxgiDevice();
     void EnumarateDxgiAdapters();

OptiScaler/hooks/Vulkan_Hooks.cpp

@@ -5,6 +5,9 @@
 
 #include "../detours/detours.h"
 
+typedef VkResult(*PFN_QueuePresentKHR)(VkQueue, const VkPresentInfoKHR*);
+typedef VkResult(*PFN_CreateSwapchainKHR)(VkDevice, const VkSwapchainCreateInfoKHR*, const VkAllocationCallbacks*, VkSwapchainKHR*);
+
 static PFN_vkGetPhysicalDeviceProperties o_vkGetPhysicalDeviceProperties = nullptr;
 static PFN_vkGetPhysicalDeviceProperties2 o_vkGetPhysicalDeviceProperties2 = nullptr;
 static PFN_vkGetPhysicalDeviceProperties2KHR o_vkGetPhysicalDeviceProperties2KHR = nullptr;
@@ -14,6 +17,9 @@ static PFN_vkEnumerateDeviceExtensionProperties o_vkEnumerateDeviceExtensionProp
 static PFN_vkCreateDevice o_vkCreateDevice = nullptr;
 static PFN_vkCreateInstance o_vkCreateInstance = nullptr;
 
+static PFN_QueuePresentKHR o_QueuePresentKHR = nullptr;
+static PFN_CreateSwapchainKHR o_CreateSwapchainKHR = nullptr;
+
 typedef struct VkDummyProps
 {
     VkStructureType sType;
@@ -23,9 +29,12 @@ typedef struct VkDummyProps
 static uint32_t vkEnumerateInstanceExtensionPropertiesCount = 0;
 static uint32_t vkEnumerateDeviceExtensionPropertiesCount = 0;
 
-VkInstance _instance = nullptr;
-VkDevice _device = nullptr;
-VkPhysicalDevice _physicalDevice = nullptr;
+static VkInstance _instance = nullptr;
+static VkDevice _device = nullptr;
+static VkPhysicalDevice _physicalDevice = nullptr;
+
+static PFN_VulkanPresentCallback _presentCallback = nullptr;
+static PFN_VulkanCreateSwapchainCallback _createSwapchainCallback = nullptr;
 
 #pragma region Vulkan Hooks
 
@@ -89,6 +98,29 @@ static void hkvkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice phys_dev, VkPhy
     }
 }
 
+static VkResult hkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain)
+{
+    auto result = o_CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain);
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(500));
+
+    if (result == VK_SUCCESS && _createSwapchainCallback != nullptr)
+    {
+        _device = device;
+        _createSwapchainCallback(device, pCreateInfo, pSwapchain);
+    }
+
+    return result;
+}
+
+static VkResult hkQueuePresentKHR(VkQueue queue, VkPresentInfoKHR* pPresentInfo)
+{
+    if (_presentCallback != nullptr)
+        _presentCallback(pPresentInfo);
+
+    return o_QueuePresentKHR(queue, pPresentInfo);
+}
+
 static VkResult hkvkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
 {
     LOG_DEBUG("for {0}", pCreateInfo->pApplicationInfo->pApplicationName);
@@ -138,8 +170,27 @@ static VkResult hkvkCreateDevice(VkPhysicalDevice physicalDevice, VkDeviceCreate
         Config::Instance()->dxgiSkipSpoofing = false;
 
         if (result == VK_SUCCESS)
+        {
             _device = *pDevice;
 
+            if (o_QueuePresentKHR == nullptr)
+            {
+                o_QueuePresentKHR = reinterpret_cast<PFN_QueuePresentKHR>(vkGetDeviceProcAddr(_device, "vkQueuePresentKHR"));
+                o_CreateSwapchainKHR = reinterpret_cast<PFN_CreateSwapchainKHR>(vkGetDeviceProcAddr(_device, "vkCreateSwapchainKHR"));
+
+                DetourTransactionBegin();
+                DetourUpdateThread(GetCurrentThread());
+
+                if (o_QueuePresentKHR != nullptr)
+                    DetourAttach(&(PVOID&)o_QueuePresentKHR, hkQueuePresentKHR);
+
+                if (o_CreateSwapchainKHR != nullptr)
+                    DetourAttach(&(PVOID&)o_CreateSwapchainKHR, hkCreateSwapchainKHR);
+
+                DetourTransactionCommit();
+            }
+        }
+
         return result;
     }
 
@@ -186,8 +237,28 @@ static VkResult hkvkCreateDevice(VkPhysicalDevice physicalDevice, VkDeviceCreate
     Config::Instance()->dxgiSkipSpoofing = false;
 
     if (result == VK_SUCCESS)
+    {
         _device = *pDevice;
 
+        if (o_QueuePresentKHR == nullptr)
+        {
+            o_QueuePresentKHR = reinterpret_cast<PFN_QueuePresentKHR>(vkGetDeviceProcAddr(_device, "vkQueuePresentKHR"));
+            o_CreateSwapchainKHR = reinterpret_cast<PFN_CreateSwapchainKHR>(vkGetDeviceProcAddr(_device, "vkCreateSwapchainKHR"));
+
+            DetourTransactionBegin();
+            DetourUpdateThread(GetCurrentThread());
+
+            if (o_QueuePresentKHR != nullptr)
+                DetourAttach(&(PVOID&)o_QueuePresentKHR, hkQueuePresentKHR);
+
+            if (o_CreateSwapchainKHR != nullptr)
+                DetourAttach(&(PVOID&)o_CreateSwapchainKHR, hkCreateSwapchainKHR);
+
+            DetourTransactionCommit();
+        }
+
+    }
+
     LOG_FUNC_RESULT(result);
 
     return result;
@@ -427,3 +498,13 @@ VkPhysicalDevice Hooks::VulkanPD()
 {
     return _physicalDevice;
 }
+
+void Hooks::SetVulkanCreateSwapchain(PFN_VulkanCreateSwapchainCallback InCallback)
+{
+    _createSwapchainCallback = InCallback;
+}
+
+void Hooks::SetVulkanPresent(PFN_VulkanPresentCallback InCallback)
+{
+    _presentCallback = InCallback;
+}

OptiScaler/hooks/Vulkan_Hooks.h

@@ -2,6 +2,9 @@
 
 #include <vulkan/vulkan_core.h>
 
+typedef void(*PFN_VulkanCreateSwapchainCallback)(VkDevice, const VkSwapchainCreateInfoKHR*, VkSwapchainKHR*);
+typedef void(*PFN_VulkanPresentCallback)(VkPresentInfoKHR*);
+
 namespace Hooks
 {
     void AttachVulkanHooks();
@@ -11,6 +14,9 @@ namespace Hooks
     void AttachVulkanExtensionSpoofingHooks();
     void DetachVulkanExtensionSpoofingHooks();
 
+    void SetVulkanCreateSwapchain(PFN_VulkanCreateSwapchainCallback);
+    void SetVulkanPresent(PFN_VulkanPresentCallback);
+
     VkDevice VulkanDevice();
     VkInstance VulkanInstance();
     VkPhysicalDevice VulkanPD();

OptiScaler/hooks/proxies/Wrapped_SwapChain.cpp

@@ -5,7 +5,7 @@
 
 WrappedIDXGISwapChain4::WrappedIDXGISwapChain4(IDXGISwapChain* InRealSwapChain, std::function<void(IDXGISwapChain*)> InPresentCallback,
 											   std::function<void(bool)> InClearCallback, std::function<void(HWND)> InReleaseCallback) : 
-	m_pReal(InRealSwapChain), PFN_PresentCallback(InPresentCallback),  ClearCallback(InClearCallback), PFN_ReleaseCallback(InReleaseCallback), m_iRefcount(1)
+	m_pReal(InRealSwapChain), PFN_DxgiPresentCallback(InPresentCallback),  ClearCallback(InClearCallback), PFN_DxgiReleaseCallback(InReleaseCallback), m_iRefcount(1)
 {
 	m_pReal->QueryInterface(IID_PPV_ARGS(&m_pReal1));
 	m_pReal->QueryInterface(IID_PPV_ARGS(&m_pReal2));
@@ -170,16 +170,16 @@ HRESULT WrappedIDXGISwapChain4::GetDevice(REFIID riid, void** ppDevice)
 
 HRESULT WrappedIDXGISwapChain4::Present(UINT SyncInterval, UINT Flags)
 {
-	if (!((Flags & DXGI_PRESENT_TEST) || (Flags & DXGI_PRESENT_RESTART)) && PFN_PresentCallback != nullptr && m_pReal3 != nullptr)
-		PFN_PresentCallback(m_pReal);
+	if (!((Flags & DXGI_PRESENT_TEST) || (Flags & DXGI_PRESENT_RESTART)) && PFN_DxgiPresentCallback != nullptr && m_pReal3 != nullptr)
+		PFN_DxgiPresentCallback(m_pReal);
 
 	return m_pReal->Present(SyncInterval, Flags);
 }
 
 HRESULT WrappedIDXGISwapChain4::Present1(UINT SyncInterval, UINT Flags, const DXGI_PRESENT_PARAMETERS* pPresentParameters)
 {
-	if (!((Flags & DXGI_PRESENT_TEST) || (Flags & DXGI_PRESENT_RESTART)) && PFN_PresentCallback != nullptr && m_pReal3 != nullptr)
-		PFN_PresentCallback(m_pReal1);
+	if (!((Flags & DXGI_PRESENT_TEST) || (Flags & DXGI_PRESENT_RESTART)) && PFN_DxgiPresentCallback != nullptr && m_pReal3 != nullptr)
+		PFN_DxgiPresentCallback(m_pReal1);
 
 	return m_pReal1->Present1(SyncInterval, Flags, pPresentParameters);
 }

OptiScaler/hooks/proxies/Wrapped_SwapChain.h

@@ -11,9 +11,9 @@ class WrappedIDXGISwapChain4 : public IDXGISwapChain4
 	IDXGISwapChain3* m_pReal3 = nullptr;
 	IDXGISwapChain4* m_pReal4 = nullptr;
 
-	std::function<void(IDXGISwapChain*)> PFN_PresentCallback = nullptr;
+	std::function<void(IDXGISwapChain*)> PFN_DxgiPresentCallback = nullptr;
 	std::function<void(bool)> ClearCallback = nullptr;
-	std::function<void(HWND)> PFN_ReleaseCallback = nullptr;
+	std::function<void(HWND)> PFN_DxgiReleaseCallback = nullptr;
 
 	unsigned int m_iRefcount;
 
@@ -43,7 +43,7 @@ public:
 			{
 				HWND hwnd = nullptr;
 				m_pReal1->GetHwnd(&hwnd);
-				PFN_ReleaseCallback(hwnd);
+				PFN_DxgiReleaseCallback(hwnd);
 			}
 
 			delete this;