nvapi: Format code using clang-format

36 files changed, 533 insertions, 536 deletions

diff --git a/src/d3d/lfx.cpp b/src/d3d/lfx.cpp
index 6094d44..99abae2 100644
--- a/src/d3d/lfx.cpp
+++ b/src/d3d/lfx.cpp
@@ -23,16 +23,16 @@ namespace dxvk {
             auto lastError = ::GetLastError();
             if (lastError != ERROR_MOD_NOT_FOUND) // Ignore library not found
                 log::write(str::format("Loading ", !useFallbackEntrypoints ? lfxModuleName : lfxModuleNameFallback,
-                                       " failed with error code: ", lastError));
+                    " failed with error code: ", lastError));
             return;
         }
 
         m_lfx_WaitAndBeginFrame = reinterpret_cast<PFN_lfx_WaitAndBeginFrame>(reinterpret_cast<void*>(
-                GetProcAddress(m_lfxModule,
-                               !useFallbackEntrypoints ? "lfx_WaitAndBeginFrame" : "winelfx_WaitAndBeginFrame")));
+            GetProcAddress(m_lfxModule,
+                !useFallbackEntrypoints ? "lfx_WaitAndBeginFrame" : "winelfx_WaitAndBeginFrame")));
         m_lfx_SetTargetFrameTime = reinterpret_cast<PFN_lfx_SetTargetFrameTime>(reinterpret_cast<void*>(
-                GetProcAddress(m_lfxModule,
-                               !useFallbackEntrypoints ? "lfx_SetTargetFrameTime" : "winelfx_SetTargetFrameTime")));
+            GetProcAddress(m_lfxModule,
+                !useFallbackEntrypoints ? "lfx_SetTargetFrameTime" : "winelfx_SetTargetFrameTime")));
     }
 
     Lfx::~Lfx() {
diff --git a/src/d3d/lfx.h b/src/d3d/lfx.h
index c4e9d4a..fd5f9b8 100644
--- a/src/d3d/lfx.h
+++ b/src/d3d/lfx.h
@@ -5,7 +5,7 @@
 
 namespace dxvk {
     class Lfx {
-    public:
+      public:
         Lfx();
         virtual ~Lfx();
 
@@ -13,7 +13,7 @@ namespace dxvk {
         virtual void WaitAndBeginFrame();
         virtual void SetTargetFrameTime(uint64_t frame_time_ns);
 
-    private:
+      private:
         typedef void (*PFN_lfx_WaitAndBeginFrame)();
         typedef void (*PFN_lfx_SetTargetFrameTime)(__int64);
 
diff --git a/src/d3d/nvapi_d3d_instance.cpp b/src/d3d/nvapi_d3d_instance.cpp
index bd4cd95..6cdf260 100644
--- a/src/d3d/nvapi_d3d_instance.cpp
+++ b/src/d3d/nvapi_d3d_instance.cpp
@@ -2,8 +2,8 @@
 #include "nvapi_d3d_instance.h"
 
 namespace dxvk {
-    NvapiD3dInstance::NvapiD3dInstance(ResourceFactory &resourceFactory)
-            : m_resourceFactory(resourceFactory) {}
+    NvapiD3dInstance::NvapiD3dInstance(ResourceFactory& resourceFactory)
+        : m_resourceFactory(resourceFactory) {}
 
     NvapiD3dInstance::~NvapiD3dInstance() = default;
 
diff --git a/src/d3d/nvapi_d3d_instance.h b/src/d3d/nvapi_d3d_instance.h
index 60f5459..89604d6 100644
--- a/src/d3d/nvapi_d3d_instance.h
+++ b/src/d3d/nvapi_d3d_instance.h
@@ -4,8 +4,8 @@
 
 namespace dxvk {
     class NvapiD3dInstance {
-    public:
-        explicit NvapiD3dInstance(ResourceFactory &resourceFactory);
+      public:
+        explicit NvapiD3dInstance(ResourceFactory& resourceFactory);
         ~NvapiD3dInstance();
 
         void Initialize();
@@ -15,7 +15,7 @@ namespace dxvk {
         void Sleep();
         void SetTargetFrameTime(uint64_t frameTimeUs);
 
-    private:
+      private:
         ResourceFactory& m_resourceFactory;
         std::unique_ptr<Lfx> m_lfx;
         bool m_isLfxEnabled = false;
diff --git a/src/d3d11/nvapi_d3d11_device.cpp b/src/d3d11/nvapi_d3d11_device.cpp
index 06d58ba..444e190 100644
--- a/src/d3d11/nvapi_d3d11_device.cpp
+++ b/src/d3d11/nvapi_d3d11_device.cpp
@@ -85,15 +85,15 @@ namespace dxvk {
         return d3d11ExtDevice1->GetResourceHandleGPUVirtualAddressAndSizeNVX(reinterpret_cast<void*>(hObject), reinterpret_cast<uint64_t*>(gpuVAStart), reinterpret_cast<uint64_t*>(gpuVASize));
     }
 
-    bool NvapiD3d11Device::CreateUnorderedAccessViewAndGetDriverHandle(ID3D11Device* pDevice, ID3D11Resource* pResource, const D3D11_UNORDERED_ACCESS_VIEW_DESC*  pDesc, ID3D11UnorderedAccessView** ppUAV, NvU32* pDriverHandle) {
+    bool NvapiD3d11Device::CreateUnorderedAccessViewAndGetDriverHandle(ID3D11Device* pDevice, ID3D11Resource* pResource, const D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc, ID3D11UnorderedAccessView** ppUAV, NvU32* pDriverHandle) {
         Com<ID3D11VkExtDevice1> d3d11ExtDevice1;
         if (FAILED(pDevice->QueryInterface(IID_PPV_ARGS(&d3d11ExtDevice1))))
             return false;
 
         return d3d11ExtDevice1->CreateUnorderedAccessViewAndGetDriverHandleNVX(pResource, pDesc, ppUAV, reinterpret_cast<uint32_t*>(pDriverHandle));
     }
-    
-    bool NvapiD3d11Device::CreateShaderResourceViewAndGetDriverHandle(ID3D11Device* pDevice, ID3D11Resource* pResource, const D3D11_SHADER_RESOURCE_VIEW_DESC*  pDesc, ID3D11ShaderResourceView** ppSRV, NvU32* pDriverHandle) {
+
+    bool NvapiD3d11Device::CreateShaderResourceViewAndGetDriverHandle(ID3D11Device* pDevice, ID3D11Resource* pResource, const D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc, ID3D11ShaderResourceView** ppSRV, NvU32* pDriverHandle) {
         Com<ID3D11VkExtDevice1> d3d11ExtDevice1;
         if (FAILED(pDevice->QueryInterface(IID_PPV_ARGS(&d3d11ExtDevice1))))
             return false;
@@ -110,14 +110,14 @@ namespace dxvk {
         return d3d11ExtDevice1->GetCudaTextureObjectNVX(srvDriverHandle, samplerDriverHandle, reinterpret_cast<uint32_t*>(pCudaTextureHandle));
     }
 
-     bool NvapiD3d11Device::CreateSamplerStateAndGetDriverHandle(ID3D11Device* pDevice, const D3D11_SAMPLER_DESC* pSamplerDesc, ID3D11SamplerState** ppSamplerState, uint32_t* pDriverHandle) {
+    bool NvapiD3d11Device::CreateSamplerStateAndGetDriverHandle(ID3D11Device* pDevice, const D3D11_SAMPLER_DESC* pSamplerDesc, ID3D11SamplerState** ppSamplerState, uint32_t* pDriverHandle) {
         // note - getting the driver handle for a sampler state is typically a one-shot thing, no need to add complexity by caching availability of the underlying extensions, we'll just let DXVK tell us if it failed.
         Com<ID3D11VkExtDevice1> d3d11ExtDevice1;
         if (FAILED(pDevice->QueryInterface(IID_PPV_ARGS(&d3d11ExtDevice1))))
             return false;
 
         return d3d11ExtDevice1->CreateSamplerStateAndGetDriverHandleNVX(pSamplerDesc, ppSamplerState, pDriverHandle);
-     }
+    }
 
     bool NvapiD3d11Device::IsFatbinPTXSupported(ID3D11Device* pDevice) {
         return GetBinaryImportDeviceContext(pDevice) != nullptr;
diff --git a/src/d3d11/nvapi_d3d11_device.h b/src/d3d11/nvapi_d3d11_device.h
index 559bd80..ea025da 100644
--- a/src/d3d11/nvapi_d3d11_device.h
+++ b/src/d3d11/nvapi_d3d11_device.h
@@ -7,7 +7,7 @@
 namespace dxvk {
     class NvapiD3d11Device {
 
-    public:
+      public:
         static bool SetDepthBoundsTest(IUnknown* deviceOrContext, bool enable, float minDepth, float maxDepth);
         static bool BeginUAVOverlap(IUnknown* deviceOrContext);
         static bool EndUAVOverlap(IUnknown* deviceOrContext);
@@ -18,13 +18,13 @@ namespace dxvk {
         static bool DestroyCubinShader(NVDX_ObjectHandle hShader);
         static bool GetResourceDriverHandle(ID3D11Resource* pResource, NVDX_ObjectHandle* phObject);
         static bool GetResourceHandleGPUVirtualAddressAndSize(ID3D11Device* pDevice, NVDX_ObjectHandle hObject, NvU64* gpuVAStart, NvU64* gpuVASize);
-        static bool CreateUnorderedAccessViewAndGetDriverHandle(ID3D11Device* pDevice, ID3D11Resource* pResource, const D3D11_UNORDERED_ACCESS_VIEW_DESC*  pDesc, ID3D11UnorderedAccessView** ppUAV, NvU32* pDriverHandle);
+        static bool CreateUnorderedAccessViewAndGetDriverHandle(ID3D11Device* pDevice, ID3D11Resource* pResource, const D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc, ID3D11UnorderedAccessView** ppUAV, NvU32* pDriverHandle);
         static bool CreateShaderResourceViewAndGetDriverHandle(ID3D11Device* pDevice, ID3D11Resource* pResource, const D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc, ID3D11ShaderResourceView** ppSRV, NvU32* pDriverHandle);
         static bool GetCudaTextureObject(ID3D11Device* pDevice, uint32_t srvDriverHandle, uint32_t samplerDriverHandle, uint32_t* pCudaTextureHandle);
         static bool CreateSamplerStateAndGetDriverHandle(ID3D11Device* pDevice, const D3D11_SAMPLER_DESC* pSamplerDesc, ID3D11SamplerState** ppSamplerState, uint32_t* pDriverHandle);
         static bool IsFatbinPTXSupported(ID3D11Device* pDevice);
 
-    private:
+      private:
         inline static std::unordered_map<IUnknown*, ID3D11VkExtContext*> m_depthBoundsDeviceOrContextMap;
         inline static std::unordered_map<IUnknown*, ID3D11VkExtContext*> m_barrierControlDeviceOrContextMap;
         inline static std::unordered_map<IUnknown*, ID3D11VkExtContext*> m_multiDrawIndirectContextMap;
diff --git a/src/d3d12/nvapi_d3d12_device.cpp b/src/d3d12/nvapi_d3d12_device.cpp
index 5442dad..eca1bc7 100644
--- a/src/d3d12/nvapi_d3d12_device.cpp
+++ b/src/d3d12/nvapi_d3d12_device.cpp
@@ -26,7 +26,7 @@ namespace dxvk {
         return true;
     }
 
-    bool NvapiD3d12Device::CreateCubinComputeShaderWithName(ID3D12Device* device, const void* cubinData, NvU32 cubinSize, NvU32 blockX, NvU32 blockY, NvU32 blockZ, const char* shaderName, NVDX_ObjectHandle* pShader){
+    bool NvapiD3d12Device::CreateCubinComputeShaderWithName(ID3D12Device* device, const void* cubinData, NvU32 cubinSize, NvU32 blockX, NvU32 blockY, NvU32 blockZ, const char* shaderName, NVDX_ObjectHandle* pShader) {
         auto cubinDevice = GetCubinDevice(device);
         if (cubinDevice == nullptr)
             return false;
@@ -46,9 +46,8 @@ namespace dxvk {
         auto cubinDevice = GetCubinDevice(device);
         if (cubinDevice == nullptr)
             return false;
-            
-        return SUCCEEDED(cubinDevice->GetCudaTextureObject(srvHandle, samplerHandle, reinterpret_cast<UINT32*>(cudaTextureHandle)));
 
+        return SUCCEEDED(cubinDevice->GetCudaTextureObject(srvHandle, samplerHandle, reinterpret_cast<UINT32*>(cudaTextureHandle)));
     }
 
     bool NvapiD3d12Device::GetCudaSurfaceObject(ID3D12Device* device, D3D12_CPU_DESCRIPTOR_HANDLE uavHandle, NvU32* cudaSurfaceHandle) {
@@ -90,7 +89,7 @@ namespace dxvk {
 
         auto cubinDevice = GetDeviceExt(device, D3D12_VK_NVX_BINARY_IMPORT);
         if (cubinDevice != nullptr)
-             m_cubinDeviceMap.emplace(device, cubinDevice.ptr());
+            m_cubinDeviceMap.emplace(device, cubinDevice.ptr());
 
         return cubinDevice;
     }
@@ -109,7 +108,7 @@ namespace dxvk {
     Com<ID3D12GraphicsCommandListExt> NvapiD3d12Device::GetCommandListExt(ID3D12GraphicsCommandList* commandList) {
         std::scoped_lock lock(m_CommandListMutex);
         auto it = m_CommandListMap.find(commandList);
-        if (it!= m_CommandListMap.end())
+        if (it != m_CommandListMap.end())
             return it->second;
 
         Com<ID3D12GraphicsCommandListExt> commandListExt;
diff --git a/src/d3d12/nvapi_d3d12_device.h b/src/d3d12/nvapi_d3d12_device.h
index 1308963..c0e1d9c 100644
--- a/src/d3d12/nvapi_d3d12_device.h
+++ b/src/d3d12/nvapi_d3d12_device.h
@@ -8,7 +8,7 @@ namespace dxvk {
 
     class NvapiD3d12Device {
 
-    public:
+      public:
         static std::optional<LUID> GetLuid(IUnknown* unknown);
 
         static bool CreateGraphicsPipelineState(ID3D12Device* device, const D3D12_GRAPHICS_PIPELINE_STATE_DESC* pipelineStateDescription, NvU32 numberOfExtensions, const NVAPI_D3D12_PSO_EXTENSION_DESC** extensions, ID3D12PipelineState** pipelineState);
@@ -22,7 +22,7 @@ namespace dxvk {
         static bool CaptureUAVInfo(ID3D12Device* device, NVAPI_UAV_INFO* uavInfo);
         static bool IsFatbinPTXSupported(ID3D12Device* device);
 
-    private:
+      private:
         inline static std::unordered_map<ID3D12Device*, ID3D12DeviceExt*> m_cubinDeviceMap;
         inline static std::unordered_map<ID3D12GraphicsCommandList*, ID3D12GraphicsCommandListExt*> m_CommandListMap;
 
diff --git a/src/dxvk/dxvk_interfaces.cpp b/src/dxvk/dxvk_interfaces.cpp
index e4e5cf9..9cbc163 100644
--- a/src/dxvk/dxvk_interfaces.cpp
+++ b/src/dxvk/dxvk_interfaces.cpp
@@ -1,7 +1,7 @@
 #include "dxvk_interfaces.h"
 
-const GUID IDXGIVkInteropAdapter::guid  = {0x3a6d8f2c,0xb0e8,0x4ab4,{0xb4,0xdc,0x4f,0xd2,0x48,0x91,0xbf,0xa5}};
-const GUID ID3D11VkExtDevice::guid      = {0x8a6e3c42,0xf74c,0x45b7,{0x82,0x65,0xa2,0x31,0xb6,0x77,0xca,0x17}};
-const GUID ID3D11VkExtDevice1::guid     = {0xcfcf64ef,0x9586,0x46d0,{0xbc,0xa4,0x97,0xcf,0x2c,0xa6,0x1b,0x06}};
-const GUID ID3D11VkExtContext::guid     = {0xfd0bca13,0x5cb6,0x4c3a,{0x98,0x7e,0x47,0x50,0xde,0x2c,0xa7,0x91}};
-const GUID ID3D11VkExtContext1::guid    = {0x874b09b2,0xae0b,0x41d8,{0x84,0x76,0x5f,0x3b,0x7a,0x0e,0x87,0x9d}};
+const GUID IDXGIVkInteropAdapter::guid = {0x3a6d8f2c, 0xb0e8, 0x4ab4, {0xb4, 0xdc, 0x4f, 0xd2, 0x48, 0x91, 0xbf, 0xa5}};
+const GUID ID3D11VkExtDevice::guid = {0x8a6e3c42, 0xf74c, 0x45b7, {0x82, 0x65, 0xa2, 0x31, 0xb6, 0x77, 0xca, 0x17}};
+const GUID ID3D11VkExtDevice1::guid = {0xcfcf64ef, 0x9586, 0x46d0, {0xbc, 0xa4, 0x97, 0xcf, 0x2c, 0xa6, 0x1b, 0x06}};
+const GUID ID3D11VkExtContext::guid = {0xfd0bca13, 0x5cb6, 0x4c3a, {0x98, 0x7e, 0x47, 0x50, 0xde, 0x2c, 0xa7, 0x91}};
+const GUID ID3D11VkExtContext1::guid = {0x874b09b2, 0xae0b, 0x41d8, {0x84, 0x76, 0x5f, 0x3b, 0x7a, 0x0e, 0x87, 0x9d}};
diff --git a/src/dxvk/dxvk_interfaces.h b/src/dxvk/dxvk_interfaces.h
index 9a49516..2265137 100644
--- a/src/dxvk/dxvk_interfaces.h
+++ b/src/dxvk/dxvk_interfaces.h
@@ -7,19 +7,20 @@
 #endif // __GNUC__
 
 #define DXVK_DEFINE_GUID(iface) \
-    template<> inline GUID const& __mingw_uuidof<iface> () { return iface::guid; }
+    template <>                 \
+    inline GUID const& __mingw_uuidof<iface>() { return iface::guid; }
 
 enum D3D11_VK_EXTENSION : uint32_t {
-    D3D11_VK_EXT_MULTI_DRAW_INDIRECT        = 0,
-    D3D11_VK_EXT_MULTI_DRAW_INDIRECT_COUNT  = 1,
-    D3D11_VK_EXT_DEPTH_BOUNDS               = 2,
-    D3D11_VK_EXT_BARRIER_CONTROL            = 3,
-    D3D11_VK_NVX_BINARY_IMPORT              = 4,
-    D3D11_VK_NVX_IMAGE_VIEW_HANDLE          = 5,
+    D3D11_VK_EXT_MULTI_DRAW_INDIRECT = 0,
+    D3D11_VK_EXT_MULTI_DRAW_INDIRECT_COUNT = 1,
+    D3D11_VK_EXT_DEPTH_BOUNDS = 2,
+    D3D11_VK_EXT_BARRIER_CONTROL = 3,
+    D3D11_VK_NVX_BINARY_IMPORT = 4,
+    D3D11_VK_NVX_IMAGE_VIEW_HANDLE = 5,
 };
 
 enum D3D11_VK_BARRIER_CONTROL : uint32_t {
-    D3D11_VK_BARRIER_CONTROL_IGNORE_WRITE_AFTER_WRITE   = 1 << 0,
+    D3D11_VK_BARRIER_CONTROL_IGNORE_WRITE_AFTER_WRITE = 1 << 0,
 };
 
 /**
@@ -39,8 +40,8 @@ IDXGIVkInteropAdapter : public IUnknown {
      * \param [out] pPhysDev The physical device
      */
     virtual void STDMETHODCALLTYPE GetVulkanHandles(
-        VkInstance*           pInstance,
-        VkPhysicalDevice*     pPhysDev) = 0;
+        VkInstance * pInstance,
+        VkPhysicalDevice * pPhysDev) = 0;
 };
 
 MIDL_INTERFACE("8a6e3c42-f74c-45b7-8265-a231b677ca17")
@@ -54,48 +55,48 @@ ID3D11VkExtDevice : public IUnknown {
      * \returns \c TRUE if the extension is supported
      */
     virtual BOOL STDMETHODCALLTYPE GetExtensionSupport(
-        D3D11_VK_EXTENSION      Extension) = 0;
+        D3D11_VK_EXTENSION Extension) = 0;
 };
 
 MIDL_INTERFACE("cfcf64ef-9586-46d0-bca4-97cf2ca61b06")
 ID3D11VkExtDevice1 : public ID3D11VkExtDevice {
-  static const GUID guid;
-
-  virtual bool STDMETHODCALLTYPE GetResourceHandleGPUVirtualAddressAndSizeNVX(
-          void*                   hObject,
-          uint64_t*               gpuVAStart,
-          uint64_t*               gpuVASize) = 0;
-
-  virtual bool STDMETHODCALLTYPE CreateUnorderedAccessViewAndGetDriverHandleNVX(
-          ID3D11Resource*         pResource,
-          const D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc,
-          ID3D11UnorderedAccessView** ppUAV,
-          uint32_t*               pDriverHandle) = 0;
-
-  virtual bool STDMETHODCALLTYPE CreateShaderResourceViewAndGetDriverHandleNVX(
-          ID3D11Resource*         pResource,
-          const D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc,
-          ID3D11ShaderResourceView** ppSRV,
-          uint32_t*               pDriverHandle) = 0;
-
-  virtual bool STDMETHODCALLTYPE CreateSamplerStateAndGetDriverHandleNVX(
-          const D3D11_SAMPLER_DESC* pSamplerDesc,
-          ID3D11SamplerState**    ppSamplerState,
-          uint32_t*               pDriverHandle) = 0;
-
-  virtual bool STDMETHODCALLTYPE CreateCubinComputeShaderWithNameNVX(
-          const void*             pCubin,
-          uint32_t                size,
-          uint32_t                blockX,
-          uint32_t                blockY,
-          uint32_t                blockZ,
-          const char*             pShaderName,
-          IUnknown**              phShader) = 0;
-
-  virtual bool STDMETHODCALLTYPE GetCudaTextureObjectNVX(
-          uint32_t                srvDriverHandle,
-          uint32_t                samplerDriverHandle,
-          uint32_t*               pCudaTextureHandle) = 0;
+    static const GUID guid;
+
+    virtual bool STDMETHODCALLTYPE GetResourceHandleGPUVirtualAddressAndSizeNVX(
+        void* hObject,
+        uint64_t* gpuVAStart,
+        uint64_t* gpuVASize) = 0;
+
+    virtual bool STDMETHODCALLTYPE CreateUnorderedAccessViewAndGetDriverHandleNVX(
+        ID3D11Resource * pResource,
+        const D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc,
+        ID3D11UnorderedAccessView** ppUAV,
+        uint32_t* pDriverHandle) = 0;
+
+    virtual bool STDMETHODCALLTYPE CreateShaderResourceViewAndGetDriverHandleNVX(
+        ID3D11Resource * pResource,
+        const D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc,
+        ID3D11ShaderResourceView** ppSRV,
+        uint32_t* pDriverHandle) = 0;
+
+    virtual bool STDMETHODCALLTYPE CreateSamplerStateAndGetDriverHandleNVX(
+        const D3D11_SAMPLER_DESC* pSamplerDesc,
+        ID3D11SamplerState** ppSamplerState,
+        uint32_t* pDriverHandle) = 0;
+
+    virtual bool STDMETHODCALLTYPE CreateCubinComputeShaderWithNameNVX(
+        const void* pCubin,
+        uint32_t size,
+        uint32_t blockX,
+        uint32_t blockY,
+        uint32_t blockZ,
+        const char* pShaderName,
+        IUnknown** phShader) = 0;
+
+    virtual bool STDMETHODCALLTYPE GetCudaTextureObjectNVX(
+        uint32_t srvDriverHandle,
+        uint32_t samplerDriverHandle,
+        uint32_t * pCudaTextureHandle) = 0;
 };
 
 MIDL_INTERFACE("fd0bca13-5cb6-4c3a-987e-4750de2ca791")
@@ -103,57 +104,57 @@ ID3D11VkExtContext : public IUnknown {
     static const GUID guid;
 
     virtual void STDMETHODCALLTYPE MultiDrawIndirect(
-        UINT                    DrawCount,
-        ID3D11Buffer*           pBufferForArgs,
-        UINT                    ByteOffsetForArgs,
-        UINT                    ByteStrideForArgs) = 0;
+        UINT DrawCount,
+        ID3D11Buffer * pBufferForArgs,
+        UINT ByteOffsetForArgs,
+        UINT ByteStrideForArgs) = 0;
 
     virtual void STDMETHODCALLTYPE MultiDrawIndexedIndirect(
-        UINT                    DrawCount,
-        ID3D11Buffer*           pBufferForArgs,
-        UINT                    ByteOffsetForArgs,
-        UINT                    ByteStrideForArgs) = 0;
+        UINT DrawCount,
+        ID3D11Buffer * pBufferForArgs,
+        UINT ByteOffsetForArgs,
+        UINT ByteStrideForArgs) = 0;
 
     virtual void STDMETHODCALLTYPE MultiDrawIndirectCount(
-        UINT                    MaxDrawCount,
-        ID3D11Buffer*           pBufferForCount,
-        UINT                    ByteOffsetForCount,
-        ID3D11Buffer*           pBufferForArgs,
-        UINT                    ByteOffsetForArgs,
-        UINT                    ByteStrideForArgs) = 0;
+        UINT MaxDrawCount,
+        ID3D11Buffer * pBufferForCount,
+        UINT ByteOffsetForCount,
+        ID3D11Buffer * pBufferForArgs,
+        UINT ByteOffsetForArgs,
+        UINT ByteStrideForArgs) = 0;
 
     virtual void STDMETHODCALLTYPE MultiDrawIndexedIndirectCount(
-        UINT                    MaxDrawCount,
-        ID3D11Buffer*           pBufferForCount,
-        UINT                    ByteOffsetForCount,
-        ID3D11Buffer*           pBufferForArgs,
-        UINT                    ByteOffsetForArgs,
-        UINT                    ByteStrideForArgs) = 0;
-
-  virtual void STDMETHODCALLTYPE SetDepthBoundsTest(
-        BOOL                    Enable,
-        FLOAT                   MinDepthBounds,
-        FLOAT                   MaxDepthBounds) = 0;
-
-  virtual void STDMETHODCALLTYPE SetBarrierControl(
-        UINT                    ControlFlags) = 0;
+        UINT MaxDrawCount,
+        ID3D11Buffer * pBufferForCount,
+        UINT ByteOffsetForCount,
+        ID3D11Buffer * pBufferForArgs,
+        UINT ByteOffsetForArgs,
+        UINT ByteStrideForArgs) = 0;
+
+    virtual void STDMETHODCALLTYPE SetDepthBoundsTest(
+        BOOL Enable,
+        FLOAT MinDepthBounds,
+        FLOAT MaxDepthBounds) = 0;
+
+    virtual void STDMETHODCALLTYPE SetBarrierControl(
+        UINT ControlFlags) = 0;
 };
 
 MIDL_INTERFACE("874b09b2-ae0b-41d8-8476-5f3b7a0e879d")
 ID3D11VkExtContext1 : public ID3D11VkExtContext {
-  static const GUID guid;
-
-  virtual bool STDMETHODCALLTYPE LaunchCubinShaderNVX(
-          IUnknown*               hShader,
-          uint32_t                gridX,
-          uint32_t                gridY,
-          uint32_t                gridZ,
-          const void*             pParams,
-          uint32_t                paramSize,
-          void* const*            pReadResources,
-          uint32_t                numReadResources,
-          void* const*            pWriteResources,
-          uint32_t                numWriteResources) = 0;
+    static const GUID guid;
+
+    virtual bool STDMETHODCALLTYPE LaunchCubinShaderNVX(
+        IUnknown * hShader,
+        uint32_t gridX,
+        uint32_t gridY,
+        uint32_t gridZ,
+        const void* pParams,
+        uint32_t paramSize,
+        void* const* pReadResources,
+        uint32_t numReadResources,
+        void* const* pWriteResources,
+        uint32_t numWriteResources) = 0;
 };
 
 DXVK_DEFINE_GUID(IDXGIVkInteropAdapter)
diff --git a/src/nvapi.cpp b/src/nvapi.cpp
index eaf1928..19bbcb6 100644
--- a/src/nvapi.cpp
+++ b/src/nvapi.cpp
@@ -14,7 +14,7 @@
 extern "C" {
     using namespace dxvk;
 
-    NvAPI_Status __cdecl NvAPI_EnumLogicalGPUs(NvLogicalGpuHandle nvGPUHandle[NVAPI_MAX_LOGICAL_GPUS], NvU32 *pGpuCount) {
+    NvAPI_Status __cdecl NvAPI_EnumLogicalGPUs(NvLogicalGpuHandle nvGPUHandle[NVAPI_MAX_LOGICAL_GPUS], NvU32* pGpuCount) {
         constexpr auto n = __func__;
 
         if (nvapiAdapterRegistry == nullptr)
@@ -31,7 +31,7 @@ extern "C" {
         return Ok(n);
     }
 
-    NvAPI_Status __cdecl NvAPI_EnumPhysicalGPUs(NvPhysicalGpuHandle nvGPUHandle[NVAPI_MAX_PHYSICAL_GPUS], NvU32 *pGpuCount) {
+    NvAPI_Status __cdecl NvAPI_EnumPhysicalGPUs(NvPhysicalGpuHandle nvGPUHandle[NVAPI_MAX_PHYSICAL_GPUS], NvU32* pGpuCount) {
         constexpr auto n = __func__;
 
         if (nvapiAdapterRegistry == nullptr)
@@ -48,7 +48,7 @@ extern "C" {
         return Ok(n);
     }
 
-    NvAPI_Status __cdecl NvAPI_EnumTCCPhysicalGPUs(NvPhysicalGpuHandle nvGPUHandle[NVAPI_MAX_PHYSICAL_GPUS], NvU32 *pGpuCount)  {
+    NvAPI_Status __cdecl NvAPI_EnumTCCPhysicalGPUs(NvPhysicalGpuHandle nvGPUHandle[NVAPI_MAX_PHYSICAL_GPUS], NvU32* pGpuCount) {
         constexpr auto n = __func__;
 
         if (nvapiAdapterRegistry == nullptr)
@@ -66,7 +66,7 @@ extern "C" {
         return Ok(n);
     }
 
-    NvAPI_Status __cdecl NvAPI_GetGPUIDfromPhysicalGPU(NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pGpuId) {
+    NvAPI_Status __cdecl NvAPI_GetGPUIDfromPhysicalGPU(NvPhysicalGpuHandle hPhysicalGpu, NvU32* pGpuId) {
         constexpr auto n = __func__;
 
         if (nvapiAdapterRegistry == nullptr)
@@ -85,7 +85,7 @@ extern "C" {
         return Ok(n);
     }
 
-    NvAPI_Status __cdecl NvAPI_GetPhysicalGPUFromGPUID(NvU32 gpuId, NvPhysicalGpuHandle *hPhysicalGpu) {
+    NvAPI_Status __cdecl NvAPI_GetPhysicalGPUFromGPUID(NvU32 gpuId, NvPhysicalGpuHandle* hPhysicalGpu) {
         constexpr auto n = __func__;
 
         if (nvapiAdapterRegistry == nullptr)
@@ -107,7 +107,7 @@ extern "C" {
         return Ok(n);
     }
 
-    NvAPI_Status __cdecl NvAPI_GetDisplayDriverVersion(NvDisplayHandle hNvDisplay, NV_DISPLAY_DRIVER_VERSION *pVersion) {
+    NvAPI_Status __cdecl NvAPI_GetDisplayDriverVersion(NvDisplayHandle hNvDisplay, NV_DISPLAY_DRIVER_VERSION* pVersion) {
         constexpr auto n = __func__;
 
         if (nvapiAdapterRegistry == nullptr)
@@ -128,7 +128,7 @@ extern "C" {
         return Ok(n);
     }
 
-    NvAPI_Status __cdecl NvAPI_GetPhysicalGPUsFromLogicalGPU(NvLogicalGpuHandle hLogicalGPU,NvPhysicalGpuHandle hPhysicalGPU[NVAPI_MAX_PHYSICAL_GPUS], NvU32 *pGpuCount) {
+    NvAPI_Status __cdecl NvAPI_GetPhysicalGPUsFromLogicalGPU(NvLogicalGpuHandle hLogicalGPU, NvPhysicalGpuHandle hPhysicalGPU[NVAPI_MAX_PHYSICAL_GPUS], NvU32* pGpuCount) {
         constexpr auto n = __func__;
 
         if (nvapiAdapterRegistry == nullptr)
@@ -147,7 +147,7 @@ extern "C" {
         return Ok(n);
     }
 
-    NvAPI_Status __cdecl NvAPI_GetPhysicalGPUsFromDisplay(NvDisplayHandle hNvDisp, NvPhysicalGpuHandle nvGPUHandle[NVAPI_MAX_PHYSICAL_GPUS], NvU32 *pGpuCount) {
+    NvAPI_Status __cdecl NvAPI_GetPhysicalGPUsFromDisplay(NvDisplayHandle hNvDisp, NvPhysicalGpuHandle nvGPUHandle[NVAPI_MAX_PHYSICAL_GPUS], NvU32* pGpuCount) {
         constexpr auto n = __func__;
 
         if (nvapiAdapterRegistry == nullptr)
@@ -166,7 +166,7 @@ extern "C" {
         return Ok(n);
     }
 
-    NvAPI_Status __cdecl NvAPI_EnumNvidiaDisplayHandle(NvU32 thisEnum, NvDisplayHandle *pNvDispHandle) {
+    NvAPI_Status __cdecl NvAPI_EnumNvidiaDisplayHandle(NvU32 thisEnum, NvDisplayHandle* pNvDispHandle) {
         constexpr auto n = __func__;
 
         if (nvapiAdapterRegistry == nullptr)
@@ -184,7 +184,7 @@ extern "C" {
         return Ok(str::format(n, " (", thisEnum, ")"));
     }
 
-    NvAPI_Status __cdecl NvAPI_EnumNvidiaUnAttachedDisplayHandle(NvU32 thisEnum, NvUnAttachedDisplayHandle *pNvUnAttachedDispHandle) {
+    NvAPI_Status __cdecl NvAPI_EnumNvidiaUnAttachedDisplayHandle(NvU32 thisEnum, NvUnAttachedDisplayHandle* pNvUnAttachedDispHandle) {
         // DXVK does not know about unattached displays
         return EndEnumeration(str::format(__func__, " (", thisEnum, ")"));
     }
diff --git a/src/nvapi_d3d.cpp b/src/nvapi_d3d.cpp
index d331e7b..b6f4cee 100644
--- a/src/nvapi_d3d.cpp
+++ b/src/nvapi_d3d.cpp
@@ -5,7 +5,7 @@
 extern "C" {
     using namespace dxvk;
 
-    NvAPI_Status __cdecl NvAPI_D3D_GetObjectHandleForResource(IUnknown *pDevice, IUnknown *pResource, NVDX_ObjectHandle *pHandle) {
+    NvAPI_Status __cdecl NvAPI_D3D_GetObjectHandleForResource(IUnknown* pDevice, IUnknown* pResource, NVDX_ObjectHandle* pHandle) {
         static bool alreadyLogged = false;
         // Fake-implement with a dumb passthrough, though no other NvAPI entry points
         // we're likely to implement should care about the actual handle value.
@@ -13,23 +13,23 @@ extern "C" {
         return Ok(__func__, alreadyLogged);
     }
 
-    NvAPI_Status __cdecl NvAPI_D3D_SetResourceHint(IUnknown *pDev, NVDX_ObjectHandle obj, NVAPI_D3D_SETRESOURCEHINT_CATEGORY dwHintCategory, NvU32 dwHintName, NvU32 *pdwHintValue) {
+    NvAPI_Status __cdecl NvAPI_D3D_SetResourceHint(IUnknown* pDev, NVDX_ObjectHandle obj, NVAPI_D3D_SETRESOURCEHINT_CATEGORY dwHintCategory, NvU32 dwHintName, NvU32* pdwHintValue) {
         static bool alreadyLogged = false;
         return NoImplementation(__func__, alreadyLogged);
     }
 
-    NvAPI_Status __cdecl NvAPI_D3D_BeginResourceRendering(IUnknown *pDeviceOrContext, NVDX_ObjectHandle obj, NvU32 Flags) {
+    NvAPI_Status __cdecl NvAPI_D3D_BeginResourceRendering(IUnknown* pDeviceOrContext, NVDX_ObjectHandle obj, NvU32 Flags) {
         static bool alreadyLogged = false;
         // Synchronisation hints for SLI...
         return Ok(__func__, alreadyLogged);
     }
 
-    NvAPI_Status __cdecl NvAPI_D3D_EndResourceRendering(IUnknown *pDeviceOrContext, NVDX_ObjectHandle obj, NvU32 Flags) {
+    NvAPI_Status __cdecl NvAPI_D3D_EndResourceRendering(IUnknown* pDeviceOrContext, NVDX_ObjectHandle obj, NvU32 Flags) {
         static bool alreadyLogged = false;
         return Ok(__func__, alreadyLogged);
     }
 
-    NvAPI_Status __cdecl NvAPI_D3D_GetCurrentSLIState(IUnknown *pDevice, NV_GET_CURRENT_SLI_STATE *pSliState) {
+    NvAPI_Status __cdecl NvAPI_D3D_GetCurrentSLIState(IUnknown* pDevice, NV_GET_CURRENT_SLI_STATE* pSliState) {
         constexpr auto n = __func__;
         static bool alreadyLoggedOk = false;
 
@@ -74,7 +74,7 @@ extern "C" {
         return Ok(n);
     }
 
-    NvAPI_Status __cdecl NvAPI_D3D1x_GetGraphicsCapabilities(IUnknown *pDevice, NvU32 structVersion, NV_D3D1x_GRAPHICS_CAPS *pGraphicsCaps) {
+    NvAPI_Status __cdecl NvAPI_D3D1x_GetGraphicsCapabilities(IUnknown* pDevice, NvU32 structVersion, NV_D3D1x_GRAPHICS_CAPS* pGraphicsCaps) {
         constexpr auto n = __func__;
         static bool alreadyLoggedOk = false;
 
@@ -104,7 +104,7 @@ extern "C" {
         return Ok(n, alreadyLoggedOk);
     }
 
-    NvAPI_Status __cdecl NvAPI_D3D_Sleep(IUnknown *pDevice) {
+    NvAPI_Status __cdecl NvAPI_D3D_Sleep(IUnknown* pDevice) {
         constexpr auto n = __func__;
         static bool alreadyLoggedOk = false;
         static bool alreadyLoggedNoLfx = false;
@@ -117,7 +117,7 @@ extern "C" {
         return Ok(n, alreadyLoggedOk);
     }
 
-    NvAPI_Status __cdecl NvAPI_D3D_SetSleepMode(IUnknown *pDevice, NV_SET_SLEEP_MODE_PARAMS *pSetSleepModeParams) {
+    NvAPI_Status __cdecl NvAPI_D3D_SetSleepMode(IUnknown* pDevice, NV_SET_SLEEP_MODE_PARAMS* pSetSleepModeParams) {
         constexpr auto n = __func__;
         static bool alreadyLoggedNoLfx = false;
 
@@ -134,7 +134,7 @@ extern "C" {
         return Ok(str::format(n, " (", pSetSleepModeParams->bLowLatencyMode ? (str::format("Enabled/", pSetSleepModeParams->minimumIntervalUs, "us")) : "Disabled", ")"));
     }
 
-    NvAPI_Status __cdecl NvAPI_D3D_GetSleepStatus(IUnknown *pDevice, NV_GET_SLEEP_STATUS_PARAMS *pGetSleepStatusParams) {
+    NvAPI_Status __cdecl NvAPI_D3D_GetSleepStatus(IUnknown* pDevice, NV_GET_SLEEP_STATUS_PARAMS* pGetSleepStatusParams) {
         constexpr auto n = __func__;
         static bool alreadyLoggedNoLfx = false;
 
@@ -148,12 +148,12 @@ extern "C" {
         return Ok(n);
     }
 
-    NvAPI_Status __cdecl NvAPI_D3D_GetLatency(IUnknown *pDev, NV_LATENCY_RESULT_PARAMS *pGetLatencyParams) {
+    NvAPI_Status __cdecl NvAPI_D3D_GetLatency(IUnknown* pDev, NV_LATENCY_RESULT_PARAMS* pGetLatencyParams) {
         static bool alreadyLogged = false;
         return NoImplementation(__func__, alreadyLogged);
     }
 
-    NvAPI_Status __cdecl NvAPI_D3D_SetLatencyMarker(IUnknown *pDev, NV_LATENCY_MARKER_PARAMS* pSetLatencyMarkerParams) {
+    NvAPI_Status __cdecl NvAPI_D3D_SetLatencyMarker(IUnknown* pDev, NV_LATENCY_MARKER_PARAMS* pSetLatencyMarkerParams) {
         static bool alreadyLogged = false;
         return NoImplementation(__func__, alreadyLogged);
     }
diff --git a/src/nvapi_d3d11.cpp b/src/nvapi_d3d11.cpp
index 49d2e4d..c8d7284 100644
--- a/src/nvapi_d3d11.cpp
+++ b/src/nvapi_d3d11.cpp
@@ -7,11 +7,11 @@
 extern "C" {
     using namespace dxvk;
 
-    NvAPI_Status __cdecl NvAPI_D3D11_IsNvShaderExtnOpCodeSupported(IUnknown *pDeviceOrContext, NvU32 code, bool *supported) {
+    NvAPI_Status __cdecl NvAPI_D3D11_IsNvShaderExtnOpCodeSupported(IUnknown* pDeviceOrContext, NvU32 code, bool* supported) {
         constexpr auto n = __func__;
 
         if (pDeviceOrContext == nullptr || supported == nullptr)
-                return InvalidArgument(n);
+            return InvalidArgument(n);
 
         // DXVK does not know any NVIDIA intrinsics backdoors
         *supported = false;
@@ -19,7 +19,7 @@ extern "C" {
         return Ok(str::format(n, " (", code, "/", fromCode(code), ")"));
     }
 
-    NvAPI_Status __cdecl NvAPI_D3D11_SetDepthBoundsTest(IUnknown *pDeviceOrContext, NvU32 bEnable, float fMinDepth, float fMaxDepth) {
+    NvAPI_Status __cdecl NvAPI_D3D11_SetDepthBoundsTest(IUnknown* pDeviceOrContext, NvU32 bEnable, float fMinDepth, float fMaxDepth) {
         constexpr auto n = __func__;
         static bool alreadyLoggedError = false;
         static bool alreadyLoggedOk = false;
@@ -33,7 +33,7 @@ extern "C" {
         return Ok(n, alreadyLoggedOk);
     }
 
-    NvAPI_Status __cdecl NvAPI_D3D11_BeginUAVOverlap(IUnknown *pDeviceOrContext) {
+    NvAPI_Status __cdecl NvAPI_D3D11_BeginUAVOverlap(IUnknown* pDeviceOrContext) {
         constexpr auto n = __func__;
         static bool alreadyLoggedError = false;
         static bool alreadyLoggedOk = false;
@@ -47,7 +47,7 @@ extern "C" {
         return Ok(n, alreadyLoggedOk);
     }
 
-    NvAPI_Status __cdecl NvAPI_D3D11_EndUAVOverlap(IUnknown *pDeviceOrContext) {
+    NvAPI_Status __cdecl NvAPI_D3D11_EndUAVOverlap(IUnknown* pDeviceOrContext) {
         constexpr auto n = __func__;
         static bool alreadyLoggedError = false;
         static bool alreadyLoggedOk = false;
@@ -61,7 +61,7 @@ extern "C" {
         return Ok(n, alreadyLoggedOk);
     }
 
-    NvAPI_Status __cdecl NvAPI_D3D11_MultiDrawInstancedIndirect(ID3D11DeviceContext *pDevContext11, NvU32 drawCount, ID3D11Buffer *pBuffer, NvU32 alignedByteOffsetForArgs, NvU32 alignedByteStrideForArgs) {
+    NvAPI_Status __cdecl NvAPI_D3D11_MultiDrawInstancedIndirect(ID3D11DeviceContext* pDevContext11, NvU32 drawCount, ID3D11Buffer* pBuffer, NvU32 alignedByteOffsetForArgs, NvU32 alignedByteStrideForArgs) {
         constexpr auto n = __func__;
         static bool alreadyLoggedError = false;
         static bool alreadyLoggedOk = false;
@@ -75,7 +75,7 @@ extern "C" {
         return Ok(n, alreadyLoggedOk);
     }
 
-    NvAPI_Status __cdecl NvAPI_D3D11_MultiDrawIndexedInstancedIndirect(ID3D11DeviceContext *pDevContext11, NvU32 drawCount, ID3D11Buffer *pBuffer, NvU32 alignedByteOffsetForArgs, NvU32 alignedByteStrideForArgs) {
+    NvAPI_Status __cdecl NvAPI_D3D11_MultiDrawIndexedInstancedIndirect(ID3D11DeviceContext* pDevContext11, NvU32 drawCount, ID3D11Buffer* pBuffer, NvU32 alignedByteOffsetForArgs, NvU32 alignedByteStrideForArgs) {
         constexpr auto n = __func__;
         static bool alreadyLoggedError = false;
         static bool alreadyLoggedOk = false;
@@ -108,7 +108,6 @@ extern "C" {
         static bool alreadyLoggedError = false;
         static bool alreadyLoggedOk = false;
 
-
         if (pDevice == nullptr || pCubin == nullptr || phShader == nullptr)
             return InvalidArgument(n);
 
diff --git a/src/nvapi_d3d12.cpp b/src/nvapi_d3d12.cpp
index bcc269b..af30805 100644
--- a/src/nvapi_d3d12.cpp
+++ b/src/nvapi_d3d12.cpp
@@ -9,11 +9,11 @@
 extern "C" {
     using namespace dxvk;
 
-    NvAPI_Status __cdecl NvAPI_D3D12_IsNvShaderExtnOpCodeSupported(ID3D12Device *pDevice, NvU32 opCode, bool *pSupported) {
+    NvAPI_Status __cdecl NvAPI_D3D12_IsNvShaderExtnOpCodeSupported(ID3D12Device* pDevice, NvU32 opCode, bool* pSupported) {
         constexpr auto n = __func__;
 
         if (pDevice == nullptr || pSupported == nullptr)
-                return InvalidArgument(n);
+            return InvalidArgument(n);
 
         // VKD3D does not know any NVIDIA intrinsics
         *pSupported = false;
@@ -194,7 +194,7 @@ extern "C" {
         return Ok(n, alreadyLoggedOk);
     }
 
-    NvAPI_Status __cdecl NvAPI_D3D12_CreateGraphicsPipelineState(ID3D12Device *pDevice, const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pPSODesc, NvU32 numExtensions, const NVAPI_D3D12_PSO_EXTENSION_DESC** ppExtensions, ID3D12PipelineState **ppPSO) {
+    NvAPI_Status __cdecl NvAPI_D3D12_CreateGraphicsPipelineState(ID3D12Device* pDevice, const D3D12_GRAPHICS_PIPELINE_STATE_DESC* pPSODesc, NvU32 numExtensions, const NVAPI_D3D12_PSO_EXTENSION_DESC** ppExtensions, ID3D12PipelineState** ppPSO) {
         constexpr auto n = __func__;
         static bool alreadyLoggedOk = false;
 
@@ -208,7 +208,7 @@ extern "C" {
             return IncompatibleStructVersion(n);
 
         std::string extensionNames;
-        for(auto i = 0U; i < numExtensions;i++)
+        for (auto i = 0U; i < numExtensions; i++)
             extensionNames += str::format(fromPsoExtension(ppExtensions[i]->psoExtension), ",");
 
         extensionNames.pop_back();
@@ -219,7 +219,7 @@ extern "C" {
         return Ok(str::format(n, " (", numExtensions, "/", extensionNames, ")"), alreadyLoggedOk);
     }
 
-    NvAPI_Status __cdecl NvAPI_D3D12_SetDepthBoundsTestValues(ID3D12GraphicsCommandList *pCommandList, const float minDepth, const float maxDepth) {
+    NvAPI_Status __cdecl NvAPI_D3D12_SetDepthBoundsTestValues(ID3D12GraphicsCommandList* pCommandList, const float minDepth, const float maxDepth) {
         constexpr auto n = __func__;
         static bool alreadyLoggedError = false;
         static bool alreadyLoggedOk = false;
@@ -227,7 +227,7 @@ extern "C" {
         if (pCommandList == nullptr)
             return InvalidArgument(n);
 
-        if(!NvapiD3d12Device::SetDepthBoundsTestValues(pCommandList, minDepth, maxDepth))
+        if (!NvapiD3d12Device::SetDepthBoundsTestValues(pCommandList, minDepth, maxDepth))
             return Error(n, alreadyLoggedError);
 
         return Ok(n, alreadyLoggedOk);
diff --git a/src/nvapi_disp.cpp b/src/nvapi_disp.cpp
index 6f682bf..00f6d9b 100644
--- a/src/nvapi_disp.cpp
+++ b/src/nvapi_disp.cpp
@@ -6,7 +6,7 @@
 extern "C" {
     using namespace dxvk;
 
-    NvAPI_Status __cdecl NvAPI_Disp_GetHdrCapabilities(NvU32 displayId, NV_HDR_CAPABILITIES *pHdrCapabilities) {
+    NvAPI_Status __cdecl NvAPI_Disp_GetHdrCapabilities(NvU32 displayId, NV_HDR_CAPABILITIES* pHdrCapabilities) {
         constexpr auto n = __func__;
 
         if (nvapiAdapterRegistry == nullptr)
@@ -44,7 +44,7 @@ extern "C" {
         return Ok(str::format(n, " (", displayId, ")"));
     }
 
-    NvAPI_Status __cdecl NvAPI_DISP_GetDisplayIdByDisplayName(const char *displayName, NvU32 *displayId) {
+    NvAPI_Status __cdecl NvAPI_DISP_GetDisplayIdByDisplayName(const char* displayName, NvU32* displayId) {
         constexpr auto n = __func__;
 
         if (nvapiAdapterRegistry == nullptr)
@@ -62,7 +62,7 @@ extern "C" {
         return Ok(str::format(n, " (", displayName, ")"));
     }
 
-    NvAPI_Status __cdecl NvAPI_DISP_GetGDIPrimaryDisplayId(NvU32 *displayId) {
+    NvAPI_Status __cdecl NvAPI_DISP_GetGDIPrimaryDisplayId(NvU32* displayId) {
         constexpr auto n = __func__;
 
         if (nvapiAdapterRegistry == nullptr)
diff --git a/src/nvapi_drs.cpp b/src/nvapi_drs.cpp
index 915e042..f382509 100644
--- a/src/nvapi_drs.cpp
+++ b/src/nvapi_drs.cpp
@@ -6,7 +6,7 @@
 extern "C" {
     using namespace dxvk;
 
-    NvAPI_Status __cdecl NvAPI_DRS_CreateSession(NvDRSSessionHandle *phSession) {
+    NvAPI_Status __cdecl NvAPI_DRS_CreateSession(NvDRSSessionHandle* phSession) {
         constexpr auto n = __func__;
 
         *phSession = nvapiDrsSession;
@@ -22,11 +22,11 @@ extern "C" {
         return ProfileNotFound(str::format(__func__, " (", str::fromnvus(profileName), ")"));
     }
 
-    NvAPI_Status __cdecl NvAPI_DRS_FindApplicationByName(NvDRSSessionHandle hSession, NvAPI_UnicodeString appName, NvDRSProfileHandle *phProfile, NVDRS_APPLICATION *pApplication) {
+    NvAPI_Status __cdecl NvAPI_DRS_FindApplicationByName(NvDRSSessionHandle hSession, NvAPI_UnicodeString appName, NvDRSProfileHandle* phProfile, NVDRS_APPLICATION* pApplication) {
         return ExecutableNotFound(str::format(__func__, " (", str::fromnvus(appName), ")"));
     }
 
-    NvAPI_Status __cdecl NvAPI_DRS_GetBaseProfile(NvDRSSessionHandle hSession, NvDRSProfileHandle *phProfile) {
+    NvAPI_Status __cdecl NvAPI_DRS_GetBaseProfile(NvDRSSessionHandle hSession, NvDRSProfileHandle* phProfile) {
         constexpr auto n = __func__;
 
         *phProfile = nvapiDrsProfile;
@@ -34,7 +34,7 @@ extern "C" {
         return Ok(n);
     }
 
-    NvAPI_Status __cdecl NvAPI_DRS_GetSetting(NvDRSSessionHandle hSession, NvDRSProfileHandle hProfile, NvU32 settingId, NVDRS_SETTING *pSetting) {
+    NvAPI_Status __cdecl NvAPI_DRS_GetSetting(NvDRSSessionHandle hSession, NvDRSProfileHandle hProfile, NvU32 settingId, NVDRS_SETTING* pSetting) {
         constexpr auto n = __func__;
 
         auto id = str::format("0x", std::hex, settingId);
diff --git a/src/nvapi_gpu.cpp b/src/nvapi_gpu.cpp
index 20c127e..1b23b53 100644
--- a/src/nvapi_gpu.cpp
+++ b/src/nvapi_gpu.cpp
@@ -6,7 +6,7 @@
 extern "C" {
     using namespace dxvk;
 
-    NvAPI_Status __cdecl NvAPI_GPU_GetGPUType(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_TYPE *pGpuType) {
+    NvAPI_Status __cdecl NvAPI_GPU_GetGPUType(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_TYPE* pGpuType) {
         constexpr auto n = __func__;
 
         if (nvapiAdapterRegistry == nullptr)
@@ -19,12 +19,12 @@ extern "C" {
         if (!nvapiAdapterRegistry->IsAdapter(adapter))
             return ExpectedPhysicalGpuHandle(n);
 
-        *pGpuType = (NV_GPU_TYPE) adapter->GetGpuType();
+        *pGpuType = (NV_GPU_TYPE)adapter->GetGpuType();
 
         return Ok(n);
     }
 
-    NvAPI_Status __cdecl NvAPI_GPU_GetPCIIdentifiers(NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pDeviceId, NvU32 *pSubSystemId, NvU32 *pRevisionId, NvU32 *pExtDeviceId) {
+    NvAPI_Status __cdecl NvAPI_GPU_GetPCIIdentifiers(NvPhysicalGpuHandle hPhysicalGpu, NvU32* pDeviceId, NvU32* pSubSystemId, NvU32* pRevisionId, NvU32* pExtDeviceId) {
         constexpr auto n = __func__;
 
         if (nvapiAdapterRegistry == nullptr)
@@ -63,7 +63,7 @@ extern "C" {
         return Ok(n);
     }
 
-    NvAPI_Status __cdecl NvAPI_GPU_GetBusId(NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pBusId) {
+    NvAPI_Status __cdecl NvAPI_GPU_GetBusId(NvPhysicalGpuHandle hPhysicalGpu, NvU32* pBusId) {
         constexpr auto n = __func__;
 
         if (nvapiAdapterRegistry == nullptr)
@@ -81,7 +81,7 @@ extern "C" {
         return Ok(n);
     }
 
-    NvAPI_Status __cdecl NvAPI_GPU_GetBusSlotId(NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pBusSlotId) {
+    NvAPI_Status __cdecl NvAPI_GPU_GetBusSlotId(NvPhysicalGpuHandle hPhysicalGpu, NvU32* pBusSlotId) {
         constexpr auto n = __func__;
 
         if (nvapiAdapterRegistry == nullptr)
@@ -102,7 +102,7 @@ extern "C" {
         return Ok(n);
     }
 
-    NvAPI_Status __cdecl NvAPI_GPU_GetBusType(NvPhysicalGpuHandle hPhysicalGpu,NV_GPU_BUS_TYPE *pBusType) {
+    NvAPI_Status __cdecl NvAPI_GPU_GetBusType(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_BUS_TYPE* pBusType) {
         constexpr auto n = __func__;
 
         if (nvapiAdapterRegistry == nullptr)
@@ -123,7 +123,7 @@ extern "C" {
         return Ok(n);
     }
 
-    NvAPI_Status __cdecl NvAPI_GPU_GetPhysicalFrameBufferSize(NvPhysicalGpuHandle hPhysicalGpu, NvU32 *pSize) {
+    NvAPI_Status __cdecl NvAPI_GPU_GetPhysicalFrameBufferSize(NvPhysicalGpuHandle hPhysicalGpu, NvU32* pSize) {
         constexpr auto n = __func__;
 
         if (nvapiAdapterRegistry == nullptr)
@@ -141,7 +141,7 @@ extern "C" {
         return Ok(n);
     }
 
-    NvAPI_Status __cdecl NvAPI_GPU_GetAdapterIdFromPhysicalGpu(NvPhysicalGpuHandle hPhysicalGpu, void *pOSAdapterId) {
+    NvAPI_Status __cdecl NvAPI_GPU_GetAdapterIdFromPhysicalGpu(NvPhysicalGpuHandle hPhysicalGpu, void* pOSAdapterId) {
         constexpr auto n = __func__;
 
         if (nvapiAdapterRegistry == nullptr)
@@ -163,7 +163,7 @@ extern "C" {
         return Ok(n);
     }
 
-    NvAPI_Status __cdecl NvAPI_GPU_GetArchInfo(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_ARCH_INFO *pGpuArchInfo) {
+    NvAPI_Status __cdecl NvAPI_GPU_GetArchInfo(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_ARCH_INFO* pGpuArchInfo) {
         constexpr auto n = __func__;
 
         if (nvapiAdapterRegistry == nullptr)
@@ -188,7 +188,7 @@ extern "C" {
         // to do a more fine-grained query at this time. Would need wine-nvml
         // usage.
         NV_GPU_ARCH_IMPLEMENTATION_ID implementationId;
-        switch(architectureId) {
+        switch (architectureId) {
             case NV_GPU_ARCHITECTURE_GA100:
                 implementationId = NV_GPU_ARCH_IMPLEMENTATION_GA102;
                 break;
@@ -234,7 +234,7 @@ extern "C" {
         return Ok(n);
     }
 
-    NvAPI_Status __cdecl NvAPI_GPU_CudaEnumComputeCapableGpus(NV_COMPUTE_GPU_TOPOLOGY *pComputeTopo) {
+    NvAPI_Status __cdecl NvAPI_GPU_CudaEnumComputeCapableGpus(NV_COMPUTE_GPU_TOPOLOGY* pComputeTopo) {
         constexpr auto n = __func__;
 
         if (nvapiAdapterRegistry == nullptr)
@@ -249,8 +249,7 @@ extern "C" {
         auto cudaCapableGpus = std::vector<NvPhysicalGpuHandle>(0);
         for (auto i = 0U; i < nvapiAdapterRegistry->GetAdapterCount(); i++) {
             auto adapter = nvapiAdapterRegistry->GetAdapter(i);
-            if (adapter->GetDriverId() != VK_DRIVER_ID_NVIDIA_PROPRIETARY ||
-                adapter->GetArchitectureId() < NV_GPU_ARCHITECTURE_GM200) // Maxwell is the oldest generation we can detect
+            if (adapter->GetDriverId() != VK_DRIVER_ID_NVIDIA_PROPRIETARY || adapter->GetArchitectureId() < NV_GPU_ARCHITECTURE_GM200) // Maxwell is the oldest generation we can detect
                 continue;
 
             cudaCapableGpus.push_back(reinterpret_cast<NvPhysicalGpuHandle>(adapter));
@@ -317,7 +316,7 @@ extern "C" {
         }
     }
 
-    NvAPI_Status __cdecl NvAPI_GPU_GetDynamicPstatesInfoEx(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_DYNAMIC_PSTATES_INFO_EX *pDynamicPstatesInfoEx) {
+    NvAPI_Status __cdecl NvAPI_GPU_GetDynamicPstatesInfoEx(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_DYNAMIC_PSTATES_INFO_EX* pDynamicPstatesInfoEx) {
         constexpr auto n = __func__;
         static bool alreadyLoggedNoNvml = false;
         static bool alreadyLoggedHandleInvalidated = false;
@@ -372,7 +371,7 @@ extern "C" {
         }
     }
 
-    NvAPI_Status __cdecl NvAPI_GPU_GetThermalSettings(NvPhysicalGpuHandle hPhysicalGpu, NvU32 sensorIndex, NV_GPU_THERMAL_SETTINGS *pThermalSettings) {
+    NvAPI_Status __cdecl NvAPI_GPU_GetThermalSettings(NvPhysicalGpuHandle hPhysicalGpu, NvU32 sensorIndex, NV_GPU_THERMAL_SETTINGS* pThermalSettings) {
         constexpr auto n = __func__;
         static bool alreadyLoggedNoNvml = false;
         static bool alreadyLoggedHandleInvalidated = false;
@@ -450,7 +449,7 @@ extern "C" {
         }
     }
 
-    NvAPI_Status __cdecl NvAPI_GPU_GetCurrentPstate(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_PERF_PSTATE_ID *pCurrentPstate) {
+    NvAPI_Status __cdecl NvAPI_GPU_GetCurrentPstate(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_PERF_PSTATE_ID* pCurrentPstate) {
         constexpr auto n = __func__;
         static bool alreadyLoggedNoNvml = false;
         static bool alreadyLoggedHandleInvalidated = false;
@@ -484,10 +483,10 @@ extern "C" {
                 return HandleInvalidated(n);
             default:
                 return Error(str::format(n, ": ", adapter->GetNvmlErrorString(result)));
-       }
+        }
     }
 
-    NvAPI_Status __cdecl NvAPI_GPU_GetAllClockFrequencies(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_CLOCK_FREQUENCIES *pClkFreqs) {
+    NvAPI_Status __cdecl NvAPI_GPU_GetAllClockFrequencies(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_CLOCK_FREQUENCIES* pClkFreqs) {
         constexpr auto n = __func__;
         static bool alreadyLoggedNotSupported = false;
         static bool alreadyLoggedNoNvml = false;
@@ -519,7 +518,7 @@ extern "C" {
             return HandleInvalidated(str::format(n, ": NVML available but current adapter is not NVML compatible"), alreadyLoggedHandleInvalidated);
 
         // Reset all clock data for all domains
-        for (auto& domain : pClkFreqs->domain){
+        for (auto& domain : pClkFreqs->domain) {
             domain.bIsPresent = 0;
             domain.frequency = 0;
         }
@@ -528,95 +527,95 @@ extern "C" {
         // Seemingly we need to do nvml call on a "per clock unit" to get the clock
         // Set the availability of the clock to TRUE and the nvml read clock in the nvapi struct
         auto resultGpu = adapter->GetNvmlDeviceClockInfo(NVML_CLOCK_GRAPHICS, &clock);
-            switch (resultGpu) {
-                case NVML_SUCCESS:
-                    switch (pClkFreqs->version) {
-                        case NV_GPU_CLOCK_FREQUENCIES_VER_1: {
-                            auto pClkFreqsV1 = reinterpret_cast<NV_GPU_CLOCK_FREQUENCIES_V1*>(pClkFreqs);
-                            pClkFreqsV1->domain[NVAPI_GPU_PUBLIC_CLOCK_GRAPHICS].bIsPresent = 1;
-                            pClkFreqsV1->domain[NVAPI_GPU_PUBLIC_CLOCK_GRAPHICS].frequency = (clock * 1000);
-                            break;
-                        }
-                        case NV_GPU_CLOCK_FREQUENCIES_VER_2:
-                        case NV_GPU_CLOCK_FREQUENCIES_VER_3:
-                            pClkFreqs->domain[NVAPI_GPU_PUBLIC_CLOCK_GRAPHICS].bIsPresent = 1;
-                            pClkFreqs->domain[NVAPI_GPU_PUBLIC_CLOCK_GRAPHICS].frequency = (clock * 1000);
-                            break;
-                        default:
-                            return Error(n); // Unreachable, but just to be sure
+        switch (resultGpu) {
+            case NVML_SUCCESS:
+                switch (pClkFreqs->version) {
+                    case NV_GPU_CLOCK_FREQUENCIES_VER_1: {
+                        auto pClkFreqsV1 = reinterpret_cast<NV_GPU_CLOCK_FREQUENCIES_V1*>(pClkFreqs);
+                        pClkFreqsV1->domain[NVAPI_GPU_PUBLIC_CLOCK_GRAPHICS].bIsPresent = 1;
+                        pClkFreqsV1->domain[NVAPI_GPU_PUBLIC_CLOCK_GRAPHICS].frequency = (clock * 1000);
+                        break;
                     }
-                    break;
-                case NVML_ERROR_NOT_SUPPORTED:
-                    break;
-                case NVML_ERROR_GPU_IS_LOST:
-                    return HandleInvalidated(n);
-                default:
-                    return Error(str::format(n, ": ", adapter->GetNvmlErrorString(resultGpu)));
-            }
+                    case NV_GPU_CLOCK_FREQUENCIES_VER_2:
+                    case NV_GPU_CLOCK_FREQUENCIES_VER_3:
+                        pClkFreqs->domain[NVAPI_GPU_PUBLIC_CLOCK_GRAPHICS].bIsPresent = 1;
+                        pClkFreqs->domain[NVAPI_GPU_PUBLIC_CLOCK_GRAPHICS].frequency = (clock * 1000);
+                        break;
+                    default:
+                        return Error(n); // Unreachable, but just to be sure
+                }
+                break;
+            case NVML_ERROR_NOT_SUPPORTED:
+                break;
+            case NVML_ERROR_GPU_IS_LOST:
+                return HandleInvalidated(n);
+            default:
+                return Error(str::format(n, ": ", adapter->GetNvmlErrorString(resultGpu)));
+        }
 
         auto resultMem = adapter->GetNvmlDeviceClockInfo(NVML_CLOCK_MEM, &clock);
-            switch (resultMem) {
-                case NVML_SUCCESS:
-                    switch (pClkFreqs->version) {
-                        case NV_GPU_CLOCK_FREQUENCIES_VER_1: {
-                            auto pClkFreqsV1 = reinterpret_cast<NV_GPU_CLOCK_FREQUENCIES_V1*>(pClkFreqs);
-                            pClkFreqsV1->domain[NVAPI_GPU_PUBLIC_CLOCK_MEMORY].bIsPresent = 1;
-                            pClkFreqsV1->domain[NVAPI_GPU_PUBLIC_CLOCK_MEMORY].frequency = (clock * 1000);
-                            break;
-                        }
-                        case NV_GPU_CLOCK_FREQUENCIES_VER_2:
-                        case NV_GPU_CLOCK_FREQUENCIES_VER_3:
-                            pClkFreqs->domain[NVAPI_GPU_PUBLIC_CLOCK_MEMORY].bIsPresent = 1;
-                            pClkFreqs->domain[NVAPI_GPU_PUBLIC_CLOCK_MEMORY].frequency = (clock * 1000);
-                            break;
-                        default:
-                            return Error(n); // Unreachable, but just to be sure
+        switch (resultMem) {
+            case NVML_SUCCESS:
+                switch (pClkFreqs->version) {
+                    case NV_GPU_CLOCK_FREQUENCIES_VER_1: {
+                        auto pClkFreqsV1 = reinterpret_cast<NV_GPU_CLOCK_FREQUENCIES_V1*>(pClkFreqs);
+                        pClkFreqsV1->domain[NVAPI_GPU_PUBLIC_CLOCK_MEMORY].bIsPresent = 1;
+                        pClkFreqsV1->domain[NVAPI_GPU_PUBLIC_CLOCK_MEMORY].frequency = (clock * 1000);
+                        break;
                     }
-                    break;
-                case NVML_ERROR_NOT_SUPPORTED:
-                    break;
-                case NVML_ERROR_GPU_IS_LOST:
-                    return HandleInvalidated(n);
-                default:
-                    return Error(str::format(n, ": ", adapter->GetNvmlErrorString(resultMem)));
-            }
+                    case NV_GPU_CLOCK_FREQUENCIES_VER_2:
+                    case NV_GPU_CLOCK_FREQUENCIES_VER_3:
+                        pClkFreqs->domain[NVAPI_GPU_PUBLIC_CLOCK_MEMORY].bIsPresent = 1;
+                        pClkFreqs->domain[NVAPI_GPU_PUBLIC_CLOCK_MEMORY].frequency = (clock * 1000);
+                        break;
+                    default:
+                        return Error(n); // Unreachable, but just to be sure
+                }
+                break;
+            case NVML_ERROR_NOT_SUPPORTED:
+                break;
+            case NVML_ERROR_GPU_IS_LOST:
+                return HandleInvalidated(n);
+            default:
+                return Error(str::format(n, ": ", adapter->GetNvmlErrorString(resultMem)));
+        }
 
         auto resultVid = adapter->GetNvmlDeviceClockInfo(NVML_CLOCK_VIDEO, &clock);
-            switch (resultVid) {
-                case NVML_SUCCESS:
-                    switch (pClkFreqs->version) {
-                        case NV_GPU_CLOCK_FREQUENCIES_VER_1: {
-                            auto pClkFreqsV1 = reinterpret_cast<NV_GPU_CLOCK_FREQUENCIES_V1*>(pClkFreqs);
-                            pClkFreqsV1->domain[NVAPI_GPU_PUBLIC_CLOCK_VIDEO].bIsPresent = 1;
-                            pClkFreqsV1->domain[NVAPI_GPU_PUBLIC_CLOCK_VIDEO].frequency = (clock * 1000);
-                            break;
-                        }
-                        case NV_GPU_CLOCK_FREQUENCIES_VER_2:
-                        case NV_GPU_CLOCK_FREQUENCIES_VER_3:
-                            pClkFreqs->domain[NVAPI_GPU_PUBLIC_CLOCK_VIDEO].bIsPresent = 1;
-                            pClkFreqs->domain[NVAPI_GPU_PUBLIC_CLOCK_VIDEO].frequency = (clock * 1000);
-                            break;
-                        default:
-                            return Error(n); // Unreachable, but just to be sure
+        switch (resultVid) {
+            case NVML_SUCCESS:
+                switch (pClkFreqs->version) {
+                    case NV_GPU_CLOCK_FREQUENCIES_VER_1: {
+                        auto pClkFreqsV1 = reinterpret_cast<NV_GPU_CLOCK_FREQUENCIES_V1*>(pClkFreqs);
+                        pClkFreqsV1->domain[NVAPI_GPU_PUBLIC_CLOCK_VIDEO].bIsPresent = 1;
+                        pClkFreqsV1->domain[NVAPI_GPU_PUBLIC_CLOCK_VIDEO].frequency = (clock * 1000);
+                        break;
                     }
-                    break;
-                case NVML_ERROR_NOT_SUPPORTED:
-                    break;
-                case NVML_ERROR_GPU_IS_LOST:
-                    return HandleInvalidated(n);
-                default:
-                    return Error(str::format(n, ": ", adapter->GetNvmlErrorString(resultVid)));
-            }
+                    case NV_GPU_CLOCK_FREQUENCIES_VER_2:
+                    case NV_GPU_CLOCK_FREQUENCIES_VER_3:
+                        pClkFreqs->domain[NVAPI_GPU_PUBLIC_CLOCK_VIDEO].bIsPresent = 1;
+                        pClkFreqs->domain[NVAPI_GPU_PUBLIC_CLOCK_VIDEO].frequency = (clock * 1000);
+                        break;
+                    default:
+                        return Error(n); // Unreachable, but just to be sure
+                }
+                break;
+            case NVML_ERROR_NOT_SUPPORTED:
+                break;
+            case NVML_ERROR_GPU_IS_LOST:
+                return HandleInvalidated(n);
+            default:
+                return Error(str::format(n, ": ", adapter->GetNvmlErrorString(resultVid)));
+        }
 
         if (resultGpu == NVML_ERROR_NOT_SUPPORTED
             && resultMem == NVML_ERROR_NOT_SUPPORTED
             && resultVid == NVML_ERROR_NOT_SUPPORTED)
             return NotSupported(n);
 
-       return Ok(n, alreadyLoggedOk);
+        return Ok(n, alreadyLoggedOk);
     }
 
-    NvAPI_Status __cdecl NvAPI_GPU_GetPstates20(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_PERF_PSTATES20_INFO *pPstatesInfo){
+    NvAPI_Status __cdecl NvAPI_GPU_GetPstates20(NvPhysicalGpuHandle hPhysicalGpu, NV_GPU_PERF_PSTATES20_INFO* pPstatesInfo) {
         return NoImplementation(__func__);
     }
 }
diff --git a/src/nvapi_interface.cpp b/src/nvapi_interface.cpp
index abd259f..4e6e67c 100644
--- a/src/nvapi_interface.cpp
+++ b/src/nvapi_interface.cpp
@@ -12,8 +12,8 @@
 #include "util/util_log.h"
 
 #define INSERT_AND_RETURN_WHEN_EQUALS(method) \
-    if (std::string(it->func) == #method) \
-        return registry.insert({id, (void*) method}).first->second;
+    if (std::string(it->func) == #method)     \
+        return registry.insert({id, (void*)method}).first->second;
 
 extern "C" {
     using namespace dxvk;
@@ -67,7 +67,7 @@ extern "C" {
         INSERT_AND_RETURN_WHEN_EQUALS(NvAPI_D3D12_LaunchCubinShader)
         INSERT_AND_RETURN_WHEN_EQUALS(NvAPI_D3D12_CaptureUAVInfo)
         INSERT_AND_RETURN_WHEN_EQUALS(NvAPI_D3D12_GetGraphicsCapabilities)
-        INSERT_AND_RETURN_WHEN_EQUALS(NvAPI_D3D12_IsFatbinPTXSupported) 
+        INSERT_AND_RETURN_WHEN_EQUALS(NvAPI_D3D12_IsFatbinPTXSupported)
         INSERT_AND_RETURN_WHEN_EQUALS(NvAPI_D3D_GetObjectHandleForResource)
         INSERT_AND_RETURN_WHEN_EQUALS(NvAPI_D3D_SetResourceHint)
         INSERT_AND_RETURN_WHEN_EQUALS(NvAPI_D3D_GetCurrentSLIState)
diff --git a/src/nvapi_sys.cpp b/src/nvapi_sys.cpp
index 1ce2a64..ab68442 100644
--- a/src/nvapi_sys.cpp
+++ b/src/nvapi_sys.cpp
@@ -6,7 +6,7 @@
 extern "C" {
     using namespace dxvk;
 
-    NvAPI_Status __cdecl NvAPI_SYS_GetPhysicalGpuFromDisplayId(NvU32 displayId, NvPhysicalGpuHandle *hPhysicalGpu) {
+    NvAPI_Status __cdecl NvAPI_SYS_GetPhysicalGpuFromDisplayId(NvU32 displayId, NvPhysicalGpuHandle* hPhysicalGpu) {
         constexpr auto n = __func__;
 
         if (nvapiAdapterRegistry == nullptr)
@@ -16,7 +16,7 @@ extern "C" {
         if (output == nullptr)
             return InvalidArgument(n);
 
-        *hPhysicalGpu = (NvPhysicalGpuHandle) output->GetParent();
+        *hPhysicalGpu = (NvPhysicalGpuHandle)output->GetParent();
 
         return Ok(n);
     }
diff --git a/src/resource_factory.cpp b/src/resource_factory.cpp
index 61e09a1..168bf4b 100644
--- a/src/resource_factory.cpp
+++ b/src/resource_factory.cpp
@@ -1,13 +1,13 @@
 #include "resource_factory.h"
 
 namespace dxvk {
-    ResourceFactory::ResourceFactory()  = default;
+    ResourceFactory::ResourceFactory() = default;
 
-    ResourceFactory::~ResourceFactory()  = default;
+    ResourceFactory::~ResourceFactory() = default;
 
     Com<IDXGIFactory1> ResourceFactory::CreateDXGIFactory1() {
         Com<IDXGIFactory1> dxgiFactory;
-        if(FAILED(::CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void**)&dxgiFactory)))
+        if (FAILED(::CreateDXGIFactory1(__uuidof(IDXGIFactory1), (void**)&dxgiFactory)))
             return nullptr;
 
         return dxgiFactory;
@@ -21,7 +21,7 @@ namespace dxvk {
         return std::make_unique<Nvml>();
     }
 
-    std::unique_ptr <Lfx> ResourceFactory::CreateLfx() {
+    std::unique_ptr<Lfx> ResourceFactory::CreateLfx() {
         return std::make_unique<Lfx>();
     }
 }
diff --git a/src/resource_factory.h b/src/resource_factory.h
index f7f1d5e..9d78352 100644
--- a/src/resource_factory.h
+++ b/src/resource_factory.h
@@ -9,7 +9,7 @@
 namespace dxvk {
     class ResourceFactory {
 
-    public:
+      public:
         ResourceFactory();
         virtual ~ResourceFactory();
 
diff --git a/src/sysinfo/nvapi_adapter.cpp b/src/sysinfo/nvapi_adapter.cpp
index 6f4756f..26f8ed8 100644
--- a/src/sysinfo/nvapi_adapter.cpp
+++ b/src/sysinfo/nvapi_adapter.cpp
@@ -94,7 +94,7 @@ namespace dxvk {
         // Mosaic setup is not supported, thus one display output refers to one GPU
         Com<IDXGIOutput> dxgiOutput;
         for (auto i = 0U; dxgiAdapter->EnumOutputs(i, &dxgiOutput) != DXGI_ERROR_NOT_FOUND; i++) {
-            auto nvapiOutput = new NvapiOutput((uintptr_t) this);
+            auto nvapiOutput = new NvapiOutput((uintptr_t)this);
             nvapiOutput->Initialize(dxgiOutput);
             outputs.push_back(nvapiOutput);
         }
@@ -124,8 +124,7 @@ namespace dxvk {
                 stream << (driverVersionOverride / 100) << "." << std::setfill('0') << std::setw(2) << (driverVersionOverride % 100);
                 log::write(str::format(driverVersionEnvName, " is set to '", driverVersion, "', reporting driver version ", stream.str()));
                 m_driverVersionOverride = driverVersionOverride;
-            }
-            else
+            } else
                 log::write(str::format(driverVersionEnvName, " is set to '", driverVersion, "', but this value is invalid, please set a number between 100 and 99999"));
         }
 
@@ -141,8 +140,7 @@ namespace dxvk {
         // and does not have a patch number
         return m_driverVersionOverride > 0
             ? m_driverVersionOverride
-            : VK_VERSION_MAJOR(m_vkDriverVersion) * 100 +
-                std::min(VK_VERSION_MINOR(m_vkDriverVersion), 99U);
+            : VK_VERSION_MAJOR(m_vkDriverVersion) * 100 + std::min(VK_VERSION_MINOR(m_vkDriverVersion), 99U);
     }
 
     VkDriverIdKHR NvapiAdapter::GetDriverId() const {
@@ -256,11 +254,11 @@ namespace dxvk {
         return {m_nvml.ErrorString(result)};
     }
 
-    nvmlReturn_t NvapiAdapter::GetNvmlDeviceTemperature(nvmlTemperatureSensors_t sensorType, unsigned int *temp) const {
+    nvmlReturn_t NvapiAdapter::GetNvmlDeviceTemperature(nvmlTemperatureSensors_t sensorType, unsigned int* temp) const {
         return m_nvml.DeviceGetTemperature(m_nvmlDevice, sensorType, temp);
     }
 
-    nvmlReturn_t NvapiAdapter::GetNvmlDeviceUtilizationRates(nvmlUtilization_t *utilization) const {
+    nvmlReturn_t NvapiAdapter::GetNvmlDeviceUtilizationRates(nvmlUtilization_t* utilization) const {
         return m_nvml.DeviceGetUtilizationRates(m_nvmlDevice, utilization);
     }
 
@@ -268,7 +266,7 @@ namespace dxvk {
         return m_nvml.DeviceGetVbiosVersion(m_nvmlDevice, version, length);
     }
 
-    nvmlReturn_t NvapiAdapter::GetNvmlPerformanceState(nvmlPstates_t *pState) const {
+    nvmlReturn_t NvapiAdapter::GetNvmlPerformanceState(nvmlPstates_t* pState) const {
         return m_nvml.DeviceGetPerformanceState(m_nvmlDevice, pState);
     }
 
diff --git a/src/sysinfo/nvapi_adapter.h b/src/sysinfo/nvapi_adapter.h
index d7ecebc..ea94ef4 100644
--- a/src/sysinfo/nvapi_adapter.h
+++ b/src/sysinfo/nvapi_adapter.h
@@ -9,7 +9,7 @@
 namespace dxvk {
     class NvapiAdapter {
 
-    public:
+      public:
         NvapiAdapter(Vulkan& vulkan, Nvml& nvml);
         ~NvapiAdapter();
 
@@ -37,7 +37,7 @@ namespace dxvk {
         [[nodiscard]] nvmlReturn_t GetNvmlPerformanceState(nvmlPstates_t* pState) const;
         [[nodiscard]] nvmlReturn_t GetNvmlDeviceClockInfo(nvmlClockType_t type, unsigned int* clock) const;
 
-    private:
+      private:
         Vulkan& m_vulkan;
         Nvml& m_nvml;
 
diff --git a/src/sysinfo/nvapi_adapter_registry.h b/src/sysinfo/nvapi_adapter_registry.h
index b99590f..4123e68 100644
--- a/src/sysinfo/nvapi_adapter_registry.h
+++ b/src/sysinfo/nvapi_adapter_registry.h
@@ -10,7 +10,7 @@
 namespace dxvk {
     class NvapiAdapterRegistry {
 
-    public:
+      public:
         explicit NvapiAdapterRegistry(ResourceFactory& resourceFactory);
         ~NvapiAdapterRegistry();
 
@@ -27,7 +27,7 @@ namespace dxvk {
         [[nodiscard]] short GetPrimaryOutputId() const;
         [[nodiscard]] short GetOutputId(const std::string& displayName) const;
 
-    private:
+      private:
         ResourceFactory& m_resourceFactory;
         std::unique_ptr<Vulkan> m_vulkan;
         std::unique_ptr<Nvml> m_nvml;
diff --git a/src/sysinfo/nvapi_output.h b/src/sysinfo/nvapi_output.h
index f0a28dc..1ae6d94 100644
--- a/src/sysinfo/nvapi_output.h
+++ b/src/sysinfo/nvapi_output.h
@@ -6,7 +6,7 @@
 namespace dxvk {
     class NvapiOutput {
 
-    public:
+      public:
         explicit NvapiOutput(uintptr_t parent);
         ~NvapiOutput();
 
@@ -15,7 +15,7 @@ namespace dxvk {
         [[nodiscard]] std::string GetDeviceName() const;
         [[nodiscard]] bool IsPrimary() const;
 
-    private:
+      private:
         uintptr_t m_parent;
         std::string m_deviceName;
         bool m_isPrimary{};
diff --git a/src/sysinfo/nvml.cpp b/src/sysinfo/nvml.cpp
index 341706d..066c1c3 100644
--- a/src/sysinfo/nvml.cpp
+++ b/src/sysinfo/nvml.cpp
@@ -65,35 +65,35 @@ namespace dxvk {
         return m_nvmlErrorString(result);
     }
 
-    nvmlReturn_t Nvml::DeviceGetHandleByPciBusId_v2(const char *pciBusId, nvmlDevice_t *device) const {
+    nvmlReturn_t Nvml::DeviceGetHandleByPciBusId_v2(const char* pciBusId, nvmlDevice_t* device) const {
         return m_nvmlDeviceGetHandleByPciBusId_v2(pciBusId, device);
     }
 
-    nvmlReturn_t Nvml::DeviceGetPciInfo_v3(nvmlDevice_t device, nvmlPciInfo_t *pci) const {
+    nvmlReturn_t Nvml::DeviceGetPciInfo_v3(nvmlDevice_t device, nvmlPciInfo_t* pci) const {
         return m_nvmlDeviceGetPciInfo_v3(device, pci);
     }
 
-    nvmlReturn_t Nvml::DeviceGetTemperature(nvmlDevice_t device, nvmlTemperatureSensors_t sensorType, unsigned int *temp) const {
+    nvmlReturn_t Nvml::DeviceGetTemperature(nvmlDevice_t device, nvmlTemperatureSensors_t sensorType, unsigned int* temp) const {
         return m_nvmlDeviceGetTemperature(device, sensorType, temp);
     }
 
-    nvmlReturn_t Nvml::DeviceGetUtilizationRates(nvmlDevice_t device, nvmlUtilization_t *utilization) const {
+    nvmlReturn_t Nvml::DeviceGetUtilizationRates(nvmlDevice_t device, nvmlUtilization_t* utilization) const {
         return m_nvmlDeviceGetUtilizationRates(device, utilization);
     }
 
-    nvmlReturn_t Nvml::DeviceGetVbiosVersion(nvmlDevice_t device, char *version, unsigned int length) const {
+    nvmlReturn_t Nvml::DeviceGetVbiosVersion(nvmlDevice_t device, char* version, unsigned int length) const {
         return m_nvmlDeviceGetVbiosVersion(device, version, length);
     }
 
-    nvmlReturn_t Nvml::DeviceGetPerformanceState(nvmlDevice_t device, nvmlPstates_t *pState) const {
+    nvmlReturn_t Nvml::DeviceGetPerformanceState(nvmlDevice_t device, nvmlPstates_t* pState) const {
         return m_nvmlDeviceGetPerformanceState(device, pState);
     }
 
-    nvmlReturn_t Nvml::DeviceGetClockInfo(nvmlDevice_t device, nvmlClockType_t type, unsigned int *clock) const {
+    nvmlReturn_t Nvml::DeviceGetClockInfo(nvmlDevice_t device, nvmlClockType_t type, unsigned int* clock) const {
         return m_nvmlDeviceGetClockInfo(device, type, clock);
     }
 
-    template<typename T>
+    template <typename T>
     T Nvml::GetProcAddress(const char* name) {
         return reinterpret_cast<T>(reinterpret_cast<void*>(::GetProcAddress(m_nvmlModule, name)));
     }
diff --git a/src/sysinfo/nvml.h b/src/sysinfo/nvml.h
index 30a2f35..cc7e099 100644
--- a/src/sysinfo/nvml.h
+++ b/src/sysinfo/nvml.h
@@ -5,21 +5,21 @@
 namespace dxvk {
     class Nvml {
 
-    public:
+      public:
         Nvml();
         virtual ~Nvml();
 
         [[nodiscard]] virtual bool IsAvailable() const;
         [[nodiscard]] virtual const char* ErrorString(nvmlReturn_t result) const;
-        [[nodiscard]] virtual nvmlReturn_t DeviceGetHandleByPciBusId_v2(const char *pciBusId, nvmlDevice_t *device) const;
-        [[nodiscard]] virtual nvmlReturn_t DeviceGetPciInfo_v3(nvmlDevice_t device, nvmlPciInfo_t *pci) const;
-        [[nodiscard]] virtual nvmlReturn_t DeviceGetTemperature(nvmlDevice_t device, nvmlTemperatureSensors_t sensorType, unsigned int *temp) const;
-        [[nodiscard]] virtual nvmlReturn_t DeviceGetUtilizationRates(nvmlDevice_t device, nvmlUtilization_t *utilization) const;
-        [[nodiscard]] virtual nvmlReturn_t DeviceGetVbiosVersion(nvmlDevice_t device, char *version, unsigned int length) const;
-        [[nodiscard]] virtual nvmlReturn_t DeviceGetPerformanceState(nvmlDevice_t device, nvmlPstates_t *pState) const;
-        [[nodiscard]] virtual nvmlReturn_t DeviceGetClockInfo(nvmlDevice_t device, nvmlClockType_t type, unsigned int *clock) const;
+        [[nodiscard]] virtual nvmlReturn_t DeviceGetHandleByPciBusId_v2(const char* pciBusId, nvmlDevice_t* device) const;
+        [[nodiscard]] virtual nvmlReturn_t DeviceGetPciInfo_v3(nvmlDevice_t device, nvmlPciInfo_t* pci) const;
+        [[nodiscard]] virtual nvmlReturn_t DeviceGetTemperature(nvmlDevice_t device, nvmlTemperatureSensors_t sensorType, unsigned int* temp) const;
+        [[nodiscard]] virtual nvmlReturn_t DeviceGetUtilizationRates(nvmlDevice_t device, nvmlUtilization_t* utilization) const;
+        [[nodiscard]] virtual nvmlReturn_t DeviceGetVbiosVersion(nvmlDevice_t device, char* version, unsigned int length) const;
+        [[nodiscard]] virtual nvmlReturn_t DeviceGetPerformanceState(nvmlDevice_t device, nvmlPstates_t* pState) const;
+        [[nodiscard]] virtual nvmlReturn_t DeviceGetClockInfo(nvmlDevice_t device, nvmlClockType_t type, unsigned int* clock) const;
 
-    private:
+      private:
         typedef decltype(&nvmlInit_v2) PFN_nvmlInit_v2;
         typedef decltype(&nvmlShutdown) PFN_nvmlShutdown;
         typedef decltype(&nvmlErrorString) PFN_nvmlErrorString;
@@ -43,6 +43,7 @@ namespace dxvk {
         PFN_nvmlDeviceGetPerformanceState m_nvmlDeviceGetPerformanceState{};
         PFN_nvmlDeviceGetClockInfo m_nvmlDeviceGetClockInfo{};
 
-        template<typename T> T GetProcAddress(const char* name);
+        template <typename T>
+        T GetProcAddress(const char* name);
     };
 }
diff --git a/src/sysinfo/vulkan.cpp b/src/sysinfo/vulkan.cpp
index 21c9170..8e05d26 100644
--- a/src/sysinfo/vulkan.cpp
+++ b/src/sysinfo/vulkan.cpp
@@ -64,12 +64,12 @@ namespace dxvk {
         vkGetPhysicalDeviceMemoryProperties2(vkDevice, memoryProperties2);
     }
 
-    template<typename T>
+    template <typename T>
     T Vulkan::GetProcAddress(const char* name) const {
         return reinterpret_cast<T>(reinterpret_cast<void*>(::GetProcAddress(m_vkModule, name)));
     }
 
-    template<typename T>
+    template <typename T>
     T Vulkan::GetInstanceProcAddress(VkInstance vkInstance, const char* name) const {
         return reinterpret_cast<T>(m_vkGetInstanceProcAddr(vkInstance, name));
     }
diff --git a/src/sysinfo/vulkan.h b/src/sysinfo/vulkan.h
index 01d9cce..c9f57fa 100644
--- a/src/sysinfo/vulkan.h
+++ b/src/sysinfo/vulkan.h
@@ -5,7 +5,7 @@
 namespace dxvk {
     class Vulkan {
 
-    public:
+      public:
         Vulkan();
         virtual ~Vulkan();
 
@@ -14,11 +14,13 @@ namespace dxvk {
         virtual void GetPhysicalDeviceProperties2(VkInstance vkInstance, VkPhysicalDevice vkDevice, VkPhysicalDeviceProperties2* deviceProperties2) const;
         virtual void GetPhysicalDeviceMemoryProperties2(VkInstance vkInstance, VkPhysicalDevice vkDevice, VkPhysicalDeviceMemoryProperties2* memoryProperties2) const;
 
-    private:
+      private:
         HMODULE m_vkModule{};
         PFN_vkGetInstanceProcAddr m_vkGetInstanceProcAddr{};
 
-        template<typename T> T GetProcAddress(const char* name) const;
-        template<typename T> T GetInstanceProcAddress(VkInstance vkInstance, const char* name) const;
+        template <typename T>
+        T GetProcAddress(const char* name) const;
+        template <typename T>
+        T GetInstanceProcAddress(VkInstance vkInstance, const char* name) const;
     };
 }
diff --git a/src/util/com_pointer.h b/src/util/com_pointer.h
index aca60c7..d154937 100644
--- a/src/util/com_pointer.h
+++ b/src/util/com_pointer.h
@@ -7,12 +7,12 @@ namespace dxvk {
      * Implements automatic reference
      * counting for COM objects.
      */
-    template<typename T>
+    template <typename T>
     class Com {
 
-    public:
-        Com() { }
-        Com(std::nullptr_t) { }
+      public:
+        Com() {}
+        Com(std::nullptr_t) {}
         Com(T* object) : m_ptr(object) {
             this->incRef();
         }
@@ -25,28 +25,28 @@ namespace dxvk {
             other.m_ptr = nullptr;
         }
 
-        Com& operator = (T* object) {
+        Com& operator=(T* object) {
             this->decRef();
             m_ptr = object;
             this->incRef();
             return *this;
         }
 
-        Com& operator = (const Com& other) {
+        Com& operator=(const Com& other) {
             other.incRef();
             this->decRef();
             m_ptr = other.m_ptr;
             return *this;
         }
 
-        Com& operator = (Com&& other) {
+        Com& operator=(Com&& other) {
             this->decRef();
             this->m_ptr = other.m_ptr;
             other.m_ptr = nullptr;
             return *this;
         }
 
-        Com& operator = (std::nullptr_t) {
+        Com& operator=(std::nullptr_t) {
             this->decRef();
             m_ptr = nullptr;
             return *this;
@@ -56,21 +56,21 @@ namespace dxvk {
             this->decRef();
         }
 
-        T* operator -> () const {
+        T* operator->() const {
             return m_ptr;
         }
 
-        T**       operator & ()       { return &m_ptr; }
-        T* const* operator & () const { return &m_ptr; }
+        T** operator&() { return &m_ptr; }
+        T* const* operator&() const { return &m_ptr; }
 
-        bool operator == (const Com<T>& other) const { return m_ptr == other.m_ptr; }
-        bool operator != (const Com<T>& other) const { return m_ptr != other.m_ptr; }
+        bool operator==(const Com<T>& other) const { return m_ptr == other.m_ptr; }
+        bool operator!=(const Com<T>& other) const { return m_ptr != other.m_ptr; }
 
-        bool operator == (const T* other) const { return m_ptr == other; }
-        bool operator != (const T* other) const { return m_ptr != other; }
+        bool operator==(const T* other) const { return m_ptr == other; }
+        bool operator!=(const T* other) const { return m_ptr != other; }
 
-        bool operator == (std::nullptr_t) const { return m_ptr == nullptr; }
-        bool operator != (std::nullptr_t) const { return m_ptr != nullptr; }
+        bool operator==(std::nullptr_t) const { return m_ptr == nullptr; }
+        bool operator!=(std::nullptr_t) const { return m_ptr != nullptr; }
 
         T* ref() const {
             this->incRef();
@@ -81,7 +81,7 @@ namespace dxvk {
             return m_ptr;
         }
 
-    private:
+      private:
         T* m_ptr = nullptr;
 
         void incRef() const {
@@ -93,10 +93,9 @@ namespace dxvk {
             if (m_ptr != nullptr)
                 m_ptr->Release();
         }
-
     };
 
-    template<typename T>
+    template <typename T>
     T* ref(T* object) {
         if (object != nullptr)
             object->AddRef();
diff --git a/src/util/util_error.h b/src/util/util_error.h
index d3c4eb2..0fadac6 100644
--- a/src/util/util_error.h
+++ b/src/util/util_error.h
@@ -4,148 +4,147 @@
 
 namespace dxvk {
     inline std::string fromErrorNr(const short errorNr) {
-        static const std::map<short, std::string> errors {
-            {   -1, "NVAPI_ERROR" },
-            {   -2, "NVAPI_LIBRARY_NOT_FOUND" },
-            {   -3, "NVAPI_NO_IMPLEMENTATION" },
-            {   -4, "NVAPI_API_NOT_INITIALIZED" },
-            {   -5, "NVAPI_INVALID_ARGUMENT" },
-            {   -6, "NVAPI_NVIDIA_DEVICE_NOT_FOUND" },
-            {   -7, "NVAPI_END_ENUMERATION" },
-            {   -8, "NVAPI_INVALID_HANDLE" },
-            {   -9, "NVAPI_INCOMPATIBLE_STRUCT_VERSION" },
-            {  -10, "NVAPI_HANDLE_INVALIDATED" },
-            {  -11, "NVAPI_OPENGL_CONTEXT_NOT_CURRENT" },
-            {  -14, "NVAPI_INVALID_POINTER" },
-            {  -12, "NVAPI_NO_GL_EXPERT" },
-            {  -13, "NVAPI_INSTRUMENTATION_DISABLED" },
-            {  -15, "NVAPI_NO_GL_NSIGHT" },
-            { -100, "NVAPI_EXPECTED_LOGICAL_GPU_HANDLE" },
-            { -101, "NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE" },
-            { -102, "NVAPI_EXPECTED_DISPLAY_HANDLE" },
-            { -103, "NVAPI_INVALID_COMBINATION" },
-            { -104, "NVAPI_NOT_SUPPORTED" },
-            { -105, "NVAPI_PORTID_NOT_FOUND" },
-            { -106, "NVAPI_EXPECTED_UNATTACHED_DISPLAY_HANDLE" },
-            { -107, "NVAPI_INVALID_PERF_LEVEL" },
-            { -108, "NVAPI_DEVICE_BUSY" },
-            { -109, "NVAPI_NV_PERSIST_FILE_NOT_FOUND" },
-            { -110, "NVAPI_PERSIST_DATA_NOT_FOUND" },
-            { -111, "NVAPI_EXPECTED_TV_DISPLAY" },
-            { -112, "NVAPI_EXPECTED_TV_DISPLAY_ON_DCONNECTOR" },
-            { -113, "NVAPI_NO_ACTIVE_SLI_TOPOLOGY" },
-            { -114, "NVAPI_SLI_RENDERING_MODE_NOTALLOWED" },
-            { -115, "NVAPI_EXPECTED_DIGITAL_FLAT_PANEL" },
-            { -116, "NVAPI_ARGUMENT_EXCEED_MAX_SIZE" },
-            { -117, "NVAPI_DEVICE_SWITCHING_NOT_ALLOWED" },
-            { -118, "NVAPI_TESTING_CLOCKS_NOT_SUPPORTED" },
-            { -119, "NVAPI_UNKNOWN_UNDERSCAN_CONFIG" },
-            { -120, "NVAPI_TIMEOUT_RECONFIGURING_GPU_TOPO" },
-            { -121, "NVAPI_DATA_NOT_FOUND" },
-            { -122, "NVAPI_EXPECTED_ANALOG_DISPLAY" },
-            { -123, "NVAPI_NO_VIDLINK" },
-            { -124, "NVAPI_REQUIRES_REBOOT" },
-            { -125, "NVAPI_INVALID_HYBRID_MODE" },
-            { -126, "NVAPI_MIXED_TARGET_TYPES" },
-            { -127, "NVAPI_SYSWOW64_NOT_SUPPORTED" },
-            { -128, "NVAPI_IMPLICIT_SET_GPU_TOPOLOGY_CHANGE_NOT_ALLOWED" },
-            { -129, "NVAPI_REQUEST_USER_TO_CLOSE_NON_MIGRATABLE_APPS" },
-            { -130, "NVAPI_OUT_OF_MEMORY" },
-            { -131, "NVAPI_WAS_STILL_DRAWING" },
-            { -132, "NVAPI_FILE_NOT_FOUND" },
-            { -133, "NVAPI_TOO_MANY_UNIQUE_STATE_OBJECTS" },
-            { -134, "NVAPI_INVALID_CALL" },
-            { -135, "NVAPI_D3D10_1_LIBRARY_NOT_FOUND" },
-            { -136, "NVAPI_FUNCTION_NOT_FOUND" },
-            { -137, "NVAPI_INVALID_USER_PRIVILEGE" },
-            { -138, "NVAPI_EXPECTED_NON_PRIMARY_DISPLAY_HANDLE" },
-            { -139, "NVAPI_EXPECTED_COMPUTE_GPU_HANDLE" },
-            { -140, "NVAPI_STEREO_NOT_INITIALIZED" },
-            { -141, "NVAPI_STEREO_REGISTRY_ACCESS_FAILED" },
-            { -142, "NVAPI_STEREO_REGISTRY_PROFILE_TYPE_NOT_SUPPORTED" },
-            { -143, "NVAPI_STEREO_REGISTRY_VALUE_NOT_SUPPORTED" },
-            { -144, "NVAPI_STEREO_NOT_ENABLED" },
-            { -145, "NVAPI_STEREO_NOT_TURNED_ON" },
-            { -146, "NVAPI_STEREO_INVALID_DEVICE_INTERFACE" },
-            { -147, "NVAPI_STEREO_PARAMETER_OUT_OF_RANGE" },
-            { -148, "NVAPI_STEREO_FRUSTUM_ADJUST_MODE_NOT_SUPPORTED" },
-            { -149, "NVAPI_TOPO_NOT_POSSIBLE" },
-            { -150, "NVAPI_MODE_CHANGE_FAILED" },
-            { -151, "NVAPI_D3D11_LIBRARY_NOT_FOUND" },
-            { -152, "NVAPI_INVALID_ADDRESS" },
-            { -153, "NVAPI_STRING_TOO_SMALL" },
-            { -154, "NVAPI_MATCHING_DEVICE_NOT_FOUND" },
-            { -155, "NVAPI_DRIVER_RUNNING" },
-            { -156, "NVAPI_DRIVER_NOTRUNNING" },
-            { -157, "NVAPI_ERROR_DRIVER_RELOAD_REQUIRED" },
-            { -158, "NVAPI_SET_NOT_ALLOWED" },
-            { -159, "NVAPI_ADVANCED_DISPLAY_TOPOLOGY_REQUIRED" },
-            { -160, "NVAPI_SETTING_NOT_FOUND" },
-            { -161, "NVAPI_SETTING_SIZE_TOO_LARGE" },
-            { -162, "NVAPI_TOO_MANY_SETTINGS_IN_PROFILE" },
-            { -163, "NVAPI_PROFILE_NOT_FOUND" },
-            { -164, "NVAPI_PROFILE_NAME_IN_USE" },
-            { -165, "NVAPI_PROFILE_NAME_EMPTY" },
-            { -166, "NVAPI_EXECUTABLE_NOT_FOUND" },
-            { -167, "NVAPI_EXECUTABLE_ALREADY_IN_USE" },
-            { -168, "NVAPI_DATATYPE_MISMATCH" },
-            { -169, "NVAPI_PROFILE_REMOVED" },
-            { -170, "NVAPI_UNREGISTERED_RESOURCE" },
-            { -171, "NVAPI_ID_OUT_OF_RANGE" },
-            { -172, "NVAPI_DISPLAYCONFIG_VALIDATION_FAILED" },
-            { -173, "NVAPI_DPMST_CHANGED" },
-            { -174, "NVAPI_INSUFFICIENT_BUFFER" },
-            { -175, "NVAPI_ACCESS_DENIED" },
-            { -176, "NVAPI_MOSAIC_NOT_ACTIVE" },
-            { -177, "NVAPI_SHARE_RESOURCE_RELOCATED" },
-            { -178, "NVAPI_REQUEST_USER_TO_DISABLE_DWM" },
-            { -179, "NVAPI_D3D_DEVICE_LOST" },
-            { -180, "NVAPI_INVALID_CONFIGURATION" },
-            { -181, "NVAPI_STEREO_HANDSHAKE_NOT_DONE" },
-            { -182, "NVAPI_EXECUTABLE_PATH_IS_AMBIGUOUS" },
-            { -183, "NVAPI_DEFAULT_STEREO_PROFILE_IS_NOT_DEFINED" },
-            { -184, "NVAPI_DEFAULT_STEREO_PROFILE_DOES_NOT_EXIST" },
-            { -185, "NVAPI_CLUSTER_ALREADY_EXISTS" },
-            { -186, "NVAPI_DPMST_DISPLAY_ID_EXPECTED" },
-            { -187, "NVAPI_INVALID_DISPLAY_ID" },
-            { -188, "NVAPI_STREAM_IS_OUT_OF_SYNC" },
-            { -189, "NVAPI_INCOMPATIBLE_AUDIO_DRIVER" },
-            { -190, "NVAPI_VALUE_ALREADY_SET" },
-            { -191, "NVAPI_TIMEOUT" },
-            { -192, "NVAPI_GPU_WORKSTATION_FEATURE_INCOMPLETE" },
-            { -193, "NVAPI_STEREO_INIT_ACTIVATION_NOT_DONE" },
-            { -194, "NVAPI_SYNC_NOT_ACTIVE" },
-            { -195, "NVAPI_SYNC_MASTER_NOT_FOUND" },
-            { -196, "NVAPI_INVALID_SYNC_TOPOLOGY" },
-            { -197, "NVAPI_ECID_SIGN_ALGO_UNSUPPORTED" },
-            { -198, "NVAPI_ECID_KEY_VERIFICATION_FAILED" },
-            { -199, "NVAPI_FIRMWARE_OUT_OF_DATE" },
-            { -200, "NVAPI_FIRMWARE_REVISION_NOT_SUPPORTED" },
-            { -201, "NVAPI_LICENSE_CALLER_AUTHENTICATION_FAILED" },
-            { -202, "NVAPI_D3D_DEVICE_NOT_REGISTERED" },
-            { -203, "NVAPI_RESOURCE_NOT_ACQUIRED" },
-            { -204, "NVAPI_TIMING_NOT_SUPPORTED" },
-            { -205, "NVAPI_HDCP_ENCRYPTION_FAILED" },
-            { -206, "NVAPI_PCLK_LIMITATION_FAILED" },
-            { -207, "NVAPI_NO_CONNECTOR_FOUND" },
-            { -208, "NVAPI_HDCP_DISABLED" },
-            { -209, "NVAPI_API_IN_USE" },
-            { -210, "NVAPI_NVIDIA_DISPLAY_NOT_FOUND" },
-            { -211, "NVAPI_PRIV_SEC_VIOLATION" },
-            { -212, "NVAPI_INCORRECT_VENDOR" },
-            { -213, "NVAPI_DISPLAY_IN_USE" },
-            { -214, "NVAPI_UNSUPPORTED_CONFIG_NON_HDCP_HMD" },
-            { -215, "NVAPI_MAX_DISPLAY_LIMIT_REACHED" },
-            { -216, "NVAPI_INVALID_DIRECT_MODE_DISPLAY" },
-            { -217, "NVAPI_GPU_IN_DEBUG_MODE" },
-            { -218, "NVAPI_D3D_CONTEXT_NOT_FOUND" },
-            { -219, "NVAPI_STEREO_VERSION_MISMATCH" },
-            { -220, "NVAPI_GPU_NOT_POWERED" },
-            { -221, "NVAPI_ERROR_DRIVER_RELOAD_IN_PROGRESS" },
-            { -222, "NVAPI_WAIT_FOR_HW_RESOURCE" },
-            { -223, "NVAPI_REQUIRE_FURTHER_HDCP_ACTION" },
-            { -224, "NVAPI_DISPLAY_MUX_TRANSITION_FAILED" }
-        };
+        static const std::map<short, std::string> errors{
+            {-1, "NVAPI_ERROR"},
+            {-2, "NVAPI_LIBRARY_NOT_FOUND"},
+            {-3, "NVAPI_NO_IMPLEMENTATION"},
+            {-4, "NVAPI_API_NOT_INITIALIZED"},
+            {-5, "NVAPI_INVALID_ARGUMENT"},
+            {-6, "NVAPI_NVIDIA_DEVICE_NOT_FOUND"},
+            {-7, "NVAPI_END_ENUMERATION"},
+            {-8, "NVAPI_INVALID_HANDLE"},
+            {-9, "NVAPI_INCOMPATIBLE_STRUCT_VERSION"},
+            {-10, "NVAPI_HANDLE_INVALIDATED"},
+            {-11, "NVAPI_OPENGL_CONTEXT_NOT_CURRENT"},
+            {-14, "NVAPI_INVALID_POINTER"},
+            {-12, "NVAPI_NO_GL_EXPERT"},
+            {-13, "NVAPI_INSTRUMENTATION_DISABLED"},
+            {-15, "NVAPI_NO_GL_NSIGHT"},
+            {-100, "NVAPI_EXPECTED_LOGICAL_GPU_HANDLE"},
+            {-101, "NVAPI_EXPECTED_PHYSICAL_GPU_HANDLE"},
+            {-102, "NVAPI_EXPECTED_DISPLAY_HANDLE"},
+            {-103, "NVAPI_INVALID_COMBINATION"},
+            {-104, "NVAPI_NOT_SUPPORTED"},
+            {-105, "NVAPI_PORTID_NOT_FOUND"},
+            {-106, "NVAPI_EXPECTED_UNATTACHED_DISPLAY_HANDLE"},
+            {-107, "NVAPI_INVALID_PERF_LEVEL"},
+            {-108, "NVAPI_DEVICE_BUSY"},
+            {-109, "NVAPI_NV_PERSIST_FILE_NOT_FOUND"},
+            {-110, "NVAPI_PERSIST_DATA_NOT_FOUND"},
+            {-111, "NVAPI_EXPECTED_TV_DISPLAY"},
+            {-112, "NVAPI_EXPECTED_TV_DISPLAY_ON_DCONNECTOR"},
+            {-113, "NVAPI_NO_ACTIVE_SLI_TOPOLOGY"},
+            {-114, "NVAPI_SLI_RENDERING_MODE_NOTALLOWED"},
+            {-115, "NVAPI_EXPECTED_DIGITAL_FLAT_PANEL"},
+            {-116, "NVAPI_ARGUMENT_EXCEED_MAX_SIZE"},
+            {-117, "NVAPI_DEVICE_SWITCHING_NOT_ALLOWED"},
+            {-118, "NVAPI_TESTING_CLOCKS_NOT_SUPPORTED"},
+            {-119, "NVAPI_UNKNOWN_UNDERSCAN_CONFIG"},
+            {-120, "NVAPI_TIMEOUT_RECONFIGURING_GPU_TOPO"},
+            {-121, "NVAPI_DATA_NOT_FOUND"},
+            {-122, "NVAPI_EXPECTED_ANALOG_DISPLAY"},
+            {-123, "NVAPI_NO_VIDLINK"},
+            {-124, "NVAPI_REQUIRES_REBOOT"},
+            {-125, "NVAPI_INVALID_HYBRID_MODE"},
+            {-126, "NVAPI_MIXED_TARGET_TYPES"},
+            {-127, "NVAPI_SYSWOW64_NOT_SUPPORTED"},
+            {-128, "NVAPI_IMPLICIT_SET_GPU_TOPOLOGY_CHANGE_NOT_ALLOWED"},
+            {-129, "NVAPI_REQUEST_USER_TO_CLOSE_NON_MIGRATABLE_APPS"},
+            {-130, "NVAPI_OUT_OF_MEMORY"},
+            {-131, "NVAPI_WAS_STILL_DRAWING"},
+            {-132, "NVAPI_FILE_NOT_FOUND"},
+            {-133, "NVAPI_TOO_MANY_UNIQUE_STATE_OBJECTS"},
+            {-134, "NVAPI_INVALID_CALL"},
+            {-135, "NVAPI_D3D10_1_LIBRARY_NOT_FOUND"},
+            {-136, "NVAPI_FUNCTION_NOT_FOUND"},
+            {-137, "NVAPI_INVALID_USER_PRIVILEGE"},
+            {-138, "NVAPI_EXPECTED_NON_PRIMARY_DISPLAY_HANDLE"},
+            {-139, "NVAPI_EXPECTED_COMPUTE_GPU_HANDLE"},
+            {-140, "NVAPI_STEREO_NOT_INITIALIZED"},
+            {-141, "NVAPI_STEREO_REGISTRY_ACCESS_FAILED"},
+            {-142, "NVAPI_STEREO_REGISTRY_PROFILE_TYPE_NOT_SUPPORTED"},
+            {-143, "NVAPI_STEREO_REGISTRY_VALUE_NOT_SUPPORTED"},
+            {-144, "NVAPI_STEREO_NOT_ENABLED"},
+            {-145, "NVAPI_STEREO_NOT_TURNED_ON"},
+            {-146, "NVAPI_STEREO_INVALID_DEVICE_INTERFACE"},
+            {-147, "NVAPI_STEREO_PARAMETER_OUT_OF_RANGE"},
+            {-148, "NVAPI_STEREO_FRUSTUM_ADJUST_MODE_NOT_SUPPORTED"},
+            {-149, "NVAPI_TOPO_NOT_POSSIBLE"},
+            {-150, "NVAPI_MODE_CHANGE_FAILED"},
+            {-151, "NVAPI_D3D11_LIBRARY_NOT_FOUND"},
+            {-152, "NVAPI_INVALID_ADDRESS"},
+            {-153, "NVAPI_STRING_TOO_SMALL"},
+            {-154, "NVAPI_MATCHING_DEVICE_NOT_FOUND"},
+            {-155, "NVAPI_DRIVER_RUNNING"},
+            {-156, "NVAPI_DRIVER_NOTRUNNING"},
+            {-157, "NVAPI_ERROR_DRIVER_RELOAD_REQUIRED"},
+            {-158, "NVAPI_SET_NOT_ALLOWED"},
+            {-159, "NVAPI_ADVANCED_DISPLAY_TOPOLOGY_REQUIRED"},
+            {-160, "NVAPI_SETTING_NOT_FOUND"},
+            {-161, "NVAPI_SETTING_SIZE_TOO_LARGE"},
+            {-162, "NVAPI_TOO_MANY_SETTINGS_IN_PROFILE"},
+            {-163, "NVAPI_PROFILE_NOT_FOUND"},
+            {-164, "NVAPI_PROFILE_NAME_IN_USE"},
+            {-165, "NVAPI_PROFILE_NAME_EMPTY"},
+            {-166, "NVAPI_EXECUTABLE_NOT_FOUND"},
+            {-167, "NVAPI_EXECUTABLE_ALREADY_IN_USE"},
+            {-168, "NVAPI_DATATYPE_MISMATCH"},
+            {-169, "NVAPI_PROFILE_REMOVED"},
+            {-170, "NVAPI_UNREGISTERED_RESOURCE"},
+            {-171, "NVAPI_ID_OUT_OF_RANGE"},
+            {-172, "NVAPI_DISPLAYCONFIG_VALIDATION_FAILED"},
+            {-173, "NVAPI_DPMST_CHANGED"},
+            {-174, "NVAPI_INSUFFICIENT_BUFFER"},
+            {-175, "NVAPI_ACCESS_DENIED"},
+            {-176, "NVAPI_MOSAIC_NOT_ACTIVE"},
+            {-177, "NVAPI_SHARE_RESOURCE_RELOCATED"},
+            {-178, "NVAPI_REQUEST_USER_TO_DISABLE_DWM"},
+            {-179, "NVAPI_D3D_DEVICE_LOST"},
+            {-180, "NVAPI_INVALID_CONFIGURATION"},
+            {-181, "NVAPI_STEREO_HANDSHAKE_NOT_DONE"},
+            {-182, "NVAPI_EXECUTABLE_PATH_IS_AMBIGUOUS"},
+            {-183, "NVAPI_DEFAULT_STEREO_PROFILE_IS_NOT_DEFINED"},
+            {-184, "NVAPI_DEFAULT_STEREO_PROFILE_DOES_NOT_EXIST"},
+            {-185, "NVAPI_CLUSTER_ALREADY_EXISTS"},
+            {-186, "NVAPI_DPMST_DISPLAY_ID_EXPECTED"},
+            {-187, "NVAPI_INVALID_DISPLAY_ID"},
+            {-188, "NVAPI_STREAM_IS_OUT_OF_SYNC"},
+            {-189, "NVAPI_INCOMPATIBLE_AUDIO_DRIVER"},
+            {-190, "NVAPI_VALUE_ALREADY_SET"},
+            {-191, "NVAPI_TIMEOUT"},
+            {-192, "NVAPI_GPU_WORKSTATION_FEATURE_INCOMPLETE"},
+            {-193, "NVAPI_STEREO_INIT_ACTIVATION_NOT_DONE"},
+            {-194, "NVAPI_SYNC_NOT_ACTIVE"},
+            {-195, "NVAPI_SYNC_MASTER_NOT_FOUND"},
+            {-196, "NVAPI_INVALID_SYNC_TOPOLOGY"},
+            {-197, "NVAPI_ECID_SIGN_ALGO_UNSUPPORTED"},
+            {-198, "NVAPI_ECID_KEY_VERIFICATION_FAILED"},
+            {-199, "NVAPI_FIRMWARE_OUT_OF_DATE"},
+            {-200, "NVAPI_FIRMWARE_REVISION_NOT_SUPPORTED"},
+            {-201, "NVAPI_LICENSE_CALLER_AUTHENTICATION_FAILED"},
+            {-202, "NVAPI_D3D_DEVICE_NOT_REGISTERED"},
+            {-203, "NVAPI_RESOURCE_NOT_ACQUIRED"},
+            {-204, "NVAPI_TIMING_NOT_SUPPORTED"},
+            {-205, "NVAPI_HDCP_ENCRYPTION_FAILED"},
+            {-206, "NVAPI_PCLK_LIMITATION_FAILED"},
+            {-207, "NVAPI_NO_CONNECTOR_FOUND"},
+            {-208, "NVAPI_HDCP_DISABLED"},
+            {-209, "NVAPI_API_IN_USE"},
+            {-210, "NVAPI_NVIDIA_DISPLAY_NOT_FOUND"},
+            {-211, "NVAPI_PRIV_SEC_VIOLATION"},
+            {-212, "NVAPI_INCORRECT_VENDOR"},
+            {-213, "NVAPI_DISPLAY_IN_USE"},
+            {-214, "NVAPI_UNSUPPORTED_CONFIG_NON_HDCP_HMD"},
+            {-215, "NVAPI_MAX_DISPLAY_LIMIT_REACHED"},
+            {-216, "NVAPI_INVALID_DIRECT_MODE_DISPLAY"},
+            {-217, "NVAPI_GPU_IN_DEBUG_MODE"},
+            {-218, "NVAPI_D3D_CONTEXT_NOT_FOUND"},
+            {-219, "NVAPI_STEREO_VERSION_MISMATCH"},
+            {-220, "NVAPI_GPU_NOT_POWERED"},
+            {-221, "NVAPI_ERROR_DRIVER_RELOAD_IN_PROGRESS"},
+            {-222, "NVAPI_WAIT_FOR_HW_RESOURCE"},
+            {-223, "NVAPI_REQUIRE_FURTHER_HDCP_ACTION"},
+            {-224, "NVAPI_DISPLAY_MUX_TRANSITION_FAILED"}};
 
         auto it = errors.find(errorNr);
         return it != errors.end() ? it->second : "UNKNOWN_ERROR";
diff --git a/src/util/util_op_code.h b/src/util/util_op_code.h
index 03f614f..cbe8f22 100644
--- a/src/util/util_op_code.h
+++ b/src/util/util_op_code.h
@@ -2,29 +2,28 @@
 
 namespace dxvk {
     inline std::string fromCode(const uint32_t code) {
-        static const std::map<uint32_t, std::string> codes {
-            {  1, "NV_EXTN_OP_SHFL" },
-            {  2, "NV_EXTN_OP_SHFL_UP" },
-            {  3, "NV_EXTN_OP_SHFL_DOWN" },
-            {  4, "NV_EXTN_OP_SHFL_XOR" },
-            {  5, "NV_EXTN_OP_VOTE_ALL" },
-            {  6, "NV_EXTN_OP_VOTE_ANY" },
-            {  7, "NV_EXTN_OP_VOTE_BALLOT" },
-            {  8, "NV_EXTN_OP_GET_LANE_ID" },
-            { 12, "NV_EXTN_OP_FP16_ATOMIC" },
-            { 13, "NV_EXTN_OP_FP32_ATOMIC" },
-            { 19, "NV_EXTN_OP_GET_SPECIAL" },
-            { 20, "NV_EXTN_OP_UINT64_ATOMIC" },
-            { 21, "NV_EXTN_OP_MATCH_ANY" },
-            { 28, "NV_EXTN_OP_FOOTPRINT" },
-            { 29, "NV_EXTN_OP_FOOTPRINT_BIAS" },
-            { 30, "NV_EXTN_OP_GET_SHADING_RATE" },
-            { 31, "NV_EXTN_OP_FOOTPRINT_LEVEL" },
-            { 32, "NV_EXTN_OP_FOOTPRINT_GRAD" },
-            { 33, "NV_EXTN_OP_SHFL_GENERIC" },
-            { 51, "NV_EXTN_OP_VPRS_EVAL_ATTRIB_AT_SAMPLE" },
-            { 52, "NV_EXTN_OP_VPRS_EVAL_ATTRIB_SNAPPED" }
-        };
+        static const std::map<uint32_t, std::string> codes{
+            {1, "NV_EXTN_OP_SHFL"},
+            {2, "NV_EXTN_OP_SHFL_UP"},
+            {3, "NV_EXTN_OP_SHFL_DOWN"},
+            {4, "NV_EXTN_OP_SHFL_XOR"},
+            {5, "NV_EXTN_OP_VOTE_ALL"},
+            {6, "NV_EXTN_OP_VOTE_ANY"},
+            {7, "NV_EXTN_OP_VOTE_BALLOT"},
+            {8, "NV_EXTN_OP_GET_LANE_ID"},
+            {12, "NV_EXTN_OP_FP16_ATOMIC"},
+            {13, "NV_EXTN_OP_FP32_ATOMIC"},
+            {19, "NV_EXTN_OP_GET_SPECIAL"},
+            {20, "NV_EXTN_OP_UINT64_ATOMIC"},
+            {21, "NV_EXTN_OP_MATCH_ANY"},
+            {28, "NV_EXTN_OP_FOOTPRINT"},
+            {29, "NV_EXTN_OP_FOOTPRINT_BIAS"},
+            {30, "NV_EXTN_OP_GET_SHADING_RATE"},
+            {31, "NV_EXTN_OP_FOOTPRINT_LEVEL"},
+            {32, "NV_EXTN_OP_FOOTPRINT_GRAD"},
+            {33, "NV_EXTN_OP_SHFL_GENERIC"},
+            {51, "NV_EXTN_OP_VPRS_EVAL_ATTRIB_AT_SAMPLE"},
+            {52, "NV_EXTN_OP_VPRS_EVAL_ATTRIB_SNAPPED"}};
 
         auto it = codes.find(code);
         return it != codes.end() ? it->second : "UNKNOWN_EXTN_OP";
diff --git a/src/util/util_pso_extension.h b/src/util/util_pso_extension.h
index 10f53c0..4c8f9c4 100644
--- a/src/util/util_pso_extension.h
+++ b/src/util/util_pso_extension.h
@@ -2,16 +2,16 @@
 
 namespace dxvk {
     inline std::string fromPsoExtension(const uint32_t code) {
-        static const std::map<uint32_t, std::string> codes {
-            {  0, "NV_PSO_RASTER_EXTENSION"},
-            {  1, "NV_PSO_REQUEST_FASTGS_EXTENSION"},
-            {  2, "NV_PSO_GEOMETRY_SHADER_EXTENSION"},
-            {  3, "NV_PSO_ENABLE_DEPTH_BOUND_TEST_EXTENSION"},
-            {  4, "NV_PSO_EXPLICIT_FASTGS_EXTENSION"},
-            {  5, "NV_PSO_SET_SHADER_EXTENSION_SLOT_AND_SPACE"},
-            {  6, "NV_PSO_VERTEX_SHADER_EXTENSION"},
-            {  7, "NV_PSO_DOMAIN_SHADER_EXTENSION"},
-            {  9, "NV_PSO_HULL_SHADER_EXTENSION"},
+        static const std::map<uint32_t, std::string> codes{
+            {0, "NV_PSO_RASTER_EXTENSION"},
+            {1, "NV_PSO_REQUEST_FASTGS_EXTENSION"},
+            {2, "NV_PSO_GEOMETRY_SHADER_EXTENSION"},
+            {3, "NV_PSO_ENABLE_DEPTH_BOUND_TEST_EXTENSION"},
+            {4, "NV_PSO_EXPLICIT_FASTGS_EXTENSION"},
+            {5, "NV_PSO_SET_SHADER_EXTENSION_SLOT_AND_SPACE"},
+            {6, "NV_PSO_VERTEX_SHADER_EXTENSION"},
+            {7, "NV_PSO_DOMAIN_SHADER_EXTENSION"},
+            {9, "NV_PSO_HULL_SHADER_EXTENSION"},
         };
 
         auto it = codes.find(code);
diff --git a/src/util/util_string.h b/src/util/util_string.h
index 438f4c8..84043cf 100644
--- a/src/util/util_string.h
+++ b/src/util/util_string.h
@@ -18,21 +18,21 @@ namespace dxvk::str {
 
     void tonvss(NvAPI_ShortString nvss, std::string str);
 
-    inline void format1(std::stringstream&) { }
+    inline void format1(std::stringstream&) {}
 
-    template<typename... Tx>
-    void format1(std::stringstream& str, const WCHAR *arg, const Tx&... args) {
+    template <typename... Tx>
+    void format1(std::stringstream& str, const WCHAR* arg, const Tx&... args) {
         str << fromws(arg);
         format1(str, args...);
     }
 
-    template<typename T, typename... Tx>
+    template <typename T, typename... Tx>
     void format1(std::stringstream& str, const T& arg, const Tx&... args) {
         str << arg;
         format1(str, args...);
     }
 
-    template<typename... Args>
+    template <typename... Args>
     std::string format(const Args&... args) {
         std::stringstream stream;
         format1(stream, args...);
diff --git a/src/vkd3d-proton/vkd3d-proton_interfaces.cpp b/src/vkd3d-proton/vkd3d-proton_interfaces.cpp
index 6728e69..d7220eb 100644
--- a/src/vkd3d-proton/vkd3d-proton_interfaces.cpp
+++ b/src/vkd3d-proton/vkd3d-proton_interfaces.cpp
@@ -17,5 +17,5 @@
 
 #include "vkd3d-proton_interfaces.h"
 
-const GUID ID3D12DeviceExt::guid                = {0x11ea7a1a,0x0f6a,0x49bf,{0xb6,0x12,0x3e,0x30,0xf8,0xe2,0x01,0xdd}};
-const GUID ID3D12GraphicsCommandListExt::guid   = {0x77a86b09,0x2bea,0x4801,{0xb8,0x9a,0x37,0x64,0x8e,0x10,0x4a,0xf1}};
+const GUID ID3D12DeviceExt::guid = {0x11ea7a1a, 0x0f6a, 0x49bf, {0xb6, 0x12, 0x3e, 0x30, 0xf8, 0xe2, 0x01, 0xdd}};
+const GUID ID3D12GraphicsCommandListExt::guid = {0x77a86b09, 0x2bea, 0x4801, {0xb8, 0x9a, 0x37, 0x64, 0x8e, 0x10, 0x4a, 0xf1}};
diff --git a/src/vkd3d-proton/vkd3d-proton_interfaces.h b/src/vkd3d-proton/vkd3d-proton_interfaces.h
index 52168eb..181c831 100644
--- a/src/vkd3d-proton/vkd3d-proton_interfaces.h
+++ b/src/vkd3d-proton/vkd3d-proton_interfaces.h
@@ -24,11 +24,12 @@
 #endif // __GNUC__
 
 #define VKD3D_PROTON_GUID(iface) \
-    template<> inline GUID const& __mingw_uuidof<iface> () { return iface::guid; }
+    template <>                  \
+    inline GUID const& __mingw_uuidof<iface>() { return iface::guid; }
 
 enum D3D12_VK_EXTENSION : uint32_t {
-    D3D12_VK_NVX_BINARY_IMPORT      = 0x1,
-    D3D12_VK_NVX_IMAGE_VIEW_HANDLE  = 0x2
+    D3D12_VK_NVX_BINARY_IMPORT = 0x1,
+    D3D12_VK_NVX_IMAGE_VIEW_HANDLE = 0x2
 };
 
 struct D3D12_CUBIN_DATA_HANDLE {
@@ -36,65 +37,65 @@ struct D3D12_CUBIN_DATA_HANDLE {
     VkCuModuleNVX vkCuModule;
     UINT32 blockX;
     UINT32 blockY;
-    UINT32 blockZ; 
+    UINT32 blockZ;
 };
 
 typedef struct D3D12_UAV_INFO {
     UINT32 version;
     UINT32 surfaceHandle;
     UINT64 gpuVAStart;
-    UINT64 gpuVASize;  
+    UINT64 gpuVASize;
 } D3D12_UAV_INFO;
 
 MIDL_INTERFACE("11ea7a1a-0f6a-49bf-b612-3e30f8e201dd")
 ID3D12DeviceExt : public IUnknown {
     static const GUID guid;
     virtual HRESULT STDMETHODCALLTYPE GetVulkanHandles(
-        VkInstance*                   vk_instance,
-        VkPhysicalDevice*             vk_physical_device,
-        VkDevice*                     vk_device) = 0;
+        VkInstance * vk_instance,
+        VkPhysicalDevice * vk_physical_device,
+        VkDevice * vk_device) = 0;
 
     virtual BOOL STDMETHODCALLTYPE GetExtensionSupport(
-        D3D12_VK_EXTENSION            extension) = 0;
+        D3D12_VK_EXTENSION extension) = 0;
 
     virtual HRESULT STDMETHODCALLTYPE CreateCubinComputeShaderWithName(
-        const void*                   cubin_data,
-        UINT32                        cubin_size,
-        UINT32                        block_x,
-        UINT32                        block_y,
-        UINT32                        block_z,
-        const char*                   shader_name,
-        D3D12_CUBIN_DATA_HANDLE**     handle) = 0;
+        const void* cubin_data,
+        UINT32 cubin_size,
+        UINT32 block_x,
+        UINT32 block_y,
+        UINT32 block_z,
+        const char* shader_name,
+        D3D12_CUBIN_DATA_HANDLE** handle) = 0;
 
     virtual HRESULT STDMETHODCALLTYPE DestroyCubinComputeShader(
-        D3D12_CUBIN_DATA_HANDLE*      handle) = 0;
+        D3D12_CUBIN_DATA_HANDLE * handle) = 0;
 
     virtual HRESULT STDMETHODCALLTYPE GetCudaTextureObject(
-        D3D12_CPU_DESCRIPTOR_HANDLE   srv_handle,
-        D3D12_CPU_DESCRIPTOR_HANDLE   sampler_handle,
-        UINT32*                       cuda_texture_handle) = 0;
+        D3D12_CPU_DESCRIPTOR_HANDLE srv_handle,
+        D3D12_CPU_DESCRIPTOR_HANDLE sampler_handle,
+        UINT32 * cuda_texture_handle) = 0;
 
     virtual HRESULT STDMETHODCALLTYPE GetCudaSurfaceObject(
-        D3D12_CPU_DESCRIPTOR_HANDLE   uav_handle,
-        UINT32*                       cuda_surface_handle) = 0;
+        D3D12_CPU_DESCRIPTOR_HANDLE uav_handle,
+        UINT32 * cuda_surface_handle) = 0;
 
     virtual HRESULT STDMETHODCALLTYPE CaptureUAVInfo(
-        D3D12_UAV_INFO*               uav_info) = 0;
+        D3D12_UAV_INFO * uav_info) = 0;
 };
 
 MIDL_INTERFACE("77a86b09-2bea-4801-b89a-37648e104af1")
 ID3D12GraphicsCommandListExt : public IUnknown {
     static const GUID guid;
     virtual HRESULT STDMETHODCALLTYPE GetVulkanHandle(
-        VkCommandBuffer*               pVkCommandBuffer) = 0;
+        VkCommandBuffer * pVkCommandBuffer) = 0;
 
     virtual HRESULT STDMETHODCALLTYPE LaunchCubinShader(
-        D3D12_CUBIN_DATA_HANDLE*       handle,
-        UINT32                         block_x,
-        UINT32                         block_y,
-        UINT32                         block_z,
-        const void*                    params,
-        UINT32                         param_size) = 0;
+        D3D12_CUBIN_DATA_HANDLE * handle,
+        UINT32 block_x,
+        UINT32 block_y,
+        UINT32 block_z,
+        const void* params,
+        UINT32 param_size) = 0;
 };
 
 VKD3D_PROTON_GUID(ID3D12DeviceExt)