wine-devel March 2019

wine-devel@winehq.org

76 participants
1010 discussions

[PATCH vkd3d 6/7] vkd3d: Add partial support for 2D NULL SRVs.
by Józef Kucia 28 Mar '19

28 Mar '19

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d/resource.c | 163 ++++++++++++++++++++++++++++++------- libs/vkd3d/vkd3d_private.h | 3 + 2 files changed, 135 insertions(+), 31 deletions(-) diff --git a/libs/vkd3d/resource.c b/libs/vkd3d/resource.c index 294150858800..a6c22fd007c9 100644 --- a/libs/vkd3d/resource.c +++ b/libs/vkd3d/resource.c @@ -19,6 +19,7 @@ #include "vkd3d_private.h" #define VKD3D_NULL_CBV_BUFFER_SIZE 4 +#define VKD3D_NULL_VIEW_FORMAT DXGI_FORMAT_R8G8B8A8_UNORM static unsigned int vkd3d_select_memory_type(struct d3d12_device *device, uint32_t memory_type_mask, const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags) @@ -1884,7 +1885,7 @@ static bool init_default_texture_view_desc(struct vkd3d_texture_view_desc *desc, } static bool vkd3d_create_texture_view(struct d3d12_device *device, - struct d3d12_resource *resource, const struct vkd3d_texture_view_desc *desc, + VkImage vk_image, const struct vkd3d_texture_view_desc *desc, struct vkd3d_view **view) { const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; @@ -1894,12 +1895,10 @@ static bool vkd3d_create_texture_view(struct d3d12_device *device, VkImageView vk_view; VkResult vr; - assert(d3d12_resource_is_texture(resource)); - view_desc.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; view_desc.pNext = NULL; view_desc.flags = 0; - view_desc.image = resource->u.vk_image; + view_desc.image = vk_image; view_desc.viewType = desc->view_type; view_desc.format = format->vk_format; vkd3d_set_view_swizzle_for_format(&view_desc.components, format, desc->allowed_swizzle); @@ -1976,6 +1975,57 @@ static unsigned int vkd3d_view_flags_from_d3d12_buffer_srv_flags(D3D12_BUFFER_SR return 0; } +static void vkd3d_create_null_srv(struct d3d12_desc *descriptor, + struct d3d12_device *device, const D3D12_SHADER_RESOURCE_VIEW_DESC *desc) +{ + struct vkd3d_null_resources *null_resources = &device->null_resources; + struct vkd3d_texture_view_desc vkd3d_desc; + struct vkd3d_view *view; + VkImage vk_image; + + if (!desc) + { + WARN("D3D12_SHADER_RESOURCE_VIEW_DESC is required for NULL view.\n"); + return; + } + + switch (desc->ViewDimension) + { + case D3D12_SRV_DIMENSION_TEXTURE2D: + vk_image = null_resources->vk_2d_image; + vkd3d_desc.view_type = VK_IMAGE_VIEW_TYPE_2D; + break; + case D3D12_SRV_DIMENSION_TEXTURE2DARRAY: + vk_image = null_resources->vk_2d_image; + vkd3d_desc.view_type = VK_IMAGE_VIEW_TYPE_2D_ARRAY; + break; + + default: + FIXME("Unhandled view dimension %#x.\n", desc->ViewDimension); + return; + } + + WARN("Creating NULL SRV %#x.\n", desc->ViewDimension); + + vkd3d_desc.format = vkd3d_get_format(VKD3D_NULL_VIEW_FORMAT, 0); + vkd3d_desc.miplevel_idx = 0; + vkd3d_desc.miplevel_count = 1; + vkd3d_desc.layer_idx = 0; + vkd3d_desc.layer_count = 1; + vkd3d_desc.components.r = VK_COMPONENT_SWIZZLE_ZERO; + vkd3d_desc.components.g = VK_COMPONENT_SWIZZLE_ZERO; + vkd3d_desc.components.b = VK_COMPONENT_SWIZZLE_ZERO; + vkd3d_desc.components.a = VK_COMPONENT_SWIZZLE_ZERO; + vkd3d_desc.allowed_swizzle = true; + + if (!vkd3d_create_texture_view(device, vk_image, &vkd3d_desc, &view)) + return; + + descriptor->magic = VKD3D_DESCRIPTOR_MAGIC_SRV; + descriptor->vk_descriptor_type = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE; + descriptor->u.view = view; +} + static void vkd3d_create_buffer_srv(struct d3d12_desc *descriptor, struct d3d12_device *device, struct d3d12_resource *resource, const D3D12_SHADER_RESOURCE_VIEW_DESC *desc) @@ -2017,7 +2067,7 @@ void d3d12_desc_create_srv(struct d3d12_desc *descriptor, if (!resource) { - FIXME("NULL resource SRV not implemented.\n"); + vkd3d_create_null_srv(descriptor, device, desc); return; } @@ -2104,7 +2154,7 @@ void d3d12_desc_create_srv(struct d3d12_desc *descriptor, } } - if (!vkd3d_create_texture_view(device, resource, &vkd3d_desc, &view)) + if (!vkd3d_create_texture_view(device, resource->u.vk_image, &vkd3d_desc, &view)) return; descriptor->magic = VKD3D_DESCRIPTOR_MAGIC_SRV; @@ -2226,7 +2276,7 @@ static void vkd3d_create_texture_uav(struct d3d12_desc *descriptor, } } - if (!vkd3d_create_texture_view(device, resource, &vkd3d_desc, &view)) + if (!vkd3d_create_texture_view(device, resource->u.vk_image, &vkd3d_desc, &view)) return; descriptor->magic = VKD3D_DESCRIPTOR_MAGIC_UAV; @@ -2489,7 +2539,9 @@ void d3d12_rtv_desc_create_rtv(struct d3d12_rtv_desc *rtv_desc, struct d3d12_dev vkd3d_desc.layer_count = resource->desc.DepthOrArraySize; } - if (!vkd3d_create_texture_view(device, resource, &vkd3d_desc, &view)) + assert(d3d12_resource_is_texture(resource)); + + if (!vkd3d_create_texture_view(device, resource->u.vk_image, &vkd3d_desc, &view)) return; rtv_desc->magic = VKD3D_DESCRIPTOR_MAGIC_RTV; @@ -2570,7 +2622,9 @@ void d3d12_dsv_desc_create_dsv(struct d3d12_dsv_desc *dsv_desc, struct d3d12_dev } } - if (!vkd3d_create_texture_view(device, resource, &vkd3d_desc, &view)) + assert(d3d12_resource_is_texture(resource)); + + if (!vkd3d_create_texture_view(device, resource->u.vk_image, &vkd3d_desc, &view)) return; dsv_desc->magic = VKD3D_DESCRIPTOR_MAGIC_DSV; @@ -3089,6 +3143,7 @@ static HRESULT vkd3d_init_null_resources_data(struct vkd3d_null_resources *null_ VkCommandBufferBeginInfo begin_info; VkCommandBuffer vk_command_buffer; VkFence vk_fence = VK_NULL_HANDLE; + VkImageMemoryBarrier barrier; VkFenceCreateInfo fence_info; struct vkd3d_queue *queue; VkSubmitInfo submit_info; @@ -3131,8 +3186,29 @@ static HRESULT vkd3d_init_null_resources_data(struct vkd3d_null_resources *null_ goto done; } + /* fill CBV buffer */ VK_CALL(vkCmdFillBuffer(vk_command_buffer, null_resource->vk_uniform_buffer, 0, VK_WHOLE_SIZE, 0x00000000)); + /* transition 2D SRV image */ + barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; + barrier.pNext = NULL; + barrier.srcAccessMask = 0; + barrier.dstAccessMask = 0; + barrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; + barrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + barrier.image = null_resource->vk_2d_image; + barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + barrier.subresourceRange.baseMipLevel = 0; + barrier.subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS; + barrier.subresourceRange.baseArrayLayer = 0; + barrier.subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS; + + VK_CALL(vkCmdPipelineBarrier(vk_command_buffer, + VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, + 0, NULL, 0, NULL, 1, &barrier)); + if ((vr = VK_CALL(vkEndCommandBuffer(vk_command_buffer))) < 0) { WARN("Failed to end command buffer, vr %d.\n", vr); @@ -3185,8 +3261,7 @@ HRESULT vkd3d_init_null_resources(struct vkd3d_null_resources *null_resources, struct d3d12_device *device) { D3D12_HEAP_PROPERTIES heap_properties; - D3D12_RESOURCE_DESC buffer_desc; - VkResult vr; + D3D12_RESOURCE_DESC resource_desc; HRESULT hr; TRACE("Creating resources for NULL views.\n"); @@ -3196,33 +3271,55 @@ HRESULT vkd3d_init_null_resources(struct vkd3d_null_resources *null_resources, memset(&heap_properties, 0, sizeof(heap_properties)); heap_properties.Type = D3D12_HEAP_TYPE_DEFAULT; - buffer_desc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER; - buffer_desc.Alignment = 0; - buffer_desc.Width = VKD3D_NULL_CBV_BUFFER_SIZE; - buffer_desc.Height = 1; - buffer_desc.DepthOrArraySize = 1; - buffer_desc.MipLevels = 1; - buffer_desc.Format = DXGI_FORMAT_UNKNOWN; - buffer_desc.SampleDesc.Count = 1; - buffer_desc.SampleDesc.Quality = 0; - buffer_desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR; - buffer_desc.Flags = D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE; + /* CBV */ + resource_desc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER; + resource_desc.Alignment = 0; + resource_desc.Width = VKD3D_NULL_CBV_BUFFER_SIZE; + resource_desc.Height = 1; + resource_desc.DepthOrArraySize = 1; + resource_desc.MipLevels = 1; + resource_desc.Format = DXGI_FORMAT_UNKNOWN; + resource_desc.SampleDesc.Count = 1; + resource_desc.SampleDesc.Quality = 0; + resource_desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR; + resource_desc.Flags = D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE; if (FAILED(hr = vkd3d_create_buffer(device, &heap_properties, D3D12_HEAP_FLAG_NONE, - &buffer_desc, &null_resources->vk_uniform_buffer))) + &resource_desc, &null_resources->vk_uniform_buffer))) goto fail; - - if ((vr = vkd3d_set_vk_object_name_utf8(device, (uint64_t)null_resources->vk_uniform_buffer, - VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, "NULL CBV buffer")) < 0) - WARN("Failed to set object name, vr %d.\n", vr); - if (FAILED(hr = vkd3d_allocate_buffer_memory(device, null_resources->vk_uniform_buffer, &heap_properties, D3D12_HEAP_FLAG_NONE, &null_resources->vk_uniform_buffer_memory))) goto fail; - if ((vr = vkd3d_set_vk_object_name_utf8(device, (uint64_t)null_resources->vk_uniform_buffer_memory, - VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, "NULL CBV memory")) < 0) - WARN("Failed to set object name, vr %d.\n", vr); + /* 2D SRV */ + resource_desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D; + resource_desc.Alignment = 0; + resource_desc.Width = 1; + resource_desc.Height = 1; + resource_desc.DepthOrArraySize = 1; + resource_desc.MipLevels = 1; + resource_desc.Format = VKD3D_NULL_VIEW_FORMAT; + resource_desc.SampleDesc.Count = 1; + resource_desc.SampleDesc.Quality = 0; + resource_desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN; + resource_desc.Flags = D3D12_RESOURCE_FLAG_NONE; + + if (FAILED(hr = vkd3d_create_image(device, &heap_properties, D3D12_HEAP_FLAG_NONE, + &resource_desc, &null_resources->vk_2d_image))) + goto fail; + if (FAILED(hr = vkd3d_allocate_image_memory(device, null_resources->vk_2d_image, + &heap_properties, D3D12_HEAP_FLAG_NONE, &null_resources->vk_2d_image_memory))) + goto fail; + + /* set Vulkan object names */ + vkd3d_set_vk_object_name_utf8(device, (uint64_t)null_resources->vk_uniform_buffer, + VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT, "NULL CBV buffer"); + vkd3d_set_vk_object_name_utf8(device, (uint64_t)null_resources->vk_uniform_buffer_memory, + VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, "NULL CBV memory"); + vkd3d_set_vk_object_name_utf8(device, (uint64_t)null_resources->vk_2d_image, + VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT, "NULL 2D SRV image"); + vkd3d_set_vk_object_name_utf8(device, (uint64_t)null_resources->vk_2d_image_memory, + VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, "NULL 2D SRV memory"); return vkd3d_init_null_resources_data(null_resources, device); @@ -3239,5 +3336,9 @@ void vkd3d_destroy_null_resources(struct vkd3d_null_resources *null_resources, VK_CALL(vkDestroyBuffer(device->vk_device, null_resources->vk_uniform_buffer, NULL)); VK_CALL(vkFreeMemory(device->vk_device, null_resources->vk_uniform_buffer_memory, NULL)); + + VK_CALL(vkDestroyImage(device->vk_device, null_resources->vk_2d_image, NULL)); + VK_CALL(vkFreeMemory(device->vk_device, null_resources->vk_2d_image_memory, NULL)); + memset(null_resources, 0, sizeof(*null_resources)); } diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index e791d780e80b..7cde1f6baa12 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -882,6 +882,9 @@ struct vkd3d_null_resources { VkBuffer vk_uniform_buffer; VkDeviceMemory vk_uniform_buffer_memory; + + VkImage vk_2d_image; + VkDeviceMemory vk_2d_image_memory; }; HRESULT vkd3d_init_null_resources(struct vkd3d_null_resources *null_resources, -- 2.19.2

2 1

[PATCH vkd3d 5/7] vkd3d: Initialize NULL CBV buffer.
by Józef Kucia 28 Mar '19

28 Mar '19

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d/command.c | 6 +-- libs/vkd3d/resource.c | 107 ++++++++++++++++++++++++++++++++++++- libs/vkd3d/vkd3d_private.h | 4 ++ 3 files changed, 113 insertions(+), 4 deletions(-) diff --git a/libs/vkd3d/command.c b/libs/vkd3d/command.c index 3b479a2fe222..d39458f9c6d9 100644 --- a/libs/vkd3d/command.c +++ b/libs/vkd3d/command.c @@ -55,7 +55,7 @@ void vkd3d_queue_destroy(struct vkd3d_queue *queue) vkd3d_free(queue); } -static VkQueue vkd3d_queue_acquire(struct vkd3d_queue *queue) +VkQueue vkd3d_queue_acquire(struct vkd3d_queue *queue) { int rc; @@ -71,7 +71,7 @@ static VkQueue vkd3d_queue_acquire(struct vkd3d_queue *queue) return queue->vk_queue; } -static void vkd3d_queue_release(struct vkd3d_queue *queue) +void vkd3d_queue_release(struct vkd3d_queue *queue) { TRACE("queue %p.\n", queue); @@ -1164,7 +1164,7 @@ static struct d3d12_command_allocator *unsafe_impl_from_ID3D12CommandAllocator(I return impl_from_ID3D12CommandAllocator(iface); } -static struct vkd3d_queue *d3d12_device_get_vkd3d_queue(struct d3d12_device *device, +struct vkd3d_queue *d3d12_device_get_vkd3d_queue(struct d3d12_device *device, D3D12_COMMAND_LIST_TYPE type) { switch (type) diff --git a/libs/vkd3d/resource.c b/libs/vkd3d/resource.c index 8e16a854c65b..294150858800 100644 --- a/libs/vkd3d/resource.c +++ b/libs/vkd3d/resource.c @@ -3078,6 +3078,109 @@ HRESULT d3d12_query_heap_create(struct d3d12_device *device, const D3D12_QUERY_H return S_OK; } +static HRESULT vkd3d_init_null_resources_data(struct vkd3d_null_resources *null_resource, + struct d3d12_device *device) +{ + const struct vkd3d_vk_device_procs *vk_procs = &device->vk_procs; + VkCommandBufferAllocateInfo command_buffer_info; + VkCommandPool vk_command_pool = VK_NULL_HANDLE; + VkCommandPoolCreateInfo command_pool_info; + VkDevice vk_device = device->vk_device; + VkCommandBufferBeginInfo begin_info; + VkCommandBuffer vk_command_buffer; + VkFence vk_fence = VK_NULL_HANDLE; + VkFenceCreateInfo fence_info; + struct vkd3d_queue *queue; + VkSubmitInfo submit_info; + VkQueue vk_queue; + VkResult vr; + + queue = d3d12_device_get_vkd3d_queue(device, D3D12_COMMAND_LIST_TYPE_DIRECT); + + command_pool_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; + command_pool_info.pNext = NULL; + command_pool_info.flags = 0; + command_pool_info.queueFamilyIndex = queue->vk_family_index; + + if ((vr = VK_CALL(vkCreateCommandPool(vk_device, &command_pool_info, NULL, &vk_command_pool))) < 0) + { + WARN("Failed to create Vulkan command pool, vr %d.\n", vr); + goto done; + } + + command_buffer_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; + command_buffer_info.pNext = NULL; + command_buffer_info.commandPool = vk_command_pool; + command_buffer_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; + command_buffer_info.commandBufferCount = 1; + + if ((vr = VK_CALL(vkAllocateCommandBuffers(vk_device, &command_buffer_info, &vk_command_buffer))) < 0) + { + WARN("Failed to allocate Vulkan command buffer, vr %d.\n", vr); + goto done; + } + + begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + begin_info.pNext = NULL; + begin_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; + begin_info.pInheritanceInfo = NULL; + + if ((vr = VK_CALL(vkBeginCommandBuffer(vk_command_buffer, &begin_info))) < 0) + { + WARN("Failed to begin command buffer, vr %d.\n", vr); + goto done; + } + + VK_CALL(vkCmdFillBuffer(vk_command_buffer, null_resource->vk_uniform_buffer, 0, VK_WHOLE_SIZE, 0x00000000)); + + if ((vr = VK_CALL(vkEndCommandBuffer(vk_command_buffer))) < 0) + { + WARN("Failed to end command buffer, vr %d.\n", vr); + goto done; + } + + fence_info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; + fence_info.pNext = NULL; + fence_info.flags = 0; + + if ((vr = VK_CALL(vkCreateFence(device->vk_device, &fence_info, NULL, &vk_fence))) < 0) + { + WARN("Failed to create Vulkan fence, vr %d.\n", vr); + goto done; + } + + submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + submit_info.pNext = NULL; + submit_info.waitSemaphoreCount = 0; + submit_info.pWaitSemaphores = NULL; + submit_info.pWaitDstStageMask = NULL; + submit_info.commandBufferCount = 1; + submit_info.pCommandBuffers = &vk_command_buffer; + submit_info.signalSemaphoreCount = 0; + submit_info.pSignalSemaphores = NULL; + + if (!(vk_queue = vkd3d_queue_acquire(queue))) + { + WARN("Failed to acquire queue %p.\n", queue); + goto done; + } + + if ((vr = VK_CALL(vkQueueSubmit(vk_queue, 1, &submit_info, vk_fence))) < 0) + ERR("Failed to submit, vr %d.\n", vr); + + vkd3d_queue_release(queue); + + vr = VK_CALL(vkWaitForFences(device->vk_device, 1, &vk_fence, VK_FALSE, ~(uint64_t)0)); + if (vr != VK_SUCCESS) + WARN("Failed to wait fo fence, vr %d.\n", vr); + +done: + VK_CALL(vkDestroyCommandPool(vk_device, vk_command_pool, NULL)); + VK_CALL(vkDestroyFence(vk_device, vk_fence, NULL)); + + return hresult_from_vk_result(vr); +} + HRESULT vkd3d_init_null_resources(struct vkd3d_null_resources *null_resources, struct d3d12_device *device) { @@ -3086,6 +3189,8 @@ HRESULT vkd3d_init_null_resources(struct vkd3d_null_resources *null_resources, VkResult vr; HRESULT hr; + TRACE("Creating resources for NULL views.\n"); + memset(null_resources, 0, sizeof(*null_resources)); memset(&heap_properties, 0, sizeof(heap_properties)); @@ -3119,7 +3224,7 @@ HRESULT vkd3d_init_null_resources(struct vkd3d_null_resources *null_resources, VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT, "NULL CBV memory")) < 0) WARN("Failed to set object name, vr %d.\n", vr); - return S_OK; + return vkd3d_init_null_resources_data(null_resources, device); fail: ERR("Failed to initialize NULL resources, hr %#x.\n", hr); diff --git a/libs/vkd3d/vkd3d_private.h b/libs/vkd3d/vkd3d_private.h index babe5db23363..e791d780e80b 100644 --- a/libs/vkd3d/vkd3d_private.h +++ b/libs/vkd3d/vkd3d_private.h @@ -835,10 +835,12 @@ struct vkd3d_queue uint32_t timestamp_bits; }; +VkQueue vkd3d_queue_acquire(struct vkd3d_queue *queue) DECLSPEC_HIDDEN; HRESULT vkd3d_queue_create(struct d3d12_device *device, uint32_t family_index, const VkQueueFamilyProperties *properties, struct vkd3d_queue **queue) DECLSPEC_HIDDEN; void vkd3d_queue_destroy(struct vkd3d_queue *queue) DECLSPEC_HIDDEN; +void vkd3d_queue_release(struct vkd3d_queue *queue) DECLSPEC_HIDDEN; /* ID3D12CommandQueue */ struct d3d12_command_queue @@ -935,6 +937,8 @@ struct d3d12_device HRESULT d3d12_device_create(struct vkd3d_instance *instance, const struct vkd3d_device_create_info *create_info, struct d3d12_device **device) DECLSPEC_HIDDEN; +struct vkd3d_queue *d3d12_device_get_vkd3d_queue(struct d3d12_device *device, + D3D12_COMMAND_LIST_TYPE type) DECLSPEC_HIDDEN; void d3d12_device_mark_as_removed(struct d3d12_device *device, HRESULT reason, const char *message, ...) VKD3D_PRINTF_FUNC(3, 4) DECLSPEC_HIDDEN; struct d3d12_device *unsafe_impl_from_ID3D12Device(ID3D12Device *iface) DECLSPEC_HIDDEN; -- 2.19.2

2 1

[PATCH vkd3d 3/7] vkd3d: Add more Vulkan feature checks.
by Józef Kucia 28 Mar '19

28 Mar '19

From: Józef Kucia <jkucia(a)codeweavers.com> Sort the list alphabetically. Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d/device.c | 25 +++++++++++++++---------- 1 file changed, 15 insertions(+), 10 deletions(-) diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index 929e846ecb4b..bc5f370ba635 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -920,6 +920,9 @@ static void vkd3d_init_feature_level(struct vkd3d_vulkan_info *vk_info, have_11_0 = false; \ } + if (!vk_info->device_limits.timestampComputeAndGraphics) + WARN("Timestamps are not supported on all graphics and compute queues.\n"); + CHECK_MIN_REQUIREMENT(maxPushConstantsSize, D3D12_MAX_ROOT_COST * sizeof(uint32_t)); CHECK_MIN_REQUIREMENT(maxComputeSharedMemorySize, D3D12_CS_TGSM_REGISTER_COUNT * sizeof(uint32_t)); @@ -930,24 +933,26 @@ static void vkd3d_init_feature_level(struct vkd3d_vulkan_info *vk_info, CHECK_MIN_REQUIREMENT(maxPerStageDescriptorUniformBuffers, D3D12_COMMONSHADER_CONSTANT_BUFFER_REGISTER_COUNT); + CHECK_FEATURE(depthBiasClamp); + CHECK_FEATURE(depthClamp); + CHECK_FEATURE(drawIndirectFirstInstance); + CHECK_FEATURE(dualSrcBlend); + CHECK_FEATURE(fragmentStoresAndAtomics); + CHECK_FEATURE(fullDrawIndexUint32); + CHECK_FEATURE(geometryShader); CHECK_FEATURE(imageCubeArray); CHECK_FEATURE(independentBlend); - CHECK_FEATURE(geometryShader); - CHECK_FEATURE(tessellationShader); - CHECK_FEATURE(sampleRateShading); - CHECK_FEATURE(dualSrcBlend); CHECK_FEATURE(multiDrawIndirect); - CHECK_FEATURE(drawIndirectFirstInstance); - CHECK_FEATURE(depthClamp); - CHECK_FEATURE(depthBiasClamp); CHECK_FEATURE(multiViewport); CHECK_FEATURE(occlusionQueryPrecise); CHECK_FEATURE(pipelineStatisticsQuery); - CHECK_FEATURE(fragmentStoresAndAtomics); - CHECK_FEATURE(shaderImageGatherExtended); - CHECK_FEATURE(shaderStorageImageWriteWithoutFormat); + CHECK_FEATURE(samplerAnisotropy); + CHECK_FEATURE(sampleRateShading); CHECK_FEATURE(shaderClipDistance); CHECK_FEATURE(shaderCullDistance); + CHECK_FEATURE(shaderImageGatherExtended); + CHECK_FEATURE(shaderStorageImageWriteWithoutFormat); + CHECK_FEATURE(tessellationShader); if (!vk_info->EXT_transform_feedback) WARN("Stream output is not supported.\n"); -- 2.19.2

2 1

[PATCH vkd3d 2/7] vkd3d: Add support for optional device extensions.
by Józef Kucia 28 Mar '19

28 Mar '19

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- include/vkd3d.h | 13 +++++++++++++ libs/vkd3d/device.c | 38 ++++++++++++++++++++++++++++++++----- tests/vkd3d_api.c | 46 +++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 92 insertions(+), 5 deletions(-) diff --git a/include/vkd3d.h b/include/vkd3d.h index 3d560b564a67..39c4c6bdd1bc 100644 --- a/include/vkd3d.h +++ b/include/vkd3d.h @@ -42,6 +42,8 @@ enum vkd3d_structure_type VKD3D_STRUCTURE_TYPE_OPTIONAL_INSTANCE_EXTENSIONS_INFO, + VKD3D_STRUCTURE_TYPE_OPTIONAL_DEVICE_EXTENSIONS_INFO, + VKD3D_FORCE_32_BIT_ENUM(VKD3D_STRUCTURE_TYPE), }; @@ -71,6 +73,7 @@ struct vkd3d_instance_create_info uint32_t instance_extension_count; }; +/* Extends vkd3d_instance_create_info. */ struct vkd3d_optional_instance_extensions_info { enum vkd3d_structure_type type; @@ -99,6 +102,16 @@ struct vkd3d_device_create_info LUID adapter_luid; }; +/* Extends vkd3d_device_create_info. */ +struct vkd3d_optional_device_extensions_info +{ + enum vkd3d_structure_type type; + const void *next; + + const char * const *extensions; + uint32_t extension_count; +}; + /* vkd3d_image_resource_create_info flags */ #define VKD3D_RESOURCE_INITIAL_STATE_TRANSITION 0x00000001 #define VKD3D_RESOURCE_PRESENT_STATE_TRANSITION 0x00000002 diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index 60cac0d10b3f..929e846ecb4b 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -974,12 +974,13 @@ static void vkd3d_init_feature_level(struct vkd3d_vulkan_info *vk_info, } static HRESULT vkd3d_init_device_caps(struct d3d12_device *device, - const struct vkd3d_device_create_info *create_info, - VkPhysicalDeviceFeatures2KHR *features2, uint32_t *device_extension_count) + const struct vkd3d_device_create_info *create_info, VkPhysicalDeviceFeatures2KHR *features2, + uint32_t *device_extension_count, bool **user_extension_supported) { const struct vkd3d_vk_instance_procs *vk_procs = &device->vkd3d_instance->vk_procs; VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT vertex_divisor_properties; const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT *divisor_features; + const struct vkd3d_optional_device_extensions_info *optional_extensions; VkPhysicalDeviceTransformFeedbackPropertiesEXT xfb_properties; VkPhysicalDevice physical_device = device->vk_physical_device; VkPhysicalDeviceFeatures *features = &features2->features; @@ -1076,11 +1077,27 @@ static HRESULT vkd3d_init_device_caps(struct d3d12_device *device, return hresult_from_vk_result(vr); } + optional_extensions = vkd3d_find_struct(create_info->next, OPTIONAL_DEVICE_EXTENSIONS_INFO); + if (optional_extensions && optional_extensions->extension_count) + { + if (!(*user_extension_supported = vkd3d_calloc(optional_extensions->extension_count, sizeof(bool)))) + { + vkd3d_free(vk_extensions); + return E_OUTOFMEMORY; + } + } + else + { + *user_extension_supported = NULL; + } + *device_extension_count = vkd3d_check_extensions(vk_extensions, count, required_device_extensions, ARRAY_SIZE(required_device_extensions), optional_device_extensions, ARRAY_SIZE(optional_device_extensions), create_info->device_extensions, create_info->device_extension_count, - NULL, 0, NULL, vulkan_info, "device"); + optional_extensions ? optional_extensions->extensions : NULL, + optional_extensions ? optional_extensions->extension_count : 0, + *user_extension_supported, vulkan_info, "device"); divisor_features = vk_find_struct(features2->pNext, PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT); if (get_spec_version(vk_extensions, count, VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME) >= 3 @@ -1338,9 +1355,11 @@ static HRESULT vkd3d_create_vk_device(struct d3d12_device *device, { const struct vkd3d_vk_instance_procs *vk_procs = &device->vkd3d_instance->vk_procs; VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT vertex_divisor_features; + const struct vkd3d_optional_device_extensions_info *optional_extensions; VkPhysicalDeviceTransformFeedbackFeaturesEXT xfb_features; struct vkd3d_vulkan_info *vulkan_info = &device->vk_info; struct vkd3d_device_queue_info device_queue_info; + bool *user_extension_supported = NULL; VkPhysicalDeviceFeatures2 features2; VkPhysicalDevice physical_device; VkDeviceCreateInfo device_info; @@ -1385,11 +1404,17 @@ static HRESULT vkd3d_create_vk_device(struct d3d12_device *device, else VK_CALL(vkGetPhysicalDeviceFeatures(physical_device, &features2.features)); - if (FAILED(hr = vkd3d_init_device_caps(device, create_info, &features2, &extension_count))) + if (FAILED(hr = vkd3d_init_device_caps(device, create_info, &features2, + &extension_count, &user_extension_supported))) return hr; if (!(extensions = vkd3d_calloc(extension_count, sizeof(*extensions)))) + { + vkd3d_free(user_extension_supported); return E_OUTOFMEMORY; + } + + optional_extensions = vkd3d_find_struct(create_info->next, OPTIONAL_DEVICE_EXTENSIONS_INFO); /* Create device */ device_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; @@ -1403,9 +1428,12 @@ static HRESULT vkd3d_create_vk_device(struct d3d12_device *device, required_device_extensions, ARRAY_SIZE(required_device_extensions), optional_device_extensions, ARRAY_SIZE(optional_device_extensions), create_info->device_extensions, create_info->device_extension_count, - NULL, 0, NULL, &device->vk_info); + optional_extensions ? optional_extensions->extensions : NULL, + optional_extensions ? optional_extensions->extension_count : 0, + user_extension_supported, &device->vk_info); device_info.ppEnabledExtensionNames = extensions; device_info.pEnabledFeatures = &features2.features; + vkd3d_free(user_extension_supported); vr = VK_CALL(vkCreateDevice(physical_device, &device_info, NULL, &vk_device)); vkd3d_free(extensions); diff --git a/tests/vkd3d_api.c b/tests/vkd3d_api.c index f84409be8311..89b388fdf510 100644 --- a/tests/vkd3d_api.c +++ b/tests/vkd3d_api.c @@ -478,6 +478,51 @@ static void test_additional_device_extensions(void) ok(!refcount, "Instance has %u references left.\n", refcount); } +static void test_optional_device_extensions(void) +{ + static const char * const extensions[] = + { + "VK_VKD3D_invalid_extension", + VK_KHR_BIND_MEMORY_2_EXTENSION_NAME, + }; + + struct vkd3d_optional_device_extensions_info optional_extensions; + 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; + 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; + device_create_info.device_extensions = extensions; + device_create_info.device_extension_count = ARRAY_SIZE(extensions); + hr = vkd3d_create_device(&device_create_info, &IID_ID3D12Device, (void **)&device); + ok(hr == E_FAIL, "Got unexpected hr %#x.\n", hr); + + optional_extensions.type = VKD3D_STRUCTURE_TYPE_OPTIONAL_DEVICE_EXTENSIONS_INFO; + optional_extensions.next = NULL; + optional_extensions.extensions = extensions; + optional_extensions.extension_count = ARRAY_SIZE(extensions); + + device_create_info.next = &optional_extensions; + device_create_info.device_extensions = NULL; + device_create_info.device_extension_count = 0; + hr = vkd3d_create_device(&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); + 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; @@ -1039,6 +1084,7 @@ START_TEST(vkd3d_api) run_test(test_create_device); run_test(test_required_device_extensions); run_test(test_additional_device_extensions); + run_test(test_optional_device_extensions); run_test(test_physical_device); run_test(test_adapter_luid); run_test(test_device_parent); -- 2.19.2

2 1

[PATCH vkd3d 1/7] vkd3d: Trace device properties for selected device.
by Józef Kucia 28 Mar '19

28 Mar '19

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Józef Kucia <jkucia(a)codeweavers.com> --- libs/vkd3d/device.c | 30 ++++++++++++++++++------------ 1 file changed, 18 insertions(+), 12 deletions(-) diff --git a/libs/vkd3d/device.c b/libs/vkd3d/device.c index 8b35f40aea99..60cac0d10b3f 100644 --- a/libs/vkd3d/device.c +++ b/libs/vkd3d/device.c @@ -615,24 +615,30 @@ VkInstance vkd3d_instance_get_vk_instance(struct vkd3d_instance *instance) return instance->vk_instance; } +static void vkd3d_trace_physical_device_properties(const VkPhysicalDeviceProperties *properties) +{ + const uint32_t driver_version = properties->driverVersion; + const uint32_t api_version = properties->apiVersion; + + TRACE("Device name: %s.\n", properties->deviceName); + TRACE("Vendor ID: %#x, Device ID: %#x.\n", properties->vendorID, properties->deviceID); + TRACE("Driver version: %#x (%u.%u.%u, %u.%u.%u.%u).\n", driver_version, + VK_VERSION_MAJOR(driver_version), VK_VERSION_MINOR(driver_version), VK_VERSION_PATCH(driver_version), + driver_version >> 22, (driver_version >> 14) & 0xff, (driver_version >> 6) & 0xff, driver_version & 0x3f); + TRACE("API version: %u.%u.%u.\n", + VK_VERSION_MAJOR(api_version), VK_VERSION_MINOR(api_version), VK_VERSION_PATCH(api_version)); +} + static void vkd3d_trace_physical_device(VkPhysicalDevice device, const VkPhysicalDeviceProperties *vk_device_properties, const struct vkd3d_vk_instance_procs *vk_procs) { - const uint32_t driver_version = vk_device_properties->driverVersion; - const uint32_t api_version = vk_device_properties->apiVersion; VkPhysicalDeviceMemoryProperties memory_properties; VkQueueFamilyProperties *queue_properties; unsigned int i, j; uint32_t count; - TRACE("Device name: %s.\n", vk_device_properties->deviceName); - TRACE("Vendor ID: %#x, Device ID: %#x.\n", vk_device_properties->vendorID, vk_device_properties->deviceID); - TRACE("Driver version: %#x (%u.%u.%u, %u.%u.%u.%u).\n", driver_version, - VK_VERSION_MAJOR(driver_version), VK_VERSION_MINOR(driver_version), VK_VERSION_PATCH(driver_version), - driver_version >> 22, (driver_version >> 14) & 0xff, (driver_version >> 6) & 0xff, driver_version & 0x3f); - TRACE("API version: %u.%u.%u.\n", - VK_VERSION_MAJOR(api_version), VK_VERSION_MINOR(api_version), VK_VERSION_PATCH(api_version)); + vkd3d_trace_physical_device_properties(vk_device_properties); VK_CALL(vkGetPhysicalDeviceQueueFamilyProperties(device, &count, NULL)); TRACE("Queue families [%u]:\n", count); @@ -985,8 +991,6 @@ static HRESULT vkd3d_init_device_caps(struct d3d12_device *device, *device_extension_count = 0; - vkd3d_trace_physical_device_features(features2); - memset(&xfb_properties, 0, sizeof(xfb_properties)); xfb_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT; memset(&vertex_divisor_properties, 0, sizeof(vertex_divisor_properties)); @@ -999,6 +1003,8 @@ static HRESULT vkd3d_init_device_caps(struct d3d12_device *device, else VK_CALL(vkGetPhysicalDeviceProperties(physical_device, &device_properties2.properties)); + vkd3d_trace_physical_device(physical_device, &device_properties2.properties, vk_procs); + vkd3d_trace_physical_device_features(features2); vkd3d_trace_physical_device_limits(&device_properties2); vulkan_info->device_limits = device_properties2.properties.limits; @@ -1144,7 +1150,7 @@ static HRESULT vkd3d_select_physical_device(struct vkd3d_instance *instance, for (i = 0; i < count; ++i) { VK_CALL(vkGetPhysicalDeviceProperties(physical_devices[i], &device_properties)); - vkd3d_trace_physical_device(physical_devices[i], &device_properties, vk_procs); + vkd3d_trace_physical_device_properties(&device_properties); if (i == device_index) device = physical_devices[i]; -- 2.19.2

2 1

[PATCH] wined3d: Added nVidia RTX adapters
by Sveinar Søpler 28 Mar '19

28 Mar '19

Added pci-id and info for nVidia RTX adapters: RTX2060, RTX2070, RTX2080 and RTX2080Ti Signed-off-by: Sveinar Søpler <cybermax(a)dexter.no> --- dlls/wined3d/adapter_gl.c | 4 ++++ dlls/wined3d/directx.c | 4 ++++ dlls/wined3d/wined3d_private.h | 4 ++++ 3 files changed, 12 insertions(+) diff --git a/dlls/wined3d/adapter_gl.c b/dlls/wined3d/adapter_gl.c index 99073f4fbf..df1a69e5ca 100644 --- a/dlls/wined3d/adapter_gl.c +++ b/dlls/wined3d/adapter_gl.c @@ -1304,6 +1304,10 @@ cards_nvidia_binary[] = /* Direct 3D 11 */ {"TITAN V", CARD_NVIDIA_TITANV}, /* GeForce 1000 - highend */ {"TITAN X (Pascal)", CARD_NVIDIA_TITANX_PASCAL}, /* GeForce 1000 - highend */ + {"RTX 2080 Ti", CARD_NVIDIA_GEFORCE_RTX2080TI}, /* GeForce 2000 - highend */ + {"RTX 2080", CARD_NVIDIA_GEFORCE_RTX2080}, /* GeForce 2000 - highend */ + {"RTX 2070", CARD_NVIDIA_GEFORCE_RTX2070}, /* GeForce 2000 - highend */ + {"RTX 2060", CARD_NVIDIA_GEFORCE_RTX2060}, /* GeForce 2000 - highend */ {"GTX 1080 Ti", CARD_NVIDIA_GEFORCE_GTX1080TI}, /* GeForce 1000 - highend */ {"GTX 1080", CARD_NVIDIA_GEFORCE_GTX1080}, /* GeForce 1000 - highend */ {"GTX 1070", CARD_NVIDIA_GEFORCE_GTX1070}, /* GeForce 1000 - highend */ diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c index 45e28719df..395a55cc73 100644 --- a/dlls/wined3d/directx.c +++ b/dlls/wined3d/directx.c @@ -329,6 +329,10 @@ static const struct wined3d_gpu_description gpu_description_table[] = {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX1070, "NVIDIA GeForce GTX 1070", DRIVER_NVIDIA_GEFORCE8, 8192}, {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX1080, "NVIDIA GeForce GTX 1080", DRIVER_NVIDIA_GEFORCE8, 8192}, {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX1080TI, "NVIDIA GeForce GTX 1080 Ti", DRIVER_NVIDIA_GEFORCE8, 11264}, + {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_RTX2060, "NVIDIA GeForce RTX 2060", DRIVER_NVIDIA_GEFORCE8, 6144}, + {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_RTX2070, "NVIDIA GeForce RTX 2070", DRIVER_NVIDIA_GEFORCE8, 8192}, + {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_RTX2080, "NVIDIA GeForce RTX 2080", DRIVER_NVIDIA_GEFORCE8, 8192}, + {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_RTX2080TI, "NVIDIA GeForce RTX 2080 Ti", DRIVER_NVIDIA_GEFORCE8, 11264}, {HW_VENDOR_NVIDIA, CARD_NVIDIA_TITANX_PASCAL, "NVIDIA TITAN X (Pascal)", DRIVER_NVIDIA_GEFORCE8, 12288}, {HW_VENDOR_NVIDIA, CARD_NVIDIA_TITANV, "NVIDIA TITAN V", DRIVER_NVIDIA_GEFORCE8, 12288}, diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 22e7441ced..219ad02cbf 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2446,6 +2446,10 @@ enum wined3d_pci_device CARD_NVIDIA_GEFORCE_GTX1070 = 0x1b81, CARD_NVIDIA_GEFORCE_GTX1080 = 0x1b80, CARD_NVIDIA_GEFORCE_GTX1080TI = 0x1b06, + CARD_NVIDIA_GEFORCE_RTX2060 = 0x1f08, + CARD_NVIDIA_GEFORCE_RTX2070 = 0x1f07, + CARD_NVIDIA_GEFORCE_RTX2080 = 0x1e87, + CARD_NVIDIA_GEFORCE_RTX2080TI = 0x1e07, CARD_NVIDIA_TITANX_PASCAL = 0x1b00, CARD_NVIDIA_TITANV = 0x1d81, -- 2.17.1

1 0

[PATCH 1/2] scrrun/tests: Add more Clone() tests.
by Gijs Vermeulen 28 Mar '19

28 Mar '19

Signed-off-by: Gijs Vermeulen <gijsvrm(a)gmail.com> --- dlls/scrrun/tests/filesystem.c | 75 +++++++++++++++++++++++++--------- 1 file changed, 55 insertions(+), 20 deletions(-) diff --git a/dlls/scrrun/tests/filesystem.c b/dlls/scrrun/tests/filesystem.c index 29ee73f243..54363f08ba 100644 --- a/dlls/scrrun/tests/filesystem.c +++ b/dlls/scrrun/tests/filesystem.c @@ -973,6 +973,52 @@ static void test_GetFolder(void) IFolder_Release(folder); } +static void test_clone(IEnumVARIANT *enumvar, BOOL position_inherited) +{ + HRESULT hr; + IEnumVARIANT *clone; + ULONG fetched; + VARIANT var, var2; + + hr = IEnumVARIANT_Reset(enumvar); + ok(hr == S_OK, "got 0x%08x\n", hr); + + VariantInit(&var); + fetched = -1; + hr = IEnumVARIANT_Next(enumvar, 1, &var, &fetched); + ok(hr == S_OK, "got 0x%08x\n", hr); + ok(fetched == 1, "got %d\n", fetched); + + /* clone enumerator */ + hr = IEnumVARIANT_Clone(enumvar, &clone); + ok(hr == S_OK, "got 0x%08x\n", hr); + ok(clone != enumvar, "got %p, %p\n", enumvar, clone); + + /* check if clone inherits position */ + VariantInit(&var2); + fetched = -1; + hr = IEnumVARIANT_Next(clone, 1, &var2, &fetched); + ok(hr == S_OK, "got 0x%08x\n", hr); + ok(fetched == 1, "got %d\n", fetched); + if (!position_inherited) + todo_wine ok(V_DISPATCH(&var) == V_DISPATCH(&var2), "values don't match\n"); + else + { + fetched = -1; + hr = IEnumVARIANT_Next(enumvar, 1, &var, &fetched); + ok(hr == S_OK, "got 0x%08x\n", hr); + ok(fetched == 1, "got %d\n", fetched); + todo_wine ok(V_DISPATCH(&var) == V_DISPATCH(&var2), "values don't match\n"); + } + + VariantClear(&var2); + VariantClear(&var); + IEnumVARIANT_Release(clone); + + hr = IEnumVARIANT_Reset(enumvar); + ok(hr == S_OK, "got 0x%08x\n", hr); +} + /* Please keep the tests for IFolderCollection and IFileCollection in sync */ static void test_FolderCollection(void) { @@ -982,7 +1028,7 @@ static void test_FolderCollection(void) static const WCHAR cW[] = {'\\','c',0}; IFolderCollection *folders; WCHAR buffW[MAX_PATH], pathW[MAX_PATH]; - IEnumVARIANT *enumvar, *clone; + IEnumVARIANT *enumvar; LONG count, ref, ref2, i; IUnknown *unk, *unk2; IFolder *folder; @@ -1068,14 +1114,7 @@ static void test_FolderCollection(void) ref2 = GET_REFCOUNT(folders); ok(ref2 == ref, "got %d, %d\n", ref2, ref); - /* clone enumerator */ - hr = IEnumVARIANT_Clone(enumvar, &clone); - ok(hr == S_OK, "got 0x%08x\n", hr); - ok(clone != enumvar, "got %p, %p\n", enumvar, clone); - IEnumVARIANT_Release(clone); - - hr = IEnumVARIANT_Reset(enumvar); - ok(hr == S_OK, "got 0x%08x\n", hr); + test_clone(enumvar, FALSE); for (i = 0; i < 3; i++) { @@ -1165,7 +1204,7 @@ static void test_FileCollection(void) IFolder *folder; IFileCollection *files; IFile *file; - IEnumVARIANT *enumvar, *clone; + IEnumVARIANT *enumvar; LONG count, ref, ref2, i; IUnknown *unk, *unk2; ULONG fetched; @@ -1245,14 +1284,7 @@ static void test_FileCollection(void) ref2 = GET_REFCOUNT(files); ok(ref2 == ref, "got %d, %d\n", ref2, ref); - /* clone enumerator */ - hr = IEnumVARIANT_Clone(enumvar, &clone); - ok(hr == S_OK, "got 0x%08x\n", hr); - ok(clone != enumvar, "got %p, %p\n", enumvar, clone); - IEnumVARIANT_Release(clone); - - hr = IEnumVARIANT_Reset(enumvar); - ok(hr == S_OK, "got 0x%08x\n", hr); + test_clone(enumvar, FALSE); for (i = 0; i < 3; i++) { @@ -1329,7 +1361,7 @@ static void test_FileCollection(void) static void test_DriveCollection(void) { IDriveCollection *drives; - IEnumVARIANT *enumvar; + IEnumVARIANT *enumvar, *clone; ULONG fetched; VARIANT var; HRESULT hr; @@ -1366,10 +1398,13 @@ static void test_DriveCollection(void) hr = IEnumVARIANT_Skip(enumvar, 1); ok(hr == S_FALSE, "got 0x%08x\n", hr); - /* reset and iterate again */ hr = IEnumVARIANT_Reset(enumvar); ok(hr == S_OK, "got 0x%08x\n", hr); + hr = IEnumVARIANT_Clone(enumvar, &clone); + if(hr == S_OK) + test_clone(enumvar, TRUE); + while (IEnumVARIANT_Next(enumvar, 1, &var, &fetched) == S_OK) { IDrive *drive = (IDrive*)V_DISPATCH(&var); DriveTypeConst type; -- 2.21.0

1 1

[PATCH v5 1/2] user32/tests: Use calculated EC_USEFONTINFO margins in the CJK case. (resend)
by Akihiro Sagawa 28 Mar '19

28 Mar '19

In v5, reflect Nikolay's comment. Thanks for the review. Since the font metrics vary between versions, we calculate the expected value in the tests. Signed-off-by: Akihiro Sagawa <sagawa.aki(a)gmail.com> --- dlls/user32/tests/edit.c | 90 ++++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 75 insertions(+), 15 deletions(-)

1 1

RFC: reducing wasted disk space from addon files
by Vincent Povirk 28 Mar '19

28 Mar '19

I'm considering implementing a system to allow the majority of Wine Mono to be kept in a shared location, rather than installed separately into each prefix. This is motivated by concerns expressed by Andrew about the amount of space it would take up on Proton, which creates a separate prefix for each game it runs. Currently, Proton doesn't include Wine Mono. An empty Wine prefix on my current build takes up 686 MB. Most of this comes from addon directories that we could put anywhere. drive_c/windows/mono: 237.2 MB drive_c/windows/system32/gecko: 103.7 MB drive_c/windows/syswow64/gecko: 95.7 MB The .msi installers for the addons are also copied into drive_c/windows/Installer, which takes another 186.6 MB. That means that 623.2 MB of the overhead of a Wine prefix is caused by Mono and Gecko. (For those who are curious how much of that can be blamed on me, personally, that number is 323.7 MB.) Design requirements: * Wine must be able to download and verify Gecko and Mono packages if they're not available. We currently accomplish this by downloading msi files from the Wine website and checking them against a hard-coded sha256 hash in Wine. * Wine Mono contains some registry entries and files to make a fake .NET installation. These files and registry entries must be packaged together so that it's possible to remove them when installing native .NET. MSI is very convenient for this, since it manages installs, upgrades, and removals. * The files currently in windows/mono and windows/sys*/gecko must be available once Windows code is running (unless the user chooses not to download them). They may be in a read-only location, and each prefix does not need a unique copy. I am making the assumption that there's no need to write to the gecko folder once Wine Gecko is installed. Proposal #1: Optional shared installs If someone builds Wine from source and does nothing else, everything will work the same way it does now. Wine will download msi packages for Gecko and Mono, and install them. Gecko and Mono will have a new option which installs directory trees to /usr/share/wine. This will include the current contents of windows/mono and windows/sys*/gecko. For Mono, it will also include an msi package which contains the remaining files and registry keys. The addons system will recognize if Gecko or Mono is installed there. If it finds them, it won't download an msi package. If it finds Mono, it will install the msi package from the shared location. We will provide builds of Gecko and Mono as an archive that can be extracted to /usr/share/wine, in addition to the current msi packages. The mscoree and mshtml components will be updated to look for files in this shared location. Proposal #2: CAB packages and shared installs This is the same as proposal #1 for system-wide installs of Gecko or Mono. For downloading and installing addons, we will use a .cab archive instead of .msi. The addon system will download and extract this to a user location but share those files between all of the user's prefixes. The cab contents will be the same as the files that would be installed into /usr/share/wine and will be used in the same way. The .msi packages will be discontinued. This makes the different cases more consistent, but it may make it more difficult for users to install addon packages manually.

12 49

[PATCH 5/5] mshtml: Move detach_document_node call to HTMLDocumentNode_unlink.
by Jacek Caban 28 Mar '19

28 Mar '19

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/mshtml/htmldoc.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)

1 0

← Newer
1
...
8
9
10
11
12
13
14
...
101
Older →

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

wine-devel March 2019