wine/vkd3d
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/vkd3d.git synced 2024-11-21 16:46:41 -08:00
Code Issues Packages Projects Releases Wiki Activity
85521c2f82
vkd3d/tests/vkd3d_api.c
Józef Kucia c75f9ee39d vkd3d: Export vkd3d_get_dxgi_format() function. 
Signed-off-by: Józef Kucia <jkucia@codeweavers.com>
Signed-off-by: Henri Verbeet <hverbeet@codeweavers.com>
Signed-off-by: Alexandre Julliard <julliard@winehq.org>
2018-08-29 14:48:45 +02:00

995 lines
35 KiB
C
Raw Blame History

/*
* Copyright 2018 Józef Kucia for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#define COBJMACROS
#define INITGUID
#define WIDL_C_INLINE_WRAPPERS
#include "vkd3d_test.h"
#include <vkd3d.h>
#include "vkd3d_d3d12_test.h"
HRESULT WINAPI D3D12SerializeRootSignature(const D3D12_ROOT_SIGNATURE_DESC *root_signature_desc,
D3D_ROOT_SIGNATURE_VERSION version, ID3DBlob **blob, ID3DBlob **error_blob)
{
return vkd3d_serialize_root_signature(root_signature_desc, version, blob, error_blob);
}
static void wait_queue_idle_(unsigned int line, ID3D12Device *device, ID3D12CommandQueue *queue)
{
VkQueue vk_queue;
vk_queue = vkd3d_acquire_vk_queue(queue);
vkQueueWaitIdle(vk_queue);
vkd3d_release_vk_queue(queue);
}
static ULONG get_refcount(void *iface)
{
IUnknown *unk = iface;
IUnknown_AddRef(unk);
return IUnknown_Release(unk);
}
static ULONG resource_get_internal_refcount(ID3D12Resource *resource)
{
vkd3d_resource_incref(resource);
return vkd3d_resource_decref(resource);
}
static HRESULT signal_event(HANDLE event)
{
trace("Signal event %p.\n", event);
return S_OK;
}
static const struct vkd3d_instance_create_info instance_default_create_info =
{
.type = VKD3D_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
.wchar_size = sizeof(WCHAR),
.pfn_signal_event = signal_event,
};
static const struct vkd3d_device_create_info device_default_create_info =
{
.type = VKD3D_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
.minimum_feature_level = D3D_FEATURE_LEVEL_11_0,
.instance_create_info = &instance_default_create_info,
};
static ID3D12Device *create_device(void)
{
ID3D12Device *device;
HRESULT hr;
hr = vkd3d_create_device(&device_default_create_info,
&IID_ID3D12Device, (void **)&device);
return SUCCEEDED(hr) ? device : NULL;
}
static ID3D12CommandQueue *create_command_queue(ID3D12Device *device,
D3D12_COMMAND_LIST_TYPE type)
{
D3D12_COMMAND_QUEUE_DESC desc;
ID3D12CommandQueue *queue;
HRESULT hr;
desc.Type = type;
desc.Priority = D3D12_COMMAND_QUEUE_PRIORITY_NORMAL;
desc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
desc.NodeMask = 0;
hr = ID3D12Device_CreateCommandQueue(device, &desc,
&IID_ID3D12CommandQueue, (void **)&queue);
ok(hr == S_OK, "Failed to create command queue, hr %#x.\n", hr);
return queue;
}
static void test_create_instance(void)
{
struct vkd3d_instance_create_info create_info;
struct vkd3d_instance *instance;
ULONG refcount;
HRESULT hr;
create_info = instance_default_create_info;
hr = vkd3d_create_instance(&create_info, &instance);
ok(hr == S_OK, "Failed to create instance, hr %#x.\n", hr);
refcount = vkd3d_instance_incref(instance);
ok(refcount == 2, "Got unexpected refcount %u.\n", refcount);
vkd3d_instance_decref(instance);
refcount = vkd3d_instance_decref(instance);
ok(!refcount, "Instance has %u references left.\n", refcount);
create_info = instance_default_create_info;
create_info.wchar_size = 1;
hr = vkd3d_create_instance(&create_info, &instance);
ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr);
create_info = instance_default_create_info;
create_info.pfn_signal_event = NULL;
hr = vkd3d_create_instance(&create_info, &instance);
ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr);
create_info = instance_default_create_info;
create_info.pfn_vkGetInstanceProcAddr = vkGetInstanceProcAddr;
hr = vkd3d_create_instance(&create_info, &instance);
ok(hr == S_OK, "Failed to create instance, hr %#x.\n", hr);
refcount = vkd3d_instance_decref(instance);
ok(!refcount, "Instance has %u references left.\n", refcount);
}
struct vulkan_extension
{
const char *name;
bool is_supported;
};
static uint32_t check_extensions(const char **enabled_extensions,
struct vulkan_extension *extensions, unsigned int extension_count,
const VkExtensionProperties *properties, unsigned int count)
{
uint32_t enabled_extension_count = 0;
unsigned int i, j;
for (i = 0; i < count; ++i)
{
for (j = 0; j < extension_count; ++j)
{
if (!strcmp(properties[i].extensionName, extensions[j].name))
{
extensions[j].is_supported = true;
enabled_extensions[enabled_extension_count++] = extensions[j].name;
}
}
}
return enabled_extension_count;
}
static uint32_t check_instance_extensions(const char **enabled_extensions,
struct vulkan_extension *extensions, unsigned int extension_count)
{
VkExtensionProperties *properties;
uint32_t enabled_extension_count;
uint32_t count;
VkResult vr;
vr = vkEnumerateInstanceExtensionProperties(NULL, &count, NULL);
ok(vr == VK_SUCCESS, "Got unexpected VkResult %d.\n", vr);
if (!count)
return 0;
properties = calloc(count, sizeof(*properties));
ok(properties, "Failed to allocate memory.\n");
vr = vkEnumerateInstanceExtensionProperties(NULL, &count, properties);
ok(vr == VK_SUCCESS, "Got unexpected VkResult %d.\n", vr);
enabled_extension_count = check_extensions(enabled_extensions,
extensions, extension_count, properties, count);
free(properties);
return enabled_extension_count;
}
static uint32_t check_device_extensions(VkPhysicalDevice vk_physical_device,
const char **enabled_extensions, struct vulkan_extension *extensions,
unsigned int extension_count)
{
VkExtensionProperties *properties;
uint32_t enabled_extension_count;
uint32_t count;
VkResult vr;
vr = vkEnumerateDeviceExtensionProperties(vk_physical_device, NULL, &count, NULL);
ok(vr == VK_SUCCESS, "Got unexpected VkResult %d.\n", vr);
if (!count)
return 0;
properties = calloc(count, sizeof(*properties));
ok(properties, "Failed to allocate memory.\n");
vr = vkEnumerateDeviceExtensionProperties(vk_physical_device, NULL, &count, properties);
ok(vr == VK_SUCCESS, "Got unexpected VkResult %d.\n", vr);
enabled_extension_count = check_extensions(enabled_extensions,
extensions, extension_count, properties, count);
free(properties);
return enabled_extension_count;
}
static void test_additional_instance_extensions(void)
{
struct vulkan_extension extensions[] =
{
{VK_KHR_SURFACE_EXTENSION_NAME},
{"VK_KHR_xcb_surface"},
{"VK_KHR_xlib_surface"},
};
const char *enabled_extensions[ARRAY_SIZE(extensions)];
struct vkd3d_instance_create_info create_info;
struct vkd3d_instance *instance;
uint32_t extension_count;
PFN_vkVoidFunction pfn;
VkInstance vk_instance;
unsigned int i;
ULONG refcount;
HRESULT hr;
if (!(extension_count = check_instance_extensions(enabled_extensions,
extensions, ARRAY_SIZE(extensions))))
{
skip("Found 0 extensions.\n");
return;
}
create_info = instance_default_create_info;
create_info.instance_extensions = enabled_extensions;
create_info.instance_extension_count = extension_count;
hr = vkd3d_create_instance(&create_info, &instance);
ok(hr == S_OK, "Failed to create instance, hr %#x.\n", hr);
vk_instance = vkd3d_instance_get_vk_instance(instance);
ok(vk_instance != VK_NULL_HANDLE, "Failed to get Vulkan instance.\n");
for (i = 0; i < ARRAY_SIZE(extensions); ++i)
{
if (!extensions[i].is_supported)
continue;
if (!strcmp(extensions[i].name, "VK_KHR_xcb_surface"))
{
pfn = vkGetInstanceProcAddr(vk_instance, "vkCreateXcbSurfaceKHR");
ok(pfn, "Failed to get proc addr for vkCreateXcbSurfaceKHR.\n");
}
else if (!strcmp(extensions[i].name, "VK_KHR_xlib_surface"))
{
pfn = vkGetInstanceProcAddr(vk_instance, "vkCreateXlibSurfaceKHR");
ok(pfn, "Failed to get proc addr for vkCreateXlibSurfaceKHR.\n");
}
}
refcount = vkd3d_instance_decref(instance);
ok(!refcount, "Instance has %u references left.\n", refcount);
}
static void test_create_device(void)
{
struct vkd3d_instance *instance, *tmp_instance;
struct vkd3d_device_create_info create_info;
ID3D12Device *device;
ULONG refcount;
HRESULT hr;
hr = vkd3d_create_device(NULL, &IID_ID3D12Device, (void **)&device);
ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr);
create_info = device_default_create_info;
create_info.instance = NULL;
create_info.instance_create_info = NULL;
hr = vkd3d_create_device(&create_info, &IID_ID3D12Device, (void **)&device);
ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr);
create_info.instance_create_info = &instance_default_create_info;
hr = vkd3d_create_device(&create_info, &IID_ID3D12Device, (void **)&device);
ok(hr == S_OK, "Failed to create device, hr %#x.\n", hr);
refcount = ID3D12Device_Release(device);
ok(!refcount, "Device has %u references left.\n", refcount);
hr = vkd3d_create_instance(&instance_default_create_info, &instance);
ok(hr == S_OK, "Failed to create instance, hr %#x.\n", hr);
create_info.instance = instance;
create_info.instance_create_info = NULL;
hr = vkd3d_create_device(&create_info, &IID_ID3D12Device, (void **)&device);
ok(hr == S_OK, "Failed to create device, hr %#x.\n", hr);
refcount = vkd3d_instance_incref(instance);
ok(refcount >= 3, "Got unexpected refcount %u.\n", refcount);
vkd3d_instance_decref(instance);
tmp_instance = vkd3d_instance_from_device(device);
ok(tmp_instance == instance, "Got instance %p, expected %p.\n", tmp_instance, instance);
refcount = ID3D12Device_Release(device);
ok(!refcount, "Device has %u references left.\n", refcount);
create_info.instance = instance;
create_info.instance_create_info = &instance_default_create_info;
hr = vkd3d_create_device(&create_info, &IID_ID3D12Device, (void **)&device);
ok(hr == E_INVALIDARG, "Got unexpected hr %#x.\n", hr);
refcount = vkd3d_instance_decref(instance);
ok(!refcount, "Instance has %u references left.\n", refcount);
}
static VkResult VKAPI_CALL fake_vkEnumerateDeviceExtensionProperties(
VkPhysicalDevice physical_device, const char *layer_name,
uint32_t *out_count, VkExtensionProperties *out_properties)
{
VkExtensionProperties *properties;
uint32_t count, i, j;
VkResult vr;
vr = vkEnumerateDeviceExtensionProperties(physical_device, layer_name, &count, NULL);
ok(vr == VK_SUCCESS, "Got unexpected VkResult %d.\n", vr);
if (!count)
{
*out_count = count;
return vr;
}
properties = calloc(count, sizeof(*properties));
ok(properties, "Failed to allocate memory.\n");
vr = vkEnumerateDeviceExtensionProperties(physical_device, layer_name, &count, properties);
ok(vr == VK_SUCCESS, "Got unexpected VkResult %d.\n", vr);
vr = VK_SUCCESS;
for (i = 0, j = 0; i < count; ++i)
{
/* Filter out VK_KHR_maintenance1. */
if (!strcmp(properties[i].extensionName, VK_KHR_MAINTENANCE1_EXTENSION_NAME))
continue;
if (out_properties)
{
if (j < *out_count)
out_properties[j] = properties[i];
else
vr = VK_INCOMPLETE;
}
++j;
}
free(properties);
*out_count = j;
return vr;
}
static VkResult VKAPI_CALL fake_vkCreateDevice(VkPhysicalDevice physical_device,
const VkDeviceCreateInfo *create_info, const VkAllocationCallbacks *allocator,
VkDevice *device)
{
uint32_t i;
for (i = 0; i < create_info->enabledExtensionCount; ++i)
{
if (!strcmp(create_info->ppEnabledExtensionNames[i], VK_KHR_MAINTENANCE1_EXTENSION_NAME))
return VK_ERROR_EXTENSION_NOT_PRESENT;
}
return vkCreateDevice(physical_device, create_info, allocator, device);
}
static PFN_vkVoidFunction VKAPI_CALL fake_vkGetInstanceProcAddr(VkInstance instance,
const char *name)
{
if (!strcmp(name, "vkCreateDevice"))
return (PFN_vkVoidFunction)fake_vkCreateDevice;
if (!strcmp(name, "vkEnumerateDeviceExtensionProperties"))
return (PFN_vkVoidFunction)fake_vkEnumerateDeviceExtensionProperties;
return vkGetInstanceProcAddr(instance, name);
}
static void test_required_device_extensions(void)
{
struct vkd3d_instance_create_info instance_create_info;
struct vkd3d_device_create_info device_create_info;
struct vkd3d_instance *instance;
ID3D12Device *device;
ULONG refcount;
HRESULT hr;
instance_create_info = instance_default_create_info;
instance_create_info.pfn_vkGetInstanceProcAddr = fake_vkGetInstanceProcAddr;
hr = vkd3d_create_instance(&instance_create_info, &instance);
ok(hr == S_OK, "Failed to create instance, hr %#x.\n", hr);
device_create_info = device_default_create_info;
device_create_info.instance = instance;
device_create_info.instance_create_info = NULL;
hr = vkd3d_create_device(&device_create_info, &IID_ID3D12Device, (void **)&device);
ok(hr == E_FAIL, "Failed to create device, hr %#x.\n", hr);
refcount = vkd3d_instance_decref(instance);
ok(!refcount, "Instance has %u references left.\n", refcount);
}
static void test_additional_device_extensions(void)
{
struct vulkan_extension extensions[] =
{
{VK_KHR_SWAPCHAIN_EXTENSION_NAME},
};
struct vkd3d_instance_create_info instance_create_info;
const char *enabled_extensions[ARRAY_SIZE(extensions)];
struct vkd3d_device_create_info device_create_info;
VkPhysicalDevice vk_physical_device;
struct vkd3d_instance *instance;
uint32_t extension_count;
PFN_vkVoidFunction pfn;
VkInstance vk_instance;
ID3D12Device *device;
VkDevice vk_device;
uint32_t count;
ULONG refcount;
VkResult vr;
HRESULT hr;
/* Required by VK_KHR_swapchain. */
enabled_extensions[0] = VK_KHR_SURFACE_EXTENSION_NAME;
extension_count = 1;
instance_create_info = instance_default_create_info;
instance_create_info.instance_extensions = enabled_extensions;
instance_create_info.instance_extension_count = extension_count;
if (FAILED(hr = vkd3d_create_instance(&instance_create_info, &instance)))
{
skip("Failed to create instance, hr %#x.\n", hr);
return;
}
ok(hr == S_OK, "Failed to create instance, hr %#x.\n", hr);
vk_instance = vkd3d_instance_get_vk_instance(instance);
ok(vk_instance != VK_NULL_HANDLE, "Failed to get Vulkan instance.\n");
vr = vkEnumeratePhysicalDevices(vk_instance, &count, NULL);
ok(vr == VK_SUCCESS, "Got unexpected VkResult %d.\n", vr);
count = 1;
vr = vkEnumeratePhysicalDevices(vk_instance, &count, &vk_physical_device);
ok(vr == VK_SUCCESS || vr == VK_INCOMPLETE, "Got unexpected VkResult %d.\n", vr);
if (!(extension_count = check_device_extensions(vk_physical_device,
enabled_extensions, extensions, ARRAY_SIZE(extensions))))
{
skip("%s is not available.\n", VK_KHR_SWAPCHAIN_EXTENSION_NAME);
vkd3d_instance_decref(instance);
return;
}
device_create_info = device_default_create_info;
device_create_info.instance = instance;
device_create_info.instance_create_info = NULL;
device_create_info.vk_physical_device = vk_physical_device;
device_create_info.device_extensions = enabled_extensions;
device_create_info.device_extension_count = extension_count;
hr = vkd3d_create_device(&device_create_info, &IID_ID3D12Device, (void **)&device);
ok(hr == S_OK, "Failed to create device, hr %#x.\n", hr);
vk_device = vkd3d_get_vk_device(device);
pfn = vkGetDeviceProcAddr(vk_device, "vkCreateSwapchainKHR");
ok(pfn, "Failed to get proc addr for vkCreateSwapchainKHR.\n");
refcount = ID3D12Device_Release(device);
ok(!refcount, "Device has %u references left.\n", refcount);
refcount = vkd3d_instance_decref(instance);
ok(!refcount, "Instance has %u references left.\n", refcount);
}
static void test_physical_device(void)
{
struct vkd3d_device_create_info create_info;
VkPhysicalDevice *vk_physical_devices;
VkPhysicalDevice vk_physical_device;
struct vkd3d_instance *instance;
VkInstance vk_instance;
ID3D12Device *device;
uint32_t i, count;
ULONG refcount;
VkResult vr;
HRESULT hr;
hr = vkd3d_create_instance(&instance_default_create_info, &instance);
ok(hr == S_OK, "Failed to create instance, hr %#x.\n", hr);
vk_instance = vkd3d_instance_get_vk_instance(instance);
ok(vk_instance != VK_NULL_HANDLE, "Failed to get Vulkan instance.\n");
create_info = device_default_create_info;
create_info.instance = instance;
create_info.instance_create_info = NULL;
create_info.vk_physical_device = VK_NULL_HANDLE;
hr = vkd3d_create_device(&create_info, &IID_ID3D12Device, (void **)&device);
ok(hr == S_OK, "Failed to create device, hr %#x.\n", hr);
vk_physical_device = vkd3d_get_vk_physical_device(device);
trace("Default Vulkan physical device %p.\n", vk_physical_device);
refcount = ID3D12Device_Release(device);
ok(!refcount, "Device has %u references left.\n", refcount);
vr = vkEnumeratePhysicalDevices(vk_instance, &count, NULL);
ok(vr == VK_SUCCESS, "Got unexpected VkResult %d.\n", vr);
vk_physical_devices = calloc(count, sizeof(*vk_physical_devices));
ok(vk_physical_devices, "Failed to allocate memory.\n");
vr = vkEnumeratePhysicalDevices(vk_instance, &count, vk_physical_devices);
ok(vr == VK_SUCCESS, "Got unexpected VkResult %d.\n", vr);
for (i = 0; i < count; ++i)
{
trace("Creating device for Vulkan physical device %p.\n", vk_physical_devices[i]);
create_info.vk_physical_device = vk_physical_devices[i];
hr = vkd3d_create_device(&create_info, &IID_ID3D12Device, (void **)&device);
ok(hr == S_OK, "Failed to create device, hr %#x.\n", hr);
vk_physical_device = vkd3d_get_vk_physical_device(device);
ok(vk_physical_device == vk_physical_devices[i],
"Got unexpected Vulkan physical device %p.\n", vk_physical_device);
refcount = ID3D12Device_Release(device);
ok(!refcount, "Device has %u references left.\n", refcount);
}
free(vk_physical_devices);
refcount = vkd3d_instance_decref(instance);
ok(!refcount, "Instance has %u references left.\n", refcount);
}
static void test_adapter_luid(void)
{
struct vkd3d_device_create_info create_info;
ID3D12Device *device;
ULONG refcount;
HRESULT hr;
LUID luid;
create_info = device_default_create_info;
create_info.adapter_luid.HighPart = 0xdeadc0de;
create_info.adapter_luid.LowPart = 0xdeadbeef;
hr = vkd3d_create_device(&create_info, &IID_ID3D12Device, (void **)&device);
ok(hr == S_OK, "Failed to create device, hr %#x.\n", hr);
luid = ID3D12Device_GetAdapterLuid(device);
ok(luid.HighPart == 0xdeadc0de && luid.LowPart == 0xdeadbeef,
"Got unexpected LUID %08x:%08x.\n", luid.HighPart, luid.LowPart);
refcount = ID3D12Device_Release(device);
ok(!refcount, "Device has %u references left.\n", refcount);
}
struct parent
{
IUnknown IUnknown_iface;
LONG refcount;
};
static struct parent *parent_from_IUnknown(IUnknown *iface)
{
return CONTAINING_RECORD(iface, struct parent, IUnknown_iface);
}
static HRESULT STDMETHODCALLTYPE parent_QueryInterface(IUnknown *iface,
REFIID iid, void **object)
{
if (IsEqualGUID(iid, &IID_IUnknown))
{
IUnknown_AddRef(iface);
*object = iface;
return S_OK;
}
ok(false, "Unexpected QueryInterface() call.\n");
return E_NOINTERFACE;
}
static ULONG STDMETHODCALLTYPE parent_AddRef(IUnknown *iface)
{
struct parent *parent = parent_from_IUnknown(iface);
return InterlockedIncrement(&parent->refcount);
}
static ULONG STDMETHODCALLTYPE parent_Release(IUnknown *iface)
{
struct parent *parent = parent_from_IUnknown(iface);
return InterlockedDecrement(&parent->refcount);
}
static const struct IUnknownVtbl parent_vtbl =
{
parent_QueryInterface,
parent_AddRef,
parent_Release,
};
static void test_device_parent(void)
{
struct vkd3d_device_create_info create_info;
struct parent parent_impl;
ID3D12Device *device;
IUnknown *unknown;
IUnknown *parent;
ULONG refcount;
HRESULT hr;
parent_impl.IUnknown_iface.lpVtbl = &parent_vtbl;
parent_impl.refcount = 1;
parent = &parent_impl.IUnknown_iface;
refcount = get_refcount(parent);
ok(refcount == 1, "Got unexpected refcount %u.\n", refcount);
create_info = device_default_create_info;
create_info.parent = parent;
hr = vkd3d_create_device(&create_info, &IID_ID3D12Device, (void **)&device);
ok(hr == S_OK, "Failed to create device, hr %#x.\n", hr);
refcount = get_refcount(parent);
ok(refcount == 2, "Got unexpected refcount %u.\n", refcount);
unknown = vkd3d_get_device_parent(device);
ok(unknown == parent, "Got device parent %p, expected %p.\n", unknown, parent);
refcount = ID3D12Device_Release(device);
ok(!refcount, "Device has %u references left.\n", refcount);
refcount = get_refcount(parent);
ok(refcount == 1, "Got unexpected refcount %u.\n", refcount);
}
static void test_vkd3d_queue(void)
{
ID3D12CommandQueue *direct_queue, *compute_queue, *copy_queue;
uint32_t vk_queue_family;
ID3D12Device *device;
VkQueue vk_queue;
ULONG refcount;
device = create_device();
ok(device, "Failed to create device.\n");
direct_queue = create_command_queue(device, D3D12_COMMAND_LIST_TYPE_DIRECT);
ok(direct_queue, "Failed to create direct command queue.\n");
compute_queue = create_command_queue(device, D3D12_COMMAND_LIST_TYPE_COMPUTE);
ok(compute_queue, "Failed to create compute command queue.\n");
copy_queue = create_command_queue(device, D3D12_COMMAND_LIST_TYPE_COPY);
ok(copy_queue, "Failed to create copy command queue.\n");
vk_queue_family = vkd3d_get_vk_queue_family_index(direct_queue);
trace("Direct queue family index %u.\n", vk_queue_family);
vk_queue_family = vkd3d_get_vk_queue_family_index(compute_queue);
trace("Compute queue family index %u.\n", vk_queue_family);
vk_queue_family = vkd3d_get_vk_queue_family_index(copy_queue);
trace("Copy queue family index %u.\n", vk_queue_family);
vk_queue = vkd3d_acquire_vk_queue(direct_queue);
ok(vk_queue != VK_NULL_HANDLE, "Failed to acquire Vulkan queue.\n");
vkd3d_release_vk_queue(direct_queue);
vk_queue = vkd3d_acquire_vk_queue(compute_queue);
ok(vk_queue != VK_NULL_HANDLE, "Failed to acquire Vulkan queue.\n");
vkd3d_release_vk_queue(compute_queue);
vk_queue = vkd3d_acquire_vk_queue(copy_queue);
ok(vk_queue != VK_NULL_HANDLE, "Failed to acquire Vulkan queue.\n");
vkd3d_release_vk_queue(copy_queue);
ID3D12CommandQueue_Release(direct_queue);
ID3D12CommandQueue_Release(compute_queue);
ID3D12CommandQueue_Release(copy_queue);
refcount = ID3D12Device_Release(device);
ok(!refcount, "Device has %u references left.\n", refcount);
}
static void test_resource_internal_refcount(void)
{
ID3D12Resource *resource;
ID3D12Device *device;
ULONG refcount;
device = create_device();
ok(device, "Failed to create device.\n");
resource = create_buffer(device, D3D12_HEAP_TYPE_UPLOAD, 1024,
D3D12_RESOURCE_FLAG_NONE, D3D12_RESOURCE_STATE_GENERIC_READ);
refcount = vkd3d_resource_incref(resource);
ok(refcount == 2, "Got refcount %u.\n", refcount);
refcount = ID3D12Resource_Release(resource);
ok(!refcount, "Got refcount %u.\n", refcount);
refcount = resource_get_internal_refcount(resource);
ok(refcount == 1, "Got refcount %u.\n", refcount);
refcount = vkd3d_resource_decref(resource);
ok(!refcount, "Got refcount %u.\n", refcount);
resource = create_buffer(device, D3D12_HEAP_TYPE_UPLOAD, 1024,
D3D12_RESOURCE_FLAG_NONE, D3D12_RESOURCE_STATE_GENERIC_READ);
refcount = vkd3d_resource_incref(resource);
ok(refcount == 2, "Got refcount %u.\n", refcount);
refcount = ID3D12Resource_Release(resource);
ok(!refcount, "Got refcount %u.\n", refcount);
refcount = resource_get_internal_refcount(resource);
ok(refcount == 1, "Got refcount %u.\n", refcount);
refcount = ID3D12Resource_AddRef(resource);
ok(refcount == 1, "Got refcount %u.\n", refcount);
refcount = vkd3d_resource_decref(resource);
ok(refcount == 1, "Got refcount %u.\n", refcount);
refcount = ID3D12Resource_Release(resource);
ok(!refcount, "Got refcount %u.\n", refcount);
refcount = ID3D12Device_Release(device);
ok(!refcount, "Device has %u references left.\n", refcount);
}
static VkImage create_vulkan_image(ID3D12Device *device,
unsigned int width, unsigned int height, VkFormat vk_format, VkImageUsageFlags usage)
{
VkImageCreateInfo image_info;
VkDevice vk_device;
VkImage vk_image;
VkResult vr;
vk_device = vkd3d_get_vk_device(device);
image_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
image_info.pNext = NULL;
image_info.imageType = VK_IMAGE_TYPE_2D;
image_info.format = vk_format;
image_info.extent.width = width;
image_info.extent.height = height;
image_info.extent.depth = 1;
image_info.arrayLayers = 1;
image_info.mipLevels = 1;
image_info.samples = VK_SAMPLE_COUNT_1_BIT;
image_info.tiling = VK_IMAGE_TILING_OPTIMAL;
image_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
image_info.usage |= usage;
image_info.flags = 0;
image_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
image_info.queueFamilyIndexCount = 0;
image_info.pQueueFamilyIndices = NULL;
image_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
vr = vkCreateImage(vk_device, &image_info, NULL, &vk_image);
ok(vr == VK_SUCCESS, "Failed to create image, vr %d.\n", vr);
return vk_image;
}
static unsigned int select_vulkan_memory_type(ID3D12Device *device,
uint32_t memory_type_mask, VkMemoryPropertyFlags required_flags)
{
VkPhysicalDeviceMemoryProperties memory_info;
VkPhysicalDevice vk_physical_device;
unsigned int i;
vk_physical_device = vkd3d_get_vk_physical_device(device);
vkGetPhysicalDeviceMemoryProperties(vk_physical_device, &memory_info);
for (i = 0; i < memory_info.memoryTypeCount; ++i)
{
if (!(memory_type_mask & (1u << i)))
continue;
if ((memory_info.memoryTypes[i].propertyFlags & required_flags) == required_flags)
return i;
}
return ~0u;
}
static VkDeviceMemory allocate_vulkan_device_memory(ID3D12Device *device,
VkMemoryPropertyFlags required_flags, const VkMemoryRequirements *memory_requirements)
{
VkMemoryAllocateInfo allocate_info;
VkDeviceMemory vk_memory;
VkDevice vk_device;
VkResult vr;
vk_device = vkd3d_get_vk_device(device);
allocate_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
allocate_info.pNext = NULL;
allocate_info.allocationSize = memory_requirements->size;
allocate_info.memoryTypeIndex = select_vulkan_memory_type(device,
memory_requirements->memoryTypeBits, required_flags);
ok(allocate_info.memoryTypeIndex != ~0u, "Failed to find memory type.\n");
vr = vkAllocateMemory(vk_device, &allocate_info, NULL, &vk_memory);
ok(vr == VK_SUCCESS, "Got unexpected VkResult %d.\n", vr);
return vk_memory;
}
static VkDeviceMemory allocate_vulkan_image_memory(ID3D12Device *device,
VkMemoryPropertyFlags required_flags, VkImage vk_image)
{
VkMemoryRequirements memory_requirements;
VkDeviceMemory vk_memory;
VkDevice vk_device;
VkResult vr;
vk_device = vkd3d_get_vk_device(device);
vkGetImageMemoryRequirements(vk_device, vk_image, &memory_requirements);
vk_memory = allocate_vulkan_device_memory(device, required_flags, &memory_requirements);
vr = vkBindImageMemory(vk_device, vk_image, vk_memory, 0);
ok(vr == VK_SUCCESS, "Got unexpected VkResult %d.\n", vr);
return vk_memory;
}
static void test_vulkan_resource_present_state(void)
{
static const float white[] = {1.0f, 1.0f, 1.0f, 1.0f};
struct vkd3d_image_resource_create_info resource_create_info;
ID3D12GraphicsCommandList *command_list;
ID3D12Resource *vk_resource, *resource;
D3D12_CPU_DESCRIPTOR_HANDLE rtv;
struct test_context_desc desc;
struct test_context context;
ID3D12CommandQueue *queue;
VkDeviceMemory vk_memory;
ID3D12Device *device;
VkDevice vk_device;
VkImage vk_image;
HRESULT hr;
memset(&desc, 0, sizeof(desc));
desc.rt_width = desc.rt_height = 32;
if (!init_test_context(&context, &desc))
return;
device = context.device;
command_list = context.list;
queue = context.queue;
resource = create_default_texture(device, 32, 32, DXGI_FORMAT_R8G8B8A8_UNORM,
D3D12_RESOURCE_FLAG_NONE, D3D12_RESOURCE_STATE_COPY_DEST);
vk_image = create_vulkan_image(device, 32, 32,
VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
vk_memory = allocate_vulkan_image_memory(device,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, vk_image);
resource_create_info.type = VKD3D_STRUCTURE_TYPE_IMAGE_RESOURCE_CREATE_INFO;
resource_create_info.next = NULL;
resource_create_info.vk_image = vk_image;
resource_create_info.desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
resource_create_info.desc.Alignment = 0;
resource_create_info.desc.Width = 32;
resource_create_info.desc.Height = 32;
resource_create_info.desc.DepthOrArraySize = 1;
resource_create_info.desc.MipLevels = 1;
resource_create_info.desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
resource_create_info.desc.SampleDesc.Count = 1;
resource_create_info.desc.SampleDesc.Quality = 0;
resource_create_info.desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
resource_create_info.desc.Flags = D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
resource_create_info.flags = VKD3D_RESOURCE_INITIAL_STATE_TRANSITION | VKD3D_RESOURCE_PRESENT_STATE_TRANSITION;
resource_create_info.present_state = D3D12_RESOURCE_STATE_COPY_SOURCE;
hr = vkd3d_create_image_resource(device, &resource_create_info, &vk_resource);
ok(hr == S_OK, "Failed to create D3D12 resource for Vulkan image, hr %#x.\n", hr);
rtv = get_cpu_descriptor_handle(&context, context.rtv_heap, 0);
ID3D12Device_CreateRenderTargetView(device, vk_resource, NULL, rtv);
transition_resource_state(command_list, vk_resource,
D3D12_RESOURCE_STATE_PRESENT, D3D12_RESOURCE_STATE_RENDER_TARGET);
ID3D12GraphicsCommandList_ClearRenderTargetView(command_list, rtv, white, 0, NULL);
ID3D12GraphicsCommandList_OMSetRenderTargets(command_list, 1, &rtv, FALSE, NULL);
ID3D12GraphicsCommandList_SetGraphicsRootSignature(command_list, context.root_signature);
ID3D12GraphicsCommandList_SetPipelineState(command_list, context.pipeline_state);
ID3D12GraphicsCommandList_IASetPrimitiveTopology(command_list, D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
ID3D12GraphicsCommandList_RSSetViewports(command_list, 1, &context.viewport);
ID3D12GraphicsCommandList_RSSetScissorRects(command_list, 1, &context.scissor_rect);
ID3D12GraphicsCommandList_DrawInstanced(command_list, 3, 1, 0, 0);
transition_resource_state(command_list, vk_resource,
D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_PRESENT);
ID3D12GraphicsCommandList_CopyResource(command_list, resource, vk_resource);
transition_resource_state(command_list, resource,
D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_COPY_SOURCE);
check_sub_resource_uint(resource, 0, queue, command_list, 0xff00ff00, 0);
ID3D12Resource_Release(vk_resource);
vk_device = vkd3d_get_vk_device(device);
vkDestroyImage(vk_device, vk_image, NULL);
vkFreeMemory(vk_device, vk_memory, NULL);
ID3D12Resource_Release(resource);
destroy_test_context(&context);
}
static void test_formats(void)
{
DXGI_FORMAT dxgi_format, format;
VkFormat vk_format;
unsigned int i;
static const DXGI_FORMAT formats[] =
{
DXGI_FORMAT_R32G32B32A32_FLOAT,
DXGI_FORMAT_R32G32B32A32_UINT,
DXGI_FORMAT_R32G32B32A32_SINT,
DXGI_FORMAT_R32G32B32_FLOAT,
DXGI_FORMAT_R32G32B32_UINT,
DXGI_FORMAT_R32G32B32_SINT,
DXGI_FORMAT_R16G16B16A16_FLOAT,
DXGI_FORMAT_R16G16B16A16_UNORM,
DXGI_FORMAT_R16G16B16A16_UINT,
DXGI_FORMAT_R16G16B16A16_SNORM,
DXGI_FORMAT_R16G16B16A16_SINT,
DXGI_FORMAT_R32G32_FLOAT,
DXGI_FORMAT_R32G32_UINT,
DXGI_FORMAT_R32G32_SINT,
DXGI_FORMAT_R10G10B10A2_UNORM,
DXGI_FORMAT_R11G11B10_FLOAT,
DXGI_FORMAT_R8G8B8A8_UNORM,
DXGI_FORMAT_R8G8B8A8_UNORM_SRGB,
DXGI_FORMAT_R8G8B8A8_UINT,
DXGI_FORMAT_R8G8B8A8_SNORM,
DXGI_FORMAT_R8G8B8A8_SINT,
DXGI_FORMAT_R16G16_FLOAT,
DXGI_FORMAT_R16G16_UNORM,
DXGI_FORMAT_R16G16_UINT,
DXGI_FORMAT_R16G16_SNORM,
DXGI_FORMAT_R16G16_SINT,
DXGI_FORMAT_D32_FLOAT,
DXGI_FORMAT_R32_FLOAT,
DXGI_FORMAT_R32_UINT,
DXGI_FORMAT_R32_SINT,
DXGI_FORMAT_R8G8_UNORM,
DXGI_FORMAT_R8G8_UINT,
DXGI_FORMAT_R8G8_SNORM,
DXGI_FORMAT_R8G8_SINT,
DXGI_FORMAT_R16_FLOAT,
DXGI_FORMAT_D16_UNORM,
DXGI_FORMAT_R16_UNORM,
DXGI_FORMAT_R16_UINT,
DXGI_FORMAT_R16_SNORM,
DXGI_FORMAT_R16_SINT,
DXGI_FORMAT_R8_UNORM,
DXGI_FORMAT_R8_UINT,
DXGI_FORMAT_R8_SNORM,
DXGI_FORMAT_R8_SINT,
};
for (i = 0; i < ARRAY_SIZE(formats); ++i)
{
format = formats[i];
vk_format = vkd3d_get_vk_format(format);
dxgi_format = vkd3d_get_dxgi_format(vk_format);
ok(dxgi_format == format, "Got format %#x, expected %#x.\n", dxgi_format, format);
}
}
static bool have_d3d12_device(void)
{
ID3D12Device *device;
if ((device = create_device()))
ID3D12Device_Release(device);
return device;
}
START_TEST(vkd3d_api)
{
if (!have_d3d12_device())
{
skip("D3D12 device cannot be created.\n");
return;
}
run_test(test_create_instance);
run_test(test_additional_instance_extensions);
run_test(test_create_device);
run_test(test_required_device_extensions);
run_test(test_additional_device_extensions);
run_test(test_physical_device);
run_test(test_adapter_luid);
run_test(test_device_parent);
run_test(test_vkd3d_queue);
run_test(test_resource_internal_refcount);
run_test(test_vulkan_resource_present_state);
run_test(test_formats);
}
Reference in New Issue View Git Blame Copy Permalink