April 2019 - Wine-Devel - list.winehq.org

[PATCH vkd3d 5/5] vkd3d: Enable VK_EXT_descriptor_indexing.
by Józef Kucia April 2, 2019

April 2, 2019

From: Józef Kucia <jkucia(a)codeweavers.com> This extension brings dynamic indexing for all descriptor types and the update after bind feature. VK_KHR_maintenance3 is required by VK_EXT_descriptor_indexing. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d/device.c | 164 ++++++++++++++++++++++++++++++++++++- libs/vkd3d/vkd3d_private.h | 2 + libs/vkd3d/vulkan_procs.h | 3 + 3 files changed, 168 insertions(+), 1 deletion(-) diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index 9b18bc909751..a754077226b8 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -91,7 +91,7 @@ struct vk_struct }; #define vk_find_struct(c, t) vk_find_struct_(c, VK_STRUCTURE_TYPE_##t) -static const void *vk_find_struct_(struct vk_struct *chain, VkStructureType sType) +static void *vk_find_struct_(struct vk_struct *chain, VkStructureType sType) { while (chain) { @@ -113,8 +113,10 @@ struct vkd3d_optional_extension_info static const struct vkd3d_optional_extension_info optional_instance_extensions[] = { + /* KHR extensions */ {VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, offsetof(struct vkd3d_vulkan_info, KHR_get_physical_device_properties2)}, + /* EXT extensions */ {VK_EXT_DEBUG_REPORT_EXTENSION_NAME, offsetof(struct vkd3d_vulkan_info, EXT_debug_report), true}, }; @@ -126,10 +128,14 @@ static const char * const required_device_extensions[] = static const struct vkd3d_optional_extension_info optional_device_extensions[] = { + /* KHR extensions */ {VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, offsetof(struct vkd3d_vulkan_info, KHR_dedicated_allocation)}, {VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, offsetof(struct vkd3d_vulkan_info, KHR_get_memory_requirements2)}, + {VK_KHR_MAINTENANCE3_EXTENSION_NAME, offsetof(struct vkd3d_vulkan_info, KHR_maintenance3)}, {VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME, offsetof(struct vkd3d_vulkan_info, KHR_push_descriptor)}, + /* EXT extensions */ {VK_EXT_DEBUG_MARKER_EXTENSION_NAME, offsetof(struct vkd3d_vulkan_info, EXT_debug_marker)}, + {VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME, offsetof(struct vkd3d_vulkan_info, EXT_descriptor_indexing)}, {VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME, offsetof(struct vkd3d_vulkan_info, EXT_transform_feedback)}, {VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME, @@ -677,7 +683,9 @@ static void vkd3d_trace_physical_device(VkPhysicalDevice device, static void vkd3d_trace_physical_device_limits(const VkPhysicalDeviceProperties2KHR *properties2) { const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT *divisor_properties; + const VkPhysicalDeviceDescriptorIndexingPropertiesEXT *descriptor_indexing; const VkPhysicalDeviceLimits *limits = &properties2->properties.limits; + const VkPhysicalDeviceMaintenance3Properties *maintenance3; const VkPhysicalDeviceTransformFeedbackPropertiesEXT *xfb; TRACE("Device limits:\n"); @@ -797,6 +805,71 @@ static void vkd3d_trace_physical_device_limits(const VkPhysicalDeviceProperties2 TRACE(" optimalBufferCopyRowPitchAlignment: %#"PRIx64".\n", limits->optimalBufferCopyRowPitchAlignment); TRACE(" nonCoherentAtomSize: %#"PRIx64".\n", limits->nonCoherentAtomSize); + descriptor_indexing = vk_find_struct(properties2->pNext, PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT); + if (descriptor_indexing) + { + TRACE(" VkPhysicalDeviceDescriptorIndexingPropertiesEXT:\n"); + + TRACE(" maxUpdateAfterBindDescriptorsInAllPools: %u.\n", + descriptor_indexing->maxUpdateAfterBindDescriptorsInAllPools); + + TRACE(" shaderUniformBufferArrayNonUniformIndexingNative: %#x.\n", + descriptor_indexing->shaderUniformBufferArrayNonUniformIndexingNative); + TRACE(" shaderSampledImageArrayNonUniformIndexingNative: %#x.\n", + descriptor_indexing->shaderSampledImageArrayNonUniformIndexingNative); + TRACE(" shaderStorageBufferArrayNonUniformIndexingNative: %#x.\n", + descriptor_indexing->shaderStorageBufferArrayNonUniformIndexingNative); + TRACE(" shaderStorageImageArrayNonUniformIndexingNative: %#x.\n", + descriptor_indexing->shaderStorageImageArrayNonUniformIndexingNative); + TRACE(" shaderInputAttachmentArrayNonUniformIndexingNative: %#x.\n", + descriptor_indexing->shaderInputAttachmentArrayNonUniformIndexingNative); + + TRACE(" robustBufferAccessUpdateAfterBind: %#x.\n", + descriptor_indexing->robustBufferAccessUpdateAfterBind); + TRACE(" quadDivergentImplicitLod: %#x.\n", + descriptor_indexing->quadDivergentImplicitLod); + + TRACE(" maxPerStageDescriptorUpdateAfterBindSamplers: %u.\n", + descriptor_indexing->maxPerStageDescriptorUpdateAfterBindSamplers); + TRACE(" maxPerStageDescriptorUpdateAfterBindUniformBuffers: %u.\n", + descriptor_indexing->maxPerStageDescriptorUpdateAfterBindUniformBuffers); + TRACE(" maxPerStageDescriptorUpdateAfterBindStorageBuffers: %u.\n", + descriptor_indexing->maxPerStageDescriptorUpdateAfterBindStorageBuffers); + TRACE(" maxPerStageDescriptorUpdateAfterBindSampledImages: %u.\n", + descriptor_indexing->maxPerStageDescriptorUpdateAfterBindSampledImages); + TRACE(" maxPerStageDescriptorUpdateAfterBindStorageImages: %u.\n", + descriptor_indexing->maxPerStageDescriptorUpdateAfterBindStorageImages); + TRACE(" maxPerStageDescriptorUpdateAfterBindInputAttachments: %u.\n", + descriptor_indexing->maxPerStageDescriptorUpdateAfterBindInputAttachments); + TRACE(" maxPerStageUpdateAfterBindResources: %u.\n", + descriptor_indexing->maxPerStageUpdateAfterBindResources); + + TRACE(" maxDescriptorSetUpdateAfterBindSamplers: %u.\n", + descriptor_indexing->maxDescriptorSetUpdateAfterBindSamplers); + TRACE(" maxDescriptorSetUpdateAfterBindUniformBuffers: %u.\n", + descriptor_indexing->maxDescriptorSetUpdateAfterBindUniformBuffers); + TRACE(" maxDescriptorSetUpdateAfterBindUniformBuffersDynamic: %u.\n", + descriptor_indexing->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic); + TRACE(" maxDescriptorSetUpdateAfterBindStorageBuffers: %u.\n", + descriptor_indexing->maxDescriptorSetUpdateAfterBindStorageBuffers); + TRACE(" maxDescriptorSetUpdateAfterBindStorageBuffersDynamic: %u.\n", + descriptor_indexing->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic); + TRACE(" maxDescriptorSetUpdateAfterBindSampledImages: %u.\n", + descriptor_indexing->maxDescriptorSetUpdateAfterBindSampledImages); + TRACE(" maxDescriptorSetUpdateAfterBindStorageImages: %u.\n", + descriptor_indexing->maxDescriptorSetUpdateAfterBindStorageImages); + TRACE(" maxDescriptorSetUpdateAfterBindInputAttachments: %u.\n", + descriptor_indexing->maxDescriptorSetUpdateAfterBindInputAttachments); + } + + maintenance3 = vk_find_struct(properties2->pNext, PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES); + if (maintenance3) + { + TRACE(" VkPhysicalDeviceMaintenance3Properties:\n"); + TRACE(" maxPerSetDescriptors: %u.\n", maintenance3->maxPerSetDescriptors); + TRACE(" maxMemoryAllocationSize: %#"PRIx64".\n", maintenance3->maxMemoryAllocationSize); + } + xfb = vk_find_struct(properties2->pNext, PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT); if (xfb) { @@ -825,6 +898,7 @@ static void vkd3d_trace_physical_device_limits(const VkPhysicalDeviceProperties2 static void vkd3d_trace_physical_device_features(const VkPhysicalDeviceFeatures2KHR *features2) { const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *divisor_features; + const VkPhysicalDeviceDescriptorIndexingFeaturesEXT *descriptor_indexing; const VkPhysicalDeviceFeatures *features = &features2->features; const VkPhysicalDeviceTransformFeedbackFeaturesEXT *xfb; @@ -885,6 +959,56 @@ static void vkd3d_trace_physical_device_features(const VkPhysicalDeviceFeatures2 TRACE(" variableMultisampleRate: %#x.\n", features->variableMultisampleRate); TRACE(" inheritedQueries: %#x.\n", features->inheritedQueries); + descriptor_indexing = vk_find_struct(features2->pNext, PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT); + if (descriptor_indexing) + { + TRACE(" VkPhysicalDeviceDescriptorIndexingFeaturesEXT:\n"); + + TRACE(" shaderInputAttachmentArrayDynamicIndexing: %#x.\n", + descriptor_indexing->shaderInputAttachmentArrayDynamicIndexing); + TRACE(" shaderUniformTexelBufferArrayDynamicIndexing: %#x.\n", + descriptor_indexing->shaderUniformTexelBufferArrayDynamicIndexing); + TRACE(" shaderStorageTexelBufferArrayDynamicIndexing: %#x.\n", + descriptor_indexing->shaderStorageTexelBufferArrayDynamicIndexing); + + TRACE(" shaderUniformBufferArrayNonUniformIndexing: %#x.\n", + descriptor_indexing->shaderUniformBufferArrayNonUniformIndexing); + TRACE(" shaderSampledImageArrayNonUniformIndexing: %#x.\n", + descriptor_indexing->shaderSampledImageArrayNonUniformIndexing); + TRACE(" shaderStorageBufferArrayNonUniformIndexing: %#x.\n", + descriptor_indexing->shaderStorageBufferArrayNonUniformIndexing); + TRACE(" shaderStorageImageArrayNonUniformIndexing: %#x.\n", + descriptor_indexing->shaderStorageImageArrayNonUniformIndexing); + TRACE(" shaderInputAttachmentArrayNonUniformIndexing: %#x.\n", + descriptor_indexing->shaderInputAttachmentArrayNonUniformIndexing); + TRACE(" shaderUniformTexelBufferArrayNonUniformIndexing: %#x.\n", + descriptor_indexing->shaderUniformTexelBufferArrayNonUniformIndexing); + TRACE(" shaderStorageTexelBufferArrayNonUniformIndexing: %#x.\n", + descriptor_indexing->shaderStorageTexelBufferArrayNonUniformIndexing); + + TRACE(" descriptorBindingUniformBufferUpdateAfterBind: %#x.\n", + descriptor_indexing->descriptorBindingUniformBufferUpdateAfterBind); + TRACE(" descriptorBindingSampledImageUpdateAfterBind: %#x.\n", + descriptor_indexing->descriptorBindingSampledImageUpdateAfterBind); + TRACE(" descriptorBindingStorageImageUpdateAfterBind: %#x.\n", + descriptor_indexing->descriptorBindingStorageImageUpdateAfterBind); + TRACE(" descriptorBindingStorageBufferUpdateAfterBind: %#x.\n", + descriptor_indexing->descriptorBindingStorageBufferUpdateAfterBind); + TRACE(" descriptorBindingUniformTexelBufferUpdateAfterBind: %#x.\n", + descriptor_indexing->descriptorBindingUniformTexelBufferUpdateAfterBind); + TRACE(" descriptorBindingStorageTexelBufferUpdateAfterBind: %#x.\n", + descriptor_indexing->descriptorBindingStorageTexelBufferUpdateAfterBind); + + TRACE(" descriptorBindingUpdateUnusedWhilePending: %#x.\n", + descriptor_indexing->descriptorBindingUpdateUnusedWhilePending); + TRACE(" descriptorBindingPartiallyBound: %#x.\n", + descriptor_indexing->descriptorBindingPartiallyBound); + TRACE(" descriptorBindingVariableDescriptorCount: %#x.\n", + descriptor_indexing->descriptorBindingVariableDescriptorCount); + TRACE(" runtimeDescriptorArray: %#x.\n", + descriptor_indexing->runtimeDescriptorArray); + } + xfb = vk_find_struct(features2->pNext, PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT); if (xfb) { @@ -985,9 +1109,12 @@ static HRESULT vkd3d_init_device_caps(struct d3d12_device *device, uint32_t *device_extension_count, bool **user_extension_supported) { const struct vkd3d_vk_instance_procs *vk_procs = &device->vkd3d_instance->vk_procs; + VkPhysicalDeviceDescriptorIndexingPropertiesEXT descriptor_indexing_properties; VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT vertex_divisor_properties; const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *divisor_features; const struct vkd3d_optional_device_extensions_info *optional_extensions; + VkPhysicalDeviceDescriptorIndexingFeaturesEXT *descriptor_indexing; + VkPhysicalDeviceMaintenance3Properties maintenance3_properties; VkPhysicalDeviceTransformFeedbackPropertiesEXT xfb_properties; VkPhysicalDevice physical_device = device->vk_physical_device; VkPhysicalDeviceFeatures *features = &features2->features; @@ -999,13 +1126,20 @@ static HRESULT vkd3d_init_device_caps(struct d3d12_device *device, *device_extension_count = 0; + memset(&maintenance3_properties, 0, sizeof(maintenance3_properties)); + maintenance3_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES; + memset(&descriptor_indexing_properties, 0, sizeof(descriptor_indexing_properties)); + descriptor_indexing_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT; + descriptor_indexing_properties.pNext = &maintenance3_properties; memset(&xfb_properties, 0, sizeof(xfb_properties)); xfb_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT; + xfb_properties.pNext = &descriptor_indexing_properties; memset(&vertex_divisor_properties, 0, sizeof(vertex_divisor_properties)); vertex_divisor_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT; vertex_divisor_properties.pNext = &xfb_properties; device_properties2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2; device_properties2.pNext = &vertex_divisor_properties; + if (vulkan_info->KHR_get_physical_device_properties2) VK_CALL(vkGetPhysicalDeviceProperties2KHR(physical_device, &device_properties2)); else @@ -1128,8 +1262,32 @@ static HRESULT vkd3d_init_device_caps(struct d3d12_device *device, return E_INVALIDARG; } + /* Disable unused Vulkan features. */ features->shaderTessellationAndGeometryPointSize = VK_FALSE; + descriptor_indexing = vk_find_struct(features2->pNext, PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT); + if (descriptor_indexing) + { + descriptor_indexing->shaderInputAttachmentArrayDynamicIndexing = VK_FALSE; + descriptor_indexing->shaderInputAttachmentArrayNonUniformIndexing = VK_FALSE; + + /* We do not use storage buffers currently. */ + features->shaderStorageBufferArrayDynamicIndexing = VK_FALSE; + descriptor_indexing->shaderStorageBufferArrayNonUniformIndexing = VK_FALSE; + descriptor_indexing->descriptorBindingStorageBufferUpdateAfterBind = VK_FALSE; + } + + if (vulkan_info->EXT_descriptor_indexing && descriptor_indexing + && (descriptor_indexing->descriptorBindingUniformBufferUpdateAfterBind + || descriptor_indexing->descriptorBindingStorageBufferUpdateAfterBind + || descriptor_indexing->descriptorBindingUniformTexelBufferUpdateAfterBind + || descriptor_indexing->descriptorBindingStorageTexelBufferUpdateAfterBind) + && !descriptor_indexing_properties.robustBufferAccessUpdateAfterBind) + { + WARN("Disabling robust buffer access for the update after bind feature.\n"); + features->robustBufferAccess = VK_FALSE; + } + return S_OK; } @@ -1361,6 +1519,7 @@ static HRESULT vkd3d_create_vk_device(struct d3d12_device *device, const struct vkd3d_device_create_info *create_info) { const struct vkd3d_vk_instance_procs *vk_procs = &device->vkd3d_instance->vk_procs; + VkPhysicalDeviceDescriptorIndexingFeaturesEXT descriptor_indexing_features; VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT vertex_divisor_features; const struct vkd3d_optional_device_extensions_info *optional_extensions; VkPhysicalDeviceTransformFeedbackFeaturesEXT xfb_features; @@ -1399,8 +1558,11 @@ static HRESULT vkd3d_create_vk_device(struct d3d12_device *device, VK_CALL(vkGetPhysicalDeviceMemoryProperties(physical_device, &device->memory_properties)); + memset(&descriptor_indexing_features, 0, sizeof(descriptor_indexing_features)); + descriptor_indexing_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT; memset(&xfb_features, 0, sizeof(xfb_features)); xfb_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT; + xfb_features.pNext = &descriptor_indexing_features; memset(&vertex_divisor_features, 0, sizeof(vertex_divisor_features)); vertex_divisor_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT; vertex_divisor_features.pNext = &xfb_features; diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index 7cde1f6baa12..c071b414a73e 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -91,9 +91,11 @@ struct vkd3d_vulkan_info /* KHR device extensions */ bool KHR_dedicated_allocation; bool KHR_get_memory_requirements2; + bool KHR_maintenance3; bool KHR_push_descriptor; /* EXT device extensions */ bool EXT_debug_marker; + bool EXT_descriptor_indexing; bool EXT_transform_feedback; bool EXT_vertex_attribute_divisor; diff --git a/libs/vkd3d/vulkan_procs.h b/libs/vkd3d/vulkan_procs.h index d176f2417441..38ead474035d 100644 --- a/libs/vkd3d/vulkan_procs.h +++ b/libs/vkd3d/vulkan_procs.h @@ -182,6 +182,9 @@ VK_DEVICE_EXT_PFN(vkGetBufferMemoryRequirements2KHR) VK_DEVICE_EXT_PFN(vkGetImageMemoryRequirements2KHR) VK_DEVICE_EXT_PFN(vkGetImageSparseMemoryRequirements2KHR) +/* VK_KHR_maintenance3 */ +VK_DEVICE_EXT_PFN(vkGetDescriptorSetLayoutSupportKHR) + /* VK_KHR_push_descriptor */ VK_DEVICE_EXT_PFN(vkCmdPushDescriptorSetKHR) -- 2.19.2

2 1

[PATCH vkd3d 4/5] tests: Use vkd3d_optional_device_extensions_info.
by Józef Kucia April 2, 2019

April 2, 2019

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- tests/d3d12_crosstest.h | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/tests/d3d12_crosstest.h b/tests/d3d12_crosstest.h index 723659e6b66b..2103cafd03c4 100644 --- a/tests/d3d12_crosstest.h +++ b/tests/d3d12_crosstest.h @@ -455,29 +455,30 @@ static VkPhysicalDevice select_physical_device(struct vkd3d_instance *instance) static HRESULT create_vkd3d_device(struct vkd3d_instance *instance, D3D_FEATURE_LEVEL minimum_feature_level, REFIID iid, void **device) { - struct vkd3d_device_create_info device_create_info; - VkPhysicalDevice vk_physical_device; - static const char * const device_extensions[] = { VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME, }; + static const struct vkd3d_optional_device_extensions_info optional_extensions = + { + .type = VKD3D_STRUCTURE_TYPE_OPTIONAL_DEVICE_EXTENSIONS_INFO, + .extensions = device_extensions, + .extension_count = ARRAY_SIZE(device_extensions), + }; + + struct vkd3d_device_create_info device_create_info; + VkPhysicalDevice vk_physical_device; if (!(vk_physical_device = select_physical_device(instance))) return E_INVALIDARG; memset(&device_create_info, 0, sizeof(device_create_info)); device_create_info.type = VKD3D_STRUCTURE_TYPE_DEVICE_CREATE_INFO; + device_create_info.next = &optional_extensions; device_create_info.minimum_feature_level = minimum_feature_level; device_create_info.instance = instance; device_create_info.vk_physical_device = vk_physical_device; - if (check_device_extension(vk_physical_device, VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME)) - { - device_create_info.device_extensions = device_extensions; - device_create_info.device_extension_count = ARRAY_SIZE(device_extensions); - } - return vkd3d_create_device(&device_create_info, iid, device); } -- 2.19.2

2 1

[PATCH vkd3d 3/5] test: Test root CBV descriptor with big buffer.
by Józef Kucia April 2, 2019

April 2, 2019

From: Józef Kucia <jkucia(a)codeweavers.com> This test is for commit 22330b541446b62f10ef7d03dff709318420757a. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- tests/d3d12.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/d3d12.c b/tests/d3d12.c index 9a17a713ada3..00005c4d1767 100644 --- a/tests/d3d12.c +++ b/tests/d3d12.c @@ -10477,6 +10477,7 @@ static void test_immediate_constant_buffer(void) 0x0010000a, 0x00000000, 0x06000036, 0x00102042, 0x00000000, 0x0090902a, 0x0010000a, 0x00000000, 0x0100003e, }; + static const unsigned int MAX_CB_SIZE = D3D12_REQ_IMMEDIATE_CONSTANT_BUFFER_ELEMENT_COUNT * sizeof(struct vec4); static const D3D12_SHADER_BYTECODE ps = {ps_code, sizeof(ps_code)}; static struct vec4 expected_result[] = { @@ -10501,7 +10502,7 @@ static void test_immediate_constant_buffer(void) context.pipeline_state = create_pipeline_state(context.device, context.root_signature, desc.rt_format, NULL, &ps, NULL); - cb = create_upload_buffer(context.device, sizeof(index), NULL); + cb = create_upload_buffer(context.device, 2 * MAX_CB_SIZE, NULL); for (i = 0; i < ARRAY_SIZE(expected_result); ++i) { -- 2.19.2

2 1

[PATCH vkd3d 2/5] tests: Add test for updating descriptor tables after changing root signature.
by Józef Kucia April 2, 2019

April 2, 2019

From: Józef Kucia <jkucia(a)codeweavers.com> This test is for commit 74fbfee61101901666069f1f7e868e0205266c10. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- tests/d3d12.c | 189 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 189 insertions(+) diff --git a/tests/d3d12.c b/tests/d3d12.c index 79bca28003dd..9a17a713ada3 100644 --- a/tests/d3d12.c +++ b/tests/d3d12.c @@ -14727,6 +14727,194 @@ static void test_update_compute_descriptor_tables(void) destroy_test_context(&context); } +static void test_update_descriptor_tables_after_root_signature_change(void) +{ + ID3D12RootSignature *root_signature, *root_signature2; + ID3D12PipelineState *pipeline_state, *pipeline_state2; + ID3D12DescriptorHeap *heap, *sampler_heap, *heaps[2]; + D3D12_ROOT_SIGNATURE_DESC root_signature_desc; + D3D12_DESCRIPTOR_RANGE descriptor_range[4]; + D3D12_ROOT_PARAMETER root_parameters[3]; + ID3D12GraphicsCommandList *command_list; + D3D12_CPU_DESCRIPTOR_HANDLE cpu_handle; + unsigned int i, descriptor_size; + D3D12_SAMPLER_DESC sampler_desc; + struct test_context_desc desc; + ID3D12Resource *textures[2]; + D3D12_SUBRESOURCE_DATA data; + struct test_context context; + ID3D12CommandQueue *queue; + HRESULT hr; + + static const DWORD ps_code[] = + { +#if 0 + Texture2D t; + SamplerState s; + + float4 main(float4 position : SV_POSITION) : SV_Target + { + float2 p; + + p.x = position.x / 32.0f; + p.y = position.y / 32.0f; + return t.Sample(s, p); + } +#endif + 0x43425844, 0x7a0c3929, 0x75ff3ca4, 0xccb318b2, 0xe6965b4c, 0x00000001, 0x00000140, 0x00000003, + 0x0000002c, 0x00000060, 0x00000094, 0x4e475349, 0x0000002c, 0x00000001, 0x00000008, 0x00000020, + 0x00000000, 0x00000001, 0x00000003, 0x00000000, 0x0000030f, 0x505f5653, 0x5449534f, 0x004e4f49, + 0x4e47534f, 0x0000002c, 0x00000001, 0x00000008, 0x00000020, 0x00000000, 0x00000000, 0x00000003, + 0x00000000, 0x0000000f, 0x545f5653, 0x65677261, 0xabab0074, 0x58454853, 0x000000a4, 0x00000050, + 0x00000029, 0x0100086a, 0x0300005a, 0x00106000, 0x00000000, 0x04001858, 0x00107000, 0x00000000, + 0x00005555, 0x04002064, 0x00101032, 0x00000000, 0x00000001, 0x03000065, 0x001020f2, 0x00000000, + 0x02000068, 0x00000001, 0x0a000038, 0x00100032, 0x00000000, 0x00101046, 0x00000000, 0x00004002, + 0x3d000000, 0x3d000000, 0x00000000, 0x00000000, 0x8b000045, 0x800000c2, 0x00155543, 0x001020f2, + 0x00000000, 0x00100046, 0x00000000, 0x00107e46, 0x00000000, 0x00106000, 0x00000000, 0x0100003e, + }; + static const D3D12_SHADER_BYTECODE ps = {ps_code, sizeof(ps_code)}; + static const float white[] = {1.0f, 1.0f, 1.0f, 1.0f}; + static const unsigned int texture_data[] = {0xff00ff00, 0xff0000ff}; + + memset(&desc, 0, sizeof(desc)); + desc.no_root_signature = true; + if (!init_test_context(&context, &desc)) + return; + command_list = context.list; + queue = context.queue; + + descriptor_range[0].RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_SRV; + descriptor_range[0].NumDescriptors = 2; + descriptor_range[0].BaseShaderRegister = 0; + descriptor_range[0].RegisterSpace = 0; + descriptor_range[0].OffsetInDescriptorsFromTableStart = 0; + root_parameters[0].ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE; + root_parameters[0].DescriptorTable.NumDescriptorRanges = 1; + root_parameters[0].DescriptorTable.pDescriptorRanges = &descriptor_range[0]; + root_parameters[0].ShaderVisibility = D3D12_SHADER_VISIBILITY_PIXEL; + + descriptor_range[1].RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_SAMPLER; + descriptor_range[1].NumDescriptors = 1; + descriptor_range[1].BaseShaderRegister = 0; + descriptor_range[1].RegisterSpace = 0; + descriptor_range[1].OffsetInDescriptorsFromTableStart = D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND; + root_parameters[1].ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE; + root_parameters[1].DescriptorTable.NumDescriptorRanges = 1; + root_parameters[1].DescriptorTable.pDescriptorRanges = &descriptor_range[1]; + root_parameters[1].ShaderVisibility = D3D12_SHADER_VISIBILITY_PIXEL; + + descriptor_range[2].RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_SRV; + descriptor_range[2].NumDescriptors = 2; + descriptor_range[2].BaseShaderRegister = 2; + descriptor_range[2].RegisterSpace = 0; + descriptor_range[2].OffsetInDescriptorsFromTableStart = 0; + descriptor_range[3].RangeType = D3D12_DESCRIPTOR_RANGE_TYPE_CBV; + descriptor_range[3].NumDescriptors = 1; + descriptor_range[3].BaseShaderRegister = 0; + descriptor_range[3].RegisterSpace = 0; + descriptor_range[3].OffsetInDescriptorsFromTableStart = D3D12_DESCRIPTOR_RANGE_OFFSET_APPEND; + root_parameters[2].ParameterType = D3D12_ROOT_PARAMETER_TYPE_DESCRIPTOR_TABLE; + root_parameters[2].DescriptorTable.NumDescriptorRanges = 2; + root_parameters[2].DescriptorTable.pDescriptorRanges = &descriptor_range[2]; + root_parameters[2].ShaderVisibility = D3D12_SHADER_VISIBILITY_PIXEL; + + memset(&root_signature_desc, 0, sizeof(root_signature_desc)); + root_signature_desc.NumParameters = ARRAY_SIZE(root_parameters); + root_signature_desc.pParameters = root_parameters; + hr = create_root_signature(context.device, &root_signature_desc, &root_signature); + ok(hr == S_OK, "Failed to create root signature, hr %#x.\n", hr); + root_signature_desc.NumParameters = ARRAY_SIZE(root_parameters) - 1; + hr = create_root_signature(context.device, &root_signature_desc, &root_signature2); + ok(hr == S_OK, "Failed to create root signature, hr %#x.\n", hr); + + pipeline_state = create_pipeline_state(context.device, + root_signature, context.render_target_desc.Format, NULL, &ps, NULL); + pipeline_state2 = create_pipeline_state(context.device, + root_signature2, context.render_target_desc.Format, NULL, &ps, NULL); + + heap = create_gpu_descriptor_heap(context.device, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, 6); + sampler_heap = create_gpu_descriptor_heap(context.device, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER, 1); + + memset(&sampler_desc, 0, sizeof(sampler_desc)); + sampler_desc.Filter = D3D12_FILTER_MIN_MAG_MIP_POINT; + sampler_desc.AddressU = D3D12_TEXTURE_ADDRESS_MODE_CLAMP; + sampler_desc.AddressV = D3D12_TEXTURE_ADDRESS_MODE_CLAMP; + sampler_desc.AddressW = D3D12_TEXTURE_ADDRESS_MODE_CLAMP; + ID3D12Device_CreateSampler(context.device, &sampler_desc, get_cpu_descriptor_handle(&context, sampler_heap, 0)); + + descriptor_size = ID3D12Device_GetDescriptorHandleIncrementSize(context.device, + D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); + + for (i = 0; i < ARRAY_SIZE(textures); ++i) + { + textures[i] = create_default_texture(context.device, + 1, 1, DXGI_FORMAT_R8G8B8A8_UNORM, 0, D3D12_RESOURCE_STATE_COPY_DEST); + data.pData = &texture_data[i]; + data.RowPitch = sizeof(texture_data[i]); + data.SlicePitch = data.RowPitch; + upload_texture_data(textures[i], &data, 1, queue, command_list); + reset_command_list(command_list, context.allocator); + } + + cpu_handle = ID3D12DescriptorHeap_GetCPUDescriptorHandleForHeapStart(heap); + for (i = 0; i < ARRAY_SIZE(textures); ++i) + { + transition_resource_state(command_list, textures[i], + D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE); + ID3D12Device_CreateShaderResourceView(context.device, textures[i], NULL, cpu_handle); + cpu_handle.ptr += descriptor_size; + } + for (; i < 6; ++i) + { + ID3D12Device_CreateShaderResourceView(context.device, textures[1], NULL, cpu_handle); + cpu_handle.ptr += descriptor_size; + } + + heaps[0] = heap; heaps[1] = sampler_heap; + ID3D12GraphicsCommandList_SetDescriptorHeaps(command_list, ARRAY_SIZE(heaps), heaps); + + ID3D12GraphicsCommandList_ClearRenderTargetView(command_list, context.rtv, white, 0, NULL); + + ID3D12GraphicsCommandList_OMSetRenderTargets(command_list, 1, &context.rtv, FALSE, NULL); + ID3D12GraphicsCommandList_SetGraphicsRootSignature(command_list, root_signature); + ID3D12GraphicsCommandList_SetPipelineState(command_list, 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_SetGraphicsRootDescriptorTable(command_list, 0, + get_gpu_descriptor_handle(&context, heap, 0)); + ID3D12GraphicsCommandList_SetGraphicsRootDescriptorTable(command_list, 1, + ID3D12DescriptorHeap_GetGPUDescriptorHandleForHeapStart(sampler_heap)); + ID3D12GraphicsCommandList_SetGraphicsRootDescriptorTable(command_list, 2, + get_gpu_descriptor_handle(&context, heap, 2)); + + ID3D12GraphicsCommandList_SetPipelineState(command_list, pipeline_state2); + ID3D12GraphicsCommandList_SetGraphicsRootSignature(command_list, root_signature2); + + ID3D12GraphicsCommandList_SetGraphicsRootDescriptorTable(command_list, 0, + get_gpu_descriptor_handle(&context, heap, 0)); + ID3D12GraphicsCommandList_SetGraphicsRootDescriptorTable(command_list, 1, + ID3D12DescriptorHeap_GetGPUDescriptorHandleForHeapStart(sampler_heap)); + + ID3D12GraphicsCommandList_DrawInstanced(command_list, 3, 1, 0, 0); + + transition_resource_state(command_list, context.render_target, + D3D12_RESOURCE_STATE_RENDER_TARGET, D3D12_RESOURCE_STATE_COPY_SOURCE); + check_sub_resource_uint(context.render_target, 0, queue, command_list, 0xff00ff00, 0); + + ID3D12PipelineState_Release(pipeline_state); + ID3D12PipelineState_Release(pipeline_state2); + ID3D12RootSignature_Release(root_signature); + ID3D12RootSignature_Release(root_signature2); + for (i = 0; i < ARRAY_SIZE(textures); ++i) + ID3D12Resource_Release(textures[i]); + ID3D12DescriptorHeap_Release(heap); + ID3D12DescriptorHeap_Release(sampler_heap); + destroy_test_context(&context); +} + static void test_copy_descriptors(void) { struct data @@ -27204,6 +27392,7 @@ START_TEST(d3d12) run_test(test_update_descriptor_tables); run_test(test_update_descriptor_heap_after_closing_command_list); run_test(test_update_compute_descriptor_tables); + run_test(test_update_descriptor_tables_after_root_signature_change); run_test(test_copy_descriptors); run_test(test_copy_descriptors_range_sizes); run_test(test_descriptors_visibility); -- 2.19.2

2 1

[PATCH 4/4] d3d11/tests: Introduce and use check_readback_data_u24.
by Henri Verbeet April 2, 2019

April 2, 2019

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/d3d11/tests/d3d11.c | 58 +++++++++++++++++++++++++++++++++++------------- 1 file changed, 43 insertions(+), 15 deletions(-) diff --git a/dlls/d3d11/tests/d3d11.c b/dlls/d3d11/tests/d3d11.c index 6f438482fc3..90bcbae281d 100644 --- a/dlls/d3d11/tests/d3d11.c +++ b/dlls/d3d11/tests/d3d11.c @@ -946,11 +946,16 @@ static WORD get_readback_u16(struct resource_readback *rb, unsigned int x, unsig return *(WORD *)get_readback_data(rb, x, y, z, sizeof(WORD)); } -static DWORD get_readback_color(struct resource_readback *rb, unsigned int x, unsigned int y, unsigned int z) +static DWORD get_readback_u32(struct resource_readback *rb, unsigned int x, unsigned int y, unsigned int z) { return *(DWORD *)get_readback_data(rb, x, y, z, sizeof(DWORD)); } +static DWORD get_readback_color(struct resource_readback *rb, unsigned int x, unsigned int y, unsigned int z) +{ + return get_readback_u32(rb, x, y, z); +} + static float get_readback_float(struct resource_readback *rb, unsigned int x, unsigned int y) { return *(float *)get_readback_data(rb, x, y, 0, sizeof(float)); @@ -1055,6 +1060,41 @@ done: value, expected_value, x, y, z, rb->sub_resource_idx); } +#define check_readback_data_u24(a, b, c, d, e) check_readback_data_u24_(__LINE__, a, b, c, d, e) +static void check_readback_data_u24_(unsigned int line, struct resource_readback *rb, + const RECT *rect, unsigned int shift, DWORD expected_value, BYTE max_diff) +{ + unsigned int x = 0, y = 0, z = 0; + BOOL all_match = FALSE; + RECT default_rect; + DWORD value = 0; + + if (!rect) + { + SetRect(&default_rect, 0, 0, rb->width, rb->height); + rect = &default_rect; + } + + for (z = 0; z < rb->depth; ++z) + { + for (y = rect->top; y < rect->bottom; ++y) + { + for (x = rect->left; x < rect->right; ++x) + { + value = get_readback_u32(rb, x, y, z) >> shift; + if (abs((int)value - (int)expected_value) > max_diff) + goto done; + } + } + } + all_match = TRUE; + +done: + ok_(__FILE__, line)(all_match, + "Got 0x%06x, expected 0x%06x at (%u, %u, %u), sub-resource %u.\n", + value, expected_value, x, y, z, rb->sub_resource_idx); +} + #define check_readback_data_color(a, b, c, d) check_readback_data_color_(__LINE__, a, b, c, d) static void check_readback_data_color_(unsigned int line, struct resource_readback *rb, const RECT *rect, DWORD expected_color, BYTE max_diff) @@ -25446,10 +25486,10 @@ static void test_depth_bias(void) struct resource_readback rb; ID3D11DepthStencilView *dsv; unsigned int expected_value; - unsigned int x, y, i, j, k; ID3D11RasterizerState *rs; ID3D11Texture2D *texture; unsigned int format_idx; + unsigned int y, i, j, k; unsigned int shift = 0; ID3D11Device *device; float *depth_values; @@ -25590,19 +25630,7 @@ static void test_depth_bias(void) depth = min(max(0.0f, quads[i].z + bias), 1.0f); get_texture_readback(texture, 0, &rb); - for (y = 0; y < texture_desc.Height; ++y) - { - expected_value = depth * 16777215.0f + 0.5f; - for (x = 0; x < texture_desc.Width; ++x) - { - u32 = get_readback_data(&rb, x, y, 0, sizeof(*u32)); - u32_value = *u32 >> shift; - ok(abs(u32_value - expected_value) <= 1, - "Got value %#x (%.8e), expected %#x (%.8e).\n", - u32_value, u32_value / 16777215.0f, - expected_value, expected_value / 16777215.0f); - } - } + check_readback_data_u24(&rb, NULL, shift, depth * 16777215.0f + 0.5f, 1); release_resource_readback(&rb); break; case DXGI_FORMAT_D16_UNORM: -- 2.11.0

2 1

[PATCH vkd3d 1/5] vkd3d: Avoid copying empty ranges in d3d12_device_CopyDescriptors().
by Józef Kucia April 2, 2019

April 2, 2019

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d/device.c | 34 ++++++++++++++++------------------ libs/vkd3d/resource.c | 2 ++ tests/d3d12.c | 34 ++++++++++++++++++++++++++++++---- 3 files changed, 48 insertions(+), 22 deletions(-) diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index 8676434213ea..9b18bc909751 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -2306,29 +2306,27 @@ static void STDMETHODCALLTYPE d3d12_device_CopyDescriptors(ID3D12Device *iface, } dst_range_idx = dst_idx = 0; - dst = d3d12_desc_from_cpu_handle(dst_descriptor_range_offsets[0]); - dst_range_size = dst_descriptor_range_sizes ? dst_descriptor_range_sizes[0] : 1; - for (src_range_idx = 0; src_range_idx < src_descriptor_range_count; ++src_range_idx) + src_range_idx = src_idx = 0; + while (dst_range_idx < dst_descriptor_range_count && src_range_idx < src_descriptor_range_count) { - src = d3d12_desc_from_cpu_handle(src_descriptor_range_offsets[src_range_idx]); + dst_range_size = dst_descriptor_range_sizes ? dst_descriptor_range_sizes[dst_range_idx] : 1; src_range_size = src_descriptor_range_sizes ? src_descriptor_range_sizes[src_range_idx] : 1; - for (src_idx = 0; src_idx < src_range_size; ++src_idx) - { - if (dst_idx >= dst_range_size) - { - dst_idx = 0; - ++dst_range_idx; - if (dst_range_idx >= dst_descriptor_range_count) - return; - - dst = d3d12_desc_from_cpu_handle(dst_descriptor_range_offsets[dst_range_idx]); - dst_range_size = dst_descriptor_range_sizes ? dst_descriptor_range_sizes[dst_range_idx] : 1; - } + dst = d3d12_desc_from_cpu_handle(dst_descriptor_range_offsets[dst_range_idx]); + src = d3d12_desc_from_cpu_handle(src_descriptor_range_offsets[src_range_idx]); - d3d12_desc_copy(dst++, src++, device); + while (dst_idx < dst_range_size && src_idx < src_range_size) + d3d12_desc_copy(&dst[dst_idx++], &src[src_idx++], device); - ++dst_idx; + if (dst_idx >= dst_range_size) + { + ++dst_range_idx; + dst_idx = 0; + } + if (src_idx >= src_range_size) + { + ++src_range_idx; + src_idx = 0; } } } diff --git a/libs/vkd3d/resource.c b/libs/vkd3d/resource.c index a6c22fd007c9..84855853fe4b 100644 --- a/libs/vkd3d/resource.c +++ b/libs/vkd3d/resource.c @@ -1600,6 +1600,8 @@ static void d3d12_desc_destroy(struct d3d12_desc *descriptor, void d3d12_desc_copy(struct d3d12_desc *dst, const struct d3d12_desc *src, struct d3d12_device *device) { + assert(dst != src); + d3d12_desc_destroy(dst, device); *dst = *src; diff --git a/tests/d3d12.c b/tests/d3d12.c index a9255b388ce2..79bca28003dd 100644 --- a/tests/d3d12.c +++ b/tests/d3d12.c @@ -15168,12 +15168,16 @@ static void test_copy_descriptors(void) dst_handles[0] = get_cpu_descriptor_handle(&context, heap, 9); dst_range_sizes[0] = 4; - dst_handles[1] = get_cpu_descriptor_handle(&context, heap, 13); - dst_range_sizes[1] = 3; + dst_handles[1] = get_cpu_descriptor_handle(&context, heap, 9); + dst_range_sizes[1] = 0; + dst_handles[2] = get_cpu_descriptor_handle(&context, heap, 13); + dst_range_sizes[2] = 3; + dst_handles[3] = get_cpu_descriptor_handle(&context, heap, 13); + dst_range_sizes[3] = 0; src_handles[0] = get_cpu_descriptor_handle(&context, cpu_heap, 10); - src_range_sizes[0] = 7; + src_range_sizes[0] = 8; /* t0-t6 */ - ID3D12Device_CopyDescriptors(device, 2, dst_handles, dst_range_sizes, + ID3D12Device_CopyDescriptors(device, 4, dst_handles, dst_range_sizes, 1, src_handles, src_range_sizes, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); /* copy 1 uninitialized descriptor (19) */ @@ -15195,6 +15199,28 @@ static void test_copy_descriptors(void) get_cpu_descriptor_handle(&context, cpu_heap, 22), D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); + /* range sizes equal to 0 */ + dst_handles[0] = get_cpu_descriptor_handle(&context, heap, 19); + dst_range_sizes[0] = 0; + dst_handles[1] = get_cpu_descriptor_handle(&context, heap, 19); + dst_range_sizes[1] = 0; + src_handles[0] = get_cpu_descriptor_handle(&context, cpu_heap, 0); + src_range_sizes[0] = 1; + src_handles[1] = get_cpu_descriptor_handle(&context, cpu_heap, 0); + src_range_sizes[1] = 4; + ID3D12Device_CopyDescriptors(device, 2, dst_handles, dst_range_sizes, + 2, src_handles, src_range_sizes, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); + dst_handles[0] = get_cpu_descriptor_handle(&context, heap, 19); + dst_range_sizes[0] = 4; + dst_handles[1] = get_cpu_descriptor_handle(&context, heap, 19); + dst_range_sizes[1] = 4; + src_handles[0] = get_cpu_descriptor_handle(&context, cpu_heap, 0); + src_range_sizes[0] = 0; + src_handles[1] = get_cpu_descriptor_handle(&context, cpu_heap, 0); + src_range_sizes[1] = 0; + ID3D12Device_CopyDescriptors(device, 2, dst_handles, dst_range_sizes, + 2, src_handles, src_range_sizes, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV); + ID3D12GraphicsCommandList_SetComputeRootSignature(command_list, context.root_signature); heaps[0] = sampler_heap; heaps[1] = heap; ID3D12GraphicsCommandList_SetDescriptorHeaps(command_list, ARRAY_SIZE(heaps), heaps); -- 2.19.2

2 1

[PATCH 3/4] d3d11/tests: Introduce and use check_readback_data_u16.
by Henri Verbeet April 2, 2019

April 2, 2019

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/d3d11/tests/d3d11.c | 101 +++++++++++++++++++++++++++-------------------- 1 file changed, 58 insertions(+), 43 deletions(-) diff --git a/dlls/d3d11/tests/d3d11.c b/dlls/d3d11/tests/d3d11.c index 4a02b3f51f6..6f438482fc3 100644 --- a/dlls/d3d11/tests/d3d11.c +++ b/dlls/d3d11/tests/d3d11.c @@ -936,11 +936,16 @@ static void *get_readback_data(struct resource_readback *rb, return (BYTE *)rb->map_desc.pData + z * rb->map_desc.DepthPitch + y * rb->map_desc.RowPitch + x * byte_width; } -static BYTE get_readback_byte(struct resource_readback *rb, unsigned int x, unsigned int y, unsigned int z) +static BYTE get_readback_u8(struct resource_readback *rb, unsigned int x, unsigned int y, unsigned int z) { return *(BYTE *)get_readback_data(rb, x, y, z, sizeof(BYTE)); } +static WORD get_readback_u16(struct resource_readback *rb, unsigned int x, unsigned int y, unsigned int z) +{ + return *(WORD *)get_readback_data(rb, x, y, z, sizeof(WORD)); +} + static DWORD get_readback_color(struct resource_readback *rb, unsigned int x, unsigned int y, unsigned int z) { return *(DWORD *)get_readback_data(rb, x, y, z, sizeof(DWORD)); @@ -980,12 +985,12 @@ static DWORD get_texture_color(ID3D11Texture2D *texture, unsigned int x, unsigne return color; } -#define check_readback_data_byte(a, b, c, d) check_readback_data_byte_(__LINE__, a, b, c, d) -static void check_readback_data_byte_(unsigned int line, struct resource_readback *rb, +#define check_readback_data_u8(a, b, c, d) check_readback_data_u8_(__LINE__, a, b, c, d) +static void check_readback_data_u8_(unsigned int line, struct resource_readback *rb, const RECT *rect, BYTE expected_value, BYTE max_diff) { unsigned int x = 0, y = 0, z = 0; - BOOL all_match = TRUE; + BOOL all_match = FALSE; RECT default_rect; BYTE value = 0; @@ -1001,30 +1006,61 @@ static void check_readback_data_byte_(unsigned int line, struct resource_readbac { for (x = rect->left; x < rect->right; ++x) { - value = get_readback_byte(rb, x, y, z); - if (!compare_color(value, expected_value, max_diff)) - { - all_match = FALSE; - break; - } + value = get_readback_u8(rb, x, y, z); + if (abs((int)value - (int)expected_value) > max_diff) + goto done; } - if (!all_match) - break; } - if (!all_match) - break; } + all_match = TRUE; + +done: ok_(__FILE__, line)(all_match, "Got 0x%02x, expected 0x%02x at (%u, %u, %u), sub-resource %u.\n", value, expected_value, x, y, z, rb->sub_resource_idx); } +#define check_readback_data_u16(a, b, c, d) check_readback_data_u16_(__LINE__, a, b, c, d) +static void check_readback_data_u16_(unsigned int line, struct resource_readback *rb, + const RECT *rect, WORD expected_value, BYTE max_diff) +{ + unsigned int x = 0, y = 0, z = 0; + BOOL all_match = FALSE; + RECT default_rect; + WORD value = 0; + + if (!rect) + { + SetRect(&default_rect, 0, 0, rb->width, rb->height); + rect = &default_rect; + } + + for (z = 0; z < rb->depth; ++z) + { + for (y = rect->top; y < rect->bottom; ++y) + { + for (x = rect->left; x < rect->right; ++x) + { + value = get_readback_u16(rb, x, y, z); + if (abs((int)value - (int)expected_value) > max_diff) + goto done; + } + } + } + all_match = TRUE; + +done: + ok_(__FILE__, line)(all_match, + "Got 0x%04x, expected 0x%04x at (%u, %u, %u), sub-resource %u.\n", + value, expected_value, x, y, z, rb->sub_resource_idx); +} + #define check_readback_data_color(a, b, c, d) check_readback_data_color_(__LINE__, a, b, c, d) static void check_readback_data_color_(unsigned int line, struct resource_readback *rb, const RECT *rect, DWORD expected_color, BYTE max_diff) { unsigned int x = 0, y = 0, z = 0; - BOOL all_match = TRUE; + BOOL all_match = FALSE; RECT default_rect; DWORD color = 0; @@ -1042,17 +1078,13 @@ static void check_readback_data_color_(unsigned int line, struct resource_readba { color = get_readback_color(rb, x, y, z); if (!compare_color(color, expected_color, max_diff)) - { - all_match = FALSE; - break; - } + goto done; } - if (!all_match) - break; } - if (!all_match) - break; } + all_match = TRUE; + +done: ok_(__FILE__, line)(all_match, "Got 0x%08x, expected 0x%08x at (%u, %u, %u), sub-resource %u.\n", color, expected_color, x, y, z, rb->sub_resource_idx); @@ -25514,14 +25546,7 @@ static void test_depth_bias(void) break; case DXGI_FORMAT_D16_UNORM: get_texture_readback(texture, 0, &rb); - for (y = 0; y < texture_desc.Height; ++y) - { - for (x = 0; x < texture_desc.Width; ++x) - { - u16 = get_readback_data(&rb, x, y, 0, sizeof(*u16)); - ok(*u16 == 0xffff, "Got unexpected value %#x.\n", *u16); - } - } + check_readback_data_u16(&rb, NULL, 0xffffu, 0); release_resource_readback(&rb); break; default: @@ -25586,17 +25611,7 @@ static void test_depth_bias(void) depth = min(max(0.0f, quads[i].z + bias), 1.0f); get_texture_readback(texture, 0, &rb); - for (y = 0; y < texture_desc.Height; ++y) - { - expected_value = depth * 65535.0f + 0.5f; - for (x = 0; x < texture_desc.Width; ++x) - { - u16 = get_readback_data(&rb, x, y, 0, sizeof(*u16)); - ok(abs(*u16 - expected_value) <= 1, - "Got value %#x (%.8e), expected %#x (%.8e).\n", - *u16, *u16 / 65535.0f, expected_value, expected_value / 65535.0f); - } - } + check_readback_data_u16(&rb, NULL, depth * 65535.0f + 0.5f, 1); release_resource_readback(&rb); break; default: @@ -29007,7 +29022,7 @@ static void test_render_a8(void) ID3D11DeviceContext_OMSetRenderTargets(context, 1, &rtv, NULL); draw_quad(&test_context); get_texture_readback(texture, 0, &rb); - check_readback_data_byte(&rb, NULL, 0xff, 0); + check_readback_data_u8(&rb, NULL, 0xff, 0); release_resource_readback(&rb); ID3D11DeviceContext_ClearRenderTargetView(context, test_context.backbuffer_rtv, black); -- 2.11.0

2 1

[PATCH 2/4] d3d10core/tests: Introduce and use check_readback_data_u24.
by Henri Verbeet April 2, 2019

April 2, 2019

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- This partially supersedes patch 162055. dlls/d3d10core/tests/d3d10core.c | 55 +++++++++++++++++++++++++++++----------- 1 file changed, 40 insertions(+), 15 deletions(-) diff --git a/dlls/d3d10core/tests/d3d10core.c b/dlls/d3d10core/tests/d3d10core.c index 7d76cc28d63..00bd16ba0d6 100644 --- a/dlls/d3d10core/tests/d3d10core.c +++ b/dlls/d3d10core/tests/d3d10core.c @@ -738,11 +738,16 @@ static WORD get_readback_u16(struct resource_readback *rb, unsigned int x, unsig return *(WORD *)get_readback_data(rb, x, y, sizeof(WORD)); } -static DWORD get_readback_color(struct resource_readback *rb, unsigned int x, unsigned int y) +static DWORD get_readback_u32(struct resource_readback *rb, unsigned int x, unsigned int y) { return *(DWORD *)get_readback_data(rb, x, y, sizeof(DWORD)); } +static DWORD get_readback_color(struct resource_readback *rb, unsigned int x, unsigned int y) +{ + return get_readback_u32(rb, x, y); +} + static float get_readback_float(struct resource_readback *rb, unsigned int x, unsigned int y) { return *(float *)get_readback_data(rb, x, y, sizeof(float)); @@ -854,6 +859,38 @@ done: value, expected_value, x, y, rb->sub_resource_idx); } +#define check_readback_data_u24(a, b, c, d, e) check_readback_data_u24_(__LINE__, a, b, c, d, e) +static void check_readback_data_u24_(unsigned int line, struct resource_readback *rb, + const RECT *rect, unsigned int shift, DWORD expected_value, BYTE max_diff) +{ + unsigned int x = 0, y = 0; + BOOL all_match = FALSE; + RECT default_rect; + DWORD value = 0; + + if (!rect) + { + SetRect(&default_rect, 0, 0, rb->width, rb->height); + rect = &default_rect; + } + + for (y = rect->top; y < rect->bottom; ++y) + { + for (x = rect->left; x < rect->right; ++x) + { + value = get_readback_u32(rb, x, y) >> shift; + if (abs((int)value - (int)expected_value) > max_diff) + goto done; + } + } + all_match = TRUE; + +done: + ok_(__FILE__, line)(all_match, + "Got 0x%06x, expected 0x%06x at (%u, %u), sub-resource %u.\n", + value, expected_value, x, y, rb->sub_resource_idx); +} + #define check_readback_data_color(a, b, c, d) check_readback_data_color_(__LINE__, a, b, c, d) static void check_readback_data_color_(unsigned int line, struct resource_readback *rb, const RECT *rect, DWORD expected_color, BYTE max_diff) @@ -15524,10 +15561,10 @@ static void test_depth_bias(void) struct resource_readback rb; ID3D10DepthStencilView *dsv; unsigned int expected_value; - unsigned int x, y, i, j, k; ID3D10RasterizerState *rs; ID3D10Texture2D *texture; unsigned int format_idx; + unsigned int y, i, j, k; unsigned int shift = 0; ID3D10Device *device; float *depth_values; @@ -15667,19 +15704,7 @@ static void test_depth_bias(void) depth = min(max(0.0f, quads[i].z + bias), 1.0f); get_texture_readback(texture, 0, &rb); - for (y = 0; y < texture_desc.Height; ++y) - { - expected_value = depth * 16777215.0f + 0.5f; - for (x = 0; x < texture_desc.Width; ++x) - { - u32 = get_readback_data(&rb, x, y, sizeof(*u32)); - u32_value = *u32 >> shift; - ok(abs(u32_value - expected_value) <= 1, - "Got value %#x (%.8e), expected %#x (%.8e).\n", - u32_value, u32_value / 16777215.0f, - expected_value, expected_value / 16777215.0f); - } - } + check_readback_data_u24(&rb, NULL, shift, depth * 16777215.0f + 0.5f, 1); release_resource_readback(&rb); break; case DXGI_FORMAT_D16_UNORM: -- 2.11.0

2 1

[PATCH v2] ddraw/tests: add test for HWTRANSFORMANDLIGHT flags
by Vijay Kiran Kamuju April 2, 2019

April 2, 2019

From: Michael Müller <michael(a)fds-team.de> Signed-off-by: Vijay Kiran Kamuju <infyquest(a)gmail.com> --- dlls/ddraw/tests/ddraw7.c | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/dlls/ddraw/tests/ddraw7.c b/dlls/ddraw/tests/ddraw7.c index c199994d52..d695e968c9 100644 --- a/dlls/ddraw/tests/ddraw7.c +++ b/dlls/ddraw/tests/ddraw7.c @@ -346,6 +346,19 @@ static HRESULT WINAPI enum_devtype_cb(char *desc_str, char *name, D3DDEVICEDESC7 return DDENUMRET_OK; } +static HRESULT WINAPI enum_devtype_software_cb(char *desc_str, char *name, D3DDEVICEDESC7 *desc, void *ctx) +{ + BOOL *software_ok = ctx; + if (IsEqualGUID(&desc->deviceGUID, &IID_IDirect3DRGBDevice)) + { + todo_wine ok(!(desc->dwDevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT), + "RGB emulation device shouldn't have HWTRANSFORMANDLIGHT flag\n"); + *software_ok = TRUE; + return DDENUMRET_CANCEL; + } + return DDENUMRET_OK; +} + static IDirect3DDevice7 *create_device(HWND window, DWORD coop_level) { IDirectDrawSurface7 *surface, *ds; @@ -356,6 +369,7 @@ static IDirect3DDevice7 *create_device(HWND window, DWORD coop_level) IDirect3D7 *d3d7; HRESULT hr; BOOL hal_ok = FALSE; + BOOL software_ok = FALSE; const GUID *devtype = &IID_IDirect3DHALDevice; if (!(ddraw = create_ddraw())) @@ -399,6 +413,10 @@ static IDirect3DDevice7 *create_device(HWND window, DWORD coop_level) ok(SUCCEEDED(hr), "Failed to enumerate devices, hr %#x.\n", hr); if (hal_ok) devtype = &IID_IDirect3DTnLHalDevice; + hr = IDirect3D7_EnumDevices(d3d7, enum_devtype_software_cb , &software_ok); + ok(SUCCEEDED(hr), "Failed to enumerate devices, hr %#x.\n", hr); + if (!software_ok) win_skip("RGB device not found, unable to check flags\n"); + memset(&z_fmt, 0, sizeof(z_fmt)); hr = IDirect3D7_EnumZBufferFormats(d3d7, devtype, enum_z_fmt, &z_fmt); if (FAILED(hr) || !z_fmt.dwSize) -- 2.21.0

3 3

[PATCH 1/3] wined3d: Initialise Vulkan for adapters.
by Józef Kucia April 2, 2019

April 2, 2019

Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- We always build Vulkan backend even when libvulkan is not found. We do the same for winevulkan. We may want to change that. --- dlls/wined3d/adapter_vk.c | 82 ++++++++++++++- dlls/wined3d/wined3d_private.h | 3 + dlls/wined3d/wined3d_vk.h | 186 +++++++++++++++++++++++++++++++++ 3 files changed, 266 insertions(+), 5 deletions(-) create mode 100644 dlls/wined3d/wined3d_vk.h diff --git a/dlls/wined3d/adapter_vk.c b/dlls/wined3d/adapter_vk.c index e2c940dae9d9..e63e89361b0b 100644 --- a/dlls/wined3d/adapter_vk.c +++ b/dlls/wined3d/adapter_vk.c @@ -20,12 +20,18 @@ #include "wine/port.h" #include "wined3d_private.h" +#include "wine/vulkan_driver.h" + WINE_DEFAULT_DEBUG_CHANNEL(d3d); static void adapter_vk_destroy(struct wined3d_adapter *adapter) { - wined3d_adapter_cleanup(adapter); - heap_free(adapter); + struct wined3d_adapter_vk *adapter_vk = wined3d_adapter_vk(adapter); + const struct wined3d_vk_info *vk_info = &adapter_vk->vk_info; + + VK_CALL(vkDestroyInstance(vk_info->instance, NULL)); + wined3d_adapter_cleanup(&adapter_vk->a); + heap_free(adapter_vk); } static BOOL adapter_vk_create_context(struct wined3d_context *context, @@ -53,9 +59,63 @@ static const struct wined3d_adapter_ops wined3d_adapter_vk_ops = adapter_vk_check_format, }; +static BOOL wined3d_init_vulkan(struct wined3d_vk_info *vk_info) +{ + struct vulkan_ops *vk_ops = &vk_info->vk_ops; + const struct vulkan_funcs *vk_funcs; + VkInstanceCreateInfo instance_info; + VkInstance instance; + VkResult vr; + HDC dc; + + dc = GetDC(0); + vk_funcs = __wine_get_vulkan_driver(dc, WINE_VULKAN_DRIVER_VERSION); + ReleaseDC(0, dc); + + if (!vk_funcs) + return FALSE; + + vk_ops->vkGetInstanceProcAddr = (void *)vk_funcs->p_vkGetInstanceProcAddr; + + if (!(vk_ops->vkCreateInstance = (void *)VK_CALL(vkGetInstanceProcAddr(NULL, "vkCreateInstance")))) + { + ERR("Could not get 'vkCreateInstance'.\n"); + return FALSE; + } + + memset(&instance_info, 0, sizeof(instance_info)); + instance_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; + if ((vr = VK_CALL(vkCreateInstance(&instance_info, NULL, &instance))) < 0) + { + WARN("Failed to create Vulkan instance, vr %d.\n", vr); + return FALSE; + } + + TRACE("Created Vulkan instance %p.\n", instance); + +#define LOAD_INSTANCE_PFN(name) \ + if (!(vk_ops->name = (void *)VK_CALL(vkGetInstanceProcAddr(instance, #name)))) \ + { \ + WARN("Could not get instance proc addr for '" #name "'.\n"); \ + vk_funcs->p_vkDestroyInstance(instance, NULL); \ + return FALSE; \ + } +#define VK_INSTANCE_PFN LOAD_INSTANCE_PFN +#define VK_DEVICE_PFN LOAD_INSTANCE_PFN + VK_INSTANCE_FUNCS() + VK_DEVICE_FUNCS() +#undef VK_INSTANCE_PFN +#undef VK_DEVICE_PFN + + vk_info->instance = instance; + + return TRUE; +} + static BOOL wined3d_adapter_vk_init(struct wined3d_adapter_vk *adapter_vk, unsigned int ordinal, unsigned int wined3d_creation_flags) { + struct wined3d_vk_info *vk_info = &adapter_vk->vk_info; const struct wined3d_gpu_description *gpu_description; struct wined3d_adapter *adapter = &adapter_vk->a; @@ -63,17 +123,23 @@ static BOOL wined3d_adapter_vk_init(struct wined3d_adapter_vk *adapter_vk, adapter_vk, ordinal, wined3d_creation_flags); if (!wined3d_adapter_init(adapter, ordinal)) - return FALSE; + goto fail; + + if (!wined3d_init_vulkan(vk_info)) + { + WARN("Failed to initialize Vulkan.\n"); + goto fail; + } if (!(gpu_description = wined3d_get_gpu_description(HW_VENDOR_AMD, CARD_AMD_RADEON_RX_VEGA))) { ERR("Failed to get GPU description.\n"); - return FALSE; + goto fail; } wined3d_driver_info_init(&adapter->driver_info, gpu_description, wined3d_settings.emulated_textureram); if (!wined3d_adapter_vk_init_format_info(adapter)) - return FALSE; + goto fail; adapter->vertex_pipe = &none_vertex_pipe; adapter->fragment_pipe = &none_fragment_pipe; @@ -83,6 +149,12 @@ static BOOL wined3d_adapter_vk_init(struct wined3d_adapter_vk *adapter_vk, adapter->d3d_info.wined3d_creation_flags = wined3d_creation_flags; return TRUE; + +fail: + if (vk_info->vk_ops.vkDestroyInstance) + VK_CALL(vkDestroyInstance(vk_info->instance, NULL)); + wined3d_adapter_cleanup(adapter); + return FALSE; } struct wined3d_adapter *wined3d_adapter_vk_create(unsigned int ordinal, diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 5a455edb0c2f..012c90f5d345 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -54,6 +54,7 @@ #include "objbase.h" #include "wine/wined3d.h" #include "wined3d_gl.h" +#include "wined3d_vk.h" #include "wine/list.h" #include "wine/rbtree.h" #include "wine/wgl_driver.h" @@ -2752,6 +2753,8 @@ BOOL wined3d_adapter_gl_create_context(struct wined3d_context *context, struct wined3d_adapter_vk { struct wined3d_adapter a; + + struct wined3d_vk_info vk_info; }; static inline struct wined3d_adapter_vk *wined3d_adapter_vk(struct wined3d_adapter *adapter) diff --git a/dlls/wined3d/wined3d_vk.h b/dlls/wined3d/wined3d_vk.h new file mode 100644 index 000000000000..ac59a2dcd1ab --- /dev/null +++ b/dlls/wined3d/wined3d_vk.h @@ -0,0 +1,186 @@ +/* + * 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 + */ + +#ifndef __WINE_WINED3D_VK_H +#define __WINE_WINED3D_VK_H + +#define VK_NO_PROTOTYPES +#define WINE_VK_HOST +#include "wine/vulkan.h" + +#define VK_INSTANCE_FUNCS() \ + VK_INSTANCE_PFN(vkCreateDevice) \ + VK_INSTANCE_PFN(vkDestroyInstance) \ + VK_INSTANCE_PFN(vkEnumerateDeviceExtensionProperties) \ + VK_INSTANCE_PFN(vkEnumerateDeviceLayerProperties) \ + VK_INSTANCE_PFN(vkEnumeratePhysicalDevices) \ + VK_INSTANCE_PFN(vkGetDeviceProcAddr) \ + VK_INSTANCE_PFN(vkGetPhysicalDeviceFeatures) \ + VK_INSTANCE_PFN(vkGetPhysicalDeviceFormatProperties) \ + VK_INSTANCE_PFN(vkGetPhysicalDeviceImageFormatProperties) \ + VK_INSTANCE_PFN(vkGetPhysicalDeviceMemoryProperties) \ + VK_INSTANCE_PFN(vkGetPhysicalDeviceProperties) \ + VK_INSTANCE_PFN(vkGetPhysicalDeviceQueueFamilyProperties) \ + VK_INSTANCE_PFN(vkGetPhysicalDeviceSparseImageFormatProperties) + +#define VK_DEVICE_FUNCS() \ + VK_DEVICE_PFN(vkAllocateCommandBuffers) \ + VK_DEVICE_PFN(vkAllocateDescriptorSets) \ + VK_DEVICE_PFN(vkAllocateMemory) \ + VK_DEVICE_PFN(vkBeginCommandBuffer) \ + VK_DEVICE_PFN(vkBindBufferMemory) \ + VK_DEVICE_PFN(vkBindImageMemory) \ + VK_DEVICE_PFN(vkCmdBeginQuery) \ + VK_DEVICE_PFN(vkCmdBeginRenderPass) \ + VK_DEVICE_PFN(vkCmdBindDescriptorSets) \ + VK_DEVICE_PFN(vkCmdBindIndexBuffer) \ + VK_DEVICE_PFN(vkCmdBindPipeline) \ + VK_DEVICE_PFN(vkCmdBindVertexBuffers) \ + VK_DEVICE_PFN(vkCmdBlitImage) \ + VK_DEVICE_PFN(vkCmdClearAttachments) \ + VK_DEVICE_PFN(vkCmdClearColorImage) \ + VK_DEVICE_PFN(vkCmdClearDepthStencilImage) \ + VK_DEVICE_PFN(vkCmdCopyBuffer) \ + VK_DEVICE_PFN(vkCmdCopyBufferToImage) \ + VK_DEVICE_PFN(vkCmdCopyImage) \ + VK_DEVICE_PFN(vkCmdCopyImageToBuffer) \ + VK_DEVICE_PFN(vkCmdCopyQueryPoolResults) \ + VK_DEVICE_PFN(vkCmdDispatch) \ + VK_DEVICE_PFN(vkCmdDispatchIndirect) \ + VK_DEVICE_PFN(vkCmdDraw) \ + VK_DEVICE_PFN(vkCmdDrawIndexed) \ + VK_DEVICE_PFN(vkCmdDrawIndexedIndirect) \ + VK_DEVICE_PFN(vkCmdDrawIndirect) \ + VK_DEVICE_PFN(vkCmdEndQuery) \ + VK_DEVICE_PFN(vkCmdEndRenderPass) \ + VK_DEVICE_PFN(vkCmdExecuteCommands) \ + VK_DEVICE_PFN(vkCmdFillBuffer) \ + VK_DEVICE_PFN(vkCmdNextSubpass) \ + VK_DEVICE_PFN(vkCmdPipelineBarrier) \ + VK_DEVICE_PFN(vkCmdPushConstants) \ + VK_DEVICE_PFN(vkCmdResetEvent) \ + VK_DEVICE_PFN(vkCmdResetQueryPool) \ + VK_DEVICE_PFN(vkCmdResolveImage) \ + VK_DEVICE_PFN(vkCmdSetBlendConstants) \ + VK_DEVICE_PFN(vkCmdSetDepthBias) \ + VK_DEVICE_PFN(vkCmdSetDepthBounds) \ + VK_DEVICE_PFN(vkCmdSetEvent) \ + VK_DEVICE_PFN(vkCmdSetLineWidth) \ + VK_DEVICE_PFN(vkCmdSetScissor) \ + VK_DEVICE_PFN(vkCmdSetStencilCompareMask) \ + VK_DEVICE_PFN(vkCmdSetStencilReference) \ + VK_DEVICE_PFN(vkCmdSetStencilWriteMask) \ + VK_DEVICE_PFN(vkCmdSetViewport) \ + VK_DEVICE_PFN(vkCmdUpdateBuffer) \ + VK_DEVICE_PFN(vkCmdWaitEvents) \ + VK_DEVICE_PFN(vkCmdWriteTimestamp) \ + VK_DEVICE_PFN(vkCreateBuffer) \ + VK_DEVICE_PFN(vkCreateBufferView) \ + VK_DEVICE_PFN(vkCreateCommandPool) \ + VK_DEVICE_PFN(vkCreateComputePipelines) \ + VK_DEVICE_PFN(vkCreateDescriptorPool) \ + VK_DEVICE_PFN(vkCreateDescriptorSetLayout) \ + VK_DEVICE_PFN(vkCreateEvent) \ + VK_DEVICE_PFN(vkCreateFence) \ + VK_DEVICE_PFN(vkCreateFramebuffer) \ + VK_DEVICE_PFN(vkCreateGraphicsPipelines) \ + VK_DEVICE_PFN(vkCreateImage) \ + VK_DEVICE_PFN(vkCreateImageView) \ + VK_DEVICE_PFN(vkCreatePipelineCache) \ + VK_DEVICE_PFN(vkCreatePipelineLayout) \ + VK_DEVICE_PFN(vkCreateQueryPool) \ + VK_DEVICE_PFN(vkCreateRenderPass) \ + VK_DEVICE_PFN(vkCreateSampler) \ + VK_DEVICE_PFN(vkCreateSemaphore) \ + VK_DEVICE_PFN(vkCreateShaderModule) \ + VK_DEVICE_PFN(vkDestroyBuffer) \ + VK_DEVICE_PFN(vkDestroyBufferView) \ + VK_DEVICE_PFN(vkDestroyCommandPool) \ + VK_DEVICE_PFN(vkDestroyDescriptorPool) \ + VK_DEVICE_PFN(vkDestroyDescriptorSetLayout) \ + VK_DEVICE_PFN(vkDestroyDevice) \ + VK_DEVICE_PFN(vkDestroyEvent) \ + VK_DEVICE_PFN(vkDestroyFence) \ + VK_DEVICE_PFN(vkDestroyFramebuffer) \ + VK_DEVICE_PFN(vkDestroyImage) \ + VK_DEVICE_PFN(vkDestroyImageView) \ + VK_DEVICE_PFN(vkDestroyPipeline) \ + VK_DEVICE_PFN(vkDestroyPipelineCache) \ + VK_DEVICE_PFN(vkDestroyPipelineLayout) \ + VK_DEVICE_PFN(vkDestroyQueryPool) \ + VK_DEVICE_PFN(vkDestroyRenderPass) \ + VK_DEVICE_PFN(vkDestroySampler) \ + VK_DEVICE_PFN(vkDestroySemaphore) \ + VK_DEVICE_PFN(vkDestroyShaderModule) \ + VK_DEVICE_PFN(vkDeviceWaitIdle) \ + VK_DEVICE_PFN(vkEndCommandBuffer) \ + VK_DEVICE_PFN(vkFlushMappedMemoryRanges) \ + VK_DEVICE_PFN(vkFreeCommandBuffers) \ + VK_DEVICE_PFN(vkFreeDescriptorSets) \ + VK_DEVICE_PFN(vkFreeMemory) \ + VK_DEVICE_PFN(vkGetBufferMemoryRequirements) \ + VK_DEVICE_PFN(vkGetDeviceMemoryCommitment) \ + VK_DEVICE_PFN(vkGetDeviceQueue) \ + VK_DEVICE_PFN(vkGetEventStatus) \ + VK_DEVICE_PFN(vkGetFenceStatus) \ + VK_DEVICE_PFN(vkGetImageMemoryRequirements) \ + VK_DEVICE_PFN(vkGetImageSparseMemoryRequirements) \ + VK_DEVICE_PFN(vkGetImageSubresourceLayout) \ + VK_DEVICE_PFN(vkGetPipelineCacheData) \ + VK_DEVICE_PFN(vkGetQueryPoolResults) \ + VK_DEVICE_PFN(vkGetRenderAreaGranularity) \ + VK_DEVICE_PFN(vkInvalidateMappedMemoryRanges) \ + VK_DEVICE_PFN(vkMapMemory) \ + VK_DEVICE_PFN(vkMergePipelineCaches) \ + VK_DEVICE_PFN(vkQueueBindSparse) \ + VK_DEVICE_PFN(vkQueueSubmit) \ + VK_DEVICE_PFN(vkQueueWaitIdle) \ + VK_DEVICE_PFN(vkResetCommandBuffer) \ + VK_DEVICE_PFN(vkResetCommandPool) \ + VK_DEVICE_PFN(vkResetDescriptorPool) \ + VK_DEVICE_PFN(vkResetEvent) \ + VK_DEVICE_PFN(vkResetFences) \ + VK_DEVICE_PFN(vkSetEvent) \ + VK_DEVICE_PFN(vkUnmapMemory) \ + VK_DEVICE_PFN(vkUpdateDescriptorSets) \ + VK_DEVICE_PFN(vkWaitForFences) + +#define DECLARE_VK_PFN(name) PFN_##name name; + +struct vulkan_ops +{ +#define VK_INSTANCE_PFN DECLARE_VK_PFN +#define VK_DEVICE_PFN DECLARE_VK_PFN + VK_DEVICE_FUNCS() + VK_INSTANCE_FUNCS() +#undef VK_INSTANCE_PFN +#undef VK_DEVICE_PFN + + PFN_vkCreateInstance vkCreateInstance; + PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr; +}; + +struct wined3d_vk_info +{ + VkInstance instance; + struct vulkan_ops vk_ops; +}; + +#define VK_CALL(f) (vk_info->vk_ops.f) + +#endif /* __WINE_WINED3D_VK */ -- 2.19.2

2 1