ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

wined3d: Implement adapter_vk_dispatch_compute(). 

Signed-off-by: Henri Verbeet <hverbeet@codeweavers.com>
Signed-off-by: Alexandre Julliard <julliard@winehq.org>
This commit is contained in:
Henri Verbeet 2020-05-13 01:12:58 +04:30 committed by Alexandre Julliard
parent c484ba1c00
commit 9049104df2
5 changed files with 675 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
dlls/wined3d/adapter_vk.c
View File

@ -1509,7 +1509,45 @@ static void adapter_vk_draw_primitive(struct wined3d_device *device,
static void adapter_vk_dispatch_compute(struct wined3d_device *device,
const struct wined3d_state *state, const struct wined3d_dispatch_parameters *parameters)
{
FIXME("device %p, state %p, parameters %p.\n", device, state, 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;
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 (parameters->indirect)
indirect_vk = wined3d_buffer_vk(parameters->u.indirect.buffer);
if (!(vk_command_buffer = wined3d_context_vk_apply_compute_state(context_vk, state, indirect_vk)))
{
ERR("Failed to apply compute state.\n");
context_release(&context_vk->c);
return;
}
if (parameters->indirect)
{
struct wined3d_bo_vk *bo = &indirect_vk->bo;
wined3d_context_vk_reference_bo(context_vk, bo);
VK_CALL(vkCmdDispatchIndirect(vk_command_buffer, bo->vk_buffer,
bo->buffer_offset + parameters->u.indirect.offset));
}
else
{
const struct wined3d_direct_dispatch_parameters *direct = &parameters->u.direct;
VK_CALL(vkCmdDispatch(vk_command_buffer, direct->group_count_x, direct->group_count_y, direct->group_count_z));
}
VK_CALL(vkCmdPipelineBarrier(vk_command_buffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT, 0, 0, NULL, 0, NULL, 0, NULL));
context_release(&context_vk->c);
}
void adapter_vk_clear_uav(struct wined3d_context *context,

232
dlls/wined3d/context_vk.c
View File

@ -58,6 +58,28 @@ VkCompareOp vk_compare_op_from_wined3d(enum wined3d_cmp_func op)
}
}
VkShaderStageFlagBits vk_shader_stage_from_wined3d(enum wined3d_shader_type shader_type)
{
switch (shader_type)
{
case WINED3D_SHADER_TYPE_VERTEX:
return VK_SHADER_STAGE_VERTEX_BIT;
case WINED3D_SHADER_TYPE_HULL:
return VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT;
case WINED3D_SHADER_TYPE_DOMAIN:
return VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT;
case WINED3D_SHADER_TYPE_GEOMETRY:
return VK_SHADER_STAGE_GEOMETRY_BIT;
case WINED3D_SHADER_TYPE_PIXEL:
return VK_SHADER_STAGE_FRAGMENT_BIT;
case WINED3D_SHADER_TYPE_COMPUTE:
return VK_SHADER_STAGE_COMPUTE_BIT;
default:
ERR("Unhandled shader type %s.\n", debug_shader_type(shader_type));
return 0;
}
}
void *wined3d_allocator_chunk_vk_map(struct wined3d_allocator_chunk_vk *chunk_vk,
struct wined3d_context_vk *context_vk)
{
@ -350,6 +372,31 @@ void wined3d_context_vk_destroy_framebuffer(struct wined3d_context_vk *context_v
o->command_buffer_id = command_buffer_id;
}
static void wined3d_context_vk_destroy_descriptor_pool(struct wined3d_context_vk *context_vk,
VkDescriptorPool vk_descriptor_pool, uint64_t command_buffer_id)
{
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_retired_object_vk *o;
if (context_vk->completed_command_buffer_id > command_buffer_id)
{
VK_CALL(vkDestroyDescriptorPool(device_vk->vk_device, vk_descriptor_pool, NULL));
TRACE("Destroyed descriptor pool 0x%s.\n", wine_dbgstr_longlong(vk_descriptor_pool));
return;
}
if (!(o = wined3d_context_vk_get_retired_object_vk(context_vk)))
{
ERR("Leaking descriptor pool 0x%s.\n", wine_dbgstr_longlong(vk_descriptor_pool));
return;
}
o->type = WINED3D_RETIRED_DESCRIPTOR_POOL_VK;
o->u.vk_descriptor_pool = vk_descriptor_pool;
o->command_buffer_id = command_buffer_id;
}
void wined3d_context_vk_destroy_memory(struct wined3d_context_vk *context_vk,
VkDeviceMemory vk_memory, uint64_t command_buffer_id)
{
@ -647,6 +694,11 @@ static void wined3d_context_vk_cleanup_resources(struct wined3d_context_vk *cont
TRACE("Destroyed framebuffer 0x%s.\n", wine_dbgstr_longlong(o->u.vk_framebuffer));
break;
case WINED3D_RETIRED_DESCRIPTOR_POOL_VK:
VK_CALL(vkDestroyDescriptorPool(device_vk->vk_device, o->u.vk_descriptor_pool, NULL));
TRACE("Destroyed descriptor pool 0x%s.\n", wine_dbgstr_longlong(o->u.vk_descriptor_pool));
break;
case WINED3D_RETIRED_MEMORY_VK:
VK_CALL(vkFreeMemory(device_vk->vk_device, o->u.vk_memory, NULL));
TRACE("Freed memory 0x%s.\n", wine_dbgstr_longlong(o->u.vk_memory));
@ -930,6 +982,15 @@ void wined3d_context_vk_cleanup(struct wined3d_context_vk *context_vk)
wined3d_context_vk_wait_command_buffer(context_vk, buffer->id - 1);
context_vk->completed_command_buffer_id = buffer->id;
if (context_vk->vk_pipeline_layout)
{
VK_CALL(vkDestroyPipelineLayout(device_vk->vk_device, context_vk->vk_pipeline_layout, NULL));
VK_CALL(vkDestroyDescriptorSetLayout(device_vk->vk_device, context_vk->vk_set_layout, NULL));
}
heap_free(context_vk->compute.bindings.bindings);
if (context_vk->vk_descriptor_pool)
VK_CALL(vkDestroyDescriptorPool(device_vk->vk_device, context_vk->vk_descriptor_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);
@ -1012,6 +1073,10 @@ 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));
context_vk->update_compute_pipeline = 1;
context_vk->c.update_compute_shader_resource_bindings = 1;
context_vk->c.update_compute_unordered_access_view_bindings = 1;
VK_CALL(vkEndCommandBuffer(buffer->vk_command_buffer));
fence_desc.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
@ -1122,6 +1187,173 @@ static int wined3d_bo_slab_vk_compare(const void *key, const struct wine_rb_entr
return k->size - slab->bo.size;
}
static VkResult wined3d_context_vk_create_descriptor_pool(struct wined3d_device_vk *device_vk,
const struct wined3d_vk_info *vk_info, VkDescriptorPool *vk_pool)
{
struct VkDescriptorPoolCreateInfo pool_desc;
VkResult vr;
static const VkDescriptorPoolSize pool_sizes[] =
{
{VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1024},
{VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER, 1024},
{VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, 1024},
{VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, 1024},
{VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1024},
{VK_DESCRIPTOR_TYPE_SAMPLER, 1024},
};
pool_desc.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
pool_desc.pNext = NULL;
pool_desc.flags = 0;
pool_desc.maxSets = 512;
pool_desc.poolSizeCount = ARRAY_SIZE(pool_sizes);
pool_desc.pPoolSizes = pool_sizes;
if ((vr = VK_CALL(vkCreateDescriptorPool(device_vk->vk_device, &pool_desc, NULL, vk_pool))) < 0)
ERR("Failed to create descriptor pool, vr %s.\n", wined3d_debug_vkresult(vr));
return vr;
}
static VkResult wined3d_context_vk_create_descriptor_set(struct wined3d_context_vk *context_vk,
VkDescriptorSetLayout vk_set_layout, VkDescriptorSet *vk_descriptor_set)
{
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 VkDescriptorSetAllocateInfo set_desc;
VkResult vr;
if (!context_vk->vk_descriptor_pool && (vr = wined3d_context_vk_create_descriptor_pool(device_vk,
vk_info, &context_vk->vk_descriptor_pool)))
{
WARN("Failed to create descriptor pool, vr %s.\n", wined3d_debug_vkresult(vr));
return vr;
}
set_desc.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
set_desc.pNext = NULL;
set_desc.descriptorPool = context_vk->vk_descriptor_pool;
set_desc.descriptorSetCount = 1;
set_desc.pSetLayouts = &vk_set_layout;
if ((vr = VK_CALL(vkAllocateDescriptorSets(device_vk->vk_device, &set_desc, vk_descriptor_set))) >= 0)
return vr;
if (vr == VK_ERROR_FRAGMENTED_POOL || vr == VK_ERROR_OUT_OF_POOL_MEMORY)
{
wined3d_context_vk_destroy_descriptor_pool(context_vk,
context_vk->vk_descriptor_pool, context_vk->current_command_buffer.id);
context_vk->vk_descriptor_pool = VK_NULL_HANDLE;
if ((vr = wined3d_context_vk_create_descriptor_pool(device_vk, vk_info, &context_vk->vk_descriptor_pool)))
{
WARN("Failed to create descriptor pool, vr %s.\n", wined3d_debug_vkresult(vr));
return vr;
}
set_desc.descriptorPool = context_vk->vk_descriptor_pool;
if ((vr = VK_CALL(vkAllocateDescriptorSets(device_vk->vk_device, &set_desc, vk_descriptor_set))) >= 0)
return vr;
}
WARN("Failed to allocate descriptor set, vr %s.\n", wined3d_debug_vkresult(vr));
return vr;
}
static bool wined3d_context_vk_update_descriptors(struct wined3d_context_vk *context_vk,
VkCommandBuffer vk_command_buffer)
{
const struct wined3d_vk_info *vk_info = context_vk->vk_info;
const struct wined3d_shader_resource_binding *binding;
struct wined3d_shader_resource_bindings *bindings;
VkDescriptorSet vk_descriptor_set;
VkResult vr;
bindings = &context_vk->compute.bindings;
if ((vr = wined3d_context_vk_create_descriptor_set(context_vk,
context_vk->vk_set_layout, &vk_descriptor_set)))
{
WARN("Failed to create descriptor set, vr %s.\n", wined3d_debug_vkresult(vr));
return false;
}
if (bindings->count)
{
binding = bindings->bindings;
FIXME("Unhandled descriptor type %#x.\n", binding->shader_descriptor_type);
return false;
}
VK_CALL(vkCmdBindDescriptorSets(vk_command_buffer, VK_PIPELINE_BIND_POINT_COMPUTE,
context_vk->vk_pipeline_layout, 0, 1, &vk_descriptor_set, 0, NULL));
return true;
}
VkCommandBuffer wined3d_context_vk_apply_compute_state(struct wined3d_context_vk *context_vk,
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;
VkCommandBuffer vk_command_buffer;
if (wined3d_context_is_compute_state_dirty(&context_vk->c, STATE_COMPUTE_SHADER))
context_vk->c.shader_update_mask |= 1u << WINED3D_SHADER_TYPE_COMPUTE;
if (context_vk->c.shader_update_mask & (1u << WINED3D_SHADER_TYPE_COMPUTE))
{
device_vk->d.shader_backend->shader_select_compute(device_vk->d.shader_priv, &context_vk->c, state);
if (!context_vk->compute.vk_pipeline)
{
ERR("No compute pipeline set.\n");
return VK_NULL_HANDLE;
}
context_vk->c.shader_update_mask &= ~(1u << WINED3D_SHADER_TYPE_COMPUTE);
context_vk->c.update_compute_shader_resource_bindings = 1;
context_vk->c.update_compute_unordered_access_view_bindings = 1;
context_vk->update_compute_pipeline = 1;
}
if (indirect_vk)
wined3d_buffer_load_location(&indirect_vk->b, &context_vk->c, WINED3D_LOCATION_BUFFER);
if (!(vk_command_buffer = wined3d_context_vk_get_command_buffer(context_vk)))
{
ERR("Failed to get command buffer.\n");
return VK_NULL_HANDLE;
}
if (context_vk->update_compute_pipeline)
{
VK_CALL(vkCmdBindPipeline(vk_command_buffer,
VK_PIPELINE_BIND_POINT_COMPUTE, context_vk->compute.vk_pipeline));
context_vk->update_compute_pipeline = 0;
}
if (wined3d_context_is_compute_state_dirty(&context_vk->c, STATE_COMPUTE_CONSTANT_BUFFER)
|| wined3d_context_is_compute_state_dirty(&context_vk->c, STATE_COMPUTE_SHADER_RESOURCE_BINDING))
context_vk->c.update_compute_shader_resource_bindings = 1;
if (wined3d_context_is_compute_state_dirty(&context_vk->c, STATE_COMPUTE_UNORDERED_ACCESS_VIEW_BINDING))
context_vk->c.update_compute_unordered_access_view_bindings = 1;
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))
{
ERR("Failed to update shader descriptors.\n");
return VK_NULL_HANDLE;
}
context_vk->c.update_compute_shader_resource_bindings = 0;
context_vk->c.update_compute_unordered_access_view_bindings = 0;
}
memset(context_vk->c.dirty_compute_states, 0, sizeof(context_vk->c.dirty_compute_states));
return vk_command_buffer;
}
HRESULT wined3d_context_vk_init(struct wined3d_context_vk *context_vk, struct wined3d_swapchain *swapchain)
{
VkCommandPoolCreateInfo command_pool_info;

9
dlls/wined3d/shader.c
View File

@ -1123,6 +1123,7 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, DWORD co
}
reg_maps->resource_info[reg_idx].type = semantic->resource_type;
reg_maps->resource_info[reg_idx].data_type = semantic->resource_data_type;
wined3d_bitmap_set(reg_maps->resource_map, reg_idx);
break;
case WINED3DSPR_UAV:
@ -1146,9 +1147,14 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, DWORD co
{
struct wined3d_shader_register *reg = &ins.declaration.src.reg;
if (reg->idx[0].offset >= WINED3D_MAX_CBS)
{
ERR("Invalid CB index %u.\n", reg->idx[0].offset);
}
else
{
reg_maps->cb_sizes[reg->idx[0].offset] = reg->idx[1].offset;
wined3d_bitmap_set(&reg_maps->cb_map, reg->idx[0].offset);
}
}
else if (ins.handler_idx == WINED3DSIH_DCL_GLOBAL_FLAGS)
{
@ -1266,6 +1272,7 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, DWORD co
reg_maps->resource_info[reg_idx].type = WINED3D_SHADER_RESOURCE_BUFFER;
reg_maps->resource_info[reg_idx].data_type = WINED3D_DATA_UINT;
reg_maps->resource_info[reg_idx].flags = WINED3D_VIEW_BUFFER_RAW;
wined3d_bitmap_set(reg_maps->resource_map, reg_idx);
}
else if (ins.handler_idx == WINED3DSIH_DCL_RESOURCE_STRUCTURED)
{
@ -1279,6 +1286,7 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, DWORD co
reg_maps->resource_info[reg_idx].data_type = WINED3D_DATA_UINT;
reg_maps->resource_info[reg_idx].flags = 0;
reg_maps->resource_info[reg_idx].stride = ins.declaration.structured_resource.byte_stride / 4;
wined3d_bitmap_set(reg_maps->resource_map, reg_idx);
}
else if (ins.handler_idx == WINED3DSIH_DCL_SAMPLER)
{
@ -1605,6 +1613,7 @@ static HRESULT shader_get_registers_used(struct wined3d_shader *shader, DWORD co
reg_maps->resource_info[reg_idx].type = WINED3D_SHADER_RESOURCE_TEXTURE_2D;
reg_maps->resource_info[reg_idx].data_type = WINED3D_DATA_FLOAT;
shader_record_sample(reg_maps, reg_idx, reg_idx, reg_idx);
wined3d_bitmap_set(reg_maps->resource_map, reg_idx);
/* texbem is only valid with < 1.4 pixel shaders */
if (ins.handler_idx == WINED3DSIH_TEXBEM

330
dlls/wined3d/shader_spirv.c
View File

@ -25,17 +25,291 @@ WINE_DEFAULT_DEBUG_CHANNEL(d3d_shader);
static const struct wined3d_shader_backend_ops spirv_shader_backend_vk;
struct shader_spirv_resource_bindings
{
VkDescriptorSetLayoutBinding *vk_bindings;
SIZE_T vk_bindings_size, vk_binding_count;
};
struct shader_spirv_priv
{
const struct wined3d_vertex_pipe_ops *vertex_pipe;
const struct wined3d_fragment_pipe_ops *fragment_pipe;
bool ffp_proj_control;
struct shader_spirv_resource_bindings bindings;
};
struct shader_spirv_compute_program_vk
{
VkShaderModule vk_module;
VkPipeline vk_pipeline;
};
static void shader_spirv_handle_instruction(const struct wined3d_shader_instruction *ins)
{
}
static VkShaderModule shader_spirv_compile(struct wined3d_context_vk *context_vk,
struct wined3d_shader *shader, const struct shader_spirv_resource_bindings *bindings)
{
FIXME("Not implemented.\n");
return VK_NULL_HANDLE;
}
static struct shader_spirv_compute_program_vk *shader_spirv_find_compute_program_vk(struct shader_spirv_priv *priv,
struct wined3d_context_vk *context_vk, struct wined3d_shader *shader,
const struct shader_spirv_resource_bindings *bindings)
{
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 shader_spirv_compute_program_vk *program;
VkDescriptorSetLayoutCreateInfo set_layout_desc;
VkPipelineLayoutCreateInfo pipeline_layout_desc;
VkComputePipelineCreateInfo pipeline_info;
VkResult vr;
if ((program = shader->backend_data))
return program;
if (!(program = heap_alloc(sizeof(*program))))
return NULL;
if (!(program->vk_module = shader_spirv_compile(context_vk, shader, bindings)))
{
heap_free(program);
return NULL;
}
if (!context_vk->vk_pipeline_layout)
{
set_layout_desc.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
set_layout_desc.pNext = NULL;
set_layout_desc.flags = 0;
set_layout_desc.bindingCount = 0;
set_layout_desc.pBindings = NULL;
if ((vr = VK_CALL(vkCreateDescriptorSetLayout(device_vk->vk_device,
&set_layout_desc, NULL, &context_vk->vk_set_layout))) < 0)
{
WARN("Failed to create Vulkan descriptor set layout, vr %s.\n", wined3d_debug_vkresult(vr));
VK_CALL(vkDestroyShaderModule(device_vk->vk_device, program->vk_module, NULL));
heap_free(program);
return NULL;
}
pipeline_layout_desc.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
pipeline_layout_desc.pNext = NULL;
pipeline_layout_desc.flags = 0;
pipeline_layout_desc.setLayoutCount = 1;
pipeline_layout_desc.pSetLayouts = &context_vk->vk_set_layout;
pipeline_layout_desc.pushConstantRangeCount = 0;
pipeline_layout_desc.pPushConstantRanges = NULL;
if ((vr = VK_CALL(vkCreatePipelineLayout(device_vk->vk_device,
&pipeline_layout_desc, NULL, &context_vk->vk_pipeline_layout))) < 0)
{
WARN("Failed to create Vulkan pipeline layout, vr %s.\n", wined3d_debug_vkresult(vr));
VK_CALL(vkDestroyDescriptorSetLayout(device_vk->vk_device, context_vk->vk_set_layout, NULL));
VK_CALL(vkDestroyShaderModule(device_vk->vk_device, program->vk_module, NULL));
heap_free(program);
return NULL;
}
}
pipeline_info.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO;
pipeline_info.pNext = NULL;
pipeline_info.flags = 0;
pipeline_info.stage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
pipeline_info.stage.pNext = NULL;
pipeline_info.stage.flags = 0;
pipeline_info.stage.stage = VK_SHADER_STAGE_COMPUTE_BIT;
pipeline_info.stage.pName = "main";
pipeline_info.stage.pSpecializationInfo = NULL;
pipeline_info.stage.module = program->vk_module;
pipeline_info.layout = context_vk->vk_pipeline_layout;
pipeline_info.basePipelineHandle = VK_NULL_HANDLE;
pipeline_info.basePipelineIndex = -1;
if ((vr = VK_CALL(vkCreateComputePipelines(device_vk->vk_device,
VK_NULL_HANDLE, 1, &pipeline_info, NULL, &program->vk_pipeline))) < 0)
{
ERR("Failed to create Vulkan compute pipeline, vr %s.\n", wined3d_debug_vkresult(vr));
VK_CALL(vkDestroyShaderModule(device_vk->vk_device, program->vk_module, NULL));
heap_free(program);
return NULL;
}
shader->backend_data = program;
return program;
}
static void shader_spirv_resource_bindings_cleanup(struct shader_spirv_resource_bindings *bindings)
{
heap_free(bindings->vk_bindings);
}
static bool shader_spirv_resource_bindings_add_binding(struct shader_spirv_resource_bindings *bindings,
VkDescriptorType vk_type, VkShaderStageFlagBits vk_stage, size_t *binding_idx)
{
SIZE_T binding_count = bindings->vk_binding_count;
VkDescriptorSetLayoutBinding *binding;
if (!wined3d_array_reserve((void **)&bindings->vk_bindings, &bindings->vk_bindings_size,
binding_count + 1, sizeof(*bindings->vk_bindings)))
return false;
*binding_idx = binding_count;
binding = &bindings->vk_bindings[binding_count];
binding->binding = binding_count;
binding->descriptorType = vk_type;
binding->descriptorCount = 1;
binding->stageFlags = vk_stage;
binding->pImmutableSamplers = NULL;
++bindings->vk_binding_count;
return true;
}
static bool wined3d_shader_resource_bindings_add_binding(struct wined3d_shader_resource_bindings *bindings,
enum wined3d_shader_type shader_type, enum wined3d_shader_descriptor_type shader_descriptor_type,
size_t resource_idx, enum wined3d_shader_resource_type resource_type,
enum wined3d_data_type resource_data_type, size_t binding_idx)
{
struct wined3d_shader_resource_binding *binding;
SIZE_T binding_count = bindings->count;
if (!wined3d_array_reserve((void **)&bindings->bindings, &bindings->size,
binding_count + 1, sizeof(*bindings->bindings)))
return false;
binding = &bindings->bindings[binding_count];
binding->shader_type = shader_type;
binding->shader_descriptor_type = shader_descriptor_type;
binding->resource_idx = resource_idx;
binding->resource_type = resource_type;
binding->resource_data_type = resource_data_type;
binding->binding_idx = binding_idx;
++bindings->count;
return true;
}
static bool shader_spirv_resource_bindings_init(struct shader_spirv_resource_bindings *bindings,
struct wined3d_shader_resource_bindings *wined3d_bindings,
const struct wined3d_state *state, uint32_t shader_mask)
{
const struct wined3d_shader_resource_info *resource_info;
const struct wined3d_shader_reg_maps *reg_maps;
enum wined3d_shader_type shader_type;
VkDescriptorType vk_descriptor_type;
size_t binding_idx, register_idx;
VkShaderStageFlagBits vk_stage;
struct wined3d_shader *shader;
unsigned int i;
uint32_t map;
bindings->vk_binding_count = 0;
wined3d_bindings->count = 0;
for (shader_type = 0; shader_type < WINED3D_SHADER_TYPE_COUNT; ++shader_type)
{
if (!(shader_mask & (1u << shader_type)) || !(shader = state->shader[shader_type]))
continue;
reg_maps = &shader->reg_maps;
vk_stage = vk_shader_stage_from_wined3d(shader_type);
map = reg_maps->cb_map;
while (map)
{
register_idx = wined3d_bit_scan(&map);
if (!shader_spirv_resource_bindings_add_binding(bindings,
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, vk_stage, &binding_idx))
return false;
if (!wined3d_shader_resource_bindings_add_binding(wined3d_bindings,
shader_type, WINED3D_SHADER_DESCRIPTOR_TYPE_CBV, register_idx,
WINED3D_SHADER_RESOURCE_BUFFER, WINED3D_DATA_UINT, binding_idx))
return false;
}
for (i = 0; i < ARRAY_SIZE(reg_maps->resource_map); ++i)
{
map = reg_maps->resource_map[i];
while (map)
{
register_idx = (i << 5) + wined3d_bit_scan(&map);
resource_info = &reg_maps->resource_info[register_idx];
if (resource_info->type == WINED3D_SHADER_RESOURCE_BUFFER)
vk_descriptor_type = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
else
vk_descriptor_type = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
if (!shader_spirv_resource_bindings_add_binding(bindings,
vk_descriptor_type, vk_stage, &binding_idx))
return false;
if (!wined3d_shader_resource_bindings_add_binding(wined3d_bindings,
shader_type, WINED3D_SHADER_DESCRIPTOR_TYPE_SRV, register_idx,
resource_info->type, resource_info->data_type, binding_idx))
return false;
}
}
for (register_idx = 0; register_idx < ARRAY_SIZE(reg_maps->uav_resource_info); ++register_idx)
{
resource_info = &reg_maps->uav_resource_info[register_idx];
if (resource_info->type == WINED3D_SHADER_RESOURCE_NONE)
continue;
if (resource_info->type == WINED3D_SHADER_RESOURCE_BUFFER)
vk_descriptor_type = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER;
else
vk_descriptor_type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
if (!shader_spirv_resource_bindings_add_binding(bindings,
vk_descriptor_type, vk_stage, &binding_idx))
return false;
if (!wined3d_shader_resource_bindings_add_binding(wined3d_bindings,
shader_type, WINED3D_SHADER_DESCRIPTOR_TYPE_UAV, register_idx,
resource_info->type, resource_info->data_type, binding_idx))
return false;
if (reg_maps->uav_counter_mask & (1u << register_idx))
{
if (!shader_spirv_resource_bindings_add_binding(bindings,
VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER, vk_stage, &binding_idx))
return false;
if (!wined3d_shader_resource_bindings_add_binding(wined3d_bindings,
shader_type, WINED3D_SHADER_DESCRIPTOR_TYPE_UAV_COUNTER, register_idx,
WINED3D_SHADER_RESOURCE_BUFFER, WINED3D_DATA_UINT, binding_idx))
return false;
}
}
map = 0;
for (i = 0; i < reg_maps->sampler_map.count; ++i)
{
if (reg_maps->sampler_map.entries[i].sampler_idx != WINED3D_SAMPLER_DEFAULT)
map |= 1u << reg_maps->sampler_map.entries[i].sampler_idx;
}
while (map)
{
register_idx = wined3d_bit_scan(&map);
if (!shader_spirv_resource_bindings_add_binding(bindings,
VK_DESCRIPTOR_TYPE_SAMPLER, vk_stage, &binding_idx))
return false;
if (!wined3d_shader_resource_bindings_add_binding(wined3d_bindings,
shader_type, WINED3D_SHADER_DESCRIPTOR_TYPE_SAMPLER, register_idx,
WINED3D_SHADER_RESOURCE_NONE, WINED3D_DATA_SAMPLER, binding_idx))
return false;
}
}
return true;
}
static void shader_spirv_precompile(void *shader_priv, struct wined3d_shader *shader)
{
WARN("Not implemented.\n");
@ -53,16 +327,35 @@ static void shader_spirv_select(void *shader_priv, struct wined3d_context *conte
static void shader_spirv_select_compute(void *shader_priv,
struct wined3d_context *context, const struct wined3d_state *state)
{
FIXME("Not implemented.\n");
struct wined3d_context_vk *context_vk = wined3d_context_vk(context);
struct shader_spirv_compute_program_vk *program;
struct shader_spirv_priv *priv = shader_priv;
struct wined3d_shader *shader;
if (!shader_spirv_resource_bindings_init(&priv->bindings,
&context_vk->compute.bindings, state, 1u << WINED3D_SHADER_TYPE_COMPUTE))
ERR("Failed to initialise shader resource bindings.\n");
if ((shader = state->shader[WINED3D_SHADER_TYPE_COMPUTE]))
program = shader_spirv_find_compute_program_vk(priv, context_vk, shader, &priv->bindings);
else
program = NULL;
if (program)
context_vk->compute.vk_pipeline = program->vk_pipeline;
else
context_vk->compute.vk_pipeline = VK_NULL_HANDLE;
}
static void shader_spirv_disable(void *shader_priv, struct wined3d_context *context)
{
struct wined3d_context_vk *context_vk = wined3d_context_vk(context);
struct shader_spirv_priv *priv = shader_priv;
priv->vertex_pipe->vp_enable(context, false);
priv->fragment_pipe->fp_enable(context, false);
context_vk->compute.vk_pipeline = VK_NULL_HANDLE;
context->shader_update_mask = (1u << WINED3D_SHADER_TYPE_PIXEL)
| (1u << WINED3D_SHADER_TYPE_VERTEX)
| (1u << WINED3D_SHADER_TYPE_GEOMETRY)
@ -87,8 +380,41 @@ static void shader_spirv_load_constants(void *shader_priv, struct wined3d_contex
WARN("Not implemented.\n");
}
static void shader_spirv_invalidate_compute_program(struct wined3d_context_vk *context_vk,
const struct shader_spirv_compute_program_vk *program)
{
if (context_vk->compute.vk_pipeline == program->vk_pipeline)
{
context_vk->c.shader_update_mask |= (1u << WINED3D_SHADER_TYPE_COMPUTE);
context_vk->compute.vk_pipeline = VK_NULL_HANDLE;
}
}
static void shader_spirv_invalidate_contexts_compute_program(struct wined3d_device *device,
const struct shader_spirv_compute_program_vk *program)
{
unsigned int i;
for (i = 0; i < device->context_count; ++i)
{
shader_spirv_invalidate_compute_program(wined3d_context_vk(device->contexts[i]), program);
}
}
static void shader_spirv_destroy(struct wined3d_shader *shader)
{
struct wined3d_device_vk *device_vk = wined3d_device_vk(shader->device);
struct wined3d_vk_info *vk_info = &device_vk->vk_info;
struct shader_spirv_compute_program_vk *program;
if (!(program = shader->backend_data))
return;
shader_spirv_invalidate_contexts_compute_program(&device_vk->d, program);
VK_CALL(vkDestroyPipeline(device_vk->vk_device, program->vk_pipeline, NULL));
VK_CALL(vkDestroyShaderModule(device_vk->vk_device, program->vk_module, NULL));
shader->backend_data = NULL;
heap_free(program);
}
static HRESULT shader_spirv_alloc(struct wined3d_device *device,
@ -120,6 +446,7 @@ static HRESULT shader_spirv_alloc(struct wined3d_device *device,
priv->fragment_pipe = fragment_pipe;
fragment_pipe->get_caps(device->adapter, &fragment_caps);
priv->ffp_proj_control = fragment_caps.wined3d_caps & WINED3D_FRAGMENT_CAP_PROJ_CONTROL;
memset(&priv->bindings, 0, sizeof(priv->bindings));
device->vertex_priv = vertex_priv;
device->fragment_priv = fragment_priv;
@ -132,6 +459,7 @@ static void shader_spirv_free(struct wined3d_device *device, struct wined3d_cont
{
struct shader_spirv_priv *priv = device->shader_priv;
shader_spirv_resource_bindings_cleanup(&priv->bindings);
priv->fragment_pipe->free_private(device, context);
priv->vertex_pipe->vp_free(device, context);
heap_free(priv);

73
dlls/wined3d/wined3d_private.h
View File

@ -84,6 +84,7 @@
struct wined3d_fragment_pipe_ops;
struct wined3d_adapter;
struct wined3d_buffer_vk;
struct wined3d_context;
struct wined3d_gl_info;
struct wined3d_state;
@ -304,6 +305,7 @@ GLenum wined3d_gl_compare_func(enum wined3d_cmp_func f) DECLSPEC_HIDDEN;
VkAccessFlags vk_access_mask_from_bind_flags(uint32_t bind_flags) DECLSPEC_HIDDEN;
VkCompareOp vk_compare_op_from_wined3d(enum wined3d_cmp_func op) DECLSPEC_HIDDEN;
VkImageViewType vk_image_view_type_from_wined3d(enum wined3d_resource_type type, uint32_t flags) DECLSPEC_HIDDEN;
VkShaderStageFlagBits vk_shader_stage_from_wined3d(enum wined3d_shader_type shader_type) DECLSPEC_HIDDEN;
static inline enum wined3d_cmp_func wined3d_sanitize_cmp_func(enum wined3d_cmp_func func)
{
@ -1034,8 +1036,10 @@ struct wined3d_shader_reg_maps
WORD local_int_consts; /* WINED3D_MAX_CONSTS_I, 16 */
WORD local_bool_consts; /* WINED3D_MAX_CONSTS_B, 16 */
UINT cb_sizes[WINED3D_MAX_CBS];
uint32_t cb_map; /* WINED3D_MAX_CBS, 15 */
struct wined3d_shader_resource_info resource_info[MAX_SHADER_RESOURCE_VIEWS];
uint32_t resource_map[WINED3D_BITMAP_SIZE(MAX_SHADER_RESOURCE_VIEWS)];
struct wined3d_shader_sampler_map sampler_map;
DWORD sampler_comparison_mode;
BYTE bumpmat; /* WINED3D_MAX_TEXTURES, 8 */
@ -2230,6 +2234,7 @@ enum wined3d_retired_object_type_vk
{
WINED3D_RETIRED_FREE_VK,
WINED3D_RETIRED_FRAMEBUFFER_VK,
WINED3D_RETIRED_DESCRIPTOR_POOL_VK,
WINED3D_RETIRED_MEMORY_VK,
WINED3D_RETIRED_ALLOCATOR_BLOCK_VK,
WINED3D_RETIRED_BO_SLAB_SLICE_VK,
@ -2247,6 +2252,7 @@ struct wined3d_retired_object_vk
{
struct wined3d_retired_object_vk *next;
VkFramebuffer vk_framebuffer;
VkDescriptorPool vk_descriptor_pool;
VkDeviceMemory vk_memory;
struct wined3d_allocator_block *block;
struct
@ -2293,12 +2299,46 @@ struct wined3d_render_pass_vk
VkRenderPass vk_render_pass;
};
enum wined3d_shader_descriptor_type
{
WINED3D_SHADER_DESCRIPTOR_TYPE_CBV,
WINED3D_SHADER_DESCRIPTOR_TYPE_SRV,
WINED3D_SHADER_DESCRIPTOR_TYPE_UAV,
WINED3D_SHADER_DESCRIPTOR_TYPE_UAV_COUNTER,
WINED3D_SHADER_DESCRIPTOR_TYPE_SAMPLER,
};
struct wined3d_shader_resource_binding
{
enum wined3d_shader_type shader_type;
enum wined3d_shader_descriptor_type shader_descriptor_type;
size_t resource_idx;
enum wined3d_shader_resource_type resource_type;
enum wined3d_data_type resource_data_type;
size_t binding_idx;
};
struct wined3d_shader_resource_bindings
{
struct wined3d_shader_resource_binding *bindings;
SIZE_T size, count;
};
struct wined3d_context_vk
{
struct wined3d_context c;
const struct wined3d_vk_info *vk_info;
uint32_t update_compute_pipeline : 1;
uint32_t padding : 31;
struct
{
VkPipeline vk_pipeline;
struct wined3d_shader_resource_bindings bindings;
} compute;
VkCommandPool vk_command_pool;
struct wined3d_command_buffer_vk current_command_buffer;
uint64_t completed_command_buffer_id;
@ -2310,6 +2350,10 @@ struct wined3d_context_vk
SIZE_T buffer_count;
} submitted;
VkDescriptorPool vk_descriptor_pool;
VkPipelineLayout vk_pipeline_layout;
VkDescriptorSetLayout vk_set_layout;
struct wined3d_retired_objects_vk retired;
struct wine_rb_tree render_passes;
struct wine_rb_tree bo_slab_available;
@ -2324,6 +2368,8 @@ struct wined3d_allocator_block *wined3d_context_vk_allocate_memory(struct wined3
unsigned int memory_type, VkDeviceSize size, VkDeviceMemory *vk_memory) DECLSPEC_HIDDEN;
VkDeviceMemory wined3d_context_vk_allocate_vram_chunk_memory(struct wined3d_context_vk *context_vk,
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;
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;
@ -3621,13 +3667,6 @@ static inline struct wined3d_device_vk *wined3d_device_vk(struct wined3d_device
return CONTAINING_RECORD(device, struct wined3d_device_vk, d);
}
static inline BOOL isStateDirty(const struct wined3d_context *context, unsigned int state_id)
{
unsigned int idx = state_id / (sizeof(*context->dirty_graphics_states) * CHAR_BIT);
unsigned int shift = state_id & ((sizeof(*context->dirty_graphics_states) * CHAR_BIT) - 1);
return context->dirty_graphics_states[idx] & (1u << shift);
}
static inline float wined3d_alpha_ref(const struct wined3d_state *state)
{
return (state->render_states[WINED3D_RS_ALPHAREF] & 0xff) / 255.0f;
@ -5634,6 +5673,11 @@ static inline void wined3d_viewport_get_z_range(const struct wined3d_viewport *v
*max_z = max(vp->max_z, vp->min_z + 0.001f);
}
static inline BOOL wined3d_bitmap_set(uint32_t *map, unsigned int idx)
{
return map[idx >> 5] |= (1u << (idx & 0x1f));
}
static inline BOOL wined3d_bitmap_is_set(const uint32_t *map, unsigned int idx)
{
return map[idx >> 5] & (1u << (idx & 0x1f));
@ -5693,6 +5737,21 @@ static inline BOOL wined3d_bitmap_get_range(const DWORD *bitmap, unsigned int bi
return TRUE;
}
static inline bool wined3d_context_is_graphics_state_dirty(const struct wined3d_context *context, unsigned int state_id)
{
return wined3d_bitmap_is_set(context->dirty_graphics_states, state_id);
}
static inline bool wined3d_context_is_compute_state_dirty(const struct wined3d_context *context, unsigned int state_id)
{
return wined3d_bitmap_is_set(context->dirty_compute_states, state_id - STATE_COMPUTE_OFFSET);
}
static inline bool isStateDirty(const struct wined3d_context *context, unsigned int state_id)
{
return wined3d_context_is_graphics_state_dirty(context, state_id);
}
static inline VkImageAspectFlags vk_aspect_mask_from_format(const struct wined3d_format *format)
{
VkImageAspectFlags mask = 0;