wine-devel May 2020

wine-devel@winehq.org

79 participants
626 discussions

[PATCH 1/5] wined3d: Move device window to the correct output when handling WM_ACTIVATEAPP with full screen swapchains.
by Zhiyi Zhang 18 May '20

18 May '20

Signed-off-by: Zhiyi Zhang <zzhang(a)codeweavers.com> --- dlls/wined3d/swapchain.c | 27 +++++++++++++++++++-------- 1 file changed, 19 insertions(+), 8 deletions(-) diff --git a/dlls/wined3d/swapchain.c b/dlls/wined3d/swapchain.c index dbbfc8e72cd..21e9ec459eb 100644 --- a/dlls/wined3d/swapchain.c +++ b/dlls/wined3d/swapchain.c @@ -1239,9 +1239,11 @@ void wined3d_swapchain_activate(struct wined3d_swapchain *swapchain, BOOL activa { struct wined3d_device *device = swapchain->device; HWND window = swapchain->state.device_window; + struct wined3d_output_desc output_desc; unsigned int screensaver_active; struct wined3d_output *output; BOOL focus_messages, filter; + HRESULT hr; /* This code is not protected by the wined3d mutex, so it may run while * wined3d_device_reset is active. Testing on Windows shows that changing @@ -1251,6 +1253,13 @@ void wined3d_swapchain_activate(struct wined3d_swapchain *swapchain, BOOL activa if (!(focus_messages = device->wined3d->flags & WINED3D_FOCUS_MESSAGES)) filter = wined3d_filter_messages(window, TRUE); + output = wined3d_swapchain_get_output(swapchain); + if (!output) + { + ERR("Failed to get output from swapchain %p.\n", swapchain); + return; + } + if (activate) { SystemParametersInfoW(SPI_GETSCREENSAVEACTIVE, 0, &screensaver_active, 0); @@ -1266,16 +1275,19 @@ void wined3d_swapchain_activate(struct wined3d_swapchain *swapchain, BOOL activa * * Guild Wars 1 wants a WINDOWPOSCHANGED message on the device window to * resume drawing after a focus loss. */ - SetWindowPos(window, NULL, 0, 0, swapchain->state.desc.backbuffer_width, - swapchain->state.desc.backbuffer_height, SWP_NOACTIVATE | SWP_NOZORDER); + if (SUCCEEDED(hr = wined3d_output_get_desc(output, &output_desc))) + SetWindowPos(window, NULL, output_desc.desktop_rect.left, + output_desc.desktop_rect.top, swapchain->state.desc.backbuffer_width, + swapchain->state.desc.backbuffer_height, SWP_NOACTIVATE | SWP_NOZORDER); + else + ERR("Failed to get output description, hr %#x.\n", hr); } if (device->wined3d->flags & WINED3D_RESTORE_MODE_ON_ACTIVATE) { - output = wined3d_swapchain_get_output(swapchain); - if (!output || FAILED(wined3d_output_set_display_mode(output, + if (FAILED(hr = wined3d_output_set_display_mode(output, &swapchain->state.d3d_mode))) - ERR("Failed to set display mode.\n"); + ERR("Failed to set display mode, hr %#x.\n", hr); } if (swapchain == device->swapchains[0]) @@ -1289,9 +1301,8 @@ void wined3d_swapchain_activate(struct wined3d_swapchain *swapchain, BOOL activa device->restore_screensaver = FALSE; } - output = wined3d_swapchain_get_output(swapchain); - if (!output || FAILED(wined3d_output_set_display_mode(output, NULL))) - ERR("Failed to set display mode.\n"); + if (FAILED(hr = wined3d_output_set_display_mode(output, NULL))) + ERR("Failed to set display mode, hr %#x.\n", hr); swapchain->reapply_mode = TRUE; -- 2.25.1

2 1

[PATCH 7/7] wined3d: Implement indexed Vulkan draws.
by Henri Verbeet 18 May '20

18 May '20

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/adapter_vk.c | 28 ++++++++++++++++++++-------- dlls/wined3d/context_vk.c | 24 +++++++++++++++++++++++- dlls/wined3d/wined3d_private.h | 2 +- 3 files changed, 44 insertions(+), 10 deletions(-) diff --git a/dlls/wined3d/adapter_vk.c b/dlls/wined3d/adapter_vk.c index ade56c74077..7d152d70b06 100644 --- a/dlls/wined3d/adapter_vk.c +++ b/dlls/wined3d/adapter_vk.c @@ -1535,7 +1535,8 @@ static void adapter_vk_draw_primitive(struct wined3d_device *device, if (parameters->indirect) indirect_vk = wined3d_buffer_vk(parameters->u.indirect.buffer); - if (!(vk_command_buffer = wined3d_context_vk_apply_draw_state(context_vk, state, indirect_vk))) + if (!(vk_command_buffer = wined3d_context_vk_apply_draw_state(context_vk, + state, indirect_vk, parameters->indexed))) { ERR("Failed to apply draw state.\n"); context_release(&context_vk->c); @@ -1547,17 +1548,23 @@ static void adapter_vk_draw_primitive(struct wined3d_device *device, struct wined3d_bo_vk *bo = &indirect_vk->bo; uint32_t stride, size; - if (!parameters->indexed) - { - wined3d_context_vk_reference_bo(context_vk, bo); - size = indirect_vk->b.resource.size - parameters->u.indirect.offset; + wined3d_context_vk_reference_bo(context_vk, bo); + size = indirect_vk->b.resource.size - parameters->u.indirect.offset; + if (parameters->indexed) + { + stride = sizeof(VkDrawIndexedIndirectCommand); + VK_CALL(vkCmdDrawIndexedIndirect(vk_command_buffer, bo->vk_buffer, + bo->buffer_offset + parameters->u.indirect.offset, size / stride, stride)); + } + else + { stride = sizeof(VkDrawIndirectCommand); VK_CALL(vkCmdDrawIndirect(vk_command_buffer, bo->vk_buffer, bo->buffer_offset + parameters->u.indirect.offset, size / stride, stride)); } } - else if (!parameters->indexed) + else { instance_count = parameters->u.direct.instance_count; if (context_vk->c.instance_count) @@ -1565,8 +1572,13 @@ static void adapter_vk_draw_primitive(struct wined3d_device *device, if (!instance_count) instance_count = 1; - VK_CALL(vkCmdDraw(vk_command_buffer, parameters->u.direct.index_count, instance_count, - parameters->u.direct.start_idx, parameters->u.direct.start_instance)); + if (parameters->indexed) + VK_CALL(vkCmdDrawIndexed(vk_command_buffer, parameters->u.direct.index_count, + instance_count, parameters->u.direct.start_idx, parameters->u.direct.base_vertex_idx, + parameters->u.direct.start_instance)); + else + VK_CALL(vkCmdDraw(vk_command_buffer, parameters->u.direct.index_count, instance_count, + parameters->u.direct.start_idx, parameters->u.direct.start_instance)); } context_release(&context_vk->c); diff --git a/dlls/wined3d/context_vk.c b/dlls/wined3d/context_vk.c index 20f4c0f8b34..f5902bbd65a 100644 --- a/dlls/wined3d/context_vk.c +++ b/dlls/wined3d/context_vk.c @@ -1126,6 +1126,7 @@ void wined3d_context_vk_submit_command_buffer(struct wined3d_context_vk *context context_vk->c.update_compute_shader_resource_bindings = 1; context_vk->c.update_unordered_access_view_bindings = 1; context_vk->c.update_compute_unordered_access_view_bindings = 1; + context_invalidate_state(&context_vk->c, STATE_INDEXBUFFER); VK_CALL(vkEndCommandBuffer(buffer->vk_command_buffer)); @@ -1887,7 +1888,7 @@ static void wined3d_context_vk_load_shader_resources(struct wined3d_context_vk * } VkCommandBuffer wined3d_context_vk_apply_draw_state(struct wined3d_context_vk *context_vk, - const struct wined3d_state *state, struct wined3d_buffer_vk *indirect_vk) + const struct wined3d_state *state, struct wined3d_buffer_vk *indirect_vk, bool indexed) { struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device); const struct wined3d_vk_info *vk_info = context_vk->vk_info; @@ -1950,6 +1951,13 @@ VkCommandBuffer wined3d_context_vk_apply_draw_state(struct wined3d_context_vk *c wined3d_context_vk_load_shader_resources(context_vk, state, WINED3D_PIPELINE_GRAPHICS); + if (indexed) + { + wined3d_buffer_load(state->index_buffer, &context_vk->c, state); + if (!wined3d_buffer_vk(state->index_buffer)->bo_user.valid) + context_invalidate_state(&context_vk->c, STATE_INDEXBUFFER); + } + if (indirect_vk) wined3d_buffer_load(&indirect_vk->b, &context_vk->c, state); @@ -1974,6 +1982,20 @@ VkCommandBuffer wined3d_context_vk_apply_draw_state(struct wined3d_context_vk *c } VK_CALL(vkCmdBindPipeline(vk_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, context_vk->graphics.vk_pipeline)); + if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_INDEXBUFFER) && state->index_buffer) + { + struct wined3d_bo_vk *bo = &wined3d_buffer_vk(state->index_buffer)->bo; + VkIndexType idx_type; + + if (state->index_format == WINED3DFMT_R16_UINT) + idx_type = VK_INDEX_TYPE_UINT16; + else + idx_type = VK_INDEX_TYPE_UINT32; + wined3d_context_vk_reference_bo(context_vk, bo); + VK_CALL(vkCmdBindIndexBuffer(vk_command_buffer, bo->vk_buffer, + bo->buffer_offset + state->index_offset, idx_type)); + } + if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_PIXEL)) || wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_VERTEX)) diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 1f2efd1f785..ef82fd7b0c1 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2412,7 +2412,7 @@ VkDeviceMemory wined3d_context_vk_allocate_vram_chunk_memory(struct wined3d_cont VkCommandBuffer wined3d_context_vk_apply_compute_state(struct wined3d_context_vk *context_vk, const struct wined3d_state *state, struct wined3d_buffer_vk *indirect_vk) DECLSPEC_HIDDEN; VkCommandBuffer wined3d_context_vk_apply_draw_state(struct wined3d_context_vk *context_vk, - const struct wined3d_state *state, struct wined3d_buffer_vk *indirect_vk) DECLSPEC_HIDDEN; + const struct wined3d_state *state, struct wined3d_buffer_vk *indirect_vk, bool indexed) DECLSPEC_HIDDEN; void wined3d_context_vk_cleanup(struct wined3d_context_vk *context_vk) DECLSPEC_HIDDEN; BOOL wined3d_context_vk_create_bo(struct wined3d_context_vk *context_vk, VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags memory_type, struct wined3d_bo_vk *bo) DECLSPEC_HIDDEN; -- 2.20.1

1 0

[PATCH 6/7] wined3d: Implement indirect Vulkan draws.
by Henri Verbeet 18 May '20

18 May '20

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/adapter_vk.c | 23 +++++++++++++++++++++-- dlls/wined3d/context_vk.c | 5 ++++- dlls/wined3d/wined3d_private.h | 2 +- 3 files changed, 26 insertions(+), 4 deletions(-) diff --git a/dlls/wined3d/adapter_vk.c b/dlls/wined3d/adapter_vk.c index 4552eed4b79..ade56c74077 100644 --- a/dlls/wined3d/adapter_vk.c +++ b/dlls/wined3d/adapter_vk.c @@ -1521,6 +1521,7 @@ static void adapter_vk_flush_context(struct wined3d_context *context) static void adapter_vk_draw_primitive(struct wined3d_device *device, const struct wined3d_state *state, const struct wined3d_draw_parameters *parameters) { + struct wined3d_buffer_vk *indirect_vk = NULL; const struct wined3d_vk_info *vk_info; struct wined3d_context_vk *context_vk; VkCommandBuffer vk_command_buffer; @@ -1531,14 +1532,32 @@ static void adapter_vk_draw_primitive(struct wined3d_device *device, context_vk = wined3d_context_vk(context_acquire(device, NULL, 0)); vk_info = context_vk->vk_info; - if (!(vk_command_buffer = wined3d_context_vk_apply_draw_state(context_vk, state))) + if (parameters->indirect) + indirect_vk = wined3d_buffer_vk(parameters->u.indirect.buffer); + + if (!(vk_command_buffer = wined3d_context_vk_apply_draw_state(context_vk, state, indirect_vk))) { ERR("Failed to apply draw state.\n"); context_release(&context_vk->c); return; } - if (!parameters->indirect && !parameters->indexed) + if (parameters->indirect) + { + struct wined3d_bo_vk *bo = &indirect_vk->bo; + uint32_t stride, size; + + if (!parameters->indexed) + { + wined3d_context_vk_reference_bo(context_vk, bo); + size = indirect_vk->b.resource.size - parameters->u.indirect.offset; + + stride = sizeof(VkDrawIndirectCommand); + VK_CALL(vkCmdDrawIndirect(vk_command_buffer, bo->vk_buffer, + bo->buffer_offset + parameters->u.indirect.offset, size / stride, stride)); + } + } + else if (!parameters->indexed) { instance_count = parameters->u.direct.instance_count; if (context_vk->c.instance_count) diff --git a/dlls/wined3d/context_vk.c b/dlls/wined3d/context_vk.c index 8bb2457e1ad..20f4c0f8b34 100644 --- a/dlls/wined3d/context_vk.c +++ b/dlls/wined3d/context_vk.c @@ -1887,7 +1887,7 @@ static void wined3d_context_vk_load_shader_resources(struct wined3d_context_vk * } VkCommandBuffer wined3d_context_vk_apply_draw_state(struct wined3d_context_vk *context_vk, - const struct wined3d_state *state) + const struct wined3d_state *state, struct wined3d_buffer_vk *indirect_vk) { struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device); const struct wined3d_vk_info *vk_info = context_vk->vk_info; @@ -1950,6 +1950,9 @@ VkCommandBuffer wined3d_context_vk_apply_draw_state(struct wined3d_context_vk *c wined3d_context_vk_load_shader_resources(context_vk, state, WINED3D_PIPELINE_GRAPHICS); + if (indirect_vk) + wined3d_buffer_load(&indirect_vk->b, &context_vk->c, state); + if (!(vk_command_buffer = wined3d_context_vk_get_command_buffer(context_vk))) { ERR("Failed to get command buffer.\n"); diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 903057fb0ef..1f2efd1f785 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2412,7 +2412,7 @@ VkDeviceMemory wined3d_context_vk_allocate_vram_chunk_memory(struct wined3d_cont VkCommandBuffer wined3d_context_vk_apply_compute_state(struct wined3d_context_vk *context_vk, const struct wined3d_state *state, struct wined3d_buffer_vk *indirect_vk) DECLSPEC_HIDDEN; VkCommandBuffer wined3d_context_vk_apply_draw_state(struct wined3d_context_vk *context_vk, - const struct wined3d_state *state) DECLSPEC_HIDDEN; + const struct wined3d_state *state, struct wined3d_buffer_vk *indirect_vk) DECLSPEC_HIDDEN; void wined3d_context_vk_cleanup(struct wined3d_context_vk *context_vk) DECLSPEC_HIDDEN; BOOL wined3d_context_vk_create_bo(struct wined3d_context_vk *context_vk, VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags memory_type, struct wined3d_bo_vk *bo) DECLSPEC_HIDDEN; -- 2.20.1

1 0

[PATCH 5/7] wined3d: Implement Vulkan draws.
by Henri Verbeet 18 May '20

18 May '20

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/adapter_vk.c | 35 +++- dlls/wined3d/context_gl.c | 11 +- dlls/wined3d/context_vk.c | 335 +++++++++++++++++++++++++++++++-- dlls/wined3d/texture.c | 14 +- dlls/wined3d/view.c | 1 + dlls/wined3d/wined3d_private.h | 36 ++++ 6 files changed, 392 insertions(+), 40 deletions(-) diff --git a/dlls/wined3d/adapter_vk.c b/dlls/wined3d/adapter_vk.c index 253c3da7264..4552eed4b79 100644 --- a/dlls/wined3d/adapter_vk.c +++ b/dlls/wined3d/adapter_vk.c @@ -859,6 +859,8 @@ static void *adapter_vk_map_bo_address(struct wined3d_context *context, return NULL; } + wined3d_context_vk_end_current_render_pass(context_vk); + vk_barrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER; vk_barrier.pNext = NULL; vk_barrier.srcAccessMask = vk_access_mask_from_buffer_usage(bo->usage); @@ -956,6 +958,8 @@ static void adapter_vk_copy_bo_address(struct wined3d_context *context, return; } + wined3d_context_vk_end_current_render_pass(context_vk); + src_access_mask = vk_access_mask_from_buffer_usage(src_bo->usage); dst_access_mask = vk_access_mask_from_buffer_usage(dst_bo->usage); @@ -1517,7 +1521,36 @@ static void adapter_vk_flush_context(struct wined3d_context *context) static void adapter_vk_draw_primitive(struct wined3d_device *device, const struct wined3d_state *state, const struct wined3d_draw_parameters *parameters) { - FIXME("device %p, state %p, parameters %p.\n", device, state, parameters); + const struct wined3d_vk_info *vk_info; + struct wined3d_context_vk *context_vk; + VkCommandBuffer vk_command_buffer; + uint32_t instance_count; + + TRACE("device %p, state %p, parameters %p.\n", device, state, parameters); + + context_vk = wined3d_context_vk(context_acquire(device, NULL, 0)); + vk_info = context_vk->vk_info; + + if (!(vk_command_buffer = wined3d_context_vk_apply_draw_state(context_vk, state))) + { + ERR("Failed to apply draw state.\n"); + context_release(&context_vk->c); + return; + } + + if (!parameters->indirect && !parameters->indexed) + { + instance_count = parameters->u.direct.instance_count; + if (context_vk->c.instance_count) + instance_count = context_vk->c.instance_count; + if (!instance_count) + instance_count = 1; + + VK_CALL(vkCmdDraw(vk_command_buffer, parameters->u.direct.index_count, instance_count, + parameters->u.direct.start_idx, parameters->u.direct.start_instance)); + } + + context_release(&context_vk->c); } static void adapter_vk_dispatch_compute(struct wined3d_device *device, diff --git a/dlls/wined3d/context_gl.c b/dlls/wined3d/context_gl.c index b168e6026a6..f08f138e848 100644 --- a/dlls/wined3d/context_gl.c +++ b/dlls/wined3d/context_gl.c @@ -4367,15 +4367,6 @@ static GLenum gl_tfb_primitive_type_from_d3d(enum wined3d_primitive_type primiti } } -static unsigned int get_render_target_writemask(const struct wined3d_blend_state *state, unsigned int index) -{ - if (!state) - return 0xf; - if (!state->desc.independent) - index = 0; - return state->desc.rt[index].writemask; -} - /* Routine common to the draw primitive and draw indexed primitive routines */ void draw_primitive(struct wined3d_device *device, const struct wined3d_state *state, const struct wined3d_draw_parameters *parameters) @@ -4433,7 +4424,7 @@ void draw_primitive(struct wined3d_device *device, const struct wined3d_state *s if (!(rtv = fb->render_targets[i]) || rtv->format->id == WINED3DFMT_NULL) continue; - if (get_render_target_writemask(state->blend_state, i)) + if (wined3d_blend_state_get_writemask(state->blend_state, i)) { wined3d_rendertarget_view_load_location(rtv, context, rtv->resource->draw_binding); wined3d_rendertarget_view_invalidate_location(rtv, ~rtv->resource->draw_binding); diff --git a/dlls/wined3d/context_vk.c b/dlls/wined3d/context_vk.c index 2eaf9319790..8bb2457e1ad 100644 --- a/dlls/wined3d/context_vk.c +++ b/dlls/wined3d/context_vk.c @@ -976,6 +976,28 @@ VkRenderPass wined3d_context_vk_get_render_pass(struct wined3d_context_vk *conte return pass->vk_render_pass; } +void wined3d_context_vk_end_current_render_pass(struct wined3d_context_vk *context_vk) +{ + const struct wined3d_vk_info *vk_info = context_vk->vk_info; + VkCommandBuffer vk_command_buffer; + + if (context_vk->vk_render_pass) + { + vk_command_buffer = context_vk->current_command_buffer.vk_command_buffer; + VK_CALL(vkCmdEndRenderPass(vk_command_buffer)); + context_vk->vk_render_pass = VK_NULL_HANDLE; + VK_CALL(vkCmdPipelineBarrier(vk_command_buffer, VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, + VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, 0, NULL, 0, NULL, 0, NULL)); + } + + if (context_vk->vk_framebuffer) + { + wined3d_context_vk_destroy_framebuffer(context_vk, + context_vk->vk_framebuffer, context_vk->current_command_buffer.id); + context_vk->vk_framebuffer = VK_NULL_HANDLE; + } +} + static void wined3d_context_vk_destroy_render_pass(struct wine_rb_entry *entry, void *ctx) { struct wined3d_render_pass_vk *pass = WINE_RB_ENTRY_VALUE(entry, @@ -1002,14 +1024,17 @@ void wined3d_context_vk_cleanup(struct wined3d_context_vk *context_vk) context_vk->vk_command_pool, 1, &buffer->vk_command_buffer)); buffer->vk_command_buffer = VK_NULL_HANDLE; } - VK_CALL(vkDestroyCommandPool(device_vk->vk_device, context_vk->vk_command_pool, NULL)); wined3d_context_vk_wait_command_buffer(context_vk, buffer->id - 1); context_vk->completed_command_buffer_id = buffer->id; heap_free(context_vk->compute.bindings.bindings); + heap_free(context_vk->graphics.bindings.bindings); if (context_vk->vk_descriptor_pool) VK_CALL(vkDestroyDescriptorPool(device_vk->vk_device, context_vk->vk_descriptor_pool, NULL)); + if (context_vk->vk_framebuffer) + VK_CALL(vkDestroyFramebuffer(device_vk->vk_device, context_vk->vk_framebuffer, NULL)); + VK_CALL(vkDestroyCommandPool(device_vk->vk_device, context_vk->vk_command_pool, NULL)); wined3d_context_vk_cleanup_resources(context_vk); wine_rb_destroy(&context_vk->bo_slab_available, wined3d_context_vk_destroy_bo_slab, context_vk); heap_free(context_vk->submitted.buffers); @@ -1094,8 +1119,12 @@ void wined3d_context_vk_submit_command_buffer(struct wined3d_context_vk *context TRACE("Submitting command buffer %p with id 0x%s.\n", buffer->vk_command_buffer, wine_dbgstr_longlong(buffer->id)); + wined3d_context_vk_end_current_render_pass(context_vk); + context_vk->graphics.vk_pipeline = VK_NULL_HANDLE; context_vk->update_compute_pipeline = 1; + context_vk->c.update_shader_resource_bindings = 1; context_vk->c.update_compute_shader_resource_bindings = 1; + context_vk->c.update_unordered_access_view_bindings = 1; context_vk->c.update_compute_unordered_access_view_bindings = 1; VK_CALL(vkEndCommandBuffer(buffer->vk_command_buffer)); @@ -1169,6 +1198,8 @@ void wined3d_context_vk_image_barrier(struct wined3d_context_vk *context_vk, const struct wined3d_vk_info *vk_info = context_vk->vk_info; VkImageMemoryBarrier barrier; + wined3d_context_vk_end_current_render_pass(context_vk); + barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; barrier.pNext = NULL; barrier.srcAccessMask = src_access_mask; @@ -1219,6 +1250,102 @@ static int wined3d_bo_slab_vk_compare(const void *key, const struct wine_rb_entr return k->size - slab->bo.size; } +static bool wined3d_context_vk_begin_render_pass(struct wined3d_context_vk *context_vk, + VkCommandBuffer vk_command_buffer, const struct wined3d_state *state, const struct wined3d_vk_info *vk_info) +{ + struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device); + VkImageView vk_views[WINED3D_MAX_RENDER_TARGETS + 1]; + unsigned int fb_width, fb_height, fb_layer_count; + struct wined3d_rendertarget_view_vk *rtv_vk; + struct wined3d_rendertarget_view *view; + const VkPhysicalDeviceLimits *limits; + VkRenderPassBeginInfo begin_info; + unsigned int attachment_count, i; + VkFramebufferCreateInfo fb_desc; + VkResult vr; + + if (context_vk->vk_render_pass) + return true; + + limits = &wined3d_adapter_vk(device_vk->d.adapter)->device_limits; + fb_width = limits->maxFramebufferWidth; + fb_height = limits->maxFramebufferHeight; + fb_layer_count = limits->maxFramebufferLayers; + attachment_count = 0; + + for (i = 0; i < ARRAY_SIZE(state->fb.render_targets); ++i) + { + if (!(view = state->fb.render_targets[i]) || view->format->id == WINED3DFMT_NULL) + continue; + + rtv_vk = wined3d_rendertarget_view_vk(view); + vk_views[attachment_count] = wined3d_rendertarget_view_vk_get_image_view(rtv_vk, context_vk); + wined3d_context_vk_reference_rendertarget_view(context_vk, rtv_vk); + + if (view->width < fb_width) + fb_width = view->width; + if (view->height < fb_height) + fb_height = view->height; + if (view->layer_count < fb_layer_count) + fb_layer_count = view->layer_count; + ++attachment_count; + } + + if ((state->render_states[WINED3D_RS_ZWRITEENABLE] || state->render_states[WINED3D_RS_ZENABLE]) + && (view = state->fb.depth_stencil)) + { + rtv_vk = wined3d_rendertarget_view_vk(view); + vk_views[attachment_count] = wined3d_rendertarget_view_vk_get_image_view(rtv_vk, context_vk); + wined3d_context_vk_reference_rendertarget_view(context_vk, rtv_vk); + + if (view->width < fb_width) + fb_width = view->width; + if (view->height < fb_height) + fb_height = view->height; + if (view->layer_count < fb_layer_count) + fb_layer_count = view->layer_count; + ++attachment_count; + } + + if (!(context_vk->vk_render_pass = wined3d_context_vk_get_render_pass(context_vk, &state->fb, + ARRAY_SIZE(state->fb.render_targets), state->render_states[WINED3D_RS_ZWRITEENABLE] + || state->render_states[WINED3D_RS_ZENABLE], 0))) + { + ERR("Failed to get render pass.\n"); + return false; + } + + fb_desc.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; + fb_desc.pNext = NULL; + fb_desc.flags = 0; + fb_desc.renderPass = context_vk->vk_render_pass; + fb_desc.attachmentCount = attachment_count; + fb_desc.pAttachments = vk_views; + fb_desc.width = fb_width; + fb_desc.height = fb_height; + fb_desc.layers = fb_layer_count; + + if ((vr = VK_CALL(vkCreateFramebuffer(device_vk->vk_device, &fb_desc, NULL, &context_vk->vk_framebuffer))) < 0) + { + WARN("Failed to create Vulkan framebuffer, vr %s.\n", wined3d_debug_vkresult(vr)); + return false; + } + + begin_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; + begin_info.pNext = NULL; + begin_info.renderPass = context_vk->vk_render_pass; + begin_info.framebuffer = context_vk->vk_framebuffer; + begin_info.renderArea.offset.x = 0; + begin_info.renderArea.offset.y = 0; + begin_info.renderArea.extent.width = fb_width; + begin_info.renderArea.extent.height = fb_height; + begin_info.clearValueCount = 0; + begin_info.pClearValues = NULL; + VK_CALL(vkCmdBeginRenderPass(vk_command_buffer, &begin_info, VK_SUBPASS_CONTENTS_INLINE)); + + return true; +} + static VkResult wined3d_context_vk_create_descriptor_pool(struct wined3d_device_vk *device_vk, const struct wined3d_vk_info *vk_info, VkDescriptorPool *vk_pool) { @@ -1371,7 +1498,7 @@ static bool wined3d_shader_resource_bindings_add_null_srv_binding(struct wined3d } static bool wined3d_context_vk_update_descriptors(struct wined3d_context_vk *context_vk, - VkCommandBuffer vk_command_buffer, const struct wined3d_state *state) + VkCommandBuffer vk_command_buffer, const struct wined3d_state *state, enum wined3d_pipeline pipeline) { struct wined3d_shader_descriptor_writes_vk *writes = &context_vk->descriptor_writes; struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device); @@ -1385,7 +1512,10 @@ static bool wined3d_context_vk_update_descriptors(struct wined3d_context_vk *con struct wined3d_shader_resource_view *srv; const VkDescriptorImageInfo *image_info; struct wined3d_buffer_vk *buffer_vk; + VkDescriptorSetLayout vk_set_layout; + VkPipelineLayout vk_pipeline_layout; struct wined3d_resource *resource; + VkPipelineBindPoint vk_bind_point; VkDescriptorSet vk_descriptor_set; struct wined3d_view_vk *view_vk; struct wined3d_sampler *sampler; @@ -1395,9 +1525,28 @@ static bool wined3d_context_vk_update_descriptors(struct wined3d_context_vk *con VkResult vr; size_t i; - bindings = &context_vk->compute.bindings; - if ((vr = wined3d_context_vk_create_descriptor_set(context_vk, - context_vk->compute.vk_set_layout, &vk_descriptor_set))) + switch (pipeline) + { + case WINED3D_PIPELINE_GRAPHICS: + bindings = &context_vk->graphics.bindings; + vk_bind_point = VK_PIPELINE_BIND_POINT_GRAPHICS; + vk_set_layout = context_vk->graphics.vk_set_layout; + vk_pipeline_layout = context_vk->graphics.vk_pipeline_layout; + break; + + case WINED3D_PIPELINE_COMPUTE: + bindings = &context_vk->compute.bindings; + vk_bind_point = VK_PIPELINE_BIND_POINT_COMPUTE; + vk_set_layout = context_vk->compute.vk_set_layout; + vk_pipeline_layout = context_vk->compute.vk_pipeline_layout; + break; + + default: + ERR("Invalid pipeline %#x.\n", pipeline); + return false; + } + + if ((vr = wined3d_context_vk_create_descriptor_set(context_vk, vk_set_layout, &vk_descriptor_set))) { WARN("Failed to create descriptor set, vr %s.\n", wined3d_debug_vkresult(vr)); return false; @@ -1461,7 +1610,7 @@ static bool wined3d_context_vk_update_descriptors(struct wined3d_context_vk *con break; case WINED3D_SHADER_DESCRIPTOR_TYPE_UAV: - if (!(uav = state->unordered_access_view[WINED3D_PIPELINE_COMPUTE][binding->resource_idx])) + if (!(uav = state->unordered_access_view[pipeline][binding->resource_idx])) { FIXME("NULL unordered access views not implemented.\n"); return false; @@ -1495,7 +1644,7 @@ static bool wined3d_context_vk_update_descriptors(struct wined3d_context_vk *con break; case WINED3D_SHADER_DESCRIPTOR_TYPE_UAV_COUNTER: - if (!(uav = state->unordered_access_view[WINED3D_PIPELINE_COMPUTE][binding->resource_idx])) + if (!(uav = state->unordered_access_view[pipeline][binding->resource_idx])) { FIXME("NULL unordered access view counters not implemented.\n"); return false; @@ -1524,8 +1673,8 @@ static bool wined3d_context_vk_update_descriptors(struct wined3d_context_vk *con } VK_CALL(vkUpdateDescriptorSets(device_vk->vk_device, writes->count, writes->writes, 0, NULL)); - VK_CALL(vkCmdBindDescriptorSets(vk_command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE, - context_vk->compute.vk_pipeline_layout, 0, 1, &vk_descriptor_set, 0, NULL)); + VK_CALL(vkCmdBindDescriptorSets(vk_command_buffer, vk_bind_point, + vk_pipeline_layout, 0, 1, &vk_descriptor_set, 0, NULL)); return true; } @@ -1614,11 +1763,18 @@ fail: return NULL; } +static VkPipeline wined3d_context_vk_get_graphics_pipeline(struct wined3d_context_vk *context_vk) +{ + FIXME("Not implemented.\n"); + + return VK_NULL_HANDLE; +} + static void wined3d_context_vk_load_shader_resources(struct wined3d_context_vk *context_vk, - const struct wined3d_state *state) + const struct wined3d_state *state, enum wined3d_pipeline pipeline) { - const struct wined3d_shader_resource_bindings *bindings = &context_vk->compute.bindings; struct wined3d_shader_descriptor_writes_vk *writes = &context_vk->descriptor_writes; + const struct wined3d_shader_resource_bindings *bindings; const struct wined3d_shader_resource_binding *binding; struct wined3d_unordered_access_view_vk *uav_vk; struct wined3d_shader_resource_view_vk *srv_vk; @@ -1629,6 +1785,21 @@ static void wined3d_context_vk_load_shader_resources(struct wined3d_context_vk * struct wined3d_buffer *buffer; size_t i; + switch (pipeline) + { + case WINED3D_PIPELINE_GRAPHICS: + bindings = &context_vk->graphics.bindings; + break; + + case WINED3D_PIPELINE_COMPUTE: + bindings = &context_vk->compute.bindings; + break; + + default: + ERR("Invalid pipeline %#x.\n", pipeline); + return; + } + writes->count = 0; for (i = 0; i < bindings->count; ++i) { @@ -1643,7 +1814,12 @@ static void wined3d_context_vk_load_shader_resources(struct wined3d_context_vk * buffer_vk = wined3d_buffer_vk(buffer); wined3d_buffer_load(buffer, &context_vk->c, state); if (!buffer_vk->bo_user.valid) - context_invalidate_compute_state(&context_vk->c, STATE_COMPUTE_CONSTANT_BUFFER); + { + if (pipeline == WINED3D_PIPELINE_GRAPHICS) + context_invalidate_state(&context_vk->c, STATE_GRAPHICS_CONSTANT_BUFFER(binding->shader_type)); + else + context_invalidate_compute_state(&context_vk->c, STATE_COMPUTE_CONSTANT_BUFFER); + } break; case WINED3D_SHADER_DESCRIPTOR_TYPE_SRV: @@ -1656,7 +1832,10 @@ static void wined3d_context_vk_load_shader_resources(struct wined3d_context_vk * if (!srv_vk->view_vk.bo_user.valid) { wined3d_shader_resource_view_vk_update(srv_vk, context_vk); - context_invalidate_compute_state(&context_vk->c, STATE_COMPUTE_SHADER_RESOURCE_BINDING); + if (pipeline == WINED3D_PIPELINE_GRAPHICS) + context_invalidate_state(&context_vk->c, STATE_GRAPHICS_SHADER_RESOURCE_BINDING); + else + context_invalidate_compute_state(&context_vk->c, STATE_COMPUTE_SHADER_RESOURCE_BINDING); } wined3d_buffer_load(buffer_from_resource(srv->resource), &context_vk->c, state); } @@ -1667,7 +1846,7 @@ static void wined3d_context_vk_load_shader_resources(struct wined3d_context_vk * break; case WINED3D_SHADER_DESCRIPTOR_TYPE_UAV: - if (!(uav = state->unordered_access_view[WINED3D_PIPELINE_COMPUTE][binding->resource_idx])) + if (!(uav = state->unordered_access_view[pipeline][binding->resource_idx])) break; uav_vk = wined3d_unordered_access_view_vk(uav); @@ -1676,7 +1855,11 @@ static void wined3d_context_vk_load_shader_resources(struct wined3d_context_vk * if (!uav_vk->view_vk.bo_user.valid) { wined3d_unordered_access_view_vk_update(uav_vk, context_vk); - context_invalidate_compute_state(&context_vk->c, STATE_COMPUTE_UNORDERED_ACCESS_VIEW_BINDING); + if (pipeline == WINED3D_PIPELINE_GRAPHICS) + context_invalidate_state(&context_vk->c, STATE_GRAPHICS_UNORDERED_ACCESS_VIEW_BINDING); + else + context_invalidate_compute_state(&context_vk->c, + STATE_COMPUTE_UNORDERED_ACCESS_VIEW_BINDING); } wined3d_buffer_load(buffer_from_resource(uav->resource), &context_vk->c, state); wined3d_unordered_access_view_invalidate_location(uav, ~WINED3D_LOCATION_BUFFER); @@ -1703,6 +1886,122 @@ static void wined3d_context_vk_load_shader_resources(struct wined3d_context_vk * } } +VkCommandBuffer wined3d_context_vk_apply_draw_state(struct wined3d_context_vk *context_vk, + const struct wined3d_state *state) +{ + struct wined3d_device_vk *device_vk = wined3d_device_vk(context_vk->c.device); + const struct wined3d_vk_info *vk_info = context_vk->vk_info; + struct wined3d_rendertarget_view *dsv; + VkCommandBuffer vk_command_buffer; + unsigned int i; + + if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_SHADER(WINED3D_SHADER_TYPE_PIXEL)) + || wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_FRAMEBUFFER)) + context_vk->c.shader_update_mask |= (1u << WINED3D_SHADER_TYPE_PIXEL); + if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_SHADER(WINED3D_SHADER_TYPE_VERTEX))) + context_vk->c.shader_update_mask |= (1u << WINED3D_SHADER_TYPE_VERTEX); + if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_SHADER(WINED3D_SHADER_TYPE_GEOMETRY))) + context_vk->c.shader_update_mask |= (1u << WINED3D_SHADER_TYPE_GEOMETRY); + if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_SHADER(WINED3D_SHADER_TYPE_HULL))) + context_vk->c.shader_update_mask |= (1u << WINED3D_SHADER_TYPE_HULL) | (1u << WINED3D_SHADER_TYPE_DOMAIN); + if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_SHADER(WINED3D_SHADER_TYPE_DOMAIN))) + context_vk->c.shader_update_mask |= (1u << WINED3D_SHADER_TYPE_DOMAIN); + + for (i = 0; i < ARRAY_SIZE(state->fb.render_targets); ++i) + { + struct wined3d_rendertarget_view *rtv; + + if (!(rtv = state->fb.render_targets[i]) || rtv->format->id == WINED3DFMT_NULL) + continue; + + if (wined3d_blend_state_get_writemask(state->blend_state, i)) + { + wined3d_rendertarget_view_load_location(rtv, &context_vk->c, rtv->resource->draw_binding); + wined3d_rendertarget_view_invalidate_location(rtv, ~rtv->resource->draw_binding); + } + else + { + wined3d_rendertarget_view_prepare_location(rtv, &context_vk->c, rtv->resource->draw_binding); + } + } + + if ((dsv = state->fb.depth_stencil)) + { + if (state->render_states[WINED3D_RS_ZWRITEENABLE] || state->render_states[WINED3D_RS_ZENABLE]) + wined3d_rendertarget_view_load_location(dsv, &context_vk->c, dsv->resource->draw_binding); + else + wined3d_rendertarget_view_prepare_location(dsv, &context_vk->c, dsv->resource->draw_binding); + if (state->render_states[WINED3D_RS_ZWRITEENABLE]) + wined3d_rendertarget_view_invalidate_location(dsv, ~dsv->resource->draw_binding); + } + + if (context_vk->c.shader_update_mask & ~(1u << WINED3D_SHADER_TYPE_COMPUTE)) + { + device_vk->d.shader_backend->shader_select(device_vk->d.shader_priv, &context_vk->c, state); + if (!context_vk->graphics.vk_pipeline_layout) + { + ERR("No pipeline layout set.\n"); + return VK_NULL_HANDLE; + } + context_vk->c.shader_update_mask &= 1u << WINED3D_SHADER_TYPE_COMPUTE; + context_vk->c.update_shader_resource_bindings = 1; + context_vk->c.update_unordered_access_view_bindings = 1; + } + + wined3d_context_vk_load_shader_resources(context_vk, state, WINED3D_PIPELINE_GRAPHICS); + + if (!(vk_command_buffer = wined3d_context_vk_get_command_buffer(context_vk))) + { + ERR("Failed to get command buffer.\n"); + return VK_NULL_HANDLE; + } + + if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_FRAMEBUFFER)) + wined3d_context_vk_end_current_render_pass(context_vk); + if (!wined3d_context_vk_begin_render_pass(context_vk, vk_command_buffer, state, vk_info)) + { + ERR("Failed to begin render pass.\n"); + return VK_NULL_HANDLE; + } + + if (!(context_vk->graphics.vk_pipeline = wined3d_context_vk_get_graphics_pipeline(context_vk))) + { + ERR("Failed to get graphics pipeline.\n"); + return VK_NULL_HANDLE; + } + VK_CALL(vkCmdBindPipeline(vk_command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, context_vk->graphics.vk_pipeline)); + + if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_PIXEL)) + || wined3d_context_is_graphics_state_dirty(&context_vk->c, + STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_VERTEX)) + || wined3d_context_is_graphics_state_dirty(&context_vk->c, + STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_GEOMETRY)) + || wined3d_context_is_graphics_state_dirty(&context_vk->c, + STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_HULL)) + || wined3d_context_is_graphics_state_dirty(&context_vk->c, + STATE_CONSTANT_BUFFER(WINED3D_SHADER_TYPE_DOMAIN)) + || wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_GRAPHICS_SHADER_RESOURCE_BINDING)) + context_vk->c.update_shader_resource_bindings = 1; + if (wined3d_context_is_graphics_state_dirty(&context_vk->c, STATE_GRAPHICS_UNORDERED_ACCESS_VIEW_BINDING)) + context_vk->c.update_unordered_access_view_bindings = 1; + + if (context_vk->c.update_shader_resource_bindings || context_vk->c.update_unordered_access_view_bindings) + { + if (!wined3d_context_vk_update_descriptors(context_vk, vk_command_buffer, state, WINED3D_PIPELINE_GRAPHICS)) + { + ERR("Failed to update shader descriptors.\n"); + return VK_NULL_HANDLE; + } + + context_vk->c.update_shader_resource_bindings = 0; + context_vk->c.update_unordered_access_view_bindings = 0; + } + + memset(context_vk->c.dirty_graphics_states, 0, sizeof(context_vk->c.dirty_graphics_states)); + + return vk_command_buffer; +} + VkCommandBuffer wined3d_context_vk_apply_compute_state(struct wined3d_context_vk *context_vk, const struct wined3d_state *state, struct wined3d_buffer_vk *indirect_vk) { @@ -1710,6 +2009,8 @@ VkCommandBuffer wined3d_context_vk_apply_compute_state(struct wined3d_context_vk const struct wined3d_vk_info *vk_info = context_vk->vk_info; VkCommandBuffer vk_command_buffer; + wined3d_context_vk_end_current_render_pass(context_vk); + if (wined3d_context_is_compute_state_dirty(&context_vk->c, STATE_COMPUTE_SHADER)) context_vk->c.shader_update_mask |= 1u << WINED3D_SHADER_TYPE_COMPUTE; @@ -1727,7 +2028,7 @@ VkCommandBuffer wined3d_context_vk_apply_compute_state(struct wined3d_context_vk context_vk->update_compute_pipeline = 1; } - wined3d_context_vk_load_shader_resources(context_vk, state); + wined3d_context_vk_load_shader_resources(context_vk, state, WINED3D_PIPELINE_COMPUTE); if (indirect_vk) wined3d_buffer_load_location(&indirect_vk->b, &context_vk->c, WINED3D_LOCATION_BUFFER); @@ -1754,7 +2055,7 @@ VkCommandBuffer wined3d_context_vk_apply_compute_state(struct wined3d_context_vk if (context_vk->c.update_compute_shader_resource_bindings || context_vk->c.update_compute_unordered_access_view_bindings) { - if (!wined3d_context_vk_update_descriptors(context_vk, vk_command_buffer, state)) + if (!wined3d_context_vk_update_descriptors(context_vk, vk_command_buffer, state, WINED3D_PIPELINE_COMPUTE)) { ERR("Failed to update shader descriptors.\n"); return VK_NULL_HANDLE; diff --git a/dlls/wined3d/texture.c b/dlls/wined3d/texture.c index de6999105d1..e8a92acab9c 100644 --- a/dlls/wined3d/texture.c +++ b/dlls/wined3d/texture.c @@ -6082,18 +6082,6 @@ static void vk_blitter_destroy(struct wined3d_blitter *blitter, struct wined3d_c heap_free(blitter); } -static inline VkImageView wined3d_rendertarget_view_vk_get_image_view(struct wined3d_rendertarget_view_vk *rtv_vk, - struct wined3d_context_vk *context_vk) -{ - struct wined3d_texture_vk *texture_vk; - - if (rtv_vk->vk_image_view) - return rtv_vk->vk_image_view; - - texture_vk = wined3d_texture_vk(wined3d_texture_from_resource(rtv_vk->v.resource)); - return wined3d_texture_vk_get_default_image_info(texture_vk, context_vk)->imageView; -} - static void vk_blitter_clear_rendertargets(struct wined3d_context_vk *context_vk, unsigned int rt_count, const struct wined3d_fb_state *fb, unsigned int rect_count, const RECT *clear_rects, const RECT *draw_rect, uint32_t flags, const struct wined3d_color *colour, float depth, unsigned int stencil) @@ -6225,6 +6213,8 @@ static void vk_blitter_clear_rendertargets(struct wined3d_context_vk *context_vk begin_desc.clearValueCount = attachment_count; begin_desc.pClearValues = clear_values; + wined3d_context_vk_end_current_render_pass(context_vk); + for (i = 0; i < rect_count; ++i) { r.left = max(clear_rects[i].left, draw_rect->left); diff --git a/dlls/wined3d/view.c b/dlls/wined3d/view.c index 10fcd695135..28028a76395 100644 --- a/dlls/wined3d/view.c +++ b/dlls/wined3d/view.c @@ -1547,6 +1547,7 @@ static void wined3d_unordered_access_view_vk_cs_init(void *object) return; } + wined3d_context_vk_end_current_render_pass(context_vk); VK_CALL(vkCmdFillBuffer(wined3d_context_vk_get_command_buffer(context_vk), uav_vk->counter_bo.vk_buffer, uav_vk->counter_bo.buffer_offset, sizeof(uint32_t), 0)); wined3d_context_vk_reference_bo(context_vk, &uav_vk->counter_bo); diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index fff944f7773..903057fb0ef 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2360,6 +2360,15 @@ struct wined3d_context_vk uint32_t update_compute_pipeline : 1; uint32_t padding : 31; + struct + { + VkShaderModule vk_modules[WINED3D_SHADER_TYPE_GRAPHICS_COUNT]; + VkPipeline vk_pipeline; + VkPipelineLayout vk_pipeline_layout; + VkDescriptorSetLayout vk_set_layout; + struct wined3d_shader_resource_bindings bindings; + } graphics; + struct { VkPipeline vk_pipeline; @@ -2381,6 +2390,8 @@ struct wined3d_context_vk struct wined3d_shader_descriptor_writes_vk descriptor_writes; + VkFramebuffer vk_framebuffer; + VkRenderPass vk_render_pass; VkDescriptorPool vk_descriptor_pool; struct wined3d_retired_objects_vk retired; @@ -2400,6 +2411,8 @@ VkDeviceMemory wined3d_context_vk_allocate_vram_chunk_memory(struct wined3d_cont unsigned int pool, size_t size) DECLSPEC_HIDDEN; VkCommandBuffer wined3d_context_vk_apply_compute_state(struct wined3d_context_vk *context_vk, const struct wined3d_state *state, struct wined3d_buffer_vk *indirect_vk) DECLSPEC_HIDDEN; +VkCommandBuffer wined3d_context_vk_apply_draw_state(struct wined3d_context_vk *context_vk, + const struct wined3d_state *state) DECLSPEC_HIDDEN; void wined3d_context_vk_cleanup(struct wined3d_context_vk *context_vk) DECLSPEC_HIDDEN; BOOL wined3d_context_vk_create_bo(struct wined3d_context_vk *context_vk, VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags memory_type, struct wined3d_bo_vk *bo) DECLSPEC_HIDDEN; @@ -2419,6 +2432,7 @@ void wined3d_context_vk_destroy_memory(struct wined3d_context_vk *context_vk, VkDeviceMemory vk_memory, uint64_t command_buffer_id) DECLSPEC_HIDDEN; void wined3d_context_vk_destroy_sampler(struct wined3d_context_vk *context_vk, VkSampler vk_sampler, uint64_t command_buffer_id) DECLSPEC_HIDDEN; +void wined3d_context_vk_end_current_render_pass(struct wined3d_context_vk *context_vk) DECLSPEC_HIDDEN; VkCommandBuffer wined3d_context_vk_get_command_buffer(struct wined3d_context_vk *context_vk) DECLSPEC_HIDDEN; struct wined3d_pipeline_layout_vk *wined3d_context_vk_get_pipeline_layout(struct wined3d_context_vk *context_vk, VkDescriptorSetLayoutBinding *bindings, SIZE_T binding_count) DECLSPEC_HIDDEN; @@ -3387,6 +3401,16 @@ struct wined3d_blend_state struct wine_rb_entry entry; }; +static inline unsigned int wined3d_blend_state_get_writemask(const struct wined3d_blend_state *state, + unsigned int index) +{ + if (!state) + return 0xf; + if (!state->desc.independent) + index = 0; + return state->desc.rt[index].writemask; +} + struct wined3d_rasterizer_state { LONG refcount; @@ -4704,6 +4728,18 @@ static inline struct wined3d_rendertarget_view_vk *wined3d_rendertarget_view_vk( return CONTAINING_RECORD(view, struct wined3d_rendertarget_view_vk, v); } +static inline VkImageView wined3d_rendertarget_view_vk_get_image_view(struct wined3d_rendertarget_view_vk *rtv_vk, + struct wined3d_context_vk *context_vk) +{ + struct wined3d_texture_vk *texture_vk; + + if (rtv_vk->vk_image_view) + return rtv_vk->vk_image_view; + + texture_vk = wined3d_texture_vk(wined3d_texture_from_resource(rtv_vk->v.resource)); + return wined3d_texture_vk_get_default_image_info(texture_vk, context_vk)->imageView; +} + HRESULT wined3d_rendertarget_view_vk_init(struct wined3d_rendertarget_view_vk *view_vk, const struct wined3d_view_desc *desc, struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops) DECLSPEC_HIDDEN; -- 2.20.1

1 0

[PATCH 4/7] wined3d: Introduce a (stub) SPIR-V fixed-function fragment pipe implementation.
by Henri Verbeet 18 May '20

18 May '20

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/adapter_vk.c | 2 +- dlls/wined3d/shader_spirv.c | 82 ++++++++++++++++++++++++++++++++++ dlls/wined3d/wined3d_private.h | 2 + 3 files changed, 85 insertions(+), 1 deletion(-) diff --git a/dlls/wined3d/adapter_vk.c b/dlls/wined3d/adapter_vk.c index 74231652683..253c3da7264 100644 --- a/dlls/wined3d/adapter_vk.c +++ b/dlls/wined3d/adapter_vk.c @@ -1939,7 +1939,7 @@ static BOOL wined3d_adapter_vk_init(struct wined3d_adapter_vk *adapter_vk, goto fail_vulkan; adapter->vertex_pipe = wined3d_spirv_vertex_pipe_init_vk(); - adapter->fragment_pipe = &none_fragment_pipe; + adapter->fragment_pipe = wined3d_spirv_fragment_pipe_init_vk(); adapter->misc_state_template = misc_state_template_vk; adapter->shader_backend = wined3d_spirv_shader_backend_init_vk(); diff --git a/dlls/wined3d/shader_spirv.c b/dlls/wined3d/shader_spirv.c index fc43ec33f93..2dc07b14f1d 100644 --- a/dlls/wined3d/shader_spirv.c +++ b/dlls/wined3d/shader_spirv.c @@ -581,3 +581,85 @@ const struct wined3d_vertex_pipe_ops *wined3d_spirv_vertex_pipe_init_vk(void) { return &spirv_vertex_pipe_vk; } + +static void spirv_fragment_pipe_vk_fp_enable(const struct wined3d_context *context, BOOL enable) +{ + /* Nothing to do. */ +} + +static void spirv_fragment_pipe_vk_fp_get_caps(const struct wined3d_adapter *adapter, struct fragment_caps *caps) +{ + memset(caps, 0, sizeof(*caps)); +} + +static uint32_t spirv_fragment_pipe_vk_fp_get_emul_mask(const struct wined3d_gl_info *gl_info) +{ + return 0; +} + +static void *spirv_fragment_pipe_vk_fp_alloc(const struct wined3d_shader_backend_ops *shader_backend, void *shader_priv) +{ + if (shader_backend != &spirv_shader_backend_vk) + { + FIXME("SPIR-V fragment pipe without SPIR-V shader backend not implemented.\n"); + return NULL; + } + + return shader_priv; +} + +static void spirv_fragment_pipe_vk_fp_free(struct wined3d_device *device, struct wined3d_context *context) +{ + /* Nothing to do. */ +} + +static BOOL spirv_fragment_pipe_vk_fp_alloc_context_data(struct wined3d_context *context) +{ + return TRUE; +} + +static void spirv_fragment_pipe_vk_fp_free_context_data(struct wined3d_context *context) +{ + /* Nothing to do. */ +} + +static const struct wined3d_state_entry_template spirv_fragment_pipe_vk_fp_states[] = +{ + {STATE_RENDER(WINED3D_RS_SHADEMODE), {STATE_RENDER(WINED3D_RS_SHADEMODE), state_nop}}, + {STATE_RENDER(WINED3D_RS_ALPHATESTENABLE), {STATE_RENDER(WINED3D_RS_ALPHATESTENABLE), state_nop}}, + {STATE_RENDER(WINED3D_RS_ALPHAREF), {STATE_RENDER(WINED3D_RS_ALPHAREF), state_nop}}, + {STATE_RENDER(WINED3D_RS_ALPHAFUNC), {STATE_RENDER(WINED3D_RS_ALPHAFUNC), state_nop}}, + {STATE_RENDER(WINED3D_RS_FOGENABLE), {STATE_RENDER(WINED3D_RS_FOGENABLE), state_nop}}, + {STATE_RENDER(WINED3D_RS_SPECULARENABLE), {STATE_RENDER(WINED3D_RS_SPECULARENABLE), state_nop}}, + {STATE_RENDER(WINED3D_RS_FOGCOLOR), {STATE_RENDER(WINED3D_RS_FOGCOLOR), state_nop}}, + {STATE_RENDER(WINED3D_RS_FOGTABLEMODE), {STATE_RENDER(WINED3D_RS_FOGTABLEMODE), state_nop}}, + {STATE_RENDER(WINED3D_RS_FOGSTART), {STATE_RENDER(WINED3D_RS_FOGSTART), state_nop}}, + {STATE_RENDER(WINED3D_RS_FOGEND), {STATE_RENDER(WINED3D_RS_FOGEND), state_nop}}, + {STATE_RENDER(WINED3D_RS_FOGDENSITY), {STATE_RENDER(WINED3D_RS_FOGDENSITY), state_nop}}, + {STATE_RENDER(WINED3D_RS_COLORKEYENABLE), {STATE_RENDER(WINED3D_RS_COLORKEYENABLE), state_nop}}, + {STATE_RENDER(WINED3D_RS_TEXTUREFACTOR), {STATE_RENDER(WINED3D_RS_TEXTUREFACTOR), state_nop}}, + {STATE_RENDER(WINED3D_RS_FOGVERTEXMODE), {STATE_RENDER(WINED3D_RS_FOGVERTEXMODE), state_nop}}, + {STATE_RENDER(WINED3D_RS_POINTSPRITEENABLE), {STATE_RENDER(WINED3D_RS_POINTSPRITEENABLE), state_nop}}, + {STATE_RENDER(WINED3D_RS_SRGBWRITEENABLE), {STATE_RENDER(WINED3D_RS_SRGBWRITEENABLE), state_nop}}, + {STATE_POINT_ENABLE, {STATE_POINT_ENABLE, state_nop}}, + {STATE_COLOR_KEY, {STATE_COLOR_KEY, state_nop}}, + {0}, /* Terminate */ +}; + +static const struct wined3d_fragment_pipe_ops spirv_fragment_pipe_vk = +{ + .fp_enable = spirv_fragment_pipe_vk_fp_enable, + .get_caps = spirv_fragment_pipe_vk_fp_get_caps, + .get_emul_mask = spirv_fragment_pipe_vk_fp_get_emul_mask, + .alloc_private = spirv_fragment_pipe_vk_fp_alloc, + .free_private = spirv_fragment_pipe_vk_fp_free, + .allocate_context_data = spirv_fragment_pipe_vk_fp_alloc_context_data, + .free_context_data = spirv_fragment_pipe_vk_fp_free_context_data, + .color_fixup_supported = shader_spirv_color_fixup_supported, + .states = spirv_fragment_pipe_vk_fp_states, +}; + +const struct wined3d_fragment_pipe_ops *wined3d_spirv_fragment_pipe_init_vk(void) +{ + return &spirv_fragment_pipe_vk; +} diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index ee0e3545c96..fff944f7773 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2513,6 +2513,8 @@ extern const struct wined3d_fragment_pipe_ops nvts_fragment_pipeline DECLSPEC_HI extern const struct wined3d_fragment_pipe_ops nvrc_fragment_pipeline DECLSPEC_HIDDEN; extern const struct wined3d_fragment_pipe_ops glsl_fragment_pipe DECLSPEC_HIDDEN; +const struct wined3d_fragment_pipe_ops *wined3d_spirv_fragment_pipe_init_vk(void) DECLSPEC_HIDDEN; + extern const struct wined3d_vertex_pipe_ops none_vertex_pipe DECLSPEC_HIDDEN; extern const struct wined3d_vertex_pipe_ops ffp_vertex_pipe DECLSPEC_HIDDEN; extern const struct wined3d_vertex_pipe_ops glsl_vertex_pipe DECLSPEC_HIDDEN; -- 2.20.1

1 0

[PATCH 3/7] wined3d: Introduce a (stub) SPIR-V fixed-function vertex pipe implementation.
by Henri Verbeet 18 May '20

18 May '20

From: Józef Kucia <jkucia(a)codeweavers.com> Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/adapter_vk.c | 2 +- dlls/wined3d/shader_spirv.c | 77 ++++++++++++++++++++++++++++++++++ dlls/wined3d/wined3d_private.h | 2 + 3 files changed, 80 insertions(+), 1 deletion(-) diff --git a/dlls/wined3d/adapter_vk.c b/dlls/wined3d/adapter_vk.c index dc229f3465a..74231652683 100644 --- a/dlls/wined3d/adapter_vk.c +++ b/dlls/wined3d/adapter_vk.c @@ -1938,7 +1938,7 @@ static BOOL wined3d_adapter_vk_init(struct wined3d_adapter_vk *adapter_vk, if (!wined3d_adapter_vk_init_format_info(adapter_vk, vk_info)) goto fail_vulkan; - adapter->vertex_pipe = &none_vertex_pipe; + adapter->vertex_pipe = wined3d_spirv_vertex_pipe_init_vk(); adapter->fragment_pipe = &none_fragment_pipe; adapter->misc_state_template = misc_state_template_vk; adapter->shader_backend = wined3d_spirv_shader_backend_init_vk(); diff --git a/dlls/wined3d/shader_spirv.c b/dlls/wined3d/shader_spirv.c index 28add47c7e5..fc43ec33f93 100644 --- a/dlls/wined3d/shader_spirv.c +++ b/dlls/wined3d/shader_spirv.c @@ -1,5 +1,6 @@ /* * Copyright 2018 Henri Verbeet for CodeWeavers + * Copyright 2019 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 @@ -504,3 +505,79 @@ const struct wined3d_shader_backend_ops *wined3d_spirv_shader_backend_init_vk(vo { return &spirv_shader_backend_vk; } + +static void spirv_vertex_pipe_vk_vp_enable(const struct wined3d_context *context, BOOL enable) +{ + /* Nothing to do. */ +} + +static void spirv_vertex_pipe_vk_vp_get_caps(const struct wined3d_adapter *adapter, struct wined3d_vertex_caps *caps) +{ + memset(caps, 0, sizeof(*caps)); +} + +static uint32_t spirv_vertex_pipe_vk_vp_get_emul_mask(const struct wined3d_gl_info *gl_info) +{ + return 0; +} + +static void *spirv_vertex_pipe_vk_vp_alloc(const struct wined3d_shader_backend_ops *shader_backend, void *shader_priv) +{ + if (shader_backend != &spirv_shader_backend_vk) + { + FIXME("SPIR-V vertex pipe without SPIR-V shader backend not implemented.\n"); + return NULL; + } + + return shader_priv; +} + +static void spirv_vertex_pipe_vk_vp_free(struct wined3d_device *device, struct wined3d_context *context) +{ + /* Nothing to do. */ +} + +static const struct wined3d_state_entry_template spirv_vertex_pipe_vk_vp_states[] = +{ + {STATE_RENDER(WINED3D_RS_RANGEFOGENABLE), {STATE_RENDER(WINED3D_RS_RANGEFOGENABLE), state_nop}}, + {STATE_RENDER(WINED3D_RS_CLIPPING), {STATE_RENDER(WINED3D_RS_CLIPPING), state_nop}}, + {STATE_RENDER(WINED3D_RS_LIGHTING), {STATE_RENDER(WINED3D_RS_LIGHTING), state_nop}}, + {STATE_RENDER(WINED3D_RS_AMBIENT), {STATE_RENDER(WINED3D_RS_AMBIENT), state_nop}}, + {STATE_RENDER(WINED3D_RS_COLORVERTEX), {STATE_RENDER(WINED3D_RS_COLORVERTEX), state_nop}}, + {STATE_RENDER(WINED3D_RS_LOCALVIEWER), {STATE_RENDER(WINED3D_RS_LOCALVIEWER), state_nop}}, + {STATE_RENDER(WINED3D_RS_NORMALIZENORMALS), {STATE_RENDER(WINED3D_RS_NORMALIZENORMALS), state_nop}}, + {STATE_RENDER(WINED3D_RS_DIFFUSEMATERIALSOURCE), {STATE_RENDER(WINED3D_RS_DIFFUSEMATERIALSOURCE), state_nop}}, + {STATE_RENDER(WINED3D_RS_SPECULARMATERIALSOURCE), {STATE_RENDER(WINED3D_RS_SPECULARMATERIALSOURCE), state_nop}}, + {STATE_RENDER(WINED3D_RS_AMBIENTMATERIALSOURCE), {STATE_RENDER(WINED3D_RS_AMBIENTMATERIALSOURCE), state_nop}}, + {STATE_RENDER(WINED3D_RS_EMISSIVEMATERIALSOURCE), {STATE_RENDER(WINED3D_RS_EMISSIVEMATERIALSOURCE), state_nop}}, + {STATE_RENDER(WINED3D_RS_VERTEXBLEND), {STATE_RENDER(WINED3D_RS_VERTEXBLEND), state_nop}}, + {STATE_RENDER(WINED3D_RS_CLIPPLANEENABLE), {STATE_RENDER(WINED3D_RS_CLIPPLANEENABLE), state_nop}}, + {STATE_RENDER(WINED3D_RS_POINTSIZE), {STATE_RENDER(WINED3D_RS_POINTSIZE), state_nop}}, + {STATE_RENDER(WINED3D_RS_POINTSIZE_MIN), {STATE_RENDER(WINED3D_RS_POINTSIZE_MIN), state_nop}}, + {STATE_RENDER(WINED3D_RS_POINTSCALEENABLE), {STATE_RENDER(WINED3D_RS_POINTSCALEENABLE), state_nop}}, + {STATE_RENDER(WINED3D_RS_POINTSCALE_A), {STATE_RENDER(WINED3D_RS_POINTSCALE_A), state_nop}}, + {STATE_RENDER(WINED3D_RS_POINTSCALE_B), {STATE_RENDER(WINED3D_RS_POINTSCALE_B), state_nop}}, + {STATE_RENDER(WINED3D_RS_POINTSCALE_C), {STATE_RENDER(WINED3D_RS_POINTSCALE_C), state_nop}}, + {STATE_RENDER(WINED3D_RS_POINTSIZE_MAX), {STATE_RENDER(WINED3D_RS_POINTSIZE_MAX), state_nop}}, + {STATE_RENDER(WINED3D_RS_INDEXEDVERTEXBLENDENABLE), {STATE_RENDER(WINED3D_RS_INDEXEDVERTEXBLENDENABLE), state_nop}}, + {STATE_RENDER(WINED3D_RS_TWEENFACTOR), {STATE_RENDER(WINED3D_RS_TWEENFACTOR), state_nop}}, + {STATE_MATERIAL, {STATE_MATERIAL, state_nop}}, + {STATE_SHADER(WINED3D_SHADER_TYPE_VERTEX), {STATE_SHADER(WINED3D_SHADER_TYPE_VERTEX), state_nop}}, + {STATE_LIGHT_TYPE, {STATE_LIGHT_TYPE, state_nop}}, + {0}, /* Terminate */ +}; + +static const struct wined3d_vertex_pipe_ops spirv_vertex_pipe_vk = +{ + .vp_enable = spirv_vertex_pipe_vk_vp_enable, + .vp_get_caps = spirv_vertex_pipe_vk_vp_get_caps, + .vp_get_emul_mask = spirv_vertex_pipe_vk_vp_get_emul_mask, + .vp_alloc = spirv_vertex_pipe_vk_vp_alloc, + .vp_free = spirv_vertex_pipe_vk_vp_free, + .vp_states = spirv_vertex_pipe_vk_vp_states, +}; + +const struct wined3d_vertex_pipe_ops *wined3d_spirv_vertex_pipe_init_vk(void) +{ + return &spirv_vertex_pipe_vk; +} diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index 82ea7239c6a..ee0e3545c96 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -2517,6 +2517,8 @@ extern const struct wined3d_vertex_pipe_ops none_vertex_pipe DECLSPEC_HIDDEN; extern const struct wined3d_vertex_pipe_ops ffp_vertex_pipe DECLSPEC_HIDDEN; extern const struct wined3d_vertex_pipe_ops glsl_vertex_pipe DECLSPEC_HIDDEN; +const struct wined3d_vertex_pipe_ops *wined3d_spirv_vertex_pipe_init_vk(void) DECLSPEC_HIDDEN; + /* "Base" state table */ HRESULT compile_state_table(struct wined3d_state_entry *state_table, APPLYSTATEFUNC **dev_multistate_funcs, const struct wined3d_d3d_info *d3d_info, const BOOL *supported_extensions, -- 2.20.1

1 0

[PATCH 2/7] wined3d: Add a supported extensions array to the wined3d_vk_info structure.
by Henri Verbeet 18 May '20

18 May '20

Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/adapter_gl.c | 4 ++-- dlls/wined3d/adapter_vk.c | 7 +++++-- dlls/wined3d/device.c | 4 ++-- dlls/wined3d/directx.c | 4 ++-- dlls/wined3d/wined3d_private.h | 2 +- dlls/wined3d/wined3d_vk.h | 7 +++++++ 6 files changed, 19 insertions(+), 9 deletions(-) diff --git a/dlls/wined3d/adapter_gl.c b/dlls/wined3d/adapter_gl.c index 48a135ce07c..4e953207e42 100644 --- a/dlls/wined3d/adapter_gl.c +++ b/dlls/wined3d/adapter_gl.c @@ -4313,8 +4313,8 @@ static HRESULT adapter_gl_create_device(struct wined3d *wined3d, const struct wi if (!(device_gl = heap_alloc_zero(sizeof(*device_gl)))) return E_OUTOFMEMORY; - if (FAILED(hr = wined3d_device_init(&device_gl->d, wined3d, adapter->ordinal, device_type, - focus_window, flags, surface_alignment, levels, level_count, device_parent))) + if (FAILED(hr = wined3d_device_init(&device_gl->d, wined3d, adapter->ordinal, device_type, focus_window, + flags, surface_alignment, levels, level_count, adapter->gl_info.supported, device_parent))) { WARN("Failed to initialize device, hr %#x.\n", hr); heap_free(device_gl); diff --git a/dlls/wined3d/adapter_vk.c b/dlls/wined3d/adapter_vk.c index cf82d00e40b..dc229f3465a 100644 --- a/dlls/wined3d/adapter_vk.c +++ b/dlls/wined3d/adapter_vk.c @@ -477,8 +477,8 @@ static HRESULT adapter_vk_create_device(struct wined3d *wined3d, const struct wi goto fail; } - if (FAILED(hr = wined3d_device_init(&device_vk->d, wined3d, adapter->ordinal, device_type, - focus_window, flags, surface_alignment, levels, level_count, device_parent))) + if (FAILED(hr = wined3d_device_init(&device_vk->d, wined3d, adapter->ordinal, device_type, focus_window, + flags, surface_alignment, levels, level_count, vk_info->supported, device_parent))) { WARN("Failed to initialize device, hr %#x.\n", hr); wined3d_allocator_cleanup(&device_vk->allocator); @@ -1745,6 +1745,9 @@ static BOOL wined3d_init_vulkan(struct wined3d_vk_info *vk_info) if (!enable_vulkan_instance_extensions(&instance_info.enabledExtensionCount, enabled_instance_extensions, vk_info)) goto fail; + memset(vk_info->supported, 0, sizeof(vk_info->supported)); + vk_info->supported[WINED3D_VK_EXT_NONE] = TRUE; + if ((vr = VK_CALL(vkCreateInstance(&instance_info, NULL, &instance))) < 0) { WARN("Failed to create Vulkan instance, vr %s.\n", wined3d_debug_vkresult(vr)); diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c index ffc73bd2339..349dcbaad7d 100644 --- a/dlls/wined3d/device.c +++ b/dlls/wined3d/device.c @@ -5683,7 +5683,7 @@ static BOOL wined3d_select_feature_level(const struct wined3d_adapter *adapter, HRESULT wined3d_device_init(struct wined3d_device *device, struct wined3d *wined3d, unsigned int adapter_idx, enum wined3d_device_type device_type, HWND focus_window, unsigned int flags, BYTE surface_alignment, const enum wined3d_feature_level *levels, unsigned int level_count, - struct wined3d_device_parent *device_parent) + const BOOL *supported_extensions, struct wined3d_device_parent *device_parent) { struct wined3d_adapter *adapter = wined3d->adapters[adapter_idx]; const struct wined3d_fragment_pipe_ops *fragment_pipeline; @@ -5723,7 +5723,7 @@ HRESULT wined3d_device_init(struct wined3d_device *device, struct wined3d *wined if (vertex_pipeline->vp_states && fragment_pipeline->states && FAILED(hr = compile_state_table(device->state_table, device->multistate_funcs, - &adapter->d3d_info, adapter->gl_info.supported, vertex_pipeline, + &adapter->d3d_info, supported_extensions, vertex_pipeline, fragment_pipeline, adapter->misc_state_template))) { ERR("Failed to compile state table, hr %#x.\n", hr); diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c index b6a9b502d82..0b945919b96 100644 --- a/dlls/wined3d/directx.c +++ b/dlls/wined3d/directx.c @@ -2483,8 +2483,8 @@ static HRESULT adapter_no3d_create_device(struct wined3d *wined3d, const struct if (!(device_no3d = heap_alloc_zero(sizeof(*device_no3d)))) return E_OUTOFMEMORY; - if (FAILED(hr = wined3d_device_init(&device_no3d->d, wined3d, adapter->ordinal, device_type, - focus_window, flags, surface_alignment, levels, level_count, device_parent))) + if (FAILED(hr = wined3d_device_init(&device_no3d->d, wined3d, adapter->ordinal, device_type, focus_window, + flags, surface_alignment, levels, level_count, adapter->gl_info.supported, device_parent))) { WARN("Failed to initialize device, hr %#x.\n", hr); heap_free(device_no3d); diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index dda26aacd07..82ea7239c6a 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -3572,7 +3572,7 @@ void wined3d_device_destroy_default_samplers(struct wined3d_device *device, HRESULT wined3d_device_init(struct wined3d_device *device, struct wined3d *wined3d, unsigned int adapter_idx, enum wined3d_device_type device_type, HWND focus_window, unsigned int flags, BYTE surface_alignment, const enum wined3d_feature_level *levels, unsigned int level_count, - struct wined3d_device_parent *device_parent) DECLSPEC_HIDDEN; + const BOOL *supported_extensions, struct wined3d_device_parent *device_parent) DECLSPEC_HIDDEN; LRESULT device_process_message(struct wined3d_device *device, HWND window, BOOL unicode, UINT message, WPARAM wparam, LPARAM lparam, WNDPROC proc) DECLSPEC_HIDDEN; void device_resource_add(struct wined3d_device *device, struct wined3d_resource *resource) DECLSPEC_HIDDEN; diff --git a/dlls/wined3d/wined3d_vk.h b/dlls/wined3d/wined3d_vk.h index 13e07ab3db4..0c0c1e16cd2 100644 --- a/dlls/wined3d/wined3d_vk.h +++ b/dlls/wined3d/wined3d_vk.h @@ -181,6 +181,12 @@ struct vulkan_ops PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr; }; +enum wined3d_vk_extension +{ + WINED3D_VK_EXT_NONE, + WINED3D_VK_EXT_COUNT, +}; + struct wined3d_vk_info { struct vulkan_ops vk_ops; @@ -188,6 +194,7 @@ struct wined3d_vk_info VkInstance instance; unsigned int api_version; + BOOL supported[WINED3D_VK_EXT_COUNT]; #ifdef USE_WIN32_VULKAN HMODULE vulkan_lib; #endif -- 2.20.1

1 0

[PATCH 1/7] wined3d: Reference shader resources in wined3d_context_vk_update_descriptors().
by Henri Verbeet 18 May '20

18 May '20

Instead of in wined3d_context_vk_load_shader_resources(). Loading resources can end up flushing the current command buffer. There's also no reason to reference the same resource multiple times by the same command buffer. Signed-off-by: Henri Verbeet <hverbeet(a)codeweavers.com> --- dlls/wined3d/context_vk.c | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/dlls/wined3d/context_vk.c b/dlls/wined3d/context_vk.c index f3b0a42b8f1..2eaf9319790 100644 --- a/dlls/wined3d/context_vk.c +++ b/dlls/wined3d/context_vk.c @@ -1379,10 +1379,12 @@ static bool wined3d_context_vk_update_descriptors(struct wined3d_context_vk *con const struct wined3d_shader_resource_binding *binding; struct wined3d_shader_resource_bindings *bindings; struct wined3d_unordered_access_view_vk *uav_vk; + struct wined3d_shader_resource_view_vk *srv_vk; struct wined3d_unordered_access_view *uav; const VkDescriptorBufferInfo *buffer_info; struct wined3d_shader_resource_view *srv; const VkDescriptorImageInfo *image_info; + struct wined3d_buffer_vk *buffer_vk; struct wined3d_resource *resource; VkDescriptorSet vk_descriptor_set; struct wined3d_view_vk *view_vk; @@ -1414,10 +1416,12 @@ static bool wined3d_context_vk_update_descriptors(struct wined3d_context_vk *con FIXME("NULL constant buffer views not implemented.\n"); return false; } - buffer_info = wined3d_buffer_vk_get_buffer_info(wined3d_buffer_vk(buffer)); + buffer_vk = wined3d_buffer_vk(buffer); + buffer_info = wined3d_buffer_vk_get_buffer_info(buffer_vk); if (!wined3d_shader_descriptor_writes_vk_add_write(writes, vk_descriptor_set, binding->binding_idx, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, buffer_info, NULL, NULL)) return false; + wined3d_context_vk_reference_bo(context_vk, &buffer_vk->bo); break; case WINED3D_SHADER_DESCRIPTOR_TYPE_SRV: @@ -1430,7 +1434,8 @@ static bool wined3d_context_vk_update_descriptors(struct wined3d_context_vk *con } resource = srv->resource; - view_vk = &wined3d_shader_resource_view_vk(srv)->view_vk; + srv_vk = wined3d_shader_resource_view_vk(srv); + view_vk = &srv_vk->view_vk; if (resource->type == WINED3D_RTYPE_BUFFER) { image_info = NULL; @@ -1452,6 +1457,7 @@ static bool wined3d_context_vk_update_descriptors(struct wined3d_context_vk *con if (!wined3d_shader_descriptor_writes_vk_add_write(writes, vk_descriptor_set, binding->binding_idx, type, NULL, image_info, buffer_view)) return false; + wined3d_context_vk_reference_shader_resource_view(context_vk, srv_vk); break; case WINED3D_SHADER_DESCRIPTOR_TYPE_UAV: @@ -1462,7 +1468,8 @@ static bool wined3d_context_vk_update_descriptors(struct wined3d_context_vk *con } resource = uav->resource; - view_vk = &wined3d_unordered_access_view_vk(uav)->view_vk; + uav_vk = wined3d_unordered_access_view_vk(uav); + view_vk = &uav_vk->view_vk; if (resource->type == WINED3D_RTYPE_BUFFER) { image_info = NULL; @@ -1484,6 +1491,7 @@ static bool wined3d_context_vk_update_descriptors(struct wined3d_context_vk *con if (!wined3d_shader_descriptor_writes_vk_add_write(writes, vk_descriptor_set, binding->binding_idx, type, NULL, image_info, buffer_view)) return false; + wined3d_context_vk_reference_unordered_access_view(context_vk, uav_vk); break; case WINED3D_SHADER_DESCRIPTOR_TYPE_UAV_COUNTER: @@ -1506,6 +1514,7 @@ static bool wined3d_context_vk_update_descriptors(struct wined3d_context_vk *con if (!wined3d_shader_descriptor_writes_vk_add_write(writes, vk_descriptor_set, binding->binding_idx, VK_DESCRIPTOR_TYPE_SAMPLER, NULL, &wined3d_sampler_vk(sampler)->vk_image_info, NULL)) return false; + wined3d_context_vk_reference_sampler(context_vk, wined3d_sampler_vk(sampler)); break; default: @@ -1635,7 +1644,6 @@ static void wined3d_context_vk_load_shader_resources(struct wined3d_context_vk * wined3d_buffer_load(buffer, &context_vk->c, state); if (!buffer_vk->bo_user.valid) context_invalidate_compute_state(&context_vk->c, STATE_COMPUTE_CONSTANT_BUFFER); - wined3d_context_vk_reference_bo(context_vk, &buffer_vk->bo); break; case WINED3D_SHADER_DESCRIPTOR_TYPE_SRV: @@ -1656,7 +1664,6 @@ static void wined3d_context_vk_load_shader_resources(struct wined3d_context_vk * { wined3d_texture_load(texture_from_resource(srv->resource), &context_vk->c, FALSE); } - wined3d_context_vk_reference_shader_resource_view(context_vk, srv_vk); break; case WINED3D_SHADER_DESCRIPTOR_TYPE_UAV: @@ -1679,7 +1686,6 @@ static void wined3d_context_vk_load_shader_resources(struct wined3d_context_vk * wined3d_texture_load(texture_from_resource(uav->resource), &context_vk->c, FALSE); wined3d_unordered_access_view_invalidate_location(uav, ~WINED3D_LOCATION_TEXTURE_RGB); } - wined3d_context_vk_reference_unordered_access_view(context_vk, uav_vk); break; case WINED3D_SHADER_DESCRIPTOR_TYPE_UAV_COUNTER: @@ -1688,7 +1694,6 @@ static void wined3d_context_vk_load_shader_resources(struct wined3d_context_vk * case WINED3D_SHADER_DESCRIPTOR_TYPE_SAMPLER: if (!(sampler = state->sampler[binding->shader_type][binding->resource_idx])) sampler = context_vk->c.device->null_sampler; - wined3d_context_vk_reference_sampler(context_vk, wined3d_sampler_vk(sampler)); break; default: -- 2.20.1

1 0

[PATCH] winegcc: Default to ucrtbase.
by Jacek Caban 18 May '20

18 May '20

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- We need a way out of UCRT and potentially in the future, when msvcr* DLLs will start using those headers, a way to adjust for the exact version. I used the same macro as we already use in msvcrt internally. include/msvcrt/corecrt.h | 8 ++++++++ tools/makedep.c | 3 +++ tools/winegcc/winegcc.c | 2 +- 3 files changed, 12 insertions(+), 1 deletion(-)

1 0

[PATCH] ntdll: Partially implement JobObjectBasicAccountingInformation.
by Derek Lesho 18 May '20

18 May '20

Signed-off-by: Derek Lesho <dlesho(a)codeweavers.com> --- dlls/kernel32/tests/process.c | 9 +++++++++ dlls/ntdll/sync.c | 20 +++++++++++++++++--- server/process.c | 14 ++++++++++++++ server/protocol.def | 8 ++++++++ 4 files changed, 48 insertions(+), 3 deletions(-) diff --git a/dlls/kernel32/tests/process.c b/dlls/kernel32/tests/process.c index 3281804233..8454e64265 100644 --- a/dlls/kernel32/tests/process.c +++ b/dlls/kernel32/tests/process.c @@ -2513,6 +2513,7 @@ static void test_QueryInformationJobObject(void) PJOBOBJECT_BASIC_PROCESS_ID_LIST pid_list = (JOBOBJECT_BASIC_PROCESS_ID_LIST *)buf; JOBOBJECT_EXTENDED_LIMIT_INFORMATION ext_limit_info; JOBOBJECT_BASIC_LIMIT_INFORMATION *basic_limit_info = &ext_limit_info.BasicLimitInformation; + JOBOBJECT_BASIC_ACCOUNTING_INFORMATION basic_accounting_info; DWORD ret_len; PROCESS_INFORMATION pi[2]; char buffer[50]; @@ -2620,6 +2621,14 @@ static void test_QueryInformationJobObject(void) ok(ret_len == sizeof(ext_limit_info), "QueryInformationJobObject returned ret_len=%u\n", ret_len); expect_eq_d(0, basic_limit_info->LimitFlags); + /* test JobObjectBasicAccountingInformation */ + ret = pQueryInformationJobObject(job, JobObjectBasicAccountingInformation, &basic_accounting_info, + sizeof(basic_accounting_info), &ret_len); + ok(ret, "QueryInformationJobObject error %u\n", GetLastError()); + ok(ret_len == sizeof(basic_accounting_info), "QueryInformationJobObject returned ret_len=%u\n", ret_len); + expect_eq_d(3, basic_accounting_info.TotalProcesses); + expect_eq_d(2, basic_accounting_info.ActiveProcesses); + TerminateProcess(pi[0].hProcess, 0); CloseHandle(pi[0].hProcess); CloseHandle(pi[0].hThread); diff --git a/dlls/ntdll/sync.c b/dlls/ntdll/sync.c index ad967d20e0..22af41cf0f 100644 --- a/dlls/ntdll/sync.c +++ b/dlls/ntdll/sync.c @@ -704,7 +704,9 @@ NTSTATUS WINAPI NtTerminateJobObject( HANDLE handle, NTSTATUS status ) NTSTATUS WINAPI NtQueryInformationJobObject( HANDLE handle, JOBOBJECTINFOCLASS class, PVOID info, ULONG len, PULONG ret_len ) { - FIXME( "stub: %p %u %p %u %p\n", handle, class, info, len, ret_len ); + NTSTATUS ret; + + TRACE( "semi-stub: %p %u %p %u %p\n", handle, class, info, len, ret_len ); if (class >= MaxJobObjectInfoClass) return STATUS_INVALID_PARAMETER; @@ -718,9 +720,21 @@ NTSTATUS WINAPI NtQueryInformationJobObject( HANDLE handle, JOBOBJECTINFOCLASS c return STATUS_INFO_LENGTH_MISMATCH; accounting = (JOBOBJECT_BASIC_ACCOUNTING_INFORMATION *)info; - memset(accounting, 0, sizeof(*accounting)); + + SERVER_START_REQ(get_job_info) + { + req->handle = wine_server_obj_handle( handle ); + if ((ret = wine_server_call( req )) == STATUS_SUCCESS) + { + memset(accounting, 0, sizeof(*accounting)); + accounting->TotalProcesses = reply->total_processes; + accounting->ActiveProcesses = reply->active_processes; + } + } + SERVER_END_REQ; + if (ret_len) *ret_len = sizeof(*accounting); - return STATUS_SUCCESS; + return ret; } case JobObjectBasicProcessIdList: diff --git a/server/process.c b/server/process.c index 6722addb09..263b37555b 100644 --- a/server/process.c +++ b/server/process.c @@ -156,6 +156,7 @@ struct job struct object obj; /* object header */ struct list process_list; /* list of all processes */ int num_processes; /* count of running processes */ + int total_processes; /* Number of processes which have been assigned */ unsigned int limit_flags; /* limit flags */ int terminating; /* job is terminating */ int signaled; /* job is signaled */ @@ -198,6 +199,7 @@ static struct job *create_job_object( struct object *root, const struct unicode_ /* initialize it if it didn't already exist */ list_init( &job->process_list ); job->num_processes = 0; + job->total_processes = 0; job->limit_flags = 0; job->terminating = 0; job->signaled = 0; @@ -240,6 +242,7 @@ static void add_job_process( struct job *job, struct process *process ) process->job = (struct job *)grab_object( job ); list_add_tail( &job->process_list, &process->job_entry ); job->num_processes++; + job->total_processes++; add_job_completion( job, JOB_OBJECT_MSG_NEW_PROCESS, get_process_id(process) ); } @@ -1728,6 +1731,17 @@ DECL_HANDLER(process_in_job) release_object( process ); } +/* retrieve information about a job */ +DECL_HANDLER(get_job_info) +{ + struct job *job = get_job_obj( current->process, req->handle, JOB_OBJECT_QUERY ); + + reply->total_processes = job->total_processes; + reply->active_processes = job->num_processes; + + release_object( job ); +} + /* terminate all processes associated with the job */ DECL_HANDLER(terminate_job) { diff --git a/server/protocol.def b/server/protocol.def index 2fb8e2ec80..e6bcd6f456 100644 --- a/server/protocol.def +++ b/server/protocol.def @@ -3934,6 +3934,14 @@ struct handle_info client_ptr_t key; /* key to send with completion messages */ @END +/* Retrieve information about a job */ +@REQ(get_job_info) + obj_handle_t handle; +@REPLY + unsigned int total_processes; + unsigned int active_processes; +@END + /* Terminate all processes associated with the job */ @REQ(terminate_job) -- 2.26.2

1 0

← Newer
1
...
26
27
28
29
30
31
32
...
63
Older →

Jump to page:

2025

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 May 2020