mirror of
https://github.com/doitsujin/dxvk.git
synced 2024-12-14 00:48:44 +01:00
238 lines
7.8 KiB
C
238 lines
7.8 KiB
C
#pragma once
|
|
|
|
#include "d3d9_include.h"
|
|
#include "../vulkan/vulkan_loader.h"
|
|
|
|
/**
|
|
* \brief D3D9 interface for Vulkan interop
|
|
*
|
|
* Provides access to the instance and physical device
|
|
* handles for the given D3D9 interface and adapter ordinals.
|
|
*/
|
|
MIDL_INTERFACE("3461a81b-ce41-485b-b6b5-fcf08ba6a6bd")
|
|
ID3D9VkInteropInterface : public IUnknown {
|
|
/**
|
|
* \brief Queries Vulkan handles used by DXVK
|
|
*
|
|
* \param [out] pInstance The Vulkan instance
|
|
*/
|
|
virtual void STDMETHODCALLTYPE GetInstanceHandle(
|
|
VkInstance* pInstance) = 0;
|
|
|
|
/**
|
|
* \brief Queries Vulkan handles used by DXVK
|
|
*
|
|
* \param [in] Adapter Adapter ordinal
|
|
* \param [out] pInstance The Vulkan instance
|
|
*/
|
|
virtual void STDMETHODCALLTYPE GetPhysicalDeviceHandle(
|
|
UINT Adapter,
|
|
VkPhysicalDevice* pPhysicalDevice) = 0;
|
|
};
|
|
|
|
/**
|
|
* \brief D3D9 texture interface for Vulkan interop
|
|
*
|
|
* Provides access to the backing resource of a
|
|
* D3D9 texture.
|
|
*/
|
|
MIDL_INTERFACE("d56344f5-8d35-46fd-806d-94c351b472c1")
|
|
ID3D9VkInteropTexture : public IUnknown {
|
|
/**
|
|
* \brief Retrieves Vulkan image info
|
|
*
|
|
* Retrieves both the image handle as well as the image's
|
|
* properties. Any of the given pointers may be \c nullptr.
|
|
*
|
|
* If \c pInfo is not \c nullptr, the following rules apply:
|
|
* - \c pInfo->sType \e must be \c VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO
|
|
* - \c pInfo->pNext \e must be \c nullptr or point to a supported
|
|
* extension-specific structure (currently none)
|
|
* - \c pInfo->queueFamilyIndexCount must be the length of the
|
|
* \c pInfo->pQueueFamilyIndices array, in \c uint32_t units.
|
|
* - \c pInfo->pQueueFamilyIndices must point to a pre-allocated
|
|
* array of \c uint32_t of size \c pInfo->pQueueFamilyIndices.
|
|
*
|
|
* \note As of now, the sharing mode will always be
|
|
* \c VK_SHARING_MODE_EXCLUSIVE and no queue
|
|
* family indices will be written to the array.
|
|
*
|
|
* After the call, the structure pointed to by \c pInfo can
|
|
* be used to create an image with identical properties.
|
|
*
|
|
* If \c pLayout is not \c nullptr, it will receive the
|
|
* layout that the image will be in after flushing any
|
|
* outstanding commands on the device.
|
|
* \param [out] pHandle The image handle
|
|
* \param [out] pLayout Image layout
|
|
* \param [out] pInfo Image properties
|
|
* \returns \c S_OK on success, or \c D3DERR_INVALIDCALL
|
|
*/
|
|
virtual HRESULT STDMETHODCALLTYPE GetVulkanImageInfo(
|
|
VkImage* pHandle,
|
|
VkImageLayout* pLayout,
|
|
VkImageCreateInfo* pInfo) = 0;
|
|
};
|
|
|
|
/**
|
|
* \brief D3D9 device interface for Vulkan interop
|
|
*
|
|
* Provides access to the device and instance handles
|
|
* as well as the queue that is used for rendering.
|
|
*/
|
|
MIDL_INTERFACE("2eaa4b89-0107-4bdb-87f7-0f541c493ce0")
|
|
ID3D9VkInteropDevice : public IUnknown {
|
|
/**
|
|
* \brief Queries Vulkan handles used by DXVK
|
|
*
|
|
* \param [out] pInstance The Vulkan instance
|
|
* \param [out] pPhysDev The physical device
|
|
* \param [out] pDevide The device handle
|
|
*/
|
|
virtual void STDMETHODCALLTYPE GetVulkanHandles(
|
|
VkInstance* pInstance,
|
|
VkPhysicalDevice* pPhysDev,
|
|
VkDevice* pDevice) = 0;
|
|
|
|
/**
|
|
* \brief Queries the rendering queue used by DXVK
|
|
*
|
|
* \param [out] pQueue The Vulkan queue handle
|
|
* \param [out] pQueueIndex Queue index
|
|
* \param [out] pQueueFamilyIndex Queue family index
|
|
*/
|
|
virtual void STDMETHODCALLTYPE GetSubmissionQueue(
|
|
VkQueue* pQueue,
|
|
uint32_t* pQueueIndex,
|
|
uint32_t* pQueueFamilyIndex) = 0;
|
|
|
|
/**
|
|
* \brief Transitions a Texture to a given layout
|
|
*
|
|
* Executes an explicit image layout transition on the
|
|
* D3D device. Note that the image subresources \e must
|
|
* be transitioned back to its original layout before
|
|
* using it again from D3D9.
|
|
* Synchronization is left up to the caller.
|
|
* This function merely emits a call to transition the
|
|
* texture on the DXVK internal command stream.
|
|
* \param [in] pTexture The image to transform
|
|
* \param [in] pSubresources Subresources to transform
|
|
* \param [in] OldLayout Current image layout
|
|
* \param [in] NewLayout Desired image layout
|
|
*/
|
|
virtual void STDMETHODCALLTYPE TransitionTextureLayout(
|
|
ID3D9VkInteropTexture* pTexture,
|
|
const VkImageSubresourceRange* pSubresources,
|
|
VkImageLayout OldLayout,
|
|
VkImageLayout NewLayout) = 0;
|
|
|
|
/**
|
|
* \brief Flushes outstanding D3D rendering commands
|
|
*
|
|
* Must be called before submitting Vulkan commands
|
|
* to the rendering queue if those commands use the
|
|
* backing resource of a D3D9 object.
|
|
*/
|
|
virtual void STDMETHODCALLTYPE FlushRenderingCommands() = 0;
|
|
|
|
/**
|
|
* \brief Locks submission queue
|
|
*
|
|
* Should be called immediately before submitting
|
|
* Vulkan commands to the rendering queue in order
|
|
* to prevent DXVK from using the queue.
|
|
*
|
|
* While the submission queue is locked, no D3D9
|
|
* methods must be called from the locking thread,
|
|
* or otherwise a deadlock might occur.
|
|
*/
|
|
virtual void STDMETHODCALLTYPE LockSubmissionQueue() = 0;
|
|
|
|
/**
|
|
* \brief Releases submission queue
|
|
*
|
|
* Should be called immediately after submitting
|
|
* Vulkan commands to the rendering queue in order
|
|
* to allow DXVK to submit new commands.
|
|
*/
|
|
virtual void STDMETHODCALLTYPE ReleaseSubmissionQueue() = 0;
|
|
|
|
/**
|
|
* \brief Locks the device
|
|
*
|
|
* Can be called to ensure no D3D9 device methods
|
|
* can be executed until UnlockDevice has been called.
|
|
*
|
|
* This will do nothing if the D3DCREATE_MULTITHREADED
|
|
* is not set.
|
|
*/
|
|
virtual void STDMETHODCALLTYPE LockDevice() = 0;
|
|
|
|
/**
|
|
* \brief Unlocks the device
|
|
*
|
|
* Must only be called after a call to LockDevice.
|
|
*/
|
|
virtual void STDMETHODCALLTYPE UnlockDevice() = 0;
|
|
|
|
/**
|
|
* \brief Wait for a resource to finish being used
|
|
*
|
|
* Waits for the GPU resource associated with the
|
|
* resource to finish being used by the GPU.
|
|
*
|
|
* Valid D3DLOCK flags:
|
|
* - D3DLOCK_READONLY: Only waits for writes
|
|
* - D3DLOCK_DONOTWAIT: Does not wait for the resource (may flush)
|
|
*
|
|
* \param [in] pResource Resource to be waited upon
|
|
* \param [in] MapFlags D3DLOCK flags
|
|
* \returns true if the resource is ready to use,
|
|
* false if the resource is till in use
|
|
*/
|
|
virtual bool STDMETHODCALLTYPE WaitForResource(
|
|
IDirect3DResource9* pResource,
|
|
DWORD MapFlags) = 0;
|
|
};
|
|
|
|
/**
|
|
* \brief D3D9 current output metadata
|
|
*/
|
|
struct D3D9VkExtOutputMetadata {
|
|
float RedPrimary[2];
|
|
float GreenPrimary[2];
|
|
float BluePrimary[2];
|
|
float WhitePoint[2];
|
|
float MinLuminance;
|
|
float MaxLuminance;
|
|
float MaxFullFrameLuminance;
|
|
};
|
|
|
|
/**
|
|
* \brief D3D9 extended swapchain
|
|
*/
|
|
MIDL_INTERFACE("13776e93-4aa9-430a-a4ec-fe9e281181d5")
|
|
ID3D9VkExtSwapchain : public IUnknown {
|
|
virtual BOOL STDMETHODCALLTYPE CheckColorSpaceSupport(
|
|
VkColorSpaceKHR ColorSpace) = 0;
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE SetColorSpace(
|
|
VkColorSpaceKHR ColorSpace) = 0;
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE SetHDRMetaData(
|
|
const VkHdrMetadataEXT *pHDRMetadata) = 0;
|
|
|
|
virtual HRESULT STDMETHODCALLTYPE GetCurrentOutputDesc(
|
|
D3D9VkExtOutputMetadata *pOutputDesc) = 0;
|
|
|
|
virtual void STDMETHODCALLTYPE UnlockAdditionalFormats() = 0;
|
|
};
|
|
|
|
#ifndef _MSC_VER
|
|
__CRT_UUID_DECL(ID3D9VkInteropInterface, 0x3461a81b,0xce41,0x485b,0xb6,0xb5,0xfc,0xf0,0x8b,0xa6,0xa6,0xbd);
|
|
__CRT_UUID_DECL(ID3D9VkInteropTexture, 0xd56344f5,0x8d35,0x46fd,0x80,0x6d,0x94,0xc3,0x51,0xb4,0x72,0xc1);
|
|
__CRT_UUID_DECL(ID3D9VkInteropDevice, 0x2eaa4b89,0x0107,0x4bdb,0x87,0xf7,0x0f,0x54,0x1c,0x49,0x3c,0xe0);
|
|
__CRT_UUID_DECL(ID3D9VkExtSwapchain, 0x13776e93,0x4aa9,0x430a,0xa4,0xec,0xfe,0x9e,0x28,0x11,0x81,0xd5);
|
|
#endif
|