1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
|
#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;
};
#ifdef _MSC_VER
struct __declspec(uuid("3461a81b-ce41-485b-b6b5-fcf08ba6a6bd")) ID3D9VkInteropInterface;
struct __declspec(uuid("d56344f5-8d35-46fd-806d-94c351b472c1")) ID3D9VkInteropTexture;
struct __declspec(uuid("2eaa4b89-0107-4bdb-87f7-0f541c493ce0")) ID3D9VkInteropDevice;
struct __declspec(uuid("13776e93-4aa9-430a-a4ec-fe9e281181d5")) ID3D9VkExtSwapchain;
#else
__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
|
