diff --git a/src/gallium/frontends/lavapipe/ci/deqp-lvp-asan-fails.txt b/src/gallium/frontends/lavapipe/ci/deqp-lvp-asan-fails.txt index f97426b49b7..45d071823af 100644 --- a/src/gallium/frontends/lavapipe/ci/deqp-lvp-asan-fails.txt +++ b/src/gallium/frontends/lavapipe/ci/deqp-lvp-asan-fails.txt @@ -1,4 +1,2 @@ dEQP-VK.glsl.builtin.precision.pow.highp.vec2,Fail dEQP-VK.glsl.texture_functions.query.texturequerylod.sampler2d_fixed_fragment,Fail -dEQP-VK.draw.multi_draw.mosaic.indexed_packed.max_draws.standard_stride.10_instances.offset_6,Crash -dEQP-VK.draw.multi_draw.overlapping.indexed_packed.one_draw.standard_stride.no_instances.offset_6,Crash diff --git a/src/gallium/frontends/lavapipe/lvp_cmd_buffer.c b/src/gallium/frontends/lavapipe/lvp_cmd_buffer.c index a04f7442fd5..b9ebaa0b2d1 100644 --- a/src/gallium/frontends/lavapipe/lvp_cmd_buffer.c +++ b/src/gallium/frontends/lavapipe/lvp_cmd_buffer.c @@ -42,8 +42,10 @@ static VkResult lvp_create_cmd_buffer( VK_OBJECT_TYPE_COMMAND_BUFFER); cmd_buffer->device = device; cmd_buffer->pool = pool; - list_inithead(&cmd_buffer->cmds); - cmd_buffer->last_emit = &cmd_buffer->cmds; + + cmd_buffer->queue.alloc = &pool->alloc; + list_inithead(&cmd_buffer->queue.cmds); + cmd_buffer->status = LVP_CMD_BUFFER_STATUS_INITIAL; if (pool) { list_addtail(&cmd_buffer->pool_link, &pool->cmd_buffers); @@ -58,21 +60,10 @@ static VkResult lvp_create_cmd_buffer( return VK_SUCCESS; } -static void -lvp_cmd_buffer_free_all_cmds(struct lvp_cmd_buffer *cmd_buffer) -{ - struct lvp_cmd_buffer_entry *tmp, *cmd; - LIST_FOR_EACH_ENTRY_SAFE(cmd, tmp, &cmd_buffer->cmds, cmd_link) { - list_del(&cmd->cmd_link); - vk_free(&cmd_buffer->pool->alloc, cmd); - } -} - static VkResult lvp_reset_cmd_buffer(struct lvp_cmd_buffer *cmd_buffer) { - lvp_cmd_buffer_free_all_cmds(cmd_buffer); - list_inithead(&cmd_buffer->cmds); - cmd_buffer->last_emit = &cmd_buffer->cmds; + vk_free_queue(&cmd_buffer->queue); + list_inithead(&cmd_buffer->queue.cmds); cmd_buffer->status = LVP_CMD_BUFFER_STATUS_INITIAL; return VK_SUCCESS; } @@ -122,7 +113,7 @@ VKAPI_ATTR VkResult VKAPI_CALL lvp_AllocateCommandBuffers( static void lvp_cmd_buffer_destroy(struct lvp_cmd_buffer *cmd_buffer) { - lvp_cmd_buffer_free_all_cmds(cmd_buffer); + vk_free_queue(&cmd_buffer->queue); list_del(&cmd_buffer->pool_link); vk_object_base_finish(&cmd_buffer->base); vk_free(&cmd_buffer->pool->alloc, cmd_buffer); @@ -266,168 +257,220 @@ VKAPI_ATTR void VKAPI_CALL lvp_TrimCommandPool( } } -static struct lvp_cmd_buffer_entry *cmd_buf_entry_alloc_size(struct lvp_cmd_buffer *cmd_buffer, - uint32_t extra_size, - enum lvp_cmds type) +VKAPI_ATTR void VKAPI_CALL lvp_CmdDrawMultiEXT( + VkCommandBuffer commandBuffer, + uint32_t drawCount, + const VkMultiDrawInfoEXT *pVertexInfo, + uint32_t instanceCount, + uint32_t firstInstance, + uint32_t stride) { - struct lvp_cmd_buffer_entry *cmd; - uint32_t cmd_size = sizeof(*cmd) + extra_size; - cmd = vk_alloc(&cmd_buffer->pool->alloc, - cmd_size, - 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); + + struct vk_cmd_queue_entry *cmd = vk_zalloc(cmd_buffer->queue.alloc, + sizeof(*cmd), 8, + VK_SYSTEM_ALLOCATION_SCOPE_COMMAND); if (!cmd) - return NULL; + return; - cmd->cmd_type = type; - return cmd; -} + cmd->type = VK_CMD_DRAW_MULTI_EXT; + list_addtail(&cmd->cmd_link, &cmd_buffer->queue.cmds); -static struct lvp_cmd_buffer_entry *cmd_buf_entry_alloc(struct lvp_cmd_buffer *cmd_buffer, - enum lvp_cmds type) -{ - return cmd_buf_entry_alloc_size(cmd_buffer, 0, type); -} - -static void cmd_buf_queue(struct lvp_cmd_buffer *cmd_buffer, - struct lvp_cmd_buffer_entry *cmd) -{ - switch (cmd->cmd_type) { - case LVP_CMD_BIND_DESCRIPTOR_SETS: - case LVP_CMD_PUSH_DESCRIPTOR_SET: - list_add(&cmd->cmd_link, cmd_buffer->last_emit); - cmd_buffer->last_emit = &cmd->cmd_link; - break; - case LVP_CMD_NEXT_SUBPASS: - case LVP_CMD_DRAW: - case LVP_CMD_DRAW_INDEXED: - case LVP_CMD_DRAW_INDIRECT: - case LVP_CMD_DRAW_INDEXED_INDIRECT: - case LVP_CMD_DISPATCH: - case LVP_CMD_DISPATCH_INDIRECT: - cmd_buffer->last_emit = &cmd->cmd_link; - FALLTHROUGH; - default: - list_addtail(&cmd->cmd_link, &cmd_buffer->cmds); + cmd->u.draw_multi_ext.draw_count = drawCount; + if (pVertexInfo) { + unsigned i = 0; + cmd->u.draw_multi_ext.vertex_info = vk_zalloc(cmd_buffer->queue.alloc, + sizeof(*cmd->u.draw_multi_ext.vertex_info) * drawCount, + 8, + VK_SYSTEM_ALLOCATION_SCOPE_COMMAND); + vk_foreach_multi_draw(draw, i, pVertexInfo, drawCount, stride) + memcpy(&cmd->u.draw_multi_ext.vertex_info[i], draw, sizeof(*cmd->u.draw_multi_ext.vertex_info)); } + cmd->u.draw_multi_ext.instance_count = instanceCount; + cmd->u.draw_multi_ext.first_instance = firstInstance; + cmd->u.draw_multi_ext.stride = stride; } -static void -state_setup_attachments(struct lvp_attachment_state *attachments, - struct lvp_render_pass *pass, - const VkClearValue *clear_values) +VKAPI_ATTR void VKAPI_CALL lvp_CmdDrawMultiIndexedEXT( + VkCommandBuffer commandBuffer, + uint32_t drawCount, + const VkMultiDrawIndexedInfoEXT *pIndexInfo, + uint32_t instanceCount, + uint32_t firstInstance, + uint32_t stride, + const int32_t *pVertexOffset) { - for (uint32_t i = 0; i < pass->attachment_count; ++i) { - struct lvp_render_pass_attachment *att = &pass->attachments[i]; - VkImageAspectFlags att_aspects = vk_format_aspects(att->format); - VkImageAspectFlags clear_aspects = 0; - if (att_aspects == VK_IMAGE_ASPECT_COLOR_BIT) { - /* color attachment */ - if (att->load_op == VK_ATTACHMENT_LOAD_OP_CLEAR) { - clear_aspects |= VK_IMAGE_ASPECT_COLOR_BIT; - } - } else { - /* depthstencil attachment */ - if ((att_aspects & VK_IMAGE_ASPECT_DEPTH_BIT) && - att->load_op == VK_ATTACHMENT_LOAD_OP_CLEAR) { - clear_aspects |= VK_IMAGE_ASPECT_DEPTH_BIT; - if ((att_aspects & VK_IMAGE_ASPECT_STENCIL_BIT) && - att->stencil_load_op == VK_ATTACHMENT_LOAD_OP_DONT_CARE) - clear_aspects |= VK_IMAGE_ASPECT_STENCIL_BIT; - } - if ((att_aspects & VK_IMAGE_ASPECT_STENCIL_BIT) && - att->stencil_load_op == VK_ATTACHMENT_LOAD_OP_CLEAR) { - clear_aspects |= VK_IMAGE_ASPECT_STENCIL_BIT; - } + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); + + struct vk_cmd_queue_entry *cmd = vk_zalloc(cmd_buffer->queue.alloc, + sizeof(*cmd), 8, + VK_SYSTEM_ALLOCATION_SCOPE_COMMAND); + if (!cmd) + return; + + cmd->type = VK_CMD_DRAW_MULTI_INDEXED_EXT; + list_addtail(&cmd->cmd_link, &cmd_buffer->queue.cmds); + + cmd->u.draw_multi_indexed_ext.draw_count = drawCount; + + if (pIndexInfo) { + unsigned i = 0; + cmd->u.draw_multi_indexed_ext.index_info = vk_zalloc(cmd_buffer->queue.alloc, + sizeof(*cmd->u.draw_multi_indexed_ext.index_info) * drawCount, + 8, + VK_SYSTEM_ALLOCATION_SCOPE_COMMAND); + vk_foreach_multi_draw_indexed(draw, i, pIndexInfo, drawCount, stride) { + cmd->u.draw_multi_indexed_ext.index_info[i].firstIndex = draw->firstIndex; + cmd->u.draw_multi_indexed_ext.index_info[i].indexCount = draw->indexCount; + if (pVertexOffset == NULL) + cmd->u.draw_multi_indexed_ext.index_info[i].vertexOffset = draw->vertexOffset; } - attachments[i].pending_clear_aspects = clear_aspects; - if (clear_aspects) - attachments[i].clear_value = clear_values[i]; + } + + cmd->u.draw_multi_indexed_ext.instance_count = instanceCount; + cmd->u.draw_multi_indexed_ext.first_instance = firstInstance; + cmd->u.draw_multi_indexed_ext.stride = stride; + + if (pVertexOffset) { + cmd->u.draw_multi_indexed_ext.vertex_offset = vk_zalloc(cmd_buffer->queue.alloc, sizeof(*cmd->u.draw_multi_indexed_ext.vertex_offset), 8, VK_SYSTEM_ALLOCATION_SCOPE_COMMAND); + memcpy(cmd->u.draw_multi_indexed_ext.vertex_offset, pVertexOffset, sizeof(*cmd->u.draw_multi_indexed_ext.vertex_offset)); } } -VKAPI_ATTR void VKAPI_CALL lvp_CmdBeginRenderPass2( - VkCommandBuffer commandBuffer, - const VkRenderPassBeginInfo* pRenderPassBeginInfo, - const VkSubpassBeginInfo* pSubpassBeginInfo) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - LVP_FROM_HANDLE(lvp_render_pass, pass, pRenderPassBeginInfo->renderPass); - LVP_FROM_HANDLE(lvp_framebuffer, framebuffer, pRenderPassBeginInfo->framebuffer); - const struct VkRenderPassAttachmentBeginInfo *attachment_info = - vk_find_struct_const(pRenderPassBeginInfo->pNext, - RENDER_PASS_ATTACHMENT_BEGIN_INFO); - struct lvp_cmd_buffer_entry *cmd; - uint32_t cmd_size = pass->attachment_count * sizeof(struct lvp_attachment_state); - - if (attachment_info) - cmd_size += attachment_info->attachmentCount * sizeof(struct lvp_image_view *); - - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_BEGIN_RENDER_PASS); - if (!cmd) - return; - - cmd->u.begin_render_pass.render_pass = pass; - cmd->u.begin_render_pass.framebuffer = framebuffer; - cmd->u.begin_render_pass.render_area = pRenderPassBeginInfo->renderArea; - - cmd->u.begin_render_pass.attachments = (struct lvp_attachment_state *)(cmd + 1); - cmd->u.begin_render_pass.imageless_views = NULL; - if (attachment_info) { - cmd->u.begin_render_pass.imageless_views = (struct lvp_image_view **)(cmd->u.begin_render_pass.attachments + pass->attachment_count); - for (unsigned i = 0; i < attachment_info->attachmentCount; i++) - cmd->u.begin_render_pass.imageless_views[i] = lvp_image_view_from_handle(attachment_info->pAttachments[i]); - } - - state_setup_attachments(cmd->u.begin_render_pass.attachments, pass, pRenderPassBeginInfo->pClearValues); - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdNextSubpass2( - VkCommandBuffer commandBuffer, - const VkSubpassBeginInfo* pSubpassBeginInfo, - const VkSubpassEndInfo* pSubpassEndInfo) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_NEXT_SUBPASS); - if (!cmd) - return; - - cmd->u.next_subpass.contents = pSubpassBeginInfo->contents; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdBindVertexBuffers( - VkCommandBuffer commandBuffer, - uint32_t firstBinding, - uint32_t bindingCount, - const VkBuffer* pBuffers, - const VkDeviceSize* pOffsets) -{ - lvp_CmdBindVertexBuffers2EXT(commandBuffer, firstBinding, - bindingCount, pBuffers, pOffsets, NULL, NULL); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdBindPipeline( +VKAPI_ATTR void VKAPI_CALL lvp_CmdPushDescriptorSetKHR( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, - VkPipeline _pipeline) + VkPipelineLayout layout, + uint32_t set, + uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites) { LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - LVP_FROM_HANDLE(lvp_pipeline, pipeline, _pipeline); - struct lvp_cmd_buffer_entry *cmd; + struct vk_cmd_push_descriptor_set_khr *pds; - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_BIND_PIPELINE); + struct vk_cmd_queue_entry *cmd = vk_zalloc(cmd_buffer->queue.alloc, + sizeof(*cmd), 8, + VK_SYSTEM_ALLOCATION_SCOPE_COMMAND); if (!cmd) return; - cmd->u.pipeline.bind_point = pipelineBindPoint; - cmd->u.pipeline.pipeline = pipeline; + pds = &cmd->u.push_descriptor_set_khr; - cmd_buf_queue(cmd_buffer, cmd); + cmd->type = VK_CMD_PUSH_DESCRIPTOR_SET_KHR; + list_addtail(&cmd->cmd_link, &cmd_buffer->queue.cmds); + + pds->pipeline_bind_point = pipelineBindPoint; + pds->layout = layout; + pds->set = set; + pds->descriptor_write_count = descriptorWriteCount; + + if (pDescriptorWrites) { + pds->descriptor_writes = vk_zalloc(cmd_buffer->queue.alloc, + sizeof(*pds->descriptor_writes) * descriptorWriteCount, + 8, + VK_SYSTEM_ALLOCATION_SCOPE_COMMAND); + memcpy(pds->descriptor_writes, + pDescriptorWrites, + sizeof(*pds->descriptor_writes) * descriptorWriteCount); + + for (unsigned i = 0; i < descriptorWriteCount; i++) { + switch (pds->descriptor_writes[i].descriptorType) { + case VK_DESCRIPTOR_TYPE_SAMPLER: + case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: + case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: + case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: + case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: + pds->descriptor_writes[i].pImageInfo = vk_zalloc(cmd_buffer->queue.alloc, + sizeof(VkDescriptorImageInfo) * pds->descriptor_writes[i].descriptorCount, + 8, + VK_SYSTEM_ALLOCATION_SCOPE_COMMAND); + memcpy((VkDescriptorImageInfo *)pds->descriptor_writes[i].pImageInfo, + pDescriptorWrites[i].pImageInfo, + sizeof(VkDescriptorImageInfo) * pds->descriptor_writes[i].descriptorCount); + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: + case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: + pds->descriptor_writes[i].pTexelBufferView = vk_zalloc(cmd_buffer->queue.alloc, + sizeof(VkBufferView) * pds->descriptor_writes[i].descriptorCount, + 8, + VK_SYSTEM_ALLOCATION_SCOPE_COMMAND); + memcpy((VkBufferView *)pds->descriptor_writes[i].pTexelBufferView, + pDescriptorWrites[i].pTexelBufferView, + sizeof(VkBufferView) * pds->descriptor_writes[i].descriptorCount); + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: + default: + pds->descriptor_writes[i].pBufferInfo = vk_zalloc(cmd_buffer->queue.alloc, + sizeof(VkDescriptorBufferInfo) * pds->descriptor_writes[i].descriptorCount, + 8, + VK_SYSTEM_ALLOCATION_SCOPE_COMMAND); + memcpy((VkDescriptorBufferInfo *)pds->descriptor_writes[i].pBufferInfo, + pDescriptorWrites[i].pBufferInfo, + sizeof(VkDescriptorBufferInfo) * pds->descriptor_writes[i].descriptorCount); + break; + } + } + } +} + +VKAPI_ATTR void VKAPI_CALL lvp_CmdPushDescriptorSetWithTemplateKHR( + VkCommandBuffer commandBuffer, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + VkPipelineLayout layout, + uint32_t set, + const void* pData) +{ + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); + LVP_FROM_HANDLE(lvp_descriptor_update_template, templ, descriptorUpdateTemplate); + size_t info_size = 0; + struct vk_cmd_queue_entry *cmd = vk_zalloc(cmd_buffer->queue.alloc, + sizeof(*cmd), 8, + VK_SYSTEM_ALLOCATION_SCOPE_COMMAND); + if (!cmd) + return; + + cmd->type = VK_CMD_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_KHR; + + list_addtail(&cmd->cmd_link, &cmd_buffer->queue.cmds); + + cmd->u.push_descriptor_set_with_template_khr.descriptor_update_template = descriptorUpdateTemplate; + cmd->u.push_descriptor_set_with_template_khr.layout = layout; + cmd->u.push_descriptor_set_with_template_khr.set = set; + + for (unsigned i = 0; i < templ->entry_count; i++) { + VkDescriptorUpdateTemplateEntry *entry = &templ->entry[i]; + + if (entry->descriptorCount > 1) { + info_size += entry->stride * entry->descriptorCount; + } else { + switch (entry->descriptorType) { + case VK_DESCRIPTOR_TYPE_SAMPLER: + case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: + case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: + case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: + case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: + info_size += sizeof(VkDescriptorImageInfo); + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: + case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: + info_size += sizeof(VkBufferView); + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: + default: + info_size += sizeof(VkDescriptorBufferInfo); + break; + } + } + } + + cmd->u.push_descriptor_set_with_template_khr.data = vk_zalloc(cmd_buffer->queue.alloc, info_size, 8, VK_SYSTEM_ALLOCATION_SCOPE_COMMAND); + memcpy(cmd->u.push_descriptor_set_with_template_khr.data, pData, info_size); } VKAPI_ATTR void VKAPI_CALL lvp_CmdBindDescriptorSets( @@ -442,1842 +485,31 @@ VKAPI_ATTR void VKAPI_CALL lvp_CmdBindDescriptorSets( { LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); LVP_FROM_HANDLE(lvp_pipeline_layout, layout, _layout); - struct lvp_cmd_buffer_entry *cmd; - struct lvp_descriptor_set **sets; - uint32_t *offsets; - int i; - uint32_t cmd_size = descriptorSetCount * sizeof(struct lvp_descriptor_set *) + dynamicOffsetCount * sizeof(uint32_t); - - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_BIND_DESCRIPTOR_SETS); + struct vk_cmd_queue_entry *cmd = vk_zalloc(cmd_buffer->queue.alloc, + sizeof(*cmd), 8, + VK_SYSTEM_ALLOCATION_SCOPE_COMMAND); if (!cmd) return; - cmd->u.descriptor_sets.bind_point = pipelineBindPoint; - cmd->u.descriptor_sets.first = firstSet; - cmd->u.descriptor_sets.count = descriptorSetCount; + cmd->type = VK_CMD_BIND_DESCRIPTOR_SETS; + list_addtail(&cmd->cmd_link, &cmd_buffer->queue.cmds); - for (i = 0; i < layout->num_sets; i++) - cmd->u.descriptor_sets.set_layout[i] = layout->set[i].layout; - sets = (struct lvp_descriptor_set **)(cmd + 1); - for (i = 0; i < descriptorSetCount; i++) { + /* _layout could have been destroyed by when this command executes */ + struct lvp_descriptor_set_layout **set_layout = vk_zalloc(cmd_buffer->queue.alloc, sizeof(*set_layout) * layout->num_sets, 8, VK_SYSTEM_ALLOCATION_SCOPE_COMMAND); + cmd->driver_data = set_layout; + for (unsigned i = 0; i < layout->num_sets; i++) + set_layout[i] = layout->set[i].layout; - sets[i] = lvp_descriptor_set_from_handle(pDescriptorSets[i]); + cmd->u.bind_descriptor_sets.pipeline_bind_point = pipelineBindPoint; + cmd->u.bind_descriptor_sets.first_set = firstSet; + cmd->u.bind_descriptor_sets.descriptor_set_count = descriptorSetCount; + if (pDescriptorSets) { + cmd->u.bind_descriptor_sets.descriptor_sets = vk_zalloc(cmd_buffer->queue.alloc, sizeof(*cmd->u.bind_descriptor_sets.descriptor_sets) * descriptorSetCount, 8, VK_SYSTEM_ALLOCATION_SCOPE_COMMAND); + memcpy(( VkDescriptorSet* )cmd->u.bind_descriptor_sets.descriptor_sets, pDescriptorSets, sizeof(*cmd->u.bind_descriptor_sets.descriptor_sets) * descriptorSetCount); } - cmd->u.descriptor_sets.sets = sets; - - cmd->u.descriptor_sets.dynamic_offset_count = dynamicOffsetCount; - offsets = (uint32_t *)(sets + descriptorSetCount); - for (i = 0; i < dynamicOffsetCount; i++) - offsets[i] = pDynamicOffsets[i]; - cmd->u.descriptor_sets.dynamic_offsets = offsets; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdDraw( - VkCommandBuffer commandBuffer, - uint32_t vertexCount, - uint32_t instanceCount, - uint32_t firstVertex, - uint32_t firstInstance) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - uint32_t cmd_size = sizeof(struct pipe_draw_start_count_bias); - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_DRAW); - if (!cmd) - return; - - cmd->u.draw.instance_count = instanceCount; - cmd->u.draw.first_instance = firstInstance; - cmd->u.draw.draw_count = 1; - cmd->u.draw.draws[0].start = firstVertex; - cmd->u.draw.draws[0].count = vertexCount; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdDrawMultiEXT( - VkCommandBuffer commandBuffer, - uint32_t drawCount, - const VkMultiDrawInfoEXT *pVertexInfo, - uint32_t instanceCount, - uint32_t firstInstance, - uint32_t stride) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - uint32_t cmd_size = drawCount * sizeof(struct pipe_draw_start_count_bias); - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_DRAW); - if (!cmd) - return; - - cmd->u.draw.instance_count = instanceCount; - cmd->u.draw.first_instance = firstInstance; - cmd->u.draw.draw_count = drawCount; - if (stride == sizeof(struct pipe_draw_start_count_bias)) - memcpy(cmd->u.draw.draws, pVertexInfo, cmd_size); - else { - unsigned i = 0; - vk_foreach_multi_draw(draw, i, pVertexInfo, drawCount, stride) - memcpy(&cmd->u.draw.draws[i], draw, sizeof(struct VkMultiDrawInfoEXT)); + cmd->u.bind_descriptor_sets.dynamic_offset_count = dynamicOffsetCount; + if (pDynamicOffsets) { + cmd->u.bind_descriptor_sets.dynamic_offsets = vk_zalloc(cmd_buffer->queue.alloc, sizeof(*cmd->u.bind_descriptor_sets.dynamic_offsets) * dynamicOffsetCount, 8, VK_SYSTEM_ALLOCATION_SCOPE_COMMAND); + memcpy(( uint32_t* )cmd->u.bind_descriptor_sets.dynamic_offsets, pDynamicOffsets, sizeof(*cmd->u.bind_descriptor_sets.dynamic_offsets) * dynamicOffsetCount); } - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdEndRenderPass2( - VkCommandBuffer commandBuffer, - const VkSubpassEndInfo* pSubpassEndInfo) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_END_RENDER_PASS); - if (!cmd) - return; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdSetViewport( - VkCommandBuffer commandBuffer, - uint32_t firstViewport, - uint32_t viewportCount, - const VkViewport* pViewports) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - int i; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_VIEWPORT); - if (!cmd) - return; - - cmd->u.set_viewport.first_viewport = firstViewport; - cmd->u.set_viewport.viewport_count = viewportCount; - for (i = 0; i < viewportCount; i++) - cmd->u.set_viewport.viewports[i] = pViewports[i]; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdSetScissor( - VkCommandBuffer commandBuffer, - uint32_t firstScissor, - uint32_t scissorCount, - const VkRect2D* pScissors) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - int i; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_SCISSOR); - if (!cmd) - return; - - cmd->u.set_scissor.first_scissor = firstScissor; - cmd->u.set_scissor.scissor_count = scissorCount; - for (i = 0; i < scissorCount; i++) - cmd->u.set_scissor.scissors[i] = pScissors[i]; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdSetLineWidth( - VkCommandBuffer commandBuffer, - float lineWidth) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_LINE_WIDTH); - if (!cmd) - return; - - cmd->u.set_line_width.line_width = lineWidth; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdSetDepthBias( - VkCommandBuffer commandBuffer, - float depthBiasConstantFactor, - float depthBiasClamp, - float depthBiasSlopeFactor) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_DEPTH_BIAS); - if (!cmd) - return; - - cmd->u.set_depth_bias.constant_factor = depthBiasConstantFactor; - cmd->u.set_depth_bias.clamp = depthBiasClamp; - cmd->u.set_depth_bias.slope_factor = depthBiasSlopeFactor; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdSetBlendConstants( - VkCommandBuffer commandBuffer, - const float blendConstants[4]) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_BLEND_CONSTANTS); - if (!cmd) - return; - - memcpy(cmd->u.set_blend_constants.blend_constants, blendConstants, 4 * sizeof(float)); - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdSetDepthBounds( - VkCommandBuffer commandBuffer, - float minDepthBounds, - float maxDepthBounds) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_DEPTH_BOUNDS); - if (!cmd) - return; - - cmd->u.set_depth_bounds.min_depth = minDepthBounds; - cmd->u.set_depth_bounds.max_depth = maxDepthBounds; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdSetStencilCompareMask( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - uint32_t compareMask) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_STENCIL_COMPARE_MASK); - if (!cmd) - return; - - cmd->u.stencil_vals.face_mask = faceMask; - cmd->u.stencil_vals.value = compareMask; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdSetStencilWriteMask( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - uint32_t writeMask) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_STENCIL_WRITE_MASK); - if (!cmd) - return; - - cmd->u.stencil_vals.face_mask = faceMask; - cmd->u.stencil_vals.value = writeMask; - - cmd_buf_queue(cmd_buffer, cmd); -} - - -VKAPI_ATTR void VKAPI_CALL lvp_CmdSetStencilReference( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - uint32_t reference) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_STENCIL_REFERENCE); - if (!cmd) - return; - - cmd->u.stencil_vals.face_mask = faceMask; - cmd->u.stencil_vals.value = reference; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdPushConstants( - VkCommandBuffer commandBuffer, - VkPipelineLayout layout, - VkShaderStageFlags stageFlags, - uint32_t offset, - uint32_t size, - const void* pValues) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc_size(cmd_buffer, (size - 4), LVP_CMD_PUSH_CONSTANTS); - if (!cmd) - return; - - cmd->u.push_constants.stage = stageFlags; - cmd->u.push_constants.offset = offset; - cmd->u.push_constants.size = size; - memcpy(cmd->u.push_constants.val, pValues, size); - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdBindIndexBuffer( - VkCommandBuffer commandBuffer, - VkBuffer _buffer, - VkDeviceSize offset, - VkIndexType indexType) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - LVP_FROM_HANDLE(lvp_buffer, buffer, _buffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_BIND_INDEX_BUFFER); - if (!cmd) - return; - - cmd->u.index_buffer.buffer = buffer; - cmd->u.index_buffer.offset = offset; - cmd->u.index_buffer.index_type = indexType; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdDrawIndexed( - VkCommandBuffer commandBuffer, - uint32_t indexCount, - uint32_t instanceCount, - uint32_t firstIndex, - int32_t vertexOffset, - uint32_t firstInstance) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - uint32_t cmd_size = sizeof(struct pipe_draw_start_count_bias); - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_DRAW_INDEXED); - if (!cmd) - return; - - cmd->u.draw_indexed.instance_count = instanceCount; - cmd->u.draw_indexed.first_instance = firstInstance; - cmd->u.draw_indexed.draw_count = 1; - cmd->u.draw_indexed.draws[0].start = firstIndex; - cmd->u.draw_indexed.draws[0].count = indexCount; - cmd->u.draw_indexed.draws[0].index_bias = vertexOffset; - cmd->u.draw_indexed.calc_start = true; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdDrawMultiIndexedEXT( - VkCommandBuffer commandBuffer, - uint32_t drawCount, - const VkMultiDrawIndexedInfoEXT *pIndexInfo, - uint32_t instanceCount, - uint32_t firstInstance, - uint32_t stride, - const int32_t *pVertexOffset) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - uint32_t cmd_size = drawCount * sizeof(struct pipe_draw_start_count_bias); - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_DRAW_INDEXED); - if (!cmd) - return; - - cmd->u.draw_indexed.instance_count = instanceCount; - cmd->u.draw_indexed.first_instance = firstInstance; - cmd->u.draw_indexed.draw_count = drawCount; - cmd->u.draw_indexed.vertex_offset_changes = !pVertexOffset; - if (stride == sizeof(struct pipe_draw_start_count_bias)) - memcpy(cmd->u.draw_indexed.draws, pIndexInfo, cmd_size); - else { - unsigned i = 0; - vk_foreach_multi_draw_indexed(draw, i, pIndexInfo, drawCount, stride) - memcpy(&cmd->u.draw_indexed.draws[i], draw, sizeof(struct pipe_draw_start_count_bias)); - } - /* only the first member is read if vertex_offset_changes is true */ - if (pVertexOffset) - cmd->u.draw_indexed.draws[0].index_bias = *pVertexOffset; - cmd->u.draw_indexed.calc_start = true; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdDrawIndirect( - VkCommandBuffer commandBuffer, - VkBuffer _buffer, - VkDeviceSize offset, - uint32_t drawCount, - uint32_t stride) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - LVP_FROM_HANDLE(lvp_buffer, buf, _buffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_DRAW_INDIRECT); - if (!cmd) - return; - - cmd->u.draw_indirect.offset = offset; - cmd->u.draw_indirect.buffer = buf; - cmd->u.draw_indirect.draw_count = drawCount; - cmd->u.draw_indirect.stride = stride; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdDrawIndexedIndirect( - VkCommandBuffer commandBuffer, - VkBuffer _buffer, - VkDeviceSize offset, - uint32_t drawCount, - uint32_t stride) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - LVP_FROM_HANDLE(lvp_buffer, buf, _buffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_DRAW_INDEXED_INDIRECT); - if (!cmd) - return; - - cmd->u.draw_indirect.offset = offset; - cmd->u.draw_indirect.buffer = buf; - cmd->u.draw_indirect.draw_count = drawCount; - cmd->u.draw_indirect.stride = stride; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdDispatch( - VkCommandBuffer commandBuffer, - uint32_t x, - uint32_t y, - uint32_t z) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_DISPATCH); - if (!cmd) - return; - - cmd->u.dispatch.x = x; - cmd->u.dispatch.y = y; - cmd->u.dispatch.z = z; - cmd->u.dispatch.base_x = 0; - cmd->u.dispatch.base_y = 0; - cmd->u.dispatch.base_z = 0; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdDispatchIndirect( - VkCommandBuffer commandBuffer, - VkBuffer _buffer, - VkDeviceSize offset) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_DISPATCH_INDIRECT); - if (!cmd) - return; - - cmd->u.dispatch_indirect.buffer = lvp_buffer_from_handle(_buffer); - cmd->u.dispatch_indirect.offset = offset; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdExecuteCommands( - VkCommandBuffer commandBuffer, - uint32_t commandBufferCount, - const VkCommandBuffer* pCmdBuffers) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - uint32_t cmd_size = commandBufferCount * sizeof(struct lvp_cmd_buffer *); - - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_EXECUTE_COMMANDS); - if (!cmd) - return; - - cmd->u.execute_commands.command_buffer_count = commandBufferCount; - for (unsigned i = 0; i < commandBufferCount; i++) - cmd->u.execute_commands.cmd_buffers[i] = lvp_cmd_buffer_from_handle(pCmdBuffers[i]); - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdSetEvent(VkCommandBuffer commandBuffer, - VkEvent _event, - VkPipelineStageFlags stageMask) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - LVP_FROM_HANDLE(lvp_event, event, _event); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_EVENT); - if (!cmd) - return; - - cmd->u.event_set.event = event; - cmd->u.event_set.value = true; - cmd->u.event_set.flush = !!(stageMask == VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT); - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdResetEvent(VkCommandBuffer commandBuffer, - VkEvent _event, - VkPipelineStageFlags stageMask) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - LVP_FROM_HANDLE(lvp_event, event, _event); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_EVENT); - if (!cmd) - return; - - cmd->u.event_set.event = event; - cmd->u.event_set.value = false; - cmd->u.event_set.flush = !!(stageMask == VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT); - - cmd_buf_queue(cmd_buffer, cmd); - -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdWaitEvents(VkCommandBuffer commandBuffer, - uint32_t eventCount, - const VkEvent* pEvents, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags dstStageMask, - uint32_t memoryBarrierCount, - const VkMemoryBarrier* pMemoryBarriers, - uint32_t bufferMemoryBarrierCount, - const VkBufferMemoryBarrier* pBufferMemoryBarriers, - uint32_t imageMemoryBarrierCount, - const VkImageMemoryBarrier* pImageMemoryBarriers) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - uint32_t cmd_size = 0; - - cmd_size += eventCount * sizeof(struct lvp_event *); - cmd_size += memoryBarrierCount * sizeof(VkMemoryBarrier); - cmd_size += bufferMemoryBarrierCount * sizeof(VkBufferMemoryBarrier); - cmd_size += imageMemoryBarrierCount * sizeof(VkImageMemoryBarrier); - - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_WAIT_EVENTS); - if (!cmd) - return; - - cmd->u.wait_events.src_stage_mask = srcStageMask; - cmd->u.wait_events.dst_stage_mask = dstStageMask; - cmd->u.wait_events.event_count = eventCount; - cmd->u.wait_events.events = (struct lvp_event **)(cmd + 1); - for (unsigned i = 0; i < eventCount; i++) - cmd->u.wait_events.events[i] = lvp_event_from_handle(pEvents[i]); - cmd->u.wait_events.memory_barrier_count = memoryBarrierCount; - cmd->u.wait_events.buffer_memory_barrier_count = bufferMemoryBarrierCount; - cmd->u.wait_events.image_memory_barrier_count = imageMemoryBarrierCount; - - /* TODO finish off this */ - cmd_buf_queue(cmd_buffer, cmd); -} - -/* copy a 2KHR struct to the base struct */ -static inline void -copy_2_struct_to_base(void *base, const void *struct2, size_t struct_size) -{ - size_t offset = align(sizeof(VkStructureType) + sizeof(void*), 8); - memcpy(base, ((uint8_t*)struct2) + offset, struct_size); -} - -/* copy an array of 2KHR structs to an array of base structs */ -#define COPY_STRUCT2_ARRAY(count, base, struct2, struct_type) \ - do { \ - for (unsigned _i = 0; _i < (count); _i++) \ - copy_2_struct_to_base(&base[_i], &struct2[_i], sizeof(struct_type)); \ - } while (0) - -VKAPI_ATTR void VKAPI_CALL lvp_CmdCopyBufferToImage2KHR( - VkCommandBuffer commandBuffer, - const VkCopyBufferToImageInfo2KHR *info) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - LVP_FROM_HANDLE(lvp_buffer, src_buffer, info->srcBuffer); - LVP_FROM_HANDLE(lvp_image, dst_image, info->dstImage); - struct lvp_cmd_buffer_entry *cmd; - uint32_t cmd_size = info->regionCount * sizeof(VkBufferImageCopy); - - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_COPY_BUFFER_TO_IMAGE); - if (!cmd) - return; - - cmd->u.buffer_to_img.src = src_buffer; - cmd->u.buffer_to_img.dst = dst_image; - cmd->u.buffer_to_img.dst_layout = info->dstImageLayout; - cmd->u.buffer_to_img.region_count = info->regionCount; - - { - VkBufferImageCopy *regions; - - regions = (VkBufferImageCopy *)(cmd + 1); - COPY_STRUCT2_ARRAY(info->regionCount, regions, info->pRegions, VkBufferImageCopy); - cmd->u.buffer_to_img.regions = regions; - } - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdCopyImageToBuffer2KHR( - VkCommandBuffer commandBuffer, - const VkCopyImageToBufferInfo2KHR *info) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - LVP_FROM_HANDLE(lvp_image, src_image, info->srcImage); - LVP_FROM_HANDLE(lvp_buffer, dst_buffer, info->dstBuffer); - struct lvp_cmd_buffer_entry *cmd; - uint32_t cmd_size = info->regionCount * sizeof(VkBufferImageCopy); - - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_COPY_IMAGE_TO_BUFFER); - if (!cmd) - return; - - cmd->u.img_to_buffer.src = src_image; - cmd->u.img_to_buffer.dst = dst_buffer; - cmd->u.img_to_buffer.src_layout = info->srcImageLayout; - cmd->u.img_to_buffer.region_count = info->regionCount; - - { - VkBufferImageCopy *regions; - - regions = (VkBufferImageCopy *)(cmd + 1); - COPY_STRUCT2_ARRAY(info->regionCount, regions, info->pRegions, VkBufferImageCopy); - cmd->u.img_to_buffer.regions = regions; - } - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdCopyImage2KHR( - VkCommandBuffer commandBuffer, - const VkCopyImageInfo2KHR *info) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - LVP_FROM_HANDLE(lvp_image, src_image, info->srcImage); - LVP_FROM_HANDLE(lvp_image, dest_image, info->dstImage); - struct lvp_cmd_buffer_entry *cmd; - uint32_t cmd_size = info->regionCount * sizeof(VkImageCopy); - - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_COPY_IMAGE); - if (!cmd) - return; - - cmd->u.copy_image.src = src_image; - cmd->u.copy_image.dst = dest_image; - cmd->u.copy_image.src_layout = info->srcImageLayout; - cmd->u.copy_image.dst_layout = info->dstImageLayout; - cmd->u.copy_image.region_count = info->regionCount; - - { - VkImageCopy *regions; - - regions = (VkImageCopy *)(cmd + 1); - COPY_STRUCT2_ARRAY(info->regionCount, regions, info->pRegions, VkImageCopy); - cmd->u.copy_image.regions = regions; - } - - cmd_buf_queue(cmd_buffer, cmd); -} - - -VKAPI_ATTR void VKAPI_CALL lvp_CmdCopyBuffer2KHR( - VkCommandBuffer commandBuffer, - const VkCopyBufferInfo2KHR *info) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - LVP_FROM_HANDLE(lvp_buffer, src_buffer, info->srcBuffer); - LVP_FROM_HANDLE(lvp_buffer, dest_buffer, info->dstBuffer); - struct lvp_cmd_buffer_entry *cmd; - uint32_t cmd_size = info->regionCount * sizeof(VkBufferCopy); - - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_COPY_BUFFER); - if (!cmd) - return; - - cmd->u.copy_buffer.src = src_buffer; - cmd->u.copy_buffer.dst = dest_buffer; - cmd->u.copy_buffer.region_count = info->regionCount; - - { - VkBufferCopy *regions; - - regions = (VkBufferCopy *)(cmd + 1); - COPY_STRUCT2_ARRAY(info->regionCount, regions, info->pRegions, VkBufferCopy); - cmd->u.copy_buffer.regions = regions; - } - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdBlitImage2KHR( - VkCommandBuffer commandBuffer, - const VkBlitImageInfo2KHR *info) -{ - - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - LVP_FROM_HANDLE(lvp_image, src_image, info->srcImage); - LVP_FROM_HANDLE(lvp_image, dest_image, info->dstImage); - struct lvp_cmd_buffer_entry *cmd; - uint32_t cmd_size = info->regionCount * sizeof(VkImageBlit); - - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_BLIT_IMAGE); - if (!cmd) - return; - - cmd->u.blit_image.src = src_image; - cmd->u.blit_image.dst = dest_image; - cmd->u.blit_image.src_layout = info->srcImageLayout; - cmd->u.blit_image.dst_layout = info->dstImageLayout; - cmd->u.blit_image.filter = info->filter; - cmd->u.blit_image.region_count = info->regionCount; - - { - VkImageBlit *regions; - - regions = (VkImageBlit *)(cmd + 1); - COPY_STRUCT2_ARRAY(info->regionCount, regions, info->pRegions, VkImageBlit); - cmd->u.blit_image.regions = regions; - } - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdClearAttachments( - VkCommandBuffer commandBuffer, - uint32_t attachmentCount, - const VkClearAttachment* pAttachments, - uint32_t rectCount, - const VkClearRect* pRects) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - uint32_t cmd_size = attachmentCount * sizeof(VkClearAttachment) + rectCount * sizeof(VkClearRect); - - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_CLEAR_ATTACHMENTS); - if (!cmd) - return; - - cmd->u.clear_attachments.attachment_count = attachmentCount; - cmd->u.clear_attachments.attachments = (VkClearAttachment *)(cmd + 1); - for (unsigned i = 0; i < attachmentCount; i++) - cmd->u.clear_attachments.attachments[i] = pAttachments[i]; - cmd->u.clear_attachments.rect_count = rectCount; - cmd->u.clear_attachments.rects = (VkClearRect *)(cmd->u.clear_attachments.attachments + attachmentCount); - for (unsigned i = 0; i < rectCount; i++) - cmd->u.clear_attachments.rects[i] = pRects[i]; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdFillBuffer( - VkCommandBuffer commandBuffer, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize fillSize, - uint32_t data) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - LVP_FROM_HANDLE(lvp_buffer, dst_buffer, dstBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_FILL_BUFFER); - if (!cmd) - return; - - cmd->u.fill_buffer.buffer = dst_buffer; - cmd->u.fill_buffer.offset = dstOffset; - cmd->u.fill_buffer.fill_size = fillSize; - cmd->u.fill_buffer.data = data; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdUpdateBuffer( - VkCommandBuffer commandBuffer, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize dataSize, - const void* pData) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - LVP_FROM_HANDLE(lvp_buffer, dst_buffer, dstBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc_size(cmd_buffer, dataSize, LVP_CMD_UPDATE_BUFFER); - if (!cmd) - return; - - cmd->u.update_buffer.buffer = dst_buffer; - cmd->u.update_buffer.offset = dstOffset; - cmd->u.update_buffer.data_size = dataSize; - memcpy(cmd->u.update_buffer.data, pData, dataSize); - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdClearColorImage( - VkCommandBuffer commandBuffer, - VkImage image_h, - VkImageLayout imageLayout, - const VkClearColorValue* pColor, - uint32_t rangeCount, - const VkImageSubresourceRange* pRanges) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - LVP_FROM_HANDLE(lvp_image, image, image_h); - struct lvp_cmd_buffer_entry *cmd; - uint32_t cmd_size = rangeCount * sizeof(VkImageSubresourceRange); - - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_CLEAR_COLOR_IMAGE); - if (!cmd) - return; - - cmd->u.clear_color_image.image = image; - cmd->u.clear_color_image.layout = imageLayout; - cmd->u.clear_color_image.clear_val = *pColor; - cmd->u.clear_color_image.range_count = rangeCount; - cmd->u.clear_color_image.ranges = (VkImageSubresourceRange *)(cmd + 1); - for (unsigned i = 0; i < rangeCount; i++) - cmd->u.clear_color_image.ranges[i] = pRanges[i]; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdClearDepthStencilImage( - VkCommandBuffer commandBuffer, - VkImage image_h, - VkImageLayout imageLayout, - const VkClearDepthStencilValue* pDepthStencil, - uint32_t rangeCount, - const VkImageSubresourceRange* pRanges) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - LVP_FROM_HANDLE(lvp_image, image, image_h); - struct lvp_cmd_buffer_entry *cmd; - uint32_t cmd_size = rangeCount * sizeof(VkImageSubresourceRange); - - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_CLEAR_DEPTH_STENCIL_IMAGE); - if (!cmd) - return; - - cmd->u.clear_ds_image.image = image; - cmd->u.clear_ds_image.layout = imageLayout; - cmd->u.clear_ds_image.clear_val = *pDepthStencil; - cmd->u.clear_ds_image.range_count = rangeCount; - cmd->u.clear_ds_image.ranges = (VkImageSubresourceRange *)(cmd + 1); - for (unsigned i = 0; i < rangeCount; i++) - cmd->u.clear_ds_image.ranges[i] = pRanges[i]; - - cmd_buf_queue(cmd_buffer, cmd); -} - - -VKAPI_ATTR void VKAPI_CALL lvp_CmdResolveImage2KHR( - VkCommandBuffer commandBuffer, - const VkResolveImageInfo2KHR *info) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - LVP_FROM_HANDLE(lvp_image, src_image, info->srcImage); - LVP_FROM_HANDLE(lvp_image, dst_image, info->dstImage); - struct lvp_cmd_buffer_entry *cmd; - uint32_t cmd_size = info->regionCount * sizeof(VkImageResolve); - - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_RESOLVE_IMAGE); - if (!cmd) - return; - - cmd->u.resolve_image.src = src_image; - cmd->u.resolve_image.dst = dst_image; - cmd->u.resolve_image.src_layout = info->srcImageLayout; - cmd->u.resolve_image.dst_layout = info->dstImageLayout; - cmd->u.resolve_image.region_count = info->regionCount; - cmd->u.resolve_image.regions = (VkImageResolve *)(cmd + 1); - COPY_STRUCT2_ARRAY(info->regionCount, cmd->u.resolve_image.regions, info->pRegions, VkImageResolve); - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdResetQueryPool( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - LVP_FROM_HANDLE(lvp_query_pool, query_pool, queryPool); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_RESET_QUERY_POOL); - if (!cmd) - return; - - cmd->u.query.pool = query_pool; - cmd->u.query.query = firstQuery; - cmd->u.query.index = queryCount; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdBeginQueryIndexedEXT( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t query, - VkQueryControlFlags flags, - uint32_t index) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - LVP_FROM_HANDLE(lvp_query_pool, query_pool, queryPool); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_BEGIN_QUERY); - if (!cmd) - return; - - cmd->u.query.pool = query_pool; - cmd->u.query.query = query; - cmd->u.query.index = index; - cmd->u.query.precise = true; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdBeginQuery( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t query, - VkQueryControlFlags flags) -{ - lvp_CmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, 0); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdEndQueryIndexedEXT( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t query, - uint32_t index) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - LVP_FROM_HANDLE(lvp_query_pool, query_pool, queryPool); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_END_QUERY); - if (!cmd) - return; - - cmd->u.query.pool = query_pool; - cmd->u.query.query = query; - cmd->u.query.index = index; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdEndQuery( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t query) -{ - lvp_CmdEndQueryIndexedEXT(commandBuffer, queryPool, query, 0); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdWriteTimestamp( - VkCommandBuffer commandBuffer, - VkPipelineStageFlagBits pipelineStage, - VkQueryPool queryPool, - uint32_t query) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - LVP_FROM_HANDLE(lvp_query_pool, query_pool, queryPool); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_WRITE_TIMESTAMP); - if (!cmd) - return; - - cmd->u.query.pool = query_pool; - cmd->u.query.query = query; - cmd->u.query.flush = !(pipelineStage == VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT); - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdCopyQueryPoolResults( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize stride, - VkQueryResultFlags flags) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - LVP_FROM_HANDLE(lvp_query_pool, query_pool, queryPool); - LVP_FROM_HANDLE(lvp_buffer, buffer, dstBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_COPY_QUERY_POOL_RESULTS); - if (!cmd) - return; - - cmd->u.copy_query_pool_results.pool = query_pool; - cmd->u.copy_query_pool_results.first_query = firstQuery; - cmd->u.copy_query_pool_results.query_count = queryCount; - cmd->u.copy_query_pool_results.dst = buffer; - cmd->u.copy_query_pool_results.dst_offset = dstOffset; - cmd->u.copy_query_pool_results.stride = stride; - cmd->u.copy_query_pool_results.flags = flags; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdPipelineBarrier( - VkCommandBuffer commandBuffer, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags destStageMask, - VkBool32 byRegion, - uint32_t memoryBarrierCount, - const VkMemoryBarrier* pMemoryBarriers, - uint32_t bufferMemoryBarrierCount, - const VkBufferMemoryBarrier* pBufferMemoryBarriers, - uint32_t imageMemoryBarrierCount, - const VkImageMemoryBarrier* pImageMemoryBarriers) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - uint32_t cmd_size = 0; - - cmd_size += memoryBarrierCount * sizeof(VkMemoryBarrier); - cmd_size += bufferMemoryBarrierCount * sizeof(VkBufferMemoryBarrier); - cmd_size += imageMemoryBarrierCount * sizeof(VkImageMemoryBarrier); - - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_PIPELINE_BARRIER); - if (!cmd) - return; - - cmd->u.pipeline_barrier.src_stage_mask = srcStageMask; - cmd->u.pipeline_barrier.dst_stage_mask = destStageMask; - cmd->u.pipeline_barrier.by_region = byRegion; - cmd->u.pipeline_barrier.memory_barrier_count = memoryBarrierCount; - cmd->u.pipeline_barrier.buffer_memory_barrier_count = bufferMemoryBarrierCount; - cmd->u.pipeline_barrier.image_memory_barrier_count = imageMemoryBarrierCount; - - /* TODO finish off this */ - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdDrawIndirectCount( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - LVP_FROM_HANDLE(lvp_buffer, buf, buffer); - LVP_FROM_HANDLE(lvp_buffer, count_buf, countBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_DRAW_INDIRECT_COUNT); - if (!cmd) - return; - - cmd->u.draw_indirect_count.offset = offset; - cmd->u.draw_indirect_count.buffer = buf; - cmd->u.draw_indirect_count.count_buffer_offset = countBufferOffset; - cmd->u.draw_indirect_count.count_buffer = count_buf; - cmd->u.draw_indirect_count.max_draw_count = maxDrawCount; - cmd->u.draw_indirect_count.stride = stride; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdDrawIndexedIndirectCount( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - LVP_FROM_HANDLE(lvp_buffer, buf, buffer); - LVP_FROM_HANDLE(lvp_buffer, count_buf, countBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_DRAW_INDEXED_INDIRECT_COUNT); - if (!cmd) - return; - - cmd->u.draw_indirect_count.offset = offset; - cmd->u.draw_indirect_count.buffer = buf; - cmd->u.draw_indirect_count.count_buffer_offset = countBufferOffset; - cmd->u.draw_indirect_count.count_buffer = count_buf; - cmd->u.draw_indirect_count.max_draw_count = maxDrawCount; - cmd->u.draw_indirect_count.stride = stride; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdPushDescriptorSetKHR( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout _layout, - uint32_t set, - uint32_t descriptorWriteCount, - const VkWriteDescriptorSet* pDescriptorWrites) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - LVP_FROM_HANDLE(lvp_pipeline_layout, layout, _layout); - struct lvp_cmd_buffer_entry *cmd; - int cmd_size = 0; - - cmd_size += descriptorWriteCount * sizeof(struct lvp_write_descriptor); - - int count_descriptors = 0; - - for (unsigned i = 0; i < descriptorWriteCount; i++) { - count_descriptors += pDescriptorWrites[i].descriptorCount; - } - cmd_size += count_descriptors * sizeof(union lvp_descriptor_info); - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_PUSH_DESCRIPTOR_SET); - if (!cmd) - return; - - cmd->u.push_descriptor_set.bind_point = pipelineBindPoint; - cmd->u.push_descriptor_set.layout = layout; - cmd->u.push_descriptor_set.set = set; - cmd->u.push_descriptor_set.descriptor_write_count = descriptorWriteCount; - cmd->u.push_descriptor_set.descriptors = (struct lvp_write_descriptor *)(cmd + 1); - cmd->u.push_descriptor_set.infos = (union lvp_descriptor_info *)(cmd->u.push_descriptor_set.descriptors + descriptorWriteCount); - - unsigned descriptor_index = 0; - - for (unsigned i = 0; i < descriptorWriteCount; i++) { - struct lvp_write_descriptor *desc = &cmd->u.push_descriptor_set.descriptors[i]; - - /* dstSet is ignored */ - desc->dst_binding = pDescriptorWrites[i].dstBinding; - desc->dst_array_element = pDescriptorWrites[i].dstArrayElement; - desc->descriptor_count = pDescriptorWrites[i].descriptorCount; - desc->descriptor_type = pDescriptorWrites[i].descriptorType; - - for (unsigned j = 0; j < desc->descriptor_count; j++) { - union lvp_descriptor_info *info = &cmd->u.push_descriptor_set.infos[descriptor_index + j]; - switch (desc->descriptor_type) { - case VK_DESCRIPTOR_TYPE_SAMPLER: - info->sampler = lvp_sampler_from_handle(pDescriptorWrites[i].pImageInfo[j].sampler); - break; - case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: - info->sampler = lvp_sampler_from_handle(pDescriptorWrites[i].pImageInfo[j].sampler); - info->iview = lvp_image_view_from_handle(pDescriptorWrites[i].pImageInfo[j].imageView); - info->image_layout = pDescriptorWrites[i].pImageInfo[j].imageLayout; - break; - case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: - case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: - case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: - info->iview = lvp_image_view_from_handle(pDescriptorWrites[i].pImageInfo[j].imageView); - info->image_layout = pDescriptorWrites[i].pImageInfo[j].imageLayout; - break; - case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: - case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: - info->buffer_view = lvp_buffer_view_from_handle(pDescriptorWrites[i].pTexelBufferView[j]); - break; - case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: - case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: - case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: - case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: - default: - info->buffer = lvp_buffer_from_handle(pDescriptorWrites[i].pBufferInfo[j].buffer); - info->offset = pDescriptorWrites[i].pBufferInfo[j].offset; - info->range = pDescriptorWrites[i].pBufferInfo[j].range; - break; - } - } - descriptor_index += desc->descriptor_count; - } - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdPushDescriptorSetWithTemplateKHR( - VkCommandBuffer commandBuffer, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - VkPipelineLayout _layout, - uint32_t set, - const void* pData) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - LVP_FROM_HANDLE(lvp_descriptor_update_template, templ, descriptorUpdateTemplate); - int cmd_size = 0; - struct lvp_cmd_buffer_entry *cmd; - - cmd_size += templ->entry_count * sizeof(struct lvp_write_descriptor); - - int count_descriptors = 0; - for (unsigned i = 0; i < templ->entry_count; i++) { - VkDescriptorUpdateTemplateEntry *entry = &templ->entry[i]; - count_descriptors += entry->descriptorCount; - } - cmd_size += count_descriptors * sizeof(union lvp_descriptor_info); - - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_PUSH_DESCRIPTOR_SET); - if (!cmd) - return; - - cmd->u.push_descriptor_set.bind_point = templ->bind_point; - cmd->u.push_descriptor_set.layout = templ->pipeline_layout; - cmd->u.push_descriptor_set.set = templ->set; - cmd->u.push_descriptor_set.descriptor_write_count = templ->entry_count; - cmd->u.push_descriptor_set.descriptors = (struct lvp_write_descriptor *)(cmd + 1); - cmd->u.push_descriptor_set.infos = (union lvp_descriptor_info *)(cmd->u.push_descriptor_set.descriptors + templ->entry_count); - - unsigned descriptor_index = 0; - - for (unsigned i = 0; i < templ->entry_count; i++) { - struct lvp_write_descriptor *desc = &cmd->u.push_descriptor_set.descriptors[i]; - struct VkDescriptorUpdateTemplateEntry *entry = &templ->entry[i]; - const uint8_t *pSrc = ((const uint8_t *) pData) + entry->offset; - - /* dstSet is ignored */ - desc->dst_binding = entry->dstBinding; - desc->dst_array_element = entry->dstArrayElement; - desc->descriptor_count = entry->descriptorCount; - desc->descriptor_type = entry->descriptorType; - - for (unsigned j = 0; j < desc->descriptor_count; j++) { - union lvp_descriptor_info *info = &cmd->u.push_descriptor_set.infos[descriptor_index + j]; - switch (desc->descriptor_type) { - case VK_DESCRIPTOR_TYPE_SAMPLER: - info->sampler = lvp_sampler_from_handle(*(VkSampler *)pSrc); - break; - case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: { - VkDescriptorImageInfo *image_info = (VkDescriptorImageInfo *)pSrc; - info->sampler = lvp_sampler_from_handle(image_info->sampler); - info->iview = lvp_image_view_from_handle(image_info->imageView); - info->image_layout = image_info->imageLayout; - break; - } - case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: - case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: - case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: { - VkDescriptorImageInfo *image_info = (VkDescriptorImageInfo *)pSrc; - info->iview = lvp_image_view_from_handle(image_info->imageView); - info->image_layout = image_info->imageLayout; - break; - } - case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: - case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: - info->buffer_view = lvp_buffer_view_from_handle(*(VkBufferView *)pSrc); - break; - case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: - case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: - case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: - case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: - default: { - VkDescriptorBufferInfo *buffer_info = (VkDescriptorBufferInfo *)pSrc; - info->buffer = lvp_buffer_from_handle(buffer_info->buffer); - info->offset = buffer_info->offset; - info->range = buffer_info->range; - break; - } - } - pSrc += entry->stride; - } - descriptor_index += desc->descriptor_count; - } - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdBindTransformFeedbackBuffersEXT( - VkCommandBuffer commandBuffer, - uint32_t firstBinding, - uint32_t bindingCount, - const VkBuffer* pBuffers, - const VkDeviceSize* pOffsets, - const VkDeviceSize* pSizes) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - uint32_t cmd_size = 0; - - cmd_size += bindingCount * (sizeof(struct lvp_buffer *) + sizeof(VkDeviceSize) * 2); - - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_BIND_TRANSFORM_FEEDBACK_BUFFERS); - if (!cmd) - return; - - cmd->u.bind_transform_feedback_buffers.first_binding = firstBinding; - cmd->u.bind_transform_feedback_buffers.binding_count = bindingCount; - cmd->u.bind_transform_feedback_buffers.buffers = (struct lvp_buffer **)(cmd + 1); - cmd->u.bind_transform_feedback_buffers.offsets = (VkDeviceSize *)(cmd->u.bind_transform_feedback_buffers.buffers + bindingCount); - cmd->u.bind_transform_feedback_buffers.sizes = (VkDeviceSize *)(cmd->u.bind_transform_feedback_buffers.offsets + bindingCount); - - for (unsigned i = 0; i < bindingCount; i++) { - cmd->u.bind_transform_feedback_buffers.buffers[i] = lvp_buffer_from_handle(pBuffers[i]); - cmd->u.bind_transform_feedback_buffers.offsets[i] = pOffsets[i]; - if (pSizes && pSizes[i] != VK_WHOLE_SIZE) - cmd->u.bind_transform_feedback_buffers.sizes[i] = pSizes[i]; - else - cmd->u.bind_transform_feedback_buffers.sizes[i] = cmd->u.bind_transform_feedback_buffers.buffers[i]->size - pOffsets[i]; - } - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdBeginTransformFeedbackEXT( - VkCommandBuffer commandBuffer, - uint32_t firstCounterBuffer, - uint32_t counterBufferCount, - const VkBuffer* pCounterBuffers, - const VkDeviceSize* pCounterBufferOffsets) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - uint32_t cmd_size = 0; - - cmd_size += counterBufferCount * (sizeof(struct lvp_buffer *) + sizeof(VkDeviceSize)); - - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_BEGIN_TRANSFORM_FEEDBACK); - if (!cmd) - return; - - cmd->u.begin_transform_feedback.first_counter_buffer = firstCounterBuffer; - cmd->u.begin_transform_feedback.counter_buffer_count = counterBufferCount; - cmd->u.begin_transform_feedback.counter_buffers = (struct lvp_buffer **)(cmd + 1); - cmd->u.begin_transform_feedback.counter_buffer_offsets = (VkDeviceSize *)(cmd->u.begin_transform_feedback.counter_buffers + counterBufferCount); - - for (unsigned i = 0; i < counterBufferCount; i++) { - if (pCounterBuffers) - cmd->u.begin_transform_feedback.counter_buffers[i] = lvp_buffer_from_handle(pCounterBuffers[i]); - else - cmd->u.begin_transform_feedback.counter_buffers[i] = NULL; - if (pCounterBufferOffsets) - cmd->u.begin_transform_feedback.counter_buffer_offsets[i] = pCounterBufferOffsets[i]; - else - cmd->u.begin_transform_feedback.counter_buffer_offsets[i] = 0; - } - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdEndTransformFeedbackEXT( - VkCommandBuffer commandBuffer, - uint32_t firstCounterBuffer, - uint32_t counterBufferCount, - const VkBuffer* pCounterBuffers, - const VkDeviceSize* pCounterBufferOffsets) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - uint32_t cmd_size = 0; - - cmd_size += counterBufferCount * (sizeof(struct lvp_buffer *) + sizeof(VkDeviceSize)); - - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_END_TRANSFORM_FEEDBACK); - if (!cmd) - return; - - cmd->u.begin_transform_feedback.first_counter_buffer = firstCounterBuffer; - cmd->u.begin_transform_feedback.counter_buffer_count = counterBufferCount; - cmd->u.begin_transform_feedback.counter_buffers = (struct lvp_buffer **)(cmd + 1); - cmd->u.begin_transform_feedback.counter_buffer_offsets = (VkDeviceSize *)(cmd->u.begin_transform_feedback.counter_buffers + counterBufferCount); - - for (unsigned i = 0; i < counterBufferCount; i++) { - if (pCounterBuffers) - cmd->u.begin_transform_feedback.counter_buffers[i] = lvp_buffer_from_handle(pCounterBuffers[i]); - else - cmd->u.begin_transform_feedback.counter_buffers[i] = NULL; - if (pCounterBufferOffsets) - cmd->u.begin_transform_feedback.counter_buffer_offsets[i] = pCounterBufferOffsets[i]; - else - cmd->u.begin_transform_feedback.counter_buffer_offsets[i] = 0; - } - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdDrawIndirectByteCountEXT( - VkCommandBuffer commandBuffer, - uint32_t instanceCount, - uint32_t firstInstance, - VkBuffer counterBuffer, - VkDeviceSize counterBufferOffset, - uint32_t counterOffset, - uint32_t vertexStride) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_DRAW_INDIRECT_BYTE_COUNT); - if (!cmd) - return; - - cmd->u.draw_indirect_byte_count.instance_count = instanceCount; - cmd->u.draw_indirect_byte_count.first_instance = firstInstance; - cmd->u.draw_indirect_byte_count.counter_buffer = lvp_buffer_from_handle(counterBuffer); - cmd->u.draw_indirect_byte_count.counter_buffer_offset = counterBufferOffset; - cmd->u.draw_indirect_byte_count.counter_offset = counterOffset; - cmd->u.draw_indirect_byte_count.vertex_stride = vertexStride; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdSetDeviceMask( - VkCommandBuffer commandBuffer, - uint32_t deviceMask) -{ - /* No-op */ -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdDispatchBase( - VkCommandBuffer commandBuffer, - uint32_t base_x, - uint32_t base_y, - uint32_t base_z, - uint32_t x, - uint32_t y, - uint32_t z) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_DISPATCH); - if (!cmd) - return; - - cmd->u.dispatch.x = x; - cmd->u.dispatch.y = y; - cmd->u.dispatch.z = z; - cmd->u.dispatch.base_x = base_x; - cmd->u.dispatch.base_y = base_y; - cmd->u.dispatch.base_z = base_z; - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdBeginConditionalRenderingEXT( - VkCommandBuffer commandBuffer, - const VkConditionalRenderingBeginInfoEXT *pConditionalRenderingBegin) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_BEGIN_CONDITIONAL_RENDERING); - if (!cmd) - return; - - cmd->u.begin_conditional_rendering.buffer = lvp_buffer_from_handle(pConditionalRenderingBegin->buffer); - cmd->u.begin_conditional_rendering.offset = pConditionalRenderingBegin->offset; - cmd->u.begin_conditional_rendering.inverted = pConditionalRenderingBegin->flags & VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT; - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdEndConditionalRenderingEXT( - VkCommandBuffer commandBuffer) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_END_CONDITIONAL_RENDERING); - if (!cmd) - return; - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdSetCullModeEXT( - VkCommandBuffer commandBuffer, - VkCullModeFlags cullMode) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_CULL_MODE); - if (!cmd) - return; - - cmd->u.set_cull_mode.cull_mode = cullMode; - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdSetVertexInputEXT( - VkCommandBuffer commandBuffer, - uint32_t vertexBindingDescriptionCount, - const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, - uint32_t vertexAttributeDescriptionCount, - const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - size_t binding_size = vertexBindingDescriptionCount * sizeof(VkVertexInputBindingDescription2EXT); - size_t attr_size = vertexAttributeDescriptionCount * sizeof(VkVertexInputAttributeDescription2EXT); - cmd = cmd_buf_entry_alloc_size(cmd_buffer, binding_size + attr_size, LVP_CMD_SET_VERTEX_INPUT); - if (!cmd) - return; - - cmd->u.set_vertex_input.binding_count = vertexBindingDescriptionCount; - cmd->u.set_vertex_input.attr_count = vertexAttributeDescriptionCount; - memcpy(cmd->u.set_vertex_input.data, pVertexBindingDescriptions, binding_size); - memcpy(cmd->u.set_vertex_input.data + binding_size, pVertexAttributeDescriptions, attr_size); - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdSetFrontFaceEXT( - VkCommandBuffer commandBuffer, - VkFrontFace frontFace) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_FRONT_FACE); - if (!cmd) - return; - - cmd->u.set_front_face.front_face = frontFace; - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdSetLineStippleEXT( - VkCommandBuffer commandBuffer, - uint32_t lineStippleFactor, - uint16_t lineStipplePattern) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_LINE_STIPPLE); - if (!cmd) - return; - - cmd->u.set_line_stipple.line_stipple_factor = lineStippleFactor; - cmd->u.set_line_stipple.line_stipple_pattern = lineStipplePattern; - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdSetPrimitiveTopologyEXT( - VkCommandBuffer commandBuffer, - VkPrimitiveTopology primitiveTopology) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_PRIMITIVE_TOPOLOGY); - if (!cmd) - return; - - cmd->u.set_primitive_topology.prim = primitiveTopology; - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdSetViewportWithCountEXT( - VkCommandBuffer commandBuffer, - uint32_t viewportCount, - const VkViewport* pViewports) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - int i; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_VIEWPORT); - if (!cmd) - return; - - cmd->u.set_viewport.first_viewport = UINT32_MAX; - cmd->u.set_viewport.viewport_count = viewportCount; - for (i = 0; i < viewportCount; i++) - cmd->u.set_viewport.viewports[i] = pViewports[i]; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdSetScissorWithCountEXT( - VkCommandBuffer commandBuffer, - uint32_t scissorCount, - const VkRect2D* pScissors) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - int i; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_SCISSOR); - if (!cmd) - return; - - cmd->u.set_scissor.first_scissor = UINT32_MAX; - cmd->u.set_scissor.scissor_count = scissorCount; - for (i = 0; i < scissorCount; i++) - cmd->u.set_scissor.scissors[i] = pScissors[i]; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdBindVertexBuffers2EXT( - VkCommandBuffer commandBuffer, - uint32_t firstBinding, - uint32_t bindingCount, - const VkBuffer* pBuffers, - const VkDeviceSize* pOffsets, - const VkDeviceSize* pSizes, - const VkDeviceSize* pStrides) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - struct lvp_buffer **buffers; - VkDeviceSize *offsets; - VkDeviceSize *sizes; - VkDeviceSize *strides; - int i; - uint32_t array_count = pStrides ? 3 : 2; - uint32_t cmd_size = bindingCount * sizeof(struct lvp_buffer *) + bindingCount * array_count * sizeof(VkDeviceSize); - - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_BIND_VERTEX_BUFFERS); - if (!cmd) - return; - - cmd->u.vertex_buffers.first = firstBinding; - cmd->u.vertex_buffers.binding_count = bindingCount; - - buffers = (struct lvp_buffer **)(cmd + 1); - offsets = (VkDeviceSize *)(buffers + bindingCount); - sizes = (VkDeviceSize *)(offsets + bindingCount); - strides = (VkDeviceSize *)(sizes + bindingCount); - for (i = 0; i < bindingCount; i++) { - buffers[i] = lvp_buffer_from_handle(pBuffers[i]); - offsets[i] = pOffsets[i]; - if (pSizes) - sizes[i] = pSizes[i]; - else - sizes[i] = 0; - - if (pStrides) - strides[i] = pStrides[i]; - } - cmd->u.vertex_buffers.buffers = buffers; - cmd->u.vertex_buffers.offsets = offsets; - cmd->u.vertex_buffers.sizes = sizes; - cmd->u.vertex_buffers.strides = pStrides ? strides : NULL; - - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdSetDepthTestEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthTestEnable) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_DEPTH_TEST_ENABLE); - if (!cmd) - return; - - cmd->u.set_depth_test_enable.depth_test_enable = depthTestEnable; - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdSetDepthWriteEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthWriteEnable) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_DEPTH_WRITE_ENABLE); - if (!cmd) - return; - - cmd->u.set_depth_write_enable.depth_write_enable = depthWriteEnable; - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdSetDepthCompareOpEXT( - VkCommandBuffer commandBuffer, - VkCompareOp depthCompareOp) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_DEPTH_COMPARE_OP); - if (!cmd) - return; - - cmd->u.set_depth_compare_op.depth_op = depthCompareOp; - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdSetDepthBoundsTestEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthBoundsTestEnable) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_DEPTH_BOUNDS_TEST_ENABLE); - if (!cmd) - return; - - cmd->u.set_depth_bounds_test_enable.depth_bounds_test_enable = depthBoundsTestEnable; - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdSetStencilTestEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 stencilTestEnable) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_STENCIL_TEST_ENABLE); - if (!cmd) - return; - - cmd->u.set_stencil_test_enable.stencil_test_enable = stencilTestEnable; - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdSetStencilOpEXT( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - VkStencilOp failOp, - VkStencilOp passOp, - VkStencilOp depthFailOp, - VkCompareOp compareOp) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_STENCIL_OP); - if (!cmd) - return; - - cmd->u.set_stencil_op.face_mask = faceMask; - cmd->u.set_stencil_op.fail_op = failOp; - cmd->u.set_stencil_op.pass_op = passOp; - cmd->u.set_stencil_op.depth_fail_op = depthFailOp; - cmd->u.set_stencil_op.compare_op = compareOp; - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdSetDepthBiasEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthBiasEnable) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_DEPTH_BIAS_ENABLE); - if (!cmd) - return; - - cmd->u.set_depth_bias_enable.enable = depthBiasEnable == VK_TRUE; - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdSetLogicOpEXT( - VkCommandBuffer commandBuffer, - VkLogicOp logicOp) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_LOGIC_OP); - if (!cmd) - return; - - cmd->u.set_logic_op.op = logicOp; - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdSetPatchControlPointsEXT( - VkCommandBuffer commandBuffer, - uint32_t patchControlPoints) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_PATCH_CONTROL_POINTS); - if (!cmd) - return; - - cmd->u.set_patch_control_points.vertices_per_patch = patchControlPoints; - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdSetPrimitiveRestartEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 primitiveRestartEnable) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_PRIMITIVE_RESTART_ENABLE); - if (!cmd) - return; - - cmd->u.set_primitive_restart_enable.enable = primitiveRestartEnable == VK_TRUE; - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdSetRasterizerDiscardEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 rasterizerDiscardEnable) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_RASTERIZER_DISCARD_ENABLE); - if (!cmd) - return; - - cmd->u.set_rasterizer_discard_enable.enable = rasterizerDiscardEnable == VK_TRUE; - cmd_buf_queue(cmd_buffer, cmd); -} - -VKAPI_ATTR void VKAPI_CALL lvp_CmdSetColorWriteEnableEXT( - VkCommandBuffer commandBuffer, - uint32_t attachmentCount, - const VkBool32* pColorWriteEnables) -{ - LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - struct lvp_cmd_buffer_entry *cmd; - - cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_COLOR_WRITE_ENABLE); - if (!cmd) - return; - - cmd->u.set_color_write_enable.disable_mask = 0; - for (unsigned i = 0; i < attachmentCount; i++) { - /* this is inverted because cmdbufs are zero-initialized, meaning only 'true' - * can be detected with a bool, and the default is to enable color writes - */ - if (pColorWriteEnables[i] != VK_TRUE) - cmd->u.set_color_write_enable.disable_mask |= BITFIELD_BIT(i); - } - cmd_buf_queue(cmd_buffer, cmd); } diff --git a/src/gallium/frontends/lavapipe/lvp_execute.c b/src/gallium/frontends/lavapipe/lvp_execute.c index 50668178fc5..26757199673 100644 --- a/src/gallium/frontends/lavapipe/lvp_execute.c +++ b/src/gallium/frontends/lavapipe/lvp_execute.c @@ -44,6 +44,9 @@ #include "vk_util.h" +#define VK_PROTOTYPES +#include + #define DOUBLE_EQ(a, b) (fabs((a) - (b)) < DBL_EPSILON) enum gs_output { @@ -145,7 +148,7 @@ struct rendering_state { unsigned min_samples; struct lvp_image_view **imageless_views; - const struct lvp_attachment_state *attachments; + struct lvp_attachment_state *attachments; VkImageAspectFlags *pending_clear_aspects; uint32_t *cleared_views; int num_pending_aspects; @@ -355,10 +358,10 @@ static void emit_state(struct rendering_state *state) } } -static void handle_compute_pipeline(struct lvp_cmd_buffer_entry *cmd, +static void handle_compute_pipeline(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - struct lvp_pipeline *pipeline = cmd->u.pipeline.pipeline; + LVP_FROM_HANDLE(lvp_pipeline, pipeline, cmd->u.bind_pipeline.pipeline); state->dispatch_info.block[0] = pipeline->pipeline_nir[MESA_SHADER_COMPUTE]->info.workgroup_size[0]; state->dispatch_info.block[1] = pipeline->pipeline_nir[MESA_SHADER_COMPUTE]->info.workgroup_size[1]; @@ -448,10 +451,10 @@ static int conv_dynamic_state_idx(VkDynamicState dyn_state) return -1; } -static void handle_graphics_pipeline(struct lvp_cmd_buffer_entry *cmd, +static void handle_graphics_pipeline(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - struct lvp_pipeline *pipeline = cmd->u.pipeline.pipeline; + LVP_FROM_HANDLE(lvp_pipeline, pipeline, cmd->u.bind_pipeline.pipeline); bool dynamic_states[VK_DYNAMIC_STATE_STENCIL_REFERENCE+32]; unsigned fb_samples = 0; @@ -809,38 +812,66 @@ static void handle_graphics_pipeline(struct lvp_cmd_buffer_entry *cmd, } } -static void handle_pipeline(struct lvp_cmd_buffer_entry *cmd, +static void handle_pipeline(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - struct lvp_pipeline *pipeline = cmd->u.pipeline.pipeline; + LVP_FROM_HANDLE(lvp_pipeline, pipeline, cmd->u.bind_pipeline.pipeline); if (pipeline->is_compute_pipeline) handle_compute_pipeline(cmd, state); else handle_graphics_pipeline(cmd, state); } -static void handle_vertex_buffers(struct lvp_cmd_buffer_entry *cmd, - struct rendering_state *state) +static void vertex_buffers(uint32_t first_binding, + uint32_t binding_count, + const VkBuffer *buffers, + const VkDeviceSize *offsets, + const VkDeviceSize *strides, + struct rendering_state *state) { int i; - struct lvp_cmd_bind_vertex_buffers *vcb = &cmd->u.vertex_buffers; - for (i = 0; i < vcb->binding_count; i++) { - int idx = i + vcb->first; + for (i = 0; i < binding_count; i++) { + int idx = i + first_binding; - state->vb[idx].buffer_offset = vcb->offsets[i]; - state->vb[idx].buffer.resource = vcb->buffers[i] ? vcb->buffers[i]->bo : NULL; + state->vb[idx].buffer_offset = offsets[i]; + state->vb[idx].buffer.resource = buffers[i] ? lvp_buffer_from_handle(buffers[i])->bo : NULL; - if (vcb->strides) { - state->vb[idx].stride = vcb->strides[i]; - } + if (strides) + state->vb[idx].stride = strides[i]; } - if (vcb->first < state->start_vb) - state->start_vb = vcb->first; - if (vcb->first + vcb->binding_count >= state->num_vb) - state->num_vb = vcb->first + vcb->binding_count; + if (first_binding < state->start_vb) + state->start_vb = first_binding; + if (first_binding + binding_count >= state->num_vb) + state->num_vb = first_binding + binding_count; state->vb_dirty = true; } +static void handle_vertex_buffers(struct vk_cmd_queue_entry *cmd, + struct rendering_state *state) +{ + struct vk_cmd_bind_vertex_buffers *vcb = &cmd->u.bind_vertex_buffers; + + vertex_buffers(vcb->first_binding, + vcb->binding_count, + vcb->buffers, + vcb->offsets, + NULL, + state); +} + +static void handle_vertex_buffers2(struct vk_cmd_queue_entry *cmd, + struct rendering_state *state) +{ + struct vk_cmd_bind_vertex_buffers2_ext *vcb = &cmd->u.bind_vertex_buffers2_ext; + + vertex_buffers(vcb->first_binding, + vcb->binding_count, + vcb->buffers, + vcb->offsets, + vcb->strides, + state); +} + struct dyn_info { struct { uint16_t const_buffer_count; @@ -1193,29 +1224,31 @@ static void increment_dyn_info(struct dyn_info *dyn_info, dyn_info->dyn_index += layout->dynamic_offset_count; } -static void handle_compute_descriptor_sets(struct lvp_cmd_buffer_entry *cmd, +static void handle_compute_descriptor_sets(struct vk_cmd_queue_entry *cmd, struct dyn_info *dyn_info, struct rendering_state *state) { - struct lvp_cmd_bind_descriptor_sets *bds = &cmd->u.descriptor_sets; + struct vk_cmd_bind_descriptor_sets *bds = &cmd->u.bind_descriptor_sets; + struct lvp_descriptor_set_layout **set_layout = cmd->driver_data; int i; - for (i = 0; i < bds->first; i++) { - increment_dyn_info(dyn_info, bds->set_layout[i], false); + for (i = 0; i < bds->first_set; i++) { + increment_dyn_info(dyn_info, set_layout[i], false); } - for (i = 0; i < bds->count; i++) { - const struct lvp_descriptor_set *set = bds->sets[i]; + for (i = 0; i < bds->descriptor_set_count; i++) { + const struct lvp_descriptor_set *set = lvp_descriptor_set_from_handle(bds->descriptor_sets[i]); if (set->layout->shader_stages & VK_SHADER_STAGE_COMPUTE_BIT) handle_set_stage(state, dyn_info, set, MESA_SHADER_COMPUTE, PIPE_SHADER_COMPUTE); - increment_dyn_info(dyn_info, bds->set_layout[bds->first + i], true); + increment_dyn_info(dyn_info, set_layout[bds->first_set + i], true); } } -static void handle_descriptor_sets(struct lvp_cmd_buffer_entry *cmd, +static void handle_descriptor_sets(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - struct lvp_cmd_bind_descriptor_sets *bds = &cmd->u.descriptor_sets; + struct vk_cmd_bind_descriptor_sets *bds = &cmd->u.bind_descriptor_sets; + struct lvp_descriptor_set_layout **set_layout = cmd->driver_data; int i; struct dyn_info dyn_info; @@ -1224,17 +1257,17 @@ static void handle_descriptor_sets(struct lvp_cmd_buffer_entry *cmd, dyn_info.dynamic_offset_count = bds->dynamic_offset_count; memset(dyn_info.stage, 0, sizeof(dyn_info.stage)); - if (bds->bind_point == VK_PIPELINE_BIND_POINT_COMPUTE) { + if (bds->pipeline_bind_point == VK_PIPELINE_BIND_POINT_COMPUTE) { handle_compute_descriptor_sets(cmd, &dyn_info, state); return; } - for (i = 0; i < bds->first; i++) { - increment_dyn_info(&dyn_info, bds->set_layout[i], false); + for (i = 0; i < bds->first_set; i++) { + increment_dyn_info(&dyn_info, set_layout[i], false); } - for (i = 0; i < bds->count; i++) { - const struct lvp_descriptor_set *set = bds->sets[i]; + for (i = 0; i < bds->descriptor_set_count; i++) { + const struct lvp_descriptor_set *set = lvp_descriptor_set_from_handle(bds->descriptor_sets[i]); if (set->layout->shader_stages & VK_SHADER_STAGE_VERTEX_BIT) handle_set_stage(state, &dyn_info, set, MESA_SHADER_VERTEX, PIPE_SHADER_VERTEX); @@ -1249,8 +1282,9 @@ static void handle_descriptor_sets(struct lvp_cmd_buffer_entry *cmd, handle_set_stage(state, &dyn_info, set, MESA_SHADER_TESS_EVAL, PIPE_SHADER_TESS_EVAL); if (set->layout->shader_stages & VK_SHADER_STAGE_FRAGMENT_BIT) - handle_set_stage(state, &dyn_info, set, MESA_SHADER_FRAGMENT, PIPE_SHADER_FRAGMENT); - increment_dyn_info(&dyn_info, bds->set_layout[bds->first + i], true); + handle_set_stage(state, &dyn_info, set, MESA_SHADER_FRAGMENT, PIPE_SHADER_FRAGMENT); + + increment_dyn_info(&dyn_info, set_layout[bds->first_set + i], true); } } @@ -1671,16 +1705,25 @@ static void begin_render_subpass(struct rendering_state *state, render_subpass_clear_fast(state); } -static void handle_begin_render_pass(struct lvp_cmd_buffer_entry *cmd, - struct rendering_state *state) +static void begin_render_pass(const VkRenderPassBeginInfo *render_pass_begin, + struct rendering_state *state) { - state->pass = cmd->u.begin_render_pass.render_pass; - state->vk_framebuffer = cmd->u.begin_render_pass.framebuffer; - state->render_area = cmd->u.begin_render_pass.render_area; + LVP_FROM_HANDLE(lvp_render_pass, pass, render_pass_begin->renderPass); + LVP_FROM_HANDLE(lvp_framebuffer, framebuffer, render_pass_begin->framebuffer); + const struct VkRenderPassAttachmentBeginInfo *attachment_info = + vk_find_struct_const(render_pass_begin->pNext, + RENDER_PASS_ATTACHMENT_BEGIN_INFO); - state->attachments = cmd->u.begin_render_pass.attachments; + state->pass = pass; + state->vk_framebuffer = framebuffer; + state->render_area = render_pass_begin->renderArea; + + if (attachment_info) { + state->imageless_views = realloc(state->imageless_views, sizeof(*state->imageless_views) * attachment_info->attachmentCount); + for (unsigned i = 0; i < attachment_info->attachmentCount; i++) + state->imageless_views[i] = lvp_image_view_from_handle(attachment_info->pAttachments[i]); + } - state->imageless_views = cmd->u.begin_render_pass.imageless_views; state->framebuffer.width = state->vk_framebuffer->width; state->framebuffer.height = state->vk_framebuffer->height; state->framebuffer.layers = state->vk_framebuffer->layers; @@ -1691,26 +1734,67 @@ static void handle_begin_render_pass(struct lvp_cmd_buffer_entry *cmd, state->num_pending_aspects = state->pass->attachment_count; } - for (unsigned a = 0; a < state->pass->attachment_count; a++) { - state->pending_clear_aspects[a] = state->attachments[a].pending_clear_aspects; - state->cleared_views[a] = 0; + state->attachments = realloc(state->attachments, sizeof(*state->attachments) * pass->attachment_count); + for (unsigned i = 0; i < state->pass->attachment_count; i++) { + struct lvp_render_pass_attachment *att = &pass->attachments[i]; + VkImageAspectFlags att_aspects = vk_format_aspects(att->format); + VkImageAspectFlags clear_aspects = 0; + if (att_aspects == VK_IMAGE_ASPECT_COLOR_BIT) { + /* color attachment */ + if (att->load_op == VK_ATTACHMENT_LOAD_OP_CLEAR) { + clear_aspects |= VK_IMAGE_ASPECT_COLOR_BIT; + } + } else { + /* depthstencil attachment */ + if ((att_aspects & VK_IMAGE_ASPECT_DEPTH_BIT) && + att->load_op == VK_ATTACHMENT_LOAD_OP_CLEAR) { + clear_aspects |= VK_IMAGE_ASPECT_DEPTH_BIT; + if ((att_aspects & VK_IMAGE_ASPECT_STENCIL_BIT) && + att->stencil_load_op == VK_ATTACHMENT_LOAD_OP_DONT_CARE) + clear_aspects |= VK_IMAGE_ASPECT_STENCIL_BIT; + } + if ((att_aspects & VK_IMAGE_ASPECT_STENCIL_BIT) && + att->stencil_load_op == VK_ATTACHMENT_LOAD_OP_CLEAR) { + clear_aspects |= VK_IMAGE_ASPECT_STENCIL_BIT; + } + } + state->attachments[i].pending_clear_aspects = clear_aspects; + if (clear_aspects) + state->attachments[i].clear_value = render_pass_begin->pClearValues[i]; + + state->pending_clear_aspects[i] = state->attachments[i].pending_clear_aspects; + state->cleared_views[i] = 0; } begin_render_subpass(state, 0); } -static void handle_end_render_pass(struct lvp_cmd_buffer_entry *cmd, - struct rendering_state *state) + +static void handle_begin_render_pass(struct vk_cmd_queue_entry *cmd, + struct rendering_state *state) +{ + begin_render_pass(cmd->u.begin_render_pass.render_pass_begin, state); +} + +static void handle_begin_render_pass2(struct vk_cmd_queue_entry *cmd, + struct rendering_state *state) +{ + begin_render_pass(cmd->u.begin_render_pass2.render_pass_begin, state); +} + +static void handle_end_render_pass2(struct vk_cmd_queue_entry *cmd, + struct rendering_state *state) { state->pctx->flush(state->pctx, NULL, 0); render_pass_resolve(state); + free(state->attachments); state->attachments = NULL; state->pass = NULL; state->subpass = 0; } -static void handle_next_subpass(struct lvp_cmd_buffer_entry *cmd, +static void handle_next_subpass2(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { state->pctx->flush(state->pctx, NULL, 0); @@ -1719,53 +1803,106 @@ static void handle_next_subpass(struct lvp_cmd_buffer_entry *cmd, begin_render_subpass(state, state->subpass); } -static void handle_draw(struct lvp_cmd_buffer_entry *cmd, +static void handle_draw(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { const struct lvp_subpass *subpass = &state->pass->subpasses[state->subpass]; + struct pipe_draw_start_count_bias draw; + state->info.index_size = 0; state->info.index.resource = NULL; state->info.start_instance = cmd->u.draw.first_instance; state->info.instance_count = cmd->u.draw.instance_count; state->info.view_mask = subpass->view_mask; - if (cmd->u.draw.draw_count > 1) - state->info.increment_draw_id = true; + + draw.start = cmd->u.draw.first_vertex; + draw.count = cmd->u.draw.vertex_count; state->pctx->set_patch_vertices(state->pctx, state->patch_vertices); - state->pctx->draw_vbo(state->pctx, &state->info, 0, NULL, cmd->u.draw.draws, cmd->u.draw.draw_count); + state->pctx->draw_vbo(state->pctx, &state->info, 0, NULL, &draw, 1); } -static void handle_set_viewport(struct lvp_cmd_buffer_entry *cmd, - struct rendering_state *state) +static void handle_draw_multi(struct vk_cmd_queue_entry *cmd, + struct rendering_state *state) +{ + const struct lvp_subpass *subpass = &state->pass->subpasses[state->subpass]; + struct pipe_draw_start_count_bias *draws = calloc(cmd->u.draw_multi_ext.draw_count, + sizeof(*draws)); + + state->info.index_size = 0; + state->info.index.resource = NULL; + state->info.start_instance = cmd->u.draw_multi_ext.first_instance; + state->info.instance_count = cmd->u.draw_multi_ext.instance_count; + state->info.view_mask = subpass->view_mask; + if (cmd->u.draw_multi_ext.draw_count > 1) + state->info.increment_draw_id = true; + + for(unsigned i = 0; i < cmd->u.draw_multi_ext.draw_count; i++) { + draws[i].start = cmd->u.draw_multi_ext.vertex_info[i].firstVertex; + draws[i].count = cmd->u.draw_multi_ext.vertex_info[i].vertexCount; + draws[i].index_bias = 0; + } + + state->pctx->set_patch_vertices(state->pctx, state->patch_vertices); + + if (cmd->u.draw_multi_indexed_ext.draw_count) + state->pctx->draw_vbo(state->pctx, &state->info, 0, NULL, draws, cmd->u.draw_multi_ext.draw_count); + + free(draws); +} + +static void set_viewport(unsigned first_viewport, unsigned viewport_count, + const VkViewport* viewports, + struct rendering_state *state) { int i; unsigned base = 0; - if (cmd->u.set_viewport.first_viewport == UINT32_MAX) - state->num_viewports = cmd->u.set_viewport.viewport_count; + if (first_viewport == UINT32_MAX) + state->num_viewports = viewport_count; else - base = cmd->u.set_viewport.first_viewport; + base = first_viewport; - for (i = 0; i < cmd->u.set_viewport.viewport_count; i++) { + for (i = 0; i < viewport_count; i++) { int idx = i + base; - const VkViewport *vp = &cmd->u.set_viewport.viewports[i]; + const VkViewport *vp = &viewports[i]; get_viewport_xform(vp, state->viewports[idx].scale, state->viewports[idx].translate); } state->vp_dirty = true; } -static void handle_set_scissor(struct lvp_cmd_buffer_entry *cmd, - struct rendering_state *state) +static void handle_set_viewport(struct vk_cmd_queue_entry *cmd, + struct rendering_state *state) +{ + set_viewport(cmd->u.set_viewport.first_viewport, + cmd->u.set_viewport.viewport_count, + cmd->u.set_viewport.viewports, + state); +} + +static void handle_set_viewport_with_count(struct vk_cmd_queue_entry *cmd, + struct rendering_state *state) +{ + set_viewport(UINT32_MAX, + cmd->u.set_viewport_with_count_ext.viewport_count, + cmd->u.set_viewport_with_count_ext.viewports, + state); +} + +static void set_scissor(unsigned first_scissor, + unsigned scissor_count, + const VkRect2D *scissors, + struct rendering_state *state) { int i; unsigned base = 0; - if (cmd->u.set_scissor.first_scissor == UINT32_MAX) - state->num_scissors = cmd->u.set_scissor.scissor_count; + if (first_scissor == UINT32_MAX) + state->num_scissors = scissor_count; else - base = cmd->u.set_scissor.first_scissor; + base = first_scissor; - for (i = 0; i < cmd->u.set_scissor.scissor_count; i++) { + for (i = 0; i < scissor_count; i++) { int idx = i + base; - const VkRect2D *ss = &cmd->u.set_scissor.scissors[i]; + const VkRect2D *ss = &scissors[i]; state->scissors[idx].minx = ss->offset.x; state->scissors[idx].miny = ss->offset.y; state->scissors[idx].maxx = ss->offset.x + ss->extent.width; @@ -1774,65 +1911,83 @@ static void handle_set_scissor(struct lvp_cmd_buffer_entry *cmd, state->scissor_dirty = true; } -static void handle_set_line_width(struct lvp_cmd_buffer_entry *cmd, +static void handle_set_scissor(struct vk_cmd_queue_entry *cmd, + struct rendering_state *state) +{ + set_scissor(cmd->u.set_scissor.first_scissor, + cmd->u.set_scissor.scissor_count, + cmd->u.set_scissor.scissors, + state); +} + +static void handle_set_scissor_with_count(struct vk_cmd_queue_entry *cmd, + struct rendering_state *state) +{ + set_scissor(UINT32_MAX, + cmd->u.set_scissor_with_count_ext.scissor_count, + cmd->u.set_scissor_with_count_ext.scissors, + state); +} + +static void handle_set_line_width(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { state->rs_state.line_width = cmd->u.set_line_width.line_width; state->rs_dirty = true; } -static void handle_set_depth_bias(struct lvp_cmd_buffer_entry *cmd, +static void handle_set_depth_bias(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - state->depth_bias.offset_units = cmd->u.set_depth_bias.constant_factor; - state->depth_bias.offset_scale = cmd->u.set_depth_bias.slope_factor; - state->depth_bias.offset_clamp = cmd->u.set_depth_bias.clamp; + state->depth_bias.offset_units = cmd->u.set_depth_bias.depth_bias_constant_factor; + state->depth_bias.offset_scale = cmd->u.set_depth_bias.depth_bias_slope_factor; + state->depth_bias.offset_clamp = cmd->u.set_depth_bias.depth_bias_clamp; state->rs_dirty = true; } -static void handle_set_blend_constants(struct lvp_cmd_buffer_entry *cmd, +static void handle_set_blend_constants(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { memcpy(state->blend_color.color, cmd->u.set_blend_constants.blend_constants, 4 * sizeof(float)); state->blend_color_dirty = true; } -static void handle_set_depth_bounds(struct lvp_cmd_buffer_entry *cmd, +static void handle_set_depth_bounds(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - state->dsa_dirty |= !DOUBLE_EQ(state->dsa_state.depth_bounds_min, cmd->u.set_depth_bounds.min_depth); - state->dsa_dirty |= !DOUBLE_EQ(state->dsa_state.depth_bounds_max, cmd->u.set_depth_bounds.max_depth); - state->dsa_state.depth_bounds_min = cmd->u.set_depth_bounds.min_depth; - state->dsa_state.depth_bounds_max = cmd->u.set_depth_bounds.max_depth; + state->dsa_dirty |= !DOUBLE_EQ(state->dsa_state.depth_bounds_min, cmd->u.set_depth_bounds.min_depth_bounds); + state->dsa_dirty |= !DOUBLE_EQ(state->dsa_state.depth_bounds_max, cmd->u.set_depth_bounds.max_depth_bounds); + state->dsa_state.depth_bounds_min = cmd->u.set_depth_bounds.min_depth_bounds; + state->dsa_state.depth_bounds_max = cmd->u.set_depth_bounds.max_depth_bounds; } -static void handle_set_stencil_compare_mask(struct lvp_cmd_buffer_entry *cmd, +static void handle_set_stencil_compare_mask(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - if (cmd->u.stencil_vals.face_mask & VK_STENCIL_FACE_FRONT_BIT) - state->dsa_state.stencil[0].valuemask = cmd->u.stencil_vals.value; - if (cmd->u.stencil_vals.face_mask & VK_STENCIL_FACE_BACK_BIT) - state->dsa_state.stencil[1].valuemask = cmd->u.stencil_vals.value; + if (cmd->u.set_stencil_compare_mask.face_mask & VK_STENCIL_FACE_FRONT_BIT) + state->dsa_state.stencil[0].valuemask = cmd->u.set_stencil_compare_mask.compare_mask; + if (cmd->u.set_stencil_compare_mask.face_mask & VK_STENCIL_FACE_BACK_BIT) + state->dsa_state.stencil[1].valuemask = cmd->u.set_stencil_compare_mask.compare_mask; state->dsa_dirty = true; } -static void handle_set_stencil_write_mask(struct lvp_cmd_buffer_entry *cmd, +static void handle_set_stencil_write_mask(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - if (cmd->u.stencil_vals.face_mask & VK_STENCIL_FACE_FRONT_BIT) - state->dsa_state.stencil[0].writemask = cmd->u.stencil_vals.value; - if (cmd->u.stencil_vals.face_mask & VK_STENCIL_FACE_BACK_BIT) - state->dsa_state.stencil[1].writemask = cmd->u.stencil_vals.value; + if (cmd->u.set_stencil_write_mask.face_mask & VK_STENCIL_FACE_FRONT_BIT) + state->dsa_state.stencil[0].writemask = cmd->u.set_stencil_write_mask.write_mask; + if (cmd->u.set_stencil_write_mask.face_mask & VK_STENCIL_FACE_BACK_BIT) + state->dsa_state.stencil[1].writemask = cmd->u.set_stencil_write_mask.write_mask; state->dsa_dirty = true; } -static void handle_set_stencil_reference(struct lvp_cmd_buffer_entry *cmd, +static void handle_set_stencil_reference(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - if (cmd->u.stencil_vals.face_mask & VK_STENCIL_FACE_FRONT_BIT) - state->stencil_ref.ref_value[0] = cmd->u.stencil_vals.value; - if (cmd->u.stencil_vals.face_mask & VK_STENCIL_FACE_BACK_BIT) - state->stencil_ref.ref_value[1] = cmd->u.stencil_vals.value; + if (cmd->u.set_stencil_reference.face_mask & VK_STENCIL_FACE_FRONT_BIT) + state->stencil_ref.ref_value[0] = cmd->u.set_stencil_reference.reference; + if (cmd->u.set_stencil_reference.face_mask & VK_STENCIL_FACE_BACK_BIT) + state->stencil_ref.ref_value[1] = cmd->u.set_stencil_reference.reference; state->stencil_ref_dirty = true; } @@ -1946,78 +2101,79 @@ copy_depth_box(ubyte *dst, } } -static void handle_copy_image_to_buffer(struct lvp_cmd_buffer_entry *cmd, - struct rendering_state *state) +static void handle_copy_image_to_buffer2_khr(struct vk_cmd_queue_entry *cmd, + struct rendering_state *state) { int i; - struct lvp_cmd_copy_image_to_buffer *copycmd = &cmd->u.img_to_buffer; + struct VkCopyImageToBufferInfo2KHR *copycmd = cmd->u.copy_image_to_buffer2_khr.copy_image_to_buffer_info; + LVP_FROM_HANDLE(lvp_image, src_image, copycmd->srcImage); struct pipe_box box, dbox; struct pipe_transfer *src_t, *dst_t; ubyte *src_data, *dst_data; state->pctx->flush(state->pctx, NULL, 0); - for (i = 0; i < copycmd->region_count; i++) { + for (i = 0; i < copycmd->regionCount; i++) { - box.x = copycmd->regions[i].imageOffset.x; - box.y = copycmd->regions[i].imageOffset.y; - box.z = copycmd->src->type == VK_IMAGE_TYPE_3D ? copycmd->regions[i].imageOffset.z : copycmd->regions[i].imageSubresource.baseArrayLayer; - box.width = copycmd->regions[i].imageExtent.width; - box.height = copycmd->regions[i].imageExtent.height; - box.depth = copycmd->src->type == VK_IMAGE_TYPE_3D ? copycmd->regions[i].imageExtent.depth : copycmd->regions[i].imageSubresource.layerCount; + box.x = copycmd->pRegions[i].imageOffset.x; + box.y = copycmd->pRegions[i].imageOffset.y; + box.z = src_image->type == VK_IMAGE_TYPE_3D ? copycmd->pRegions[i].imageOffset.z : copycmd->pRegions[i].imageSubresource.baseArrayLayer; + box.width = copycmd->pRegions[i].imageExtent.width; + box.height = copycmd->pRegions[i].imageExtent.height; + box.depth = src_image->type == VK_IMAGE_TYPE_3D ? copycmd->pRegions[i].imageExtent.depth : copycmd->pRegions[i].imageSubresource.layerCount; src_data = state->pctx->texture_map(state->pctx, - copycmd->src->bo, - copycmd->regions[i].imageSubresource.mipLevel, + src_image->bo, + copycmd->pRegions[i].imageSubresource.mipLevel, PIPE_MAP_READ, &box, &src_t); - dbox.x = copycmd->regions[i].bufferOffset; + dbox.x = copycmd->pRegions[i].bufferOffset; dbox.y = 0; dbox.z = 0; - dbox.width = copycmd->dst->bo->width0; + dbox.width = lvp_buffer_from_handle(copycmd->dstBuffer)->bo->width0; dbox.height = 1; dbox.depth = 1; dst_data = state->pctx->buffer_map(state->pctx, - copycmd->dst->bo, + lvp_buffer_from_handle(copycmd->dstBuffer)->bo, 0, PIPE_MAP_WRITE, &dbox, &dst_t); - enum pipe_format src_format = copycmd->src->bo->format; + enum pipe_format src_format = src_image->bo->format; enum pipe_format dst_format = src_format; if (util_format_is_depth_or_stencil(src_format)) { - if (copycmd->regions[i].imageSubresource.aspectMask == VK_IMAGE_ASPECT_DEPTH_BIT) { + if (copycmd->pRegions[i].imageSubresource.aspectMask == VK_IMAGE_ASPECT_DEPTH_BIT) { dst_format = util_format_get_depth_only(src_format); - } else if (copycmd->regions[i].imageSubresource.aspectMask == VK_IMAGE_ASPECT_STENCIL_BIT) { + } else if (copycmd->pRegions[i].imageSubresource.aspectMask == VK_IMAGE_ASPECT_STENCIL_BIT) { dst_format = PIPE_FORMAT_S8_UINT; } } - unsigned buffer_row_len = util_format_get_stride(dst_format, copycmd->regions[i].bufferRowLength); + unsigned buffer_row_len = util_format_get_stride(dst_format, copycmd->pRegions[i].bufferRowLength); if (buffer_row_len == 0) - buffer_row_len = util_format_get_stride(dst_format, copycmd->regions[i].imageExtent.width); - unsigned buffer_image_height = copycmd->regions[i].bufferImageHeight; + buffer_row_len = util_format_get_stride(dst_format, copycmd->pRegions[i].imageExtent.width); + unsigned buffer_image_height = copycmd->pRegions[i].bufferImageHeight; if (buffer_image_height == 0) - buffer_image_height = copycmd->regions[i].imageExtent.height; + buffer_image_height = copycmd->pRegions[i].imageExtent.height; unsigned img_stride = util_format_get_2d_size(dst_format, buffer_row_len, buffer_image_height); if (src_format != dst_format) { copy_depth_box(dst_data, dst_format, buffer_row_len, img_stride, 0, 0, 0, - copycmd->regions[i].imageExtent.width, - copycmd->regions[i].imageExtent.height, + copycmd->pRegions[i].imageExtent.width, + copycmd->pRegions[i].imageExtent.height, box.depth, src_data, src_format, src_t->stride, src_t->layer_stride, 0, 0, 0); } else { util_copy_box((ubyte *)dst_data, src_format, buffer_row_len, img_stride, 0, 0, 0, - copycmd->regions[i].imageExtent.width, - copycmd->regions[i].imageExtent.height, + copycmd->pRegions[i].imageExtent.width, + copycmd->pRegions[i].imageExtent.height, box.depth, src_data, src_t->stride, src_t->layer_stride, 0, 0, 0); } @@ -2026,71 +2182,72 @@ static void handle_copy_image_to_buffer(struct lvp_cmd_buffer_entry *cmd, } } -static void handle_copy_buffer_to_image(struct lvp_cmd_buffer_entry *cmd, +static void handle_copy_buffer_to_image(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { int i; - struct lvp_cmd_copy_buffer_to_image *copycmd = &cmd->u.buffer_to_img; + struct VkCopyBufferToImageInfo2KHR *copycmd = cmd->u.copy_buffer_to_image2_khr.copy_buffer_to_image_info; + LVP_FROM_HANDLE(lvp_image, dst_image, copycmd->dstImage); struct pipe_box box, sbox; struct pipe_transfer *src_t, *dst_t; void *src_data, *dst_data; state->pctx->flush(state->pctx, NULL, 0); - for (i = 0; i < copycmd->region_count; i++) { + for (i = 0; i < copycmd->regionCount; i++) { - sbox.x = copycmd->regions[i].bufferOffset; + sbox.x = copycmd->pRegions[i].bufferOffset; sbox.y = 0; sbox.z = 0; - sbox.width = copycmd->src->bo->width0; + sbox.width = lvp_buffer_from_handle(copycmd->srcBuffer)->bo->width0; sbox.height = 1; sbox.depth = 1; src_data = state->pctx->buffer_map(state->pctx, - copycmd->src->bo, + lvp_buffer_from_handle(copycmd->srcBuffer)->bo, 0, PIPE_MAP_READ, &sbox, &src_t); - box.x = copycmd->regions[i].imageOffset.x; - box.y = copycmd->regions[i].imageOffset.y; - box.z = copycmd->dst->type == VK_IMAGE_TYPE_3D ? copycmd->regions[i].imageOffset.z : copycmd->regions[i].imageSubresource.baseArrayLayer; - box.width = copycmd->regions[i].imageExtent.width; - box.height = copycmd->regions[i].imageExtent.height; - box.depth = copycmd->dst->type == VK_IMAGE_TYPE_3D ? copycmd->regions[i].imageExtent.depth : copycmd->regions[i].imageSubresource.layerCount; + box.x = copycmd->pRegions[i].imageOffset.x; + box.y = copycmd->pRegions[i].imageOffset.y; + box.z = dst_image->type == VK_IMAGE_TYPE_3D ? copycmd->pRegions[i].imageOffset.z : copycmd->pRegions[i].imageSubresource.baseArrayLayer; + box.width = copycmd->pRegions[i].imageExtent.width; + box.height = copycmd->pRegions[i].imageExtent.height; + box.depth = dst_image->type == VK_IMAGE_TYPE_3D ? copycmd->pRegions[i].imageExtent.depth : copycmd->pRegions[i].imageSubresource.layerCount; dst_data = state->pctx->texture_map(state->pctx, - copycmd->dst->bo, - copycmd->regions[i].imageSubresource.mipLevel, + dst_image->bo, + copycmd->pRegions[i].imageSubresource.mipLevel, PIPE_MAP_WRITE, &box, &dst_t); - enum pipe_format dst_format = copycmd->dst->bo->format; + enum pipe_format dst_format = dst_image->bo->format; enum pipe_format src_format = dst_format; if (util_format_is_depth_or_stencil(dst_format)) { - if (copycmd->regions[i].imageSubresource.aspectMask == VK_IMAGE_ASPECT_DEPTH_BIT) { - src_format = util_format_get_depth_only(copycmd->dst->bo->format); - } else if (copycmd->regions[i].imageSubresource.aspectMask == VK_IMAGE_ASPECT_STENCIL_BIT) { + if (copycmd->pRegions[i].imageSubresource.aspectMask == VK_IMAGE_ASPECT_DEPTH_BIT) { + src_format = util_format_get_depth_only(dst_image->bo->format); + } else if (copycmd->pRegions[i].imageSubresource.aspectMask == VK_IMAGE_ASPECT_STENCIL_BIT) { src_format = PIPE_FORMAT_S8_UINT; } } - unsigned buffer_row_len = util_format_get_stride(src_format, copycmd->regions[i].bufferRowLength); + unsigned buffer_row_len = util_format_get_stride(src_format, copycmd->pRegions[i].bufferRowLength); if (buffer_row_len == 0) - buffer_row_len = util_format_get_stride(src_format, copycmd->regions[i].imageExtent.width); - unsigned buffer_image_height = copycmd->regions[i].bufferImageHeight; + buffer_row_len = util_format_get_stride(src_format, copycmd->pRegions[i].imageExtent.width); + unsigned buffer_image_height = copycmd->pRegions[i].bufferImageHeight; if (buffer_image_height == 0) - buffer_image_height = copycmd->regions[i].imageExtent.height; + buffer_image_height = copycmd->pRegions[i].imageExtent.height; unsigned img_stride = util_format_get_2d_size(src_format, buffer_row_len, buffer_image_height); if (src_format != dst_format) { copy_depth_box(dst_data, dst_format, dst_t->stride, dst_t->layer_stride, 0, 0, 0, - copycmd->regions[i].imageExtent.width, - copycmd->regions[i].imageExtent.height, + copycmd->pRegions[i].imageExtent.width, + copycmd->pRegions[i].imageExtent.height, box.depth, src_data, src_format, buffer_row_len, img_stride, 0, 0, 0); @@ -2098,8 +2255,8 @@ static void handle_copy_buffer_to_image(struct lvp_cmd_buffer_entry *cmd, util_copy_box(dst_data, dst_format, dst_t->stride, dst_t->layer_stride, 0, 0, 0, - copycmd->regions[i].imageExtent.width, - copycmd->regions[i].imageExtent.height, + copycmd->pRegions[i].imageExtent.width, + copycmd->pRegions[i].imageExtent.height, box.depth, src_data, buffer_row_len, img_stride, 0, 0, 0); @@ -2109,90 +2266,94 @@ static void handle_copy_buffer_to_image(struct lvp_cmd_buffer_entry *cmd, } } -static void handle_copy_image(struct lvp_cmd_buffer_entry *cmd, +static void handle_copy_image(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { int i; - struct lvp_cmd_copy_image *copycmd = &cmd->u.copy_image; + struct VkCopyImageInfo2KHR *copycmd = cmd->u.copy_image2_khr.copy_image_info; + LVP_FROM_HANDLE(lvp_image, src_image, copycmd->srcImage); + LVP_FROM_HANDLE(lvp_image, dst_image, copycmd->dstImage); state->pctx->flush(state->pctx, NULL, 0); - for (i = 0; i < copycmd->region_count; i++) { + for (i = 0; i < copycmd->regionCount; i++) { struct pipe_box src_box; - src_box.x = copycmd->regions[i].srcOffset.x; - src_box.y = copycmd->regions[i].srcOffset.y; - src_box.width = copycmd->regions[i].extent.width; - src_box.height = copycmd->regions[i].extent.height; - if (copycmd->src->bo->target == PIPE_TEXTURE_3D) { - src_box.depth = copycmd->regions[i].extent.depth; - src_box.z = copycmd->regions[i].srcOffset.z; + src_box.x = copycmd->pRegions[i].srcOffset.x; + src_box.y = copycmd->pRegions[i].srcOffset.y; + src_box.width = copycmd->pRegions[i].extent.width; + src_box.height = copycmd->pRegions[i].extent.height; + if (src_image->bo->target == PIPE_TEXTURE_3D) { + src_box.depth = copycmd->pRegions[i].extent.depth; + src_box.z = copycmd->pRegions[i].srcOffset.z; } else { - src_box.depth = copycmd->regions[i].srcSubresource.layerCount; - src_box.z = copycmd->regions[i].srcSubresource.baseArrayLayer; + src_box.depth = copycmd->pRegions[i].srcSubresource.layerCount; + src_box.z = copycmd->pRegions[i].srcSubresource.baseArrayLayer; } - unsigned dstz = copycmd->dst->bo->target == PIPE_TEXTURE_3D ? - copycmd->regions[i].dstOffset.z : - copycmd->regions[i].dstSubresource.baseArrayLayer; - state->pctx->resource_copy_region(state->pctx, copycmd->dst->bo, - copycmd->regions[i].dstSubresource.mipLevel, - copycmd->regions[i].dstOffset.x, - copycmd->regions[i].dstOffset.y, + unsigned dstz = dst_image->bo->target == PIPE_TEXTURE_3D ? + copycmd->pRegions[i].dstOffset.z : + copycmd->pRegions[i].dstSubresource.baseArrayLayer; + state->pctx->resource_copy_region(state->pctx, dst_image->bo, + copycmd->pRegions[i].dstSubresource.mipLevel, + copycmd->pRegions[i].dstOffset.x, + copycmd->pRegions[i].dstOffset.y, dstz, - copycmd->src->bo, - copycmd->regions[i].srcSubresource.mipLevel, + src_image->bo, + copycmd->pRegions[i].srcSubresource.mipLevel, &src_box); } } -static void handle_copy_buffer(struct lvp_cmd_buffer_entry *cmd, +static void handle_copy_buffer(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { int i; - struct lvp_cmd_copy_buffer *copycmd = &cmd->u.copy_buffer; + struct VkCopyBufferInfo2KHR *copycmd = cmd->u.copy_buffer2_khr.copy_buffer_info; - for (i = 0; i < copycmd->region_count; i++) { + for (i = 0; i < copycmd->regionCount; i++) { struct pipe_box box = { 0 }; - u_box_1d(copycmd->regions[i].srcOffset, copycmd->regions[i].size, &box); - state->pctx->resource_copy_region(state->pctx, copycmd->dst->bo, 0, - copycmd->regions[i].dstOffset, 0, 0, - copycmd->src->bo, 0, &box); + u_box_1d(copycmd->pRegions[i].srcOffset, copycmd->pRegions[i].size, &box); + state->pctx->resource_copy_region(state->pctx, lvp_buffer_from_handle(copycmd->dstBuffer)->bo, 0, + copycmd->pRegions[i].dstOffset, 0, 0, + lvp_buffer_from_handle(copycmd->srcBuffer)->bo, 0, &box); } } -static void handle_blit_image(struct lvp_cmd_buffer_entry *cmd, +static void handle_blit_image(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { int i; - struct lvp_cmd_blit_image *blitcmd = &cmd->u.blit_image; + struct VkBlitImageInfo2KHR *blitcmd = cmd->u.blit_image2_khr.blit_image_info; + LVP_FROM_HANDLE(lvp_image, src_image, blitcmd->srcImage); + LVP_FROM_HANDLE(lvp_image, dst_image, blitcmd->dstImage); struct pipe_blit_info info; memset(&info, 0, sizeof(info)); state->pctx->flush(state->pctx, NULL, 0); - info.src.resource = blitcmd->src->bo; - info.dst.resource = blitcmd->dst->bo; - info.src.format = blitcmd->src->bo->format; - info.dst.format = blitcmd->dst->bo->format; + info.src.resource = src_image->bo; + info.dst.resource = dst_image->bo; + info.src.format = src_image->bo->format; + info.dst.format = dst_image->bo->format; info.mask = util_format_is_depth_or_stencil(info.src.format) ? PIPE_MASK_ZS : PIPE_MASK_RGBA; info.filter = blitcmd->filter == VK_FILTER_NEAREST ? PIPE_TEX_FILTER_NEAREST : PIPE_TEX_FILTER_LINEAR; - for (i = 0; i < blitcmd->region_count; i++) { + for (i = 0; i < blitcmd->regionCount; i++) { int srcX0, srcX1, srcY0, srcY1, srcZ0, srcZ1; unsigned dstX0, dstX1, dstY0, dstY1, dstZ0, dstZ1; - srcX0 = blitcmd->regions[i].srcOffsets[0].x; - srcX1 = blitcmd->regions[i].srcOffsets[1].x; - srcY0 = blitcmd->regions[i].srcOffsets[0].y; - srcY1 = blitcmd->regions[i].srcOffsets[1].y; - srcZ0 = blitcmd->regions[i].srcOffsets[0].z; - srcZ1 = blitcmd->regions[i].srcOffsets[1].z; + srcX0 = blitcmd->pRegions[i].srcOffsets[0].x; + srcX1 = blitcmd->pRegions[i].srcOffsets[1].x; + srcY0 = blitcmd->pRegions[i].srcOffsets[0].y; + srcY1 = blitcmd->pRegions[i].srcOffsets[1].y; + srcZ0 = blitcmd->pRegions[i].srcOffsets[0].z; + srcZ1 = blitcmd->pRegions[i].srcOffsets[1].z; - dstX0 = blitcmd->regions[i].dstOffsets[0].x; - dstX1 = blitcmd->regions[i].dstOffsets[1].x; - dstY0 = blitcmd->regions[i].dstOffsets[0].y; - dstY1 = blitcmd->regions[i].dstOffsets[1].y; - dstZ0 = blitcmd->regions[i].dstOffsets[0].z; - dstZ1 = blitcmd->regions[i].dstOffsets[1].z; + dstX0 = blitcmd->pRegions[i].dstOffsets[0].x; + dstX1 = blitcmd->pRegions[i].dstOffsets[1].x; + dstY0 = blitcmd->pRegions[i].dstOffsets[0].y; + dstY1 = blitcmd->pRegions[i].dstOffsets[1].y; + dstZ0 = blitcmd->pRegions[i].dstOffsets[0].z; + dstZ1 = blitcmd->pRegions[i].dstOffsets[1].z; if (dstX0 < dstX1) { info.dst.box.x = dstX0; @@ -2218,9 +2379,9 @@ static void handle_blit_image(struct lvp_cmd_buffer_entry *cmd, info.src.box.height = srcY0 - srcY1; } - assert_subresource_layers(info.src.resource, &blitcmd->regions[i].srcSubresource, blitcmd->regions[i].srcOffsets); - assert_subresource_layers(info.dst.resource, &blitcmd->regions[i].dstSubresource, blitcmd->regions[i].dstOffsets); - if (blitcmd->src->bo->target == PIPE_TEXTURE_3D) { + assert_subresource_layers(info.src.resource, &blitcmd->pRegions[i].srcSubresource, blitcmd->pRegions[i].srcOffsets); + assert_subresource_layers(info.dst.resource, &blitcmd->pRegions[i].dstSubresource, blitcmd->pRegions[i].dstOffsets); + if (src_image->bo->target == PIPE_TEXTURE_3D) { if (dstZ0 < dstZ1) { info.dst.box.z = dstZ0; info.src.box.z = srcZ0; @@ -2233,48 +2394,48 @@ static void handle_blit_image(struct lvp_cmd_buffer_entry *cmd, info.src.box.depth = srcZ0 - srcZ1; } } else { - info.src.box.z = blitcmd->regions[i].srcSubresource.baseArrayLayer; - info.dst.box.z = blitcmd->regions[i].dstSubresource.baseArrayLayer; - info.src.box.depth = blitcmd->regions[i].srcSubresource.layerCount; - info.dst.box.depth = blitcmd->regions[i].dstSubresource.layerCount; + info.src.box.z = blitcmd->pRegions[i].srcSubresource.baseArrayLayer; + info.dst.box.z = blitcmd->pRegions[i].dstSubresource.baseArrayLayer; + info.src.box.depth = blitcmd->pRegions[i].srcSubresource.layerCount; + info.dst.box.depth = blitcmd->pRegions[i].dstSubresource.layerCount; } - info.src.level = blitcmd->regions[i].srcSubresource.mipLevel; - info.dst.level = blitcmd->regions[i].dstSubresource.mipLevel; + info.src.level = blitcmd->pRegions[i].srcSubresource.mipLevel; + info.dst.level = blitcmd->pRegions[i].dstSubresource.mipLevel; state->pctx->blit(state->pctx, &info); } } -static void handle_fill_buffer(struct lvp_cmd_buffer_entry *cmd, +static void handle_fill_buffer(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - struct lvp_cmd_fill_buffer *fillcmd = &cmd->u.fill_buffer; - uint32_t size = fillcmd->fill_size; + struct vk_cmd_fill_buffer *fillcmd = &cmd->u.fill_buffer; + uint32_t size = fillcmd->size; - if (fillcmd->fill_size == VK_WHOLE_SIZE) { - size = fillcmd->buffer->bo->width0 - fillcmd->offset; + if (fillcmd->size == VK_WHOLE_SIZE) { + size = lvp_buffer_from_handle(fillcmd->dst_buffer)->bo->width0 - fillcmd->dst_offset; size = ROUND_DOWN_TO(size, 4); } state->pctx->clear_buffer(state->pctx, - fillcmd->buffer->bo, - fillcmd->offset, + lvp_buffer_from_handle(fillcmd->dst_buffer)->bo, + fillcmd->dst_offset, size, &fillcmd->data, 4); } -static void handle_update_buffer(struct lvp_cmd_buffer_entry *cmd, +static void handle_update_buffer(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - struct lvp_cmd_update_buffer *updcmd = &cmd->u.update_buffer; + struct vk_cmd_update_buffer *updcmd = &cmd->u.update_buffer; uint32_t *dst; struct pipe_transfer *dst_t; struct pipe_box box; - u_box_1d(updcmd->offset, updcmd->data_size, &box); + u_box_1d(updcmd->dst_offset, updcmd->data_size, &box); dst = state->pctx->buffer_map(state->pctx, - updcmd->buffer->bo, + lvp_buffer_from_handle(updcmd->dst_buffer)->bo, 0, PIPE_MAP_WRITE, &box, @@ -2284,10 +2445,12 @@ static void handle_update_buffer(struct lvp_cmd_buffer_entry *cmd, state->pctx->buffer_unmap(state->pctx, dst_t); } -static void handle_draw_indexed(struct lvp_cmd_buffer_entry *cmd, +static void handle_draw_indexed(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { const struct lvp_subpass *subpass = &state->pass->subpasses[state->subpass]; + struct pipe_draw_start_count_bias draw = {0}; + state->info.index_bounds_valid = false; state->info.min_index = 0; state->info.max_index = ~0; @@ -2296,23 +2459,63 @@ static void handle_draw_indexed(struct lvp_cmd_buffer_entry *cmd, state->info.start_instance = cmd->u.draw_indexed.first_instance; state->info.instance_count = cmd->u.draw_indexed.instance_count; state->info.view_mask = subpass->view_mask; - if (cmd->u.draw_indexed.draw_count > 1) + + if (state->info.primitive_restart) + state->info.restart_index = util_prim_restart_index_from_size(state->info.index_size); + + draw.count = cmd->u.draw_indexed.index_count; + draw.index_bias = cmd->u.draw_indexed.vertex_offset; + /* TODO: avoid calculating multiple times if cmdbuf is submitted again */ + draw.start = (state->index_offset / state->index_size) + cmd->u.draw_indexed.first_index; + + state->info.index_bias_varies = !cmd->u.draw_indexed.vertex_offset; + state->pctx->set_patch_vertices(state->pctx, state->patch_vertices); + state->pctx->draw_vbo(state->pctx, &state->info, 0, NULL, &draw, 1); +} + +static void handle_draw_multi_indexed(struct vk_cmd_queue_entry *cmd, + struct rendering_state *state) +{ + const struct lvp_subpass *subpass = &state->pass->subpasses[state->subpass]; + struct pipe_draw_start_count_bias *draws = calloc(cmd->u.draw_multi_indexed_ext.draw_count, + sizeof(*draws)); + + state->info.index_bounds_valid = false; + state->info.min_index = 0; + state->info.max_index = ~0; + state->info.index_size = state->index_size; + state->info.index.resource = state->index_buffer; + state->info.start_instance = cmd->u.draw_multi_indexed_ext.first_instance; + state->info.instance_count = cmd->u.draw_multi_indexed_ext.instance_count; + state->info.view_mask = subpass->view_mask; + if (cmd->u.draw_multi_indexed_ext.draw_count > 1) state->info.increment_draw_id = true; if (state->info.primitive_restart) state->info.restart_index = util_prim_restart_index_from_size(state->info.index_size); - /* avoid calculating multiple times if cmdbuf is submitted again */ - if (cmd->u.draw_indexed.calc_start) { - for (unsigned i = 0; i < cmd->u.draw_indexed.draw_count; i++) - cmd->u.draw_indexed.draws[i].start = (state->index_offset / state->index_size) + cmd->u.draw_indexed.draws[i].start; - cmd->u.draw_indexed.calc_start = false; - } - state->info.index_bias_varies = cmd->u.draw_indexed.vertex_offset_changes; + + unsigned size = cmd->u.draw_multi_indexed_ext.draw_count * sizeof(struct pipe_draw_start_count_bias); + memcpy(draws, cmd->u.draw_multi_indexed_ext.index_info, size); + + /* only the first member is read if index_bias_varies is true */ + if (cmd->u.draw_multi_indexed_ext.draw_count && + cmd->u.draw_multi_indexed_ext.vertex_offset) + draws[0].index_bias = *cmd->u.draw_multi_indexed_ext.vertex_offset; + + /* TODO: avoid calculating multiple times if cmdbuf is submitted again */ + for (unsigned i = 0; i < cmd->u.draw_multi_indexed_ext.draw_count; i++) + draws[i].start = (state->index_offset / state->index_size) + draws[i].start; + + state->info.index_bias_varies = !cmd->u.draw_multi_indexed_ext.vertex_offset; state->pctx->set_patch_vertices(state->pctx, state->patch_vertices); - state->pctx->draw_vbo(state->pctx, &state->info, 0, NULL, cmd->u.draw_indexed.draws, cmd->u.draw_indexed.draw_count); + + if (cmd->u.draw_multi_indexed_ext.draw_count) + state->pctx->draw_vbo(state->pctx, &state->info, 0, NULL, draws, cmd->u.draw_multi_indexed_ext.draw_count); + + free(draws); } -static void handle_draw_indirect(struct lvp_cmd_buffer_entry *cmd, +static void handle_draw_indirect(struct vk_cmd_queue_entry *cmd, struct rendering_state *state, bool indexed) { const struct lvp_subpass *subpass = &state->pass->subpasses[state->subpass]; @@ -2327,17 +2530,17 @@ static void handle_draw_indirect(struct lvp_cmd_buffer_entry *cmd, state->indirect_info.offset = cmd->u.draw_indirect.offset; state->indirect_info.stride = cmd->u.draw_indirect.stride; state->indirect_info.draw_count = cmd->u.draw_indirect.draw_count; - state->indirect_info.buffer = cmd->u.draw_indirect.buffer->bo; + state->indirect_info.buffer = lvp_buffer_from_handle(cmd->u.draw_indirect.buffer)->bo; state->info.view_mask = subpass->view_mask; state->pctx->set_patch_vertices(state->pctx, state->patch_vertices); state->pctx->draw_vbo(state->pctx, &state->info, 0, &state->indirect_info, &draw, 1); } -static void handle_index_buffer(struct lvp_cmd_buffer_entry *cmd, +static void handle_index_buffer(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - struct lvp_cmd_bind_index_buffer *ib = &cmd->u.index_buffer; + struct vk_cmd_bind_index_buffer *ib = &cmd->u.bind_index_buffer; switch (ib->index_type) { case VK_INDEX_TYPE_UINT8_EXT: state->index_size = 1; @@ -2353,38 +2556,51 @@ static void handle_index_buffer(struct lvp_cmd_buffer_entry *cmd, } state->index_offset = ib->offset; if (ib->buffer) - state->index_buffer = ib->buffer->bo; + state->index_buffer = lvp_buffer_from_handle(ib->buffer)->bo; else state->index_buffer = NULL; state->ib_dirty = true; } -static void handle_dispatch(struct lvp_cmd_buffer_entry *cmd, +static void handle_dispatch(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - state->dispatch_info.grid[0] = cmd->u.dispatch.x; - state->dispatch_info.grid[1] = cmd->u.dispatch.y; - state->dispatch_info.grid[2] = cmd->u.dispatch.z; - state->dispatch_info.grid_base[0] = cmd->u.dispatch.base_x; - state->dispatch_info.grid_base[1] = cmd->u.dispatch.base_y; - state->dispatch_info.grid_base[2] = cmd->u.dispatch.base_z; + state->dispatch_info.grid[0] = cmd->u.dispatch.group_count_x; + state->dispatch_info.grid[1] = cmd->u.dispatch.group_count_y; + state->dispatch_info.grid[2] = cmd->u.dispatch.group_count_z; + state->dispatch_info.grid_base[0] = 0; + state->dispatch_info.grid_base[1] = 0; + state->dispatch_info.grid_base[2] = 0; state->dispatch_info.indirect = NULL; state->pctx->launch_grid(state->pctx, &state->dispatch_info); } -static void handle_dispatch_indirect(struct lvp_cmd_buffer_entry *cmd, +static void handle_dispatch_base(struct vk_cmd_queue_entry *cmd, + struct rendering_state *state) +{ + state->dispatch_info.grid[0] = cmd->u.dispatch_base.group_count_x; + state->dispatch_info.grid[1] = cmd->u.dispatch_base.group_count_y; + state->dispatch_info.grid[2] = cmd->u.dispatch_base.group_count_z; + state->dispatch_info.grid_base[0] = cmd->u.dispatch_base.base_group_x; + state->dispatch_info.grid_base[1] = cmd->u.dispatch_base.base_group_y; + state->dispatch_info.grid_base[2] = cmd->u.dispatch_base.base_group_z; + state->dispatch_info.indirect = NULL; + state->pctx->launch_grid(state->pctx, &state->dispatch_info); +} + +static void handle_dispatch_indirect(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - state->dispatch_info.indirect = cmd->u.dispatch_indirect.buffer->bo; + state->dispatch_info.indirect = lvp_buffer_from_handle(cmd->u.dispatch_indirect.buffer)->bo; state->dispatch_info.indirect_offset = cmd->u.dispatch_indirect.offset; state->pctx->launch_grid(state->pctx, &state->dispatch_info); } -static void handle_push_constants(struct lvp_cmd_buffer_entry *cmd, +static void handle_push_constants(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - memcpy(state->push_constants + cmd->u.push_constants.offset, cmd->u.push_constants.val, cmd->u.push_constants.size); + memcpy(state->push_constants + cmd->u.push_constants.offset, cmd->u.push_constants.values, cmd->u.push_constants.size); state->pc_buffer[PIPE_SHADER_VERTEX].buffer_size = 128 * 4; state->pc_buffer[PIPE_SHADER_VERTEX].buffer_offset = 0; @@ -2415,64 +2631,98 @@ static void handle_push_constants(struct lvp_cmd_buffer_entry *cmd, static void lvp_execute_cmd_buffer(struct lvp_cmd_buffer *cmd_buffer, struct rendering_state *state); -static void handle_execute_commands(struct lvp_cmd_buffer_entry *cmd, +static void handle_execute_commands(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { for (unsigned i = 0; i < cmd->u.execute_commands.command_buffer_count; i++) { - struct lvp_cmd_buffer *secondary_buf = cmd->u.execute_commands.cmd_buffers[i]; + LVP_FROM_HANDLE(lvp_cmd_buffer, secondary_buf, cmd->u.execute_commands.command_buffers[i]); lvp_execute_cmd_buffer(secondary_buf, state); } } -static void handle_event_set(struct lvp_cmd_buffer_entry *cmd, +static void handle_event_set(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - struct lvp_event *event = cmd->u.event_set.event; + LVP_FROM_HANDLE(lvp_event, event, cmd->u.set_event.event); - if (cmd->u.event_set.flush) + if (cmd->u.reset_event.stage_mask == VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT) state->pctx->flush(state->pctx, NULL, 0); - event->event_storage = (cmd->u.event_set.value == true) ? 1 : 0; + event->event_storage = 1; } -static void handle_wait_events(struct lvp_cmd_buffer_entry *cmd, +static void handle_event_reset(struct vk_cmd_queue_entry *cmd, + struct rendering_state *state) +{ + LVP_FROM_HANDLE(lvp_event, event, cmd->u.reset_event.event); + + if (cmd->u.reset_event.stage_mask == VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT) + state->pctx->flush(state->pctx, NULL, 0); + event->event_storage = 0; +} + +static void handle_wait_events(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { for (unsigned i = 0; i < cmd->u.wait_events.event_count; i++) { - struct lvp_event *event = cmd->u.wait_events.events[i]; + LVP_FROM_HANDLE(lvp_event, event, cmd->u.wait_events.events[i]); while (event->event_storage != true); } } -static void handle_pipeline_barrier(struct lvp_cmd_buffer_entry *cmd, +static void handle_pipeline_barrier(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { /* why hello nail, I'm a hammer. - TODO */ state->pctx->flush(state->pctx, NULL, 0); } -static void maybe_emit_state_for_begin_query(struct lvp_cmd_buffer_entry *cmd, - struct rendering_state *state) +static void handle_begin_query(struct vk_cmd_queue_entry *cmd, + struct rendering_state *state) { - struct lvp_cmd_query_cmd *qcmd = &cmd->u.query; - struct lvp_query_pool *pool = qcmd->pool; + struct vk_cmd_begin_query *qcmd = &cmd->u.begin_query; + LVP_FROM_HANDLE(lvp_query_pool, pool, qcmd->query_pool); if (pool->type == VK_QUERY_TYPE_PIPELINE_STATISTICS && pool->pipeline_stats & VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT) emit_compute_state(state); - emit_state(state); -} -static void handle_begin_query(struct lvp_cmd_buffer_entry *cmd, - struct rendering_state *state) -{ - struct lvp_cmd_query_cmd *qcmd = &cmd->u.query; - struct lvp_query_pool *pool = qcmd->pool; + emit_state(state); + + if (!pool->queries[qcmd->query]) { + enum pipe_query_type qtype = pool->base_type; + pool->queries[qcmd->query] = state->pctx->create_query(state->pctx, + qtype, 0); + } + + state->pctx->begin_query(state->pctx, pool->queries[qcmd->query]); +} + +static void handle_end_query(struct vk_cmd_queue_entry *cmd, + struct rendering_state *state) +{ + struct vk_cmd_end_query *qcmd = &cmd->u.end_query; + LVP_FROM_HANDLE(lvp_query_pool, pool, qcmd->query_pool); + assert(pool->queries[qcmd->query]); + + state->pctx->end_query(state->pctx, pool->queries[qcmd->query]); +} + + +static void handle_begin_query_indexed_ext(struct vk_cmd_queue_entry *cmd, + struct rendering_state *state) +{ + struct vk_cmd_begin_query_indexed_ext *qcmd = &cmd->u.begin_query_indexed_ext; + LVP_FROM_HANDLE(lvp_query_pool, pool, qcmd->query_pool); + + if (pool->type == VK_QUERY_TYPE_PIPELINE_STATISTICS && + pool->pipeline_stats & VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT) + emit_compute_state(state); + + emit_state(state); if (!pool->queries[qcmd->query]) { enum pipe_query_type qtype = pool->base_type; - if (qtype == PIPE_QUERY_OCCLUSION_COUNTER && !qcmd->precise) - qtype = PIPE_QUERY_OCCLUSION_PREDICATE; pool->queries[qcmd->query] = state->pctx->create_query(state->pctx, qtype, qcmd->index); } @@ -2480,22 +2730,22 @@ static void handle_begin_query(struct lvp_cmd_buffer_entry *cmd, state->pctx->begin_query(state->pctx, pool->queries[qcmd->query]); } -static void handle_end_query(struct lvp_cmd_buffer_entry *cmd, - struct rendering_state *state) +static void handle_end_query_indexed_ext(struct vk_cmd_queue_entry *cmd, + struct rendering_state *state) { - struct lvp_cmd_query_cmd *qcmd = &cmd->u.query; - struct lvp_query_pool *pool = qcmd->pool; + struct vk_cmd_end_query_indexed_ext *qcmd = &cmd->u.end_query_indexed_ext; + LVP_FROM_HANDLE(lvp_query_pool, pool, qcmd->query_pool); assert(pool->queries[qcmd->query]); state->pctx->end_query(state->pctx, pool->queries[qcmd->query]); } -static void handle_reset_query_pool(struct lvp_cmd_buffer_entry *cmd, +static void handle_reset_query_pool(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - struct lvp_cmd_query_cmd *qcmd = &cmd->u.query; - struct lvp_query_pool *pool = qcmd->pool; - for (unsigned i = qcmd->query; i < qcmd->query + qcmd->index; i++) { + struct vk_cmd_reset_query_pool *qcmd = &cmd->u.reset_query_pool; + LVP_FROM_HANDLE(lvp_query_pool, pool, qcmd->query_pool); + for (unsigned i = qcmd->first_query; i < qcmd->first_query + qcmd->query_count; i++) { if (pool->queries[i]) { state->pctx->destroy_query(state->pctx, pool->queries[i]); pool->queries[i] = NULL; @@ -2503,30 +2753,30 @@ static void handle_reset_query_pool(struct lvp_cmd_buffer_entry *cmd, } } -static void handle_write_timestamp(struct lvp_cmd_buffer_entry *cmd, +static void handle_write_timestamp(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - struct lvp_cmd_query_cmd *qcmd = &cmd->u.query; - struct lvp_query_pool *pool = qcmd->pool; + struct vk_cmd_write_timestamp *qcmd = &cmd->u.write_timestamp; + LVP_FROM_HANDLE(lvp_query_pool, pool, qcmd->query_pool); if (!pool->queries[qcmd->query]) { pool->queries[qcmd->query] = state->pctx->create_query(state->pctx, PIPE_QUERY_TIMESTAMP, 0); } - if (qcmd->flush) + if (!(qcmd->pipeline_stage == VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT)) state->pctx->flush(state->pctx, NULL, 0); state->pctx->end_query(state->pctx, pool->queries[qcmd->query]); } -static void handle_copy_query_pool_results(struct lvp_cmd_buffer_entry *cmd, +static void handle_copy_query_pool_results(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - struct lvp_cmd_copy_query_pool_results *copycmd = &cmd->u.copy_query_pool_results; - struct lvp_query_pool *pool = copycmd->pool; + struct vk_cmd_copy_query_pool_results *copycmd = &cmd->u.copy_query_pool_results; + LVP_FROM_HANDLE(lvp_query_pool, pool, copycmd->query_pool); for (unsigned i = copycmd->first_query; i < copycmd->first_query + copycmd->query_count; i++) { - unsigned offset = copycmd->dst_offset + copycmd->dst->offset + (copycmd->stride * (i - copycmd->first_query)); + unsigned offset = copycmd->dst_offset + lvp_buffer_from_handle(copycmd->dst_buffer)->offset + (copycmd->stride * (i - copycmd->first_query)); if (pool->queries[i]) { if (copycmd->flags & VK_QUERY_RESULT_WITH_AVAILABILITY_BIT) state->pctx->get_query_result_resource(state->pctx, @@ -2534,7 +2784,7 @@ static void handle_copy_query_pool_results(struct lvp_cmd_buffer_entry *cmd, copycmd->flags & VK_QUERY_RESULT_WAIT_BIT, copycmd->flags & VK_QUERY_RESULT_64_BIT ? PIPE_QUERY_TYPE_U64 : PIPE_QUERY_TYPE_U32, -1, - copycmd->dst->bo, + lvp_buffer_from_handle(copycmd->dst_buffer)->bo, offset + (copycmd->flags & VK_QUERY_RESULT_64_BIT ? 8 : 4)); if (pool->type == VK_QUERY_TYPE_PIPELINE_STATISTICS) { unsigned num_results = 0; @@ -2545,7 +2795,7 @@ static void handle_copy_query_pool_results(struct lvp_cmd_buffer_entry *cmd, copycmd->flags & VK_QUERY_RESULT_WAIT_BIT, copycmd->flags & VK_QUERY_RESULT_64_BIT ? PIPE_QUERY_TYPE_U64 : PIPE_QUERY_TYPE_U32, bit, - copycmd->dst->bo, + lvp_buffer_from_handle(copycmd->dst_buffer)->bo, offset + num_results++ * result_size); } else { state->pctx->get_query_result_resource(state->pctx, @@ -2553,7 +2803,7 @@ static void handle_copy_query_pool_results(struct lvp_cmd_buffer_entry *cmd, copycmd->flags & VK_QUERY_RESULT_WAIT_BIT, copycmd->flags & VK_QUERY_RESULT_64_BIT ? PIPE_QUERY_TYPE_U64 : PIPE_QUERY_TYPE_U32, 0, - copycmd->dst->bo, + lvp_buffer_from_handle(copycmd->dst_buffer)->bo, offset); } } else { @@ -2568,7 +2818,7 @@ static void handle_copy_query_pool_results(struct lvp_cmd_buffer_entry *cmd, box.height = 1; box.depth = 1; map = state->pctx->buffer_map(state->pctx, - copycmd->dst->bo, 0, PIPE_MAP_READ, &box, + lvp_buffer_from_handle(copycmd->dst_buffer)->bo, 0, PIPE_MAP_READ, &box, &src_t); memset(map, 0, box.width); @@ -2609,12 +2859,12 @@ static void pack_clear_color(enum pipe_format pformat, VkClearColorValue *in_val } } -static void handle_clear_color_image(struct lvp_cmd_buffer_entry *cmd, +static void handle_clear_color_image(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - struct lvp_image *image = cmd->u.clear_color_image.image; + LVP_FROM_HANDLE(lvp_image, image, cmd->u.clear_color_image.image); uint32_t col_val[4]; - pack_clear_color(image->bo->format, &cmd->u.clear_color_image.clear_val, col_val); + pack_clear_color(image->bo->format, cmd->u.clear_color_image.color, col_val); for (unsigned i = 0; i < cmd->u.clear_color_image.range_count; i++) { VkImageSubresourceRange *range = &cmd->u.clear_color_image.ranges[i]; struct pipe_box box; @@ -2644,12 +2894,12 @@ static void handle_clear_color_image(struct lvp_cmd_buffer_entry *cmd, } } -static void handle_clear_ds_image(struct lvp_cmd_buffer_entry *cmd, +static void handle_clear_ds_image(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - struct lvp_image *image = cmd->u.clear_ds_image.image; - for (unsigned i = 0; i < cmd->u.clear_ds_image.range_count; i++) { - VkImageSubresourceRange *range = &cmd->u.clear_ds_image.ranges[i]; + LVP_FROM_HANDLE(lvp_image, image, cmd->u.clear_depth_stencil_image.image); + for (unsigned i = 0; i < cmd->u.clear_depth_stencil_image.range_count; i++) { + VkImageSubresourceRange *range = &cmd->u.clear_depth_stencil_image.ranges[i]; uint32_t ds_clear_flags = 0; if (range->aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) ds_clear_flags |= PIPE_CLEAR_DEPTH; @@ -2672,8 +2922,8 @@ static void handle_clear_ds_image(struct lvp_cmd_buffer_entry *cmd, state->pctx->clear_depth_stencil(state->pctx, surf, ds_clear_flags, - cmd->u.clear_ds_image.clear_val.depth, - cmd->u.clear_ds_image.clear_val.stencil, + cmd->u.clear_depth_stencil_image.depth_stencil->depth, + cmd->u.clear_depth_stencil_image.depth_stencil->stencil, 0, 0, width, height, true); state->pctx->surface_destroy(state->pctx, surf); @@ -2681,7 +2931,7 @@ static void handle_clear_ds_image(struct lvp_cmd_buffer_entry *cmd, } } -static void handle_clear_attachments(struct lvp_cmd_buffer_entry *cmd, +static void handle_clear_attachments(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { for (uint32_t a = 0; a < cmd->u.clear_attachments.attachment_count; a++) { @@ -2735,56 +2985,58 @@ static void handle_clear_attachments(struct lvp_cmd_buffer_entry *cmd, } } -static void handle_resolve_image(struct lvp_cmd_buffer_entry *cmd, +static void handle_resolve_image(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { int i; - struct lvp_cmd_resolve_image *resolvecmd = &cmd->u.resolve_image; + struct VkResolveImageInfo2KHR *resolvecmd = cmd->u.resolve_image2_khr.resolve_image_info; + LVP_FROM_HANDLE(lvp_image, src_image, resolvecmd->srcImage); + LVP_FROM_HANDLE(lvp_image, dst_image, resolvecmd->dstImage); struct pipe_blit_info info; memset(&info, 0, sizeof(info)); state->pctx->flush(state->pctx, NULL, 0); - info.src.resource = resolvecmd->src->bo; - info.dst.resource = resolvecmd->dst->bo; - info.src.format = resolvecmd->src->bo->format; - info.dst.format = resolvecmd->dst->bo->format; + info.src.resource = src_image->bo; + info.dst.resource = dst_image->bo; + info.src.format = src_image->bo->format; + info.dst.format = dst_image->bo->format; info.mask = util_format_is_depth_or_stencil(info.src.format) ? PIPE_MASK_ZS : PIPE_MASK_RGBA; info.filter = PIPE_TEX_FILTER_NEAREST; - for (i = 0; i < resolvecmd->region_count; i++) { + for (i = 0; i < resolvecmd->regionCount; i++) { int srcX0, srcY0; unsigned dstX0, dstY0; - srcX0 = resolvecmd->regions[i].srcOffset.x; - srcY0 = resolvecmd->regions[i].srcOffset.y; + srcX0 = resolvecmd->pRegions[i].srcOffset.x; + srcY0 = resolvecmd->pRegions[i].srcOffset.y; - dstX0 = resolvecmd->regions[i].dstOffset.x; - dstY0 = resolvecmd->regions[i].dstOffset.y; + dstX0 = resolvecmd->pRegions[i].dstOffset.x; + dstY0 = resolvecmd->pRegions[i].dstOffset.y; info.dst.box.x = dstX0; info.dst.box.y = dstY0; info.src.box.x = srcX0; info.src.box.y = srcY0; - info.dst.box.width = resolvecmd->regions[i].extent.width; - info.src.box.width = resolvecmd->regions[i].extent.width; - info.dst.box.height = resolvecmd->regions[i].extent.height; - info.src.box.height = resolvecmd->regions[i].extent.height; + info.dst.box.width = resolvecmd->pRegions[i].extent.width; + info.src.box.width = resolvecmd->pRegions[i].extent.width; + info.dst.box.height = resolvecmd->pRegions[i].extent.height; + info.src.box.height = resolvecmd->pRegions[i].extent.height; - info.dst.box.depth = resolvecmd->regions[i].dstSubresource.layerCount; - info.src.box.depth = resolvecmd->regions[i].srcSubresource.layerCount; + info.dst.box.depth = resolvecmd->pRegions[i].dstSubresource.layerCount; + info.src.box.depth = resolvecmd->pRegions[i].srcSubresource.layerCount; - info.src.level = resolvecmd->regions[i].srcSubresource.mipLevel; - info.src.box.z = resolvecmd->regions[i].srcOffset.z + resolvecmd->regions[i].srcSubresource.baseArrayLayer; + info.src.level = resolvecmd->pRegions[i].srcSubresource.mipLevel; + info.src.box.z = resolvecmd->pRegions[i].srcOffset.z + resolvecmd->pRegions[i].srcSubresource.baseArrayLayer; - info.dst.level = resolvecmd->regions[i].dstSubresource.mipLevel; - info.dst.box.z = resolvecmd->regions[i].dstOffset.z + resolvecmd->regions[i].dstSubresource.baseArrayLayer; + info.dst.level = resolvecmd->pRegions[i].dstSubresource.mipLevel; + info.dst.box.z = resolvecmd->pRegions[i].dstOffset.z + resolvecmd->pRegions[i].dstSubresource.baseArrayLayer; state->pctx->blit(state->pctx, &info); } } -static void handle_draw_indirect_count(struct lvp_cmd_buffer_entry *cmd, +static void handle_draw_indirect_count(struct vk_cmd_queue_entry *cmd, struct rendering_state *state, bool indexed) { const struct lvp_subpass *subpass = &state->pass->subpasses[state->subpass]; @@ -2799,20 +3051,19 @@ static void handle_draw_indirect_count(struct lvp_cmd_buffer_entry *cmd, state->indirect_info.offset = cmd->u.draw_indirect_count.offset; state->indirect_info.stride = cmd->u.draw_indirect_count.stride; state->indirect_info.draw_count = cmd->u.draw_indirect_count.max_draw_count; - state->indirect_info.buffer = cmd->u.draw_indirect_count.buffer->bo; + state->indirect_info.buffer = lvp_buffer_from_handle(cmd->u.draw_indirect_count.buffer)->bo; state->indirect_info.indirect_draw_count_offset = cmd->u.draw_indirect_count.count_buffer_offset; - state->indirect_info.indirect_draw_count = cmd->u.draw_indirect_count.count_buffer->bo; + state->indirect_info.indirect_draw_count = lvp_buffer_from_handle(cmd->u.draw_indirect_count.count_buffer)->bo; state->info.view_mask = subpass->view_mask; state->pctx->set_patch_vertices(state->pctx, state->patch_vertices); state->pctx->draw_vbo(state->pctx, &state->info, 0, &state->indirect_info, &draw, 1); } -static void handle_compute_push_descriptor_set(struct lvp_cmd_buffer_entry *cmd, +static void handle_compute_push_descriptor_set(struct lvp_cmd_push_descriptor_set *pds, struct dyn_info *dyn_info, struct rendering_state *state) { - struct lvp_cmd_push_descriptor_set *pds = &cmd->u.push_descriptor_set; struct lvp_descriptor_set_layout *layout = pds->layout->set[pds->set].layout; if (!(layout->shader_stages & VK_SHADER_STAGE_COMPUTE_BIT)) @@ -2840,17 +3091,94 @@ static void handle_compute_push_descriptor_set(struct lvp_cmd_buffer_entry *cmd, } } -static void handle_push_descriptor_set(struct lvp_cmd_buffer_entry *cmd, - struct rendering_state *state) +static struct lvp_cmd_push_descriptor_set *create_push_descriptor_set(struct vk_cmd_push_descriptor_set_khr *in_cmd) { - struct lvp_cmd_push_descriptor_set *pds = &cmd->u.push_descriptor_set; - struct lvp_descriptor_set_layout *layout = pds->layout->set[pds->set].layout; + LVP_FROM_HANDLE(lvp_pipeline_layout, layout, in_cmd->layout); + struct lvp_cmd_push_descriptor_set *out_cmd; + int count_descriptors = 0; + int cmd_size = sizeof(*out_cmd); + + for (unsigned i = 0; i < in_cmd->descriptor_write_count; i++) { + count_descriptors += in_cmd->descriptor_writes[i].descriptorCount; + } + cmd_size += count_descriptors * sizeof(union lvp_descriptor_info); + + cmd_size += in_cmd->descriptor_write_count * sizeof(struct lvp_write_descriptor); + + out_cmd = calloc(1, cmd_size); + if (!out_cmd) + return NULL; + + out_cmd->bind_point = in_cmd->pipeline_bind_point; + out_cmd->layout = layout; + out_cmd->set = in_cmd->set; + out_cmd->descriptor_write_count = in_cmd->descriptor_write_count; + out_cmd->descriptors = (struct lvp_write_descriptor *)(out_cmd + 1); + out_cmd->infos = (union lvp_descriptor_info *)(out_cmd->descriptors + in_cmd->descriptor_write_count); + + unsigned descriptor_index = 0; + + for (unsigned i = 0; i < in_cmd->descriptor_write_count; i++) { + struct lvp_write_descriptor *desc = &out_cmd->descriptors[i]; + + /* dstSet is ignored */ + desc->dst_binding = in_cmd->descriptor_writes[i].dstBinding; + desc->dst_array_element = in_cmd->descriptor_writes[i].dstArrayElement; + desc->descriptor_count = in_cmd->descriptor_writes[i].descriptorCount; + desc->descriptor_type = in_cmd->descriptor_writes[i].descriptorType; + + for (unsigned j = 0; j < desc->descriptor_count; j++) { + union lvp_descriptor_info *info = &out_cmd->infos[descriptor_index + j]; + switch (desc->descriptor_type) { + case VK_DESCRIPTOR_TYPE_SAMPLER: + info->sampler = lvp_sampler_from_handle(in_cmd->descriptor_writes[i].pImageInfo[j].sampler); + break; + case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: + info->sampler = lvp_sampler_from_handle(in_cmd->descriptor_writes[i].pImageInfo[j].sampler); + info->iview = lvp_image_view_from_handle(in_cmd->descriptor_writes[i].pImageInfo[j].imageView); + info->image_layout = in_cmd->descriptor_writes[i].pImageInfo[j].imageLayout; + break; + case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: + case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: + case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: + info->iview = lvp_image_view_from_handle(in_cmd->descriptor_writes[i].pImageInfo[j].imageView); + info->image_layout = in_cmd->descriptor_writes[i].pImageInfo[j].imageLayout; + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: + case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: + info->buffer_view = lvp_buffer_view_from_handle(in_cmd->descriptor_writes[i].pTexelBufferView[j]); + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: + default: + info->buffer = lvp_buffer_from_handle(in_cmd->descriptor_writes[i].pBufferInfo[j].buffer); + info->offset = in_cmd->descriptor_writes[i].pBufferInfo[j].offset; + info->range = in_cmd->descriptor_writes[i].pBufferInfo[j].range; + break; + } + } + descriptor_index += desc->descriptor_count; + } + + return out_cmd; +} + +static void handle_push_descriptor_set_generic(struct vk_cmd_push_descriptor_set_khr *_pds, + struct rendering_state *state) +{ + struct lvp_cmd_push_descriptor_set *pds; + struct lvp_descriptor_set_layout *layout; struct dyn_info dyn_info; + pds = create_push_descriptor_set(_pds); + layout = pds->layout->set[pds->set].layout; + memset(&dyn_info.stage, 0, sizeof(dyn_info.stage)); dyn_info.dyn_index = 0; if (pds->bind_point == VK_PIPELINE_BIND_POINT_COMPUTE) { - handle_compute_push_descriptor_set(cmd, &dyn_info, state); + handle_compute_push_descriptor_set(pds, &dyn_info, state); } for (unsigned i = 0; i < pds->set; i++) { @@ -2896,12 +3224,108 @@ static void handle_push_descriptor_set(struct lvp_cmd_buffer_entry *cmd, } info_idx += desc->descriptor_count; } + free(pds); } -static void handle_bind_transform_feedback_buffers(struct lvp_cmd_buffer_entry *cmd, +static void handle_push_descriptor_set(struct vk_cmd_queue_entry *cmd, + struct rendering_state *state) +{ + handle_push_descriptor_set_generic(&cmd->u.push_descriptor_set_khr, state); +} + +static void handle_push_descriptor_set_with_template(struct vk_cmd_queue_entry *cmd, + struct rendering_state *state) +{ + LVP_FROM_HANDLE(lvp_descriptor_update_template, templ, cmd->u.push_descriptor_set_with_template_khr.descriptor_update_template); + struct vk_cmd_push_descriptor_set_khr *pds; + int pds_size = sizeof(*pds); + + pds_size += templ->entry_count * sizeof(struct VkWriteDescriptorSet); + + for (unsigned i = 0; i < templ->entry_count; i++) { + VkDescriptorUpdateTemplateEntry *entry = &templ->entry[i]; + switch (entry->descriptorType) { + case VK_DESCRIPTOR_TYPE_SAMPLER: + case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: + case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: + case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: + case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: + pds_size += sizeof(VkDescriptorImageInfo) * entry->descriptorCount; + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: + case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: + pds_size += sizeof(VkBufferView) * entry->descriptorCount; + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: + default: + pds_size += sizeof(VkDescriptorBufferInfo) * entry->descriptorCount; + break; + } + } + + pds = calloc(1, pds_size); + if (!pds) + return; + + pds->pipeline_bind_point = templ->bind_point; + pds->layout = lvp_pipeline_layout_to_handle(templ->pipeline_layout); + pds->set = templ->set; + pds->descriptor_write_count = templ->entry_count; + pds->descriptor_writes = (struct VkWriteDescriptorSet *)(pds + 1); + const uint8_t *next_info = (const uint8_t *) (pds->descriptor_writes + templ->entry_count); + + for (unsigned i = 0; i < templ->entry_count; i++) { + struct VkWriteDescriptorSet *desc = &pds->descriptor_writes[i]; + struct VkDescriptorUpdateTemplateEntry *entry = &templ->entry[i]; + const uint8_t *pSrc = ((const uint8_t *) cmd->u.push_descriptor_set_with_template_khr.data) + entry->offset; + + /* dstSet is ignored */ + desc->dstBinding = entry->dstBinding; + desc->dstArrayElement = entry->dstArrayElement; + desc->descriptorCount = entry->descriptorCount; + desc->descriptorType = entry->descriptorType; + desc->pImageInfo = (const VkDescriptorImageInfo *) next_info; + desc->pTexelBufferView = (const VkBufferView *) next_info; + desc->pBufferInfo = (const VkDescriptorBufferInfo *) next_info; + + for (unsigned j = 0; j < desc->descriptorCount; j++) { + switch (desc->descriptorType) { + case VK_DESCRIPTOR_TYPE_SAMPLER: + case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: + case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: + case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: + case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: + memcpy((VkDescriptorImageInfo*)&desc->pImageInfo[j], pSrc, sizeof(VkDescriptorImageInfo)); + next_info += sizeof(VkDescriptorImageInfo); + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: + case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: + memcpy((VkBufferView*)&desc->pTexelBufferView[j], pSrc, sizeof(VkBufferView)); + next_info += sizeof(VkBufferView); + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: + default: + memcpy((VkDescriptorBufferInfo*)&desc->pBufferInfo[j], pSrc, sizeof(VkDescriptorBufferInfo)); + next_info += sizeof(VkDescriptorBufferInfo); + break; + } + pSrc += entry->stride; + } + } + handle_push_descriptor_set_generic(pds, state); + free(pds); +} + +static void handle_bind_transform_feedback_buffers(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - struct lvp_cmd_bind_transform_feedback_buffers *btfb = &cmd->u.bind_transform_feedback_buffers; + struct vk_cmd_bind_transform_feedback_buffers_ext *btfb = &cmd->u.bind_transform_feedback_buffers_ext; for (unsigned i = 0; i < btfb->binding_count; i++) { int idx = i + btfb->first_binding; @@ -2909,17 +3333,17 @@ static void handle_bind_transform_feedback_buffers(struct lvp_cmd_buffer_entry * state->pctx->stream_output_target_destroy(state->pctx, state->so_targets[idx]); state->so_targets[idx] = state->pctx->create_stream_output_target(state->pctx, - btfb->buffers[i]->bo, + lvp_buffer_from_handle(btfb->buffers[i])->bo, btfb->offsets[i], btfb->sizes[i]); } state->num_so_targets = btfb->first_binding + btfb->binding_count; } -static void handle_begin_transform_feedback(struct lvp_cmd_buffer_entry *cmd, +static void handle_begin_transform_feedback(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - struct lvp_cmd_begin_transform_feedback *btf = &cmd->u.begin_transform_feedback; + struct vk_cmd_begin_transform_feedback_ext *btf = &cmd->u.begin_transform_feedback_ext; uint32_t offsets[4]; memset(offsets, 0, sizeof(uint32_t)*4); @@ -2929,8 +3353,8 @@ static void handle_begin_transform_feedback(struct lvp_cmd_buffer_entry *cmd, continue; pipe_buffer_read(state->pctx, - btf->counter_buffers[i]->bo, - btf->counter_buffer_offsets[i], + btf->counter_buffers ? lvp_buffer_from_handle(btf->counter_buffers[i])->bo : NULL, + btf->counter_buffer_offsets ? btf->counter_buffer_offsets[i] : 0, 4, &offsets[i]); } @@ -2938,10 +3362,10 @@ static void handle_begin_transform_feedback(struct lvp_cmd_buffer_entry *cmd, state->so_targets, offsets); } -static void handle_end_transform_feedback(struct lvp_cmd_buffer_entry *cmd, +static void handle_end_transform_feedback(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - struct lvp_cmd_end_transform_feedback *etf = &cmd->u.end_transform_feedback; + struct vk_cmd_end_transform_feedback_ext *etf = &cmd->u.end_transform_feedback_ext; if (etf->counter_buffer_count) { for (unsigned i = 0; i < etf->counter_buffer_count; i++) { @@ -2952,8 +3376,8 @@ static void handle_end_transform_feedback(struct lvp_cmd_buffer_entry *cmd, offset = state->pctx->stream_output_target_offset(state->so_targets[i]); pipe_buffer_write(state->pctx, - etf->counter_buffers[i]->bo, - etf->counter_buffer_offsets[i], + etf->counter_buffers ? lvp_buffer_from_handle(etf->counter_buffers[i])->bo : NULL, + etf->counter_buffer_offsets ? etf->counter_buffer_offsets[i] : 0, 4, &offset); } @@ -2961,36 +3385,36 @@ static void handle_end_transform_feedback(struct lvp_cmd_buffer_entry *cmd, state->pctx->set_stream_output_targets(state->pctx, 0, NULL, NULL); } -static void handle_draw_indirect_byte_count(struct lvp_cmd_buffer_entry *cmd, +static void handle_draw_indirect_byte_count(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - struct lvp_cmd_draw_indirect_byte_count *dibc = &cmd->u.draw_indirect_byte_count; + struct vk_cmd_draw_indirect_byte_count_ext *dibc = &cmd->u.draw_indirect_byte_count_ext; const struct lvp_subpass *subpass = &state->pass->subpasses[state->subpass]; struct pipe_draw_start_count_bias draw = {0}; pipe_buffer_read(state->pctx, - dibc->counter_buffer->bo, - dibc->counter_buffer->offset + dibc->counter_buffer_offset, + lvp_buffer_from_handle(dibc->counter_buffer)->bo, + lvp_buffer_from_handle(dibc->counter_buffer)->offset + dibc->counter_buffer_offset, 4, &draw.count); - state->info.start_instance = cmd->u.draw_indirect_byte_count.first_instance; - state->info.instance_count = cmd->u.draw_indirect_byte_count.instance_count; + state->info.start_instance = cmd->u.draw_indirect_byte_count_ext.first_instance; + state->info.instance_count = cmd->u.draw_indirect_byte_count_ext.instance_count; state->info.index_size = 0; - draw.count /= cmd->u.draw_indirect_byte_count.vertex_stride; + draw.count /= cmd->u.draw_indirect_byte_count_ext.vertex_stride; state->info.view_mask = subpass->view_mask; state->pctx->set_patch_vertices(state->pctx, state->patch_vertices); state->pctx->draw_vbo(state->pctx, &state->info, 0, &state->indirect_info, &draw, 1); } -static void handle_begin_conditional_rendering(struct lvp_cmd_buffer_entry *cmd, +static void handle_begin_conditional_rendering(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - struct lvp_cmd_begin_conditional_rendering *bcr = &cmd->u.begin_conditional_rendering; + struct VkConditionalRenderingBeginInfoEXT *bcr = cmd->u.begin_conditional_rendering_ext.conditional_rendering_begin; state->pctx->render_condition_mem(state->pctx, - bcr->buffer->bo, - bcr->buffer->offset + bcr->offset, - bcr->inverted); + lvp_buffer_from_handle(bcr->buffer)->bo, + lvp_buffer_from_handle(bcr->buffer)->offset + bcr->offset, + bcr->flags & VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT); } static void handle_end_conditional_rendering(struct rendering_state *state) @@ -2998,16 +3422,14 @@ static void handle_end_conditional_rendering(struct rendering_state *state) state->pctx->render_condition_mem(state->pctx, NULL, 0, false); } -static void handle_set_vertex_input(struct lvp_cmd_buffer_entry *cmd, +static void handle_set_vertex_input(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - const struct lvp_cmd_set_vertex_input *vertex_input = &cmd->u.set_vertex_input; - const struct VkVertexInputBindingDescription2EXT *bindings = (void*)vertex_input->data; - const struct VkVertexInputAttributeDescription2EXT *attrs = (void*)(vertex_input->data + - vertex_input->binding_count * - sizeof(struct VkVertexInputBindingDescription2EXT)); + const struct vk_cmd_set_vertex_input_ext *vertex_input = &cmd->u.set_vertex_input_ext; + const struct VkVertexInputBindingDescription2EXT *bindings = vertex_input->vertex_binding_descriptions; + const struct VkVertexInputAttributeDescription2EXT *attrs = vertex_input->vertex_attribute_descriptions; int max_location = -1; - for (unsigned i = 0; i < vertex_input->attr_count; i++) { + for (unsigned i = 0; i < vertex_input->vertex_attribute_description_count; i++) { const struct VkVertexInputBindingDescription2EXT *binding = &bindings[attrs[i].binding]; unsigned location = attrs[i].location; state->velem.velems[location].src_offset = attrs[i].offset; @@ -3035,366 +3457,419 @@ static void handle_set_vertex_input(struct lvp_cmd_buffer_entry *cmd, state->ve_dirty = true; } -static void handle_set_cull_mode(struct lvp_cmd_buffer_entry *cmd, +static void handle_set_cull_mode(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - state->rs_state.cull_face = vk_cull_to_pipe(cmd->u.set_cull_mode.cull_mode); + state->rs_state.cull_face = vk_cull_to_pipe(cmd->u.set_cull_mode_ext.cull_mode); state->rs_dirty = true; } -static void handle_set_front_face(struct lvp_cmd_buffer_entry *cmd, +static void handle_set_front_face(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - state->rs_state.front_ccw = (cmd->u.set_front_face.front_face == VK_FRONT_FACE_COUNTER_CLOCKWISE); + state->rs_state.front_ccw = (cmd->u.set_front_face_ext.front_face == VK_FRONT_FACE_COUNTER_CLOCKWISE); state->rs_dirty = true; } -static void handle_set_primitive_topology(struct lvp_cmd_buffer_entry *cmd, +static void handle_set_primitive_topology(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - state->info.mode = vk_conv_topology(cmd->u.set_primitive_topology.prim); + state->info.mode = vk_conv_topology(cmd->u.set_primitive_topology_ext.primitive_topology); state->rs_dirty = true; } -static void handle_set_depth_test_enable(struct lvp_cmd_buffer_entry *cmd, +static void handle_set_depth_test_enable(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - state->dsa_dirty |= state->dsa_state.depth_enabled != cmd->u.set_depth_test_enable.depth_test_enable; - state->dsa_state.depth_enabled = cmd->u.set_depth_test_enable.depth_test_enable; + state->dsa_dirty |= state->dsa_state.depth_enabled != cmd->u.set_depth_test_enable_ext.depth_test_enable; + state->dsa_state.depth_enabled = cmd->u.set_depth_test_enable_ext.depth_test_enable; } -static void handle_set_depth_write_enable(struct lvp_cmd_buffer_entry *cmd, +static void handle_set_depth_write_enable(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - state->dsa_dirty |= state->dsa_state.depth_writemask != cmd->u.set_depth_write_enable.depth_write_enable; - state->dsa_state.depth_writemask = cmd->u.set_depth_write_enable.depth_write_enable; + state->dsa_dirty |= state->dsa_state.depth_writemask != cmd->u.set_depth_write_enable_ext.depth_write_enable; + state->dsa_state.depth_writemask = cmd->u.set_depth_write_enable_ext.depth_write_enable; } -static void handle_set_depth_compare_op(struct lvp_cmd_buffer_entry *cmd, +static void handle_set_depth_compare_op(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - state->dsa_dirty |= state->dsa_state.depth_func != cmd->u.set_depth_compare_op.depth_op; - state->dsa_state.depth_func = cmd->u.set_depth_compare_op.depth_op; + state->dsa_dirty |= state->dsa_state.depth_func != cmd->u.set_depth_compare_op_ext.depth_compare_op; + state->dsa_state.depth_func = cmd->u.set_depth_compare_op_ext.depth_compare_op; } -static void handle_set_depth_bounds_test_enable(struct lvp_cmd_buffer_entry *cmd, +static void handle_set_depth_bounds_test_enable(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - state->dsa_dirty |= state->dsa_state.depth_bounds_test != cmd->u.set_depth_bounds_test_enable.depth_bounds_test_enable; - state->dsa_state.depth_bounds_test = cmd->u.set_depth_bounds_test_enable.depth_bounds_test_enable; + state->dsa_dirty |= state->dsa_state.depth_bounds_test != cmd->u.set_depth_bounds_test_enable_ext.depth_bounds_test_enable; + state->dsa_state.depth_bounds_test = cmd->u.set_depth_bounds_test_enable_ext.depth_bounds_test_enable; } -static void handle_set_stencil_test_enable(struct lvp_cmd_buffer_entry *cmd, +static void handle_set_stencil_test_enable(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - state->dsa_dirty |= state->dsa_state.stencil[0].enabled != cmd->u.set_stencil_test_enable.stencil_test_enable || - state->dsa_state.stencil[1].enabled != cmd->u.set_stencil_test_enable.stencil_test_enable; - state->dsa_state.stencil[0].enabled = cmd->u.set_stencil_test_enable.stencil_test_enable; - state->dsa_state.stencil[1].enabled = cmd->u.set_stencil_test_enable.stencil_test_enable; + state->dsa_dirty |= state->dsa_state.stencil[0].enabled != cmd->u.set_stencil_test_enable_ext.stencil_test_enable || + state->dsa_state.stencil[1].enabled != cmd->u.set_stencil_test_enable_ext.stencil_test_enable; + state->dsa_state.stencil[0].enabled = cmd->u.set_stencil_test_enable_ext.stencil_test_enable; + state->dsa_state.stencil[1].enabled = cmd->u.set_stencil_test_enable_ext.stencil_test_enable; } -static void handle_set_stencil_op(struct lvp_cmd_buffer_entry *cmd, +static void handle_set_stencil_op(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - if (cmd->u.set_stencil_op.face_mask & VK_STENCIL_FACE_FRONT_BIT) { - state->dsa_state.stencil[0].func = cmd->u.set_stencil_op.compare_op; - state->dsa_state.stencil[0].fail_op = vk_conv_stencil_op(cmd->u.set_stencil_op.fail_op); - state->dsa_state.stencil[0].zpass_op = vk_conv_stencil_op(cmd->u.set_stencil_op.pass_op); - state->dsa_state.stencil[0].zfail_op = vk_conv_stencil_op(cmd->u.set_stencil_op.depth_fail_op); + if (cmd->u.set_stencil_op_ext.face_mask & VK_STENCIL_FACE_FRONT_BIT) { + state->dsa_state.stencil[0].func = cmd->u.set_stencil_op_ext.compare_op; + state->dsa_state.stencil[0].fail_op = vk_conv_stencil_op(cmd->u.set_stencil_op_ext.fail_op); + state->dsa_state.stencil[0].zpass_op = vk_conv_stencil_op(cmd->u.set_stencil_op_ext.pass_op); + state->dsa_state.stencil[0].zfail_op = vk_conv_stencil_op(cmd->u.set_stencil_op_ext.depth_fail_op); } - if (cmd->u.set_stencil_op.face_mask & VK_STENCIL_FACE_BACK_BIT) { - state->dsa_state.stencil[1].func = cmd->u.set_stencil_op.compare_op; - state->dsa_state.stencil[1].fail_op = vk_conv_stencil_op(cmd->u.set_stencil_op.fail_op); - state->dsa_state.stencil[1].zpass_op = vk_conv_stencil_op(cmd->u.set_stencil_op.pass_op); - state->dsa_state.stencil[1].zfail_op = vk_conv_stencil_op(cmd->u.set_stencil_op.depth_fail_op); + if (cmd->u.set_stencil_op_ext.face_mask & VK_STENCIL_FACE_BACK_BIT) { + state->dsa_state.stencil[1].func = cmd->u.set_stencil_op_ext.compare_op; + state->dsa_state.stencil[1].fail_op = vk_conv_stencil_op(cmd->u.set_stencil_op_ext.fail_op); + state->dsa_state.stencil[1].zpass_op = vk_conv_stencil_op(cmd->u.set_stencil_op_ext.pass_op); + state->dsa_state.stencil[1].zfail_op = vk_conv_stencil_op(cmd->u.set_stencil_op_ext.depth_fail_op); } state->dsa_dirty = true; } -static void handle_set_line_stipple(struct lvp_cmd_buffer_entry *cmd, +static void handle_set_line_stipple(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - state->rs_state.line_stipple_factor = cmd->u.set_line_stipple.line_stipple_factor - 1; - state->rs_state.line_stipple_pattern = cmd->u.set_line_stipple.line_stipple_pattern; + state->rs_state.line_stipple_factor = cmd->u.set_line_stipple_ext.line_stipple_factor - 1; + state->rs_state.line_stipple_pattern = cmd->u.set_line_stipple_ext.line_stipple_pattern; state->rs_dirty = true; } -static void handle_set_depth_bias_enable(struct lvp_cmd_buffer_entry *cmd, +static void handle_set_depth_bias_enable(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - state->rs_dirty |= state->depth_bias.enabled != cmd->u.set_depth_bias_enable.enable; - state->depth_bias.enabled = cmd->u.set_depth_bias_enable.enable; + state->rs_dirty |= state->depth_bias.enabled != cmd->u.set_depth_bias_enable_ext.depth_bias_enable; + state->depth_bias.enabled = cmd->u.set_depth_bias_enable_ext.depth_bias_enable; } -static void handle_set_logic_op(struct lvp_cmd_buffer_entry *cmd, +static void handle_set_logic_op(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - unsigned op = vk_conv_logic_op(cmd->u.set_logic_op.op); + unsigned op = vk_conv_logic_op(cmd->u.set_logic_op_ext.logic_op); state->rs_dirty |= state->blend_state.logicop_func != op; state->blend_state.logicop_func = op; } -static void handle_set_patch_control_points(struct lvp_cmd_buffer_entry *cmd, +static void handle_set_patch_control_points(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - state->patch_vertices = cmd->u.set_patch_control_points.vertices_per_patch; + state->patch_vertices = cmd->u.set_patch_control_points_ext.patch_control_points; } -static void handle_set_primitive_restart_enable(struct lvp_cmd_buffer_entry *cmd, +static void handle_set_primitive_restart_enable(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - state->info.primitive_restart = cmd->u.set_primitive_restart_enable.enable; + state->info.primitive_restart = cmd->u.set_primitive_restart_enable_ext.primitive_restart_enable; } -static void handle_set_rasterizer_discard_enable(struct lvp_cmd_buffer_entry *cmd, +static void handle_set_rasterizer_discard_enable(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - state->rs_dirty |= state->rs_state.rasterizer_discard != cmd->u.set_rasterizer_discard_enable.enable; - state->rs_state.rasterizer_discard = cmd->u.set_rasterizer_discard_enable.enable; + state->rs_dirty |= state->rs_state.rasterizer_discard != cmd->u.set_rasterizer_discard_enable_ext.rasterizer_discard_enable; + state->rs_state.rasterizer_discard = cmd->u.set_rasterizer_discard_enable_ext.rasterizer_discard_enable; } -static void handle_set_color_write_enable(struct lvp_cmd_buffer_entry *cmd, +static void handle_set_color_write_enable(struct vk_cmd_queue_entry *cmd, struct rendering_state *state) { - state->blend_dirty |= state->color_write_disables != cmd->u.set_color_write_enable.disable_mask; - state->color_write_disables = cmd->u.set_color_write_enable.disable_mask; + uint8_t disable_mask = 0; //PIPE_MAX_COLOR_BUFS is max attachment count + + for (unsigned i = 0; i < cmd->u.set_color_write_enable_ext.attachment_count; i++) { + /* this is inverted because cmdbufs are zero-initialized, meaning only 'true' + * can be detected with a bool, and the default is to enable color writes + */ + if (cmd->u.set_color_write_enable_ext.color_write_enables[i] != VK_TRUE) + disable_mask |= BITFIELD_BIT(i); + } + + state->blend_dirty |= state->color_write_disables != disable_mask; + state->color_write_disables = disable_mask; } static void lvp_execute_cmd_buffer(struct lvp_cmd_buffer *cmd_buffer, struct rendering_state *state) { - struct lvp_cmd_buffer_entry *cmd; + struct vk_cmd_queue_entry *cmd; bool first = true; bool did_flush = false; - LIST_FOR_EACH_ENTRY(cmd, &cmd_buffer->cmds, cmd_link) { - switch (cmd->cmd_type) { - case LVP_CMD_BIND_PIPELINE: + LIST_FOR_EACH_ENTRY(cmd, &cmd_buffer->queue.cmds, cmd_link) { + switch (cmd->type) { + case VK_CMD_BIND_PIPELINE: handle_pipeline(cmd, state); break; - case LVP_CMD_SET_VIEWPORT: + case VK_CMD_SET_VIEWPORT: handle_set_viewport(cmd, state); break; - case LVP_CMD_SET_SCISSOR: + case VK_CMD_SET_VIEWPORT_WITH_COUNT_EXT: + handle_set_viewport_with_count(cmd, state); + break; + case VK_CMD_SET_SCISSOR: handle_set_scissor(cmd, state); break; - case LVP_CMD_SET_LINE_WIDTH: + case VK_CMD_SET_SCISSOR_WITH_COUNT_EXT: + handle_set_scissor_with_count(cmd, state); + break; + case VK_CMD_SET_LINE_WIDTH: handle_set_line_width(cmd, state); break; - case LVP_CMD_SET_DEPTH_BIAS: + case VK_CMD_SET_DEPTH_BIAS: handle_set_depth_bias(cmd, state); break; - case LVP_CMD_SET_BLEND_CONSTANTS: + case VK_CMD_SET_BLEND_CONSTANTS: handle_set_blend_constants(cmd, state); break; - case LVP_CMD_SET_DEPTH_BOUNDS: + case VK_CMD_SET_DEPTH_BOUNDS: handle_set_depth_bounds(cmd, state); break; - case LVP_CMD_SET_STENCIL_COMPARE_MASK: + case VK_CMD_SET_STENCIL_COMPARE_MASK: handle_set_stencil_compare_mask(cmd, state); break; - case LVP_CMD_SET_STENCIL_WRITE_MASK: + case VK_CMD_SET_STENCIL_WRITE_MASK: handle_set_stencil_write_mask(cmd, state); break; - case LVP_CMD_SET_STENCIL_REFERENCE: + case VK_CMD_SET_STENCIL_REFERENCE: handle_set_stencil_reference(cmd, state); break; - case LVP_CMD_BIND_DESCRIPTOR_SETS: + case VK_CMD_BIND_DESCRIPTOR_SETS: handle_descriptor_sets(cmd, state); break; - case LVP_CMD_BIND_INDEX_BUFFER: + case VK_CMD_BIND_INDEX_BUFFER: handle_index_buffer(cmd, state); break; - case LVP_CMD_BIND_VERTEX_BUFFERS: + case VK_CMD_BIND_VERTEX_BUFFERS: handle_vertex_buffers(cmd, state); break; - case LVP_CMD_DRAW: + case VK_CMD_BIND_VERTEX_BUFFERS2_EXT: + handle_vertex_buffers2(cmd, state); + break; + case VK_CMD_DRAW: emit_state(state); handle_draw(cmd, state); break; - case LVP_CMD_DRAW_INDEXED: + case VK_CMD_DRAW_MULTI_EXT: + emit_state(state); + handle_draw_multi(cmd, state); + break; + case VK_CMD_DRAW_INDEXED: emit_state(state); handle_draw_indexed(cmd, state); break; - case LVP_CMD_DRAW_INDIRECT: + case VK_CMD_DRAW_INDIRECT: emit_state(state); handle_draw_indirect(cmd, state, false); break; - case LVP_CMD_DRAW_INDEXED_INDIRECT: + case VK_CMD_DRAW_INDEXED_INDIRECT: emit_state(state); handle_draw_indirect(cmd, state, true); break; - case LVP_CMD_DISPATCH: + case VK_CMD_DRAW_MULTI_INDEXED_EXT: + emit_state(state); + handle_draw_multi_indexed(cmd, state); + break; + case VK_CMD_DISPATCH: emit_compute_state(state); handle_dispatch(cmd, state); break; - case LVP_CMD_DISPATCH_INDIRECT: + case VK_CMD_DISPATCH_BASE: + emit_compute_state(state); + handle_dispatch_base(cmd, state); + break; + case VK_CMD_DISPATCH_INDIRECT: emit_compute_state(state); handle_dispatch_indirect(cmd, state); break; - case LVP_CMD_COPY_BUFFER: + case VK_CMD_COPY_BUFFER2_KHR: handle_copy_buffer(cmd, state); break; - case LVP_CMD_COPY_IMAGE: + case VK_CMD_COPY_IMAGE2_KHR: handle_copy_image(cmd, state); break; - case LVP_CMD_BLIT_IMAGE: + case VK_CMD_BLIT_IMAGE2_KHR: handle_blit_image(cmd, state); break; - case LVP_CMD_COPY_BUFFER_TO_IMAGE: + case VK_CMD_COPY_BUFFER_TO_IMAGE2_KHR: handle_copy_buffer_to_image(cmd, state); break; - case LVP_CMD_COPY_IMAGE_TO_BUFFER: - handle_copy_image_to_buffer(cmd, state); + case VK_CMD_COPY_IMAGE_TO_BUFFER2_KHR: + handle_copy_image_to_buffer2_khr(cmd, state); break; - case LVP_CMD_UPDATE_BUFFER: + case VK_CMD_UPDATE_BUFFER: handle_update_buffer(cmd, state); break; - case LVP_CMD_FILL_BUFFER: + case VK_CMD_FILL_BUFFER: handle_fill_buffer(cmd, state); break; - case LVP_CMD_CLEAR_COLOR_IMAGE: + case VK_CMD_CLEAR_COLOR_IMAGE: handle_clear_color_image(cmd, state); break; - case LVP_CMD_CLEAR_DEPTH_STENCIL_IMAGE: + case VK_CMD_CLEAR_DEPTH_STENCIL_IMAGE: handle_clear_ds_image(cmd, state); break; - case LVP_CMD_CLEAR_ATTACHMENTS: + case VK_CMD_CLEAR_ATTACHMENTS: handle_clear_attachments(cmd, state); break; - case LVP_CMD_RESOLVE_IMAGE: + case VK_CMD_RESOLVE_IMAGE2_KHR: handle_resolve_image(cmd, state); break; - case LVP_CMD_SET_EVENT: - case LVP_CMD_RESET_EVENT: + case VK_CMD_SET_EVENT: handle_event_set(cmd, state); break; - case LVP_CMD_WAIT_EVENTS: + case VK_CMD_RESET_EVENT: + handle_event_reset(cmd, state); + break; + case VK_CMD_WAIT_EVENTS: handle_wait_events(cmd, state); break; - case LVP_CMD_PIPELINE_BARRIER: + case VK_CMD_PIPELINE_BARRIER: /* skip flushes since every cmdbuf does a flush after iterating its cmds and so this is redundant */ - if (first || did_flush || cmd->cmd_link.next == &cmd_buffer->cmds) + if (first || did_flush || cmd->cmd_link.next == &cmd_buffer->queue.cmds) continue; handle_pipeline_barrier(cmd, state); did_flush = true; continue; - case LVP_CMD_BEGIN_QUERY: - maybe_emit_state_for_begin_query(cmd, state); + case VK_CMD_BEGIN_QUERY_INDEXED_EXT: + handle_begin_query_indexed_ext(cmd, state); + break; + case VK_CMD_END_QUERY_INDEXED_EXT: + handle_end_query_indexed_ext(cmd, state); + break; + case VK_CMD_BEGIN_QUERY: handle_begin_query(cmd, state); break; - case LVP_CMD_END_QUERY: + case VK_CMD_END_QUERY: handle_end_query(cmd, state); break; - case LVP_CMD_RESET_QUERY_POOL: + case VK_CMD_RESET_QUERY_POOL: handle_reset_query_pool(cmd, state); break; - case LVP_CMD_WRITE_TIMESTAMP: + case VK_CMD_WRITE_TIMESTAMP: handle_write_timestamp(cmd, state); break; - case LVP_CMD_COPY_QUERY_POOL_RESULTS: + case VK_CMD_COPY_QUERY_POOL_RESULTS: handle_copy_query_pool_results(cmd, state); break; - case LVP_CMD_PUSH_CONSTANTS: + case VK_CMD_PUSH_CONSTANTS: handle_push_constants(cmd, state); break; - case LVP_CMD_BEGIN_RENDER_PASS: + case VK_CMD_BEGIN_RENDER_PASS: handle_begin_render_pass(cmd, state); break; - case LVP_CMD_NEXT_SUBPASS: - handle_next_subpass(cmd, state); + case VK_CMD_BEGIN_RENDER_PASS2: + handle_begin_render_pass2(cmd, state); break; - case LVP_CMD_END_RENDER_PASS: - handle_end_render_pass(cmd, state); + case VK_CMD_NEXT_SUBPASS: + case VK_CMD_NEXT_SUBPASS2: + handle_next_subpass2(cmd, state); break; - case LVP_CMD_EXECUTE_COMMANDS: + case VK_CMD_END_RENDER_PASS: + case VK_CMD_END_RENDER_PASS2: + handle_end_render_pass2(cmd, state); + break; + case VK_CMD_EXECUTE_COMMANDS: handle_execute_commands(cmd, state); break; - case LVP_CMD_DRAW_INDIRECT_COUNT: + case VK_CMD_DRAW_INDIRECT_COUNT: emit_state(state); handle_draw_indirect_count(cmd, state, false); break; - case LVP_CMD_DRAW_INDEXED_INDIRECT_COUNT: + case VK_CMD_DRAW_INDEXED_INDIRECT_COUNT: emit_state(state); handle_draw_indirect_count(cmd, state, true); break; - case LVP_CMD_PUSH_DESCRIPTOR_SET: + case VK_CMD_PUSH_DESCRIPTOR_SET_KHR: handle_push_descriptor_set(cmd, state); break; - case LVP_CMD_BIND_TRANSFORM_FEEDBACK_BUFFERS: + case VK_CMD_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_KHR: + handle_push_descriptor_set_with_template(cmd, state); + break; + case VK_CMD_BIND_TRANSFORM_FEEDBACK_BUFFERS_EXT: handle_bind_transform_feedback_buffers(cmd, state); break; - case LVP_CMD_BEGIN_TRANSFORM_FEEDBACK: + case VK_CMD_BEGIN_TRANSFORM_FEEDBACK_EXT: handle_begin_transform_feedback(cmd, state); break; - case LVP_CMD_END_TRANSFORM_FEEDBACK: + case VK_CMD_END_TRANSFORM_FEEDBACK_EXT: handle_end_transform_feedback(cmd, state); break; - case LVP_CMD_DRAW_INDIRECT_BYTE_COUNT: + case VK_CMD_DRAW_INDIRECT_BYTE_COUNT_EXT: emit_state(state); handle_draw_indirect_byte_count(cmd, state); - break; - case LVP_CMD_BEGIN_CONDITIONAL_RENDERING: + break; + case VK_CMD_BEGIN_CONDITIONAL_RENDERING_EXT: handle_begin_conditional_rendering(cmd, state); break; - case LVP_CMD_END_CONDITIONAL_RENDERING: + case VK_CMD_END_CONDITIONAL_RENDERING_EXT: handle_end_conditional_rendering(state); break; - case LVP_CMD_SET_VERTEX_INPUT: + case VK_CMD_SET_VERTEX_INPUT_EXT: handle_set_vertex_input(cmd, state); break; - case LVP_CMD_SET_CULL_MODE: + case VK_CMD_SET_CULL_MODE_EXT: handle_set_cull_mode(cmd, state); break; - case LVP_CMD_SET_FRONT_FACE: + case VK_CMD_SET_FRONT_FACE_EXT: handle_set_front_face(cmd, state); break; - case LVP_CMD_SET_PRIMITIVE_TOPOLOGY: + case VK_CMD_SET_PRIMITIVE_TOPOLOGY_EXT: handle_set_primitive_topology(cmd, state); break; - case LVP_CMD_SET_DEPTH_TEST_ENABLE: + case VK_CMD_SET_DEPTH_TEST_ENABLE_EXT: handle_set_depth_test_enable(cmd, state); break; - case LVP_CMD_SET_DEPTH_WRITE_ENABLE: + case VK_CMD_SET_DEPTH_WRITE_ENABLE_EXT: handle_set_depth_write_enable(cmd, state); break; - case LVP_CMD_SET_DEPTH_COMPARE_OP: + case VK_CMD_SET_DEPTH_COMPARE_OP_EXT: handle_set_depth_compare_op(cmd, state); break; - case LVP_CMD_SET_DEPTH_BOUNDS_TEST_ENABLE: + case VK_CMD_SET_DEPTH_BOUNDS_TEST_ENABLE_EXT: handle_set_depth_bounds_test_enable(cmd, state); break; - case LVP_CMD_SET_STENCIL_TEST_ENABLE: + case VK_CMD_SET_STENCIL_TEST_ENABLE_EXT: handle_set_stencil_test_enable(cmd, state); break; - case LVP_CMD_SET_STENCIL_OP: + case VK_CMD_SET_STENCIL_OP_EXT: handle_set_stencil_op(cmd, state); break; - case LVP_CMD_SET_LINE_STIPPLE: + case VK_CMD_SET_LINE_STIPPLE_EXT: handle_set_line_stipple(cmd, state); break; - case LVP_CMD_SET_DEPTH_BIAS_ENABLE: + case VK_CMD_SET_DEPTH_BIAS_ENABLE_EXT: handle_set_depth_bias_enable(cmd, state); break; - case LVP_CMD_SET_LOGIC_OP: + case VK_CMD_SET_LOGIC_OP_EXT: handle_set_logic_op(cmd, state); break; - case LVP_CMD_SET_PATCH_CONTROL_POINTS: + case VK_CMD_SET_PATCH_CONTROL_POINTS_EXT: handle_set_patch_control_points(cmd, state); break; - case LVP_CMD_SET_PRIMITIVE_RESTART_ENABLE: + case VK_CMD_SET_PRIMITIVE_RESTART_ENABLE_EXT: handle_set_primitive_restart_enable(cmd, state); break; - case LVP_CMD_SET_RASTERIZER_DISCARD_ENABLE: + case VK_CMD_SET_RASTERIZER_DISCARD_ENABLE_EXT: handle_set_rasterizer_discard_enable(cmd, state); break; - case LVP_CMD_SET_COLOR_WRITE_ENABLE: + case VK_CMD_SET_COLOR_WRITE_ENABLE_EXT: handle_set_color_write_enable(cmd, state); break; + case VK_CMD_SET_DEVICE_MASK: + /* no-op */ + break; + default: + fprintf(stderr, "Unsupported command %s\n", vk_cmd_queue_type_names[cmd->type]); + unreachable("Unsupported command"); + break; } first = false; did_flush = false; @@ -3429,7 +3904,9 @@ VkResult lvp_execute_cmds(struct lvp_device *device, } } + free(state.imageless_views); free(state.pending_clear_aspects); free(state.cleared_views); + free(state.attachments); return VK_SUCCESS; } diff --git a/src/gallium/frontends/lavapipe/lvp_private.h b/src/gallium/frontends/lavapipe/lvp_private.h index cad34870bde..f19e1daa668 100644 --- a/src/gallium/frontends/lavapipe/lvp_private.h +++ b/src/gallium/frontends/lavapipe/lvp_private.h @@ -59,6 +59,7 @@ typedef uint32_t xcb_window_t; #include "vk_shader_module.h" #include "vk_util.h" #include "vk_format.h" +#include "vk_cmd_queue.h" #include "wsi_common.h" @@ -597,8 +598,7 @@ struct lvp_cmd_buffer { struct lvp_cmd_pool * pool; struct list_head pool_link; - struct list_head cmds; - struct list_head *last_emit; + struct vk_cmd_queue queue; uint8_t push_constants[MAX_PUSH_CONSTANTS_SIZE]; }; @@ -653,358 +653,11 @@ VK_DEFINE_NONDISP_HANDLE_CASTS(lvp_fence, base, VkFence, VK_OBJECT_TYPE_FENCE); VK_DEFINE_NONDISP_HANDLE_CASTS(lvp_semaphore, base, VkSemaphore, VK_OBJECT_TYPE_SEMAPHORE); -/* in same order and buffer building commands in spec. */ -enum lvp_cmds { - LVP_CMD_BIND_PIPELINE, - LVP_CMD_SET_VIEWPORT, - LVP_CMD_SET_SCISSOR, - LVP_CMD_SET_LINE_WIDTH, - LVP_CMD_SET_DEPTH_BIAS, - LVP_CMD_SET_BLEND_CONSTANTS, - LVP_CMD_SET_DEPTH_BOUNDS, - LVP_CMD_SET_STENCIL_COMPARE_MASK, - LVP_CMD_SET_STENCIL_WRITE_MASK, - LVP_CMD_SET_STENCIL_REFERENCE, - LVP_CMD_BIND_DESCRIPTOR_SETS, - LVP_CMD_BIND_INDEX_BUFFER, - LVP_CMD_BIND_VERTEX_BUFFERS, - LVP_CMD_DRAW, - LVP_CMD_DRAW_INDEXED, - LVP_CMD_DRAW_INDIRECT, - LVP_CMD_DRAW_INDEXED_INDIRECT, - LVP_CMD_DISPATCH, - LVP_CMD_DISPATCH_INDIRECT, - LVP_CMD_COPY_BUFFER, - LVP_CMD_COPY_IMAGE, - LVP_CMD_BLIT_IMAGE, - LVP_CMD_COPY_BUFFER_TO_IMAGE, - LVP_CMD_COPY_IMAGE_TO_BUFFER, - LVP_CMD_UPDATE_BUFFER, - LVP_CMD_FILL_BUFFER, - LVP_CMD_CLEAR_COLOR_IMAGE, - LVP_CMD_CLEAR_DEPTH_STENCIL_IMAGE, - LVP_CMD_CLEAR_ATTACHMENTS, - LVP_CMD_RESOLVE_IMAGE, - LVP_CMD_SET_EVENT, - LVP_CMD_RESET_EVENT, - LVP_CMD_WAIT_EVENTS, - LVP_CMD_PIPELINE_BARRIER, - LVP_CMD_BEGIN_QUERY, - LVP_CMD_END_QUERY, - LVP_CMD_RESET_QUERY_POOL, - LVP_CMD_WRITE_TIMESTAMP, - LVP_CMD_COPY_QUERY_POOL_RESULTS, - LVP_CMD_PUSH_CONSTANTS, - LVP_CMD_BEGIN_RENDER_PASS, - LVP_CMD_NEXT_SUBPASS, - LVP_CMD_END_RENDER_PASS, - LVP_CMD_EXECUTE_COMMANDS, - LVP_CMD_DRAW_INDIRECT_COUNT, - LVP_CMD_DRAW_INDEXED_INDIRECT_COUNT, - LVP_CMD_PUSH_DESCRIPTOR_SET, - LVP_CMD_BIND_TRANSFORM_FEEDBACK_BUFFERS, - LVP_CMD_BEGIN_TRANSFORM_FEEDBACK, - LVP_CMD_END_TRANSFORM_FEEDBACK, - LVP_CMD_DRAW_INDIRECT_BYTE_COUNT, - LVP_CMD_BEGIN_CONDITIONAL_RENDERING, - LVP_CMD_END_CONDITIONAL_RENDERING, - LVP_CMD_SET_VERTEX_INPUT, - LVP_CMD_SET_CULL_MODE, - LVP_CMD_SET_FRONT_FACE, - LVP_CMD_SET_PRIMITIVE_TOPOLOGY, - LVP_CMD_SET_DEPTH_TEST_ENABLE, - LVP_CMD_SET_DEPTH_WRITE_ENABLE, - LVP_CMD_SET_DEPTH_COMPARE_OP, - LVP_CMD_SET_DEPTH_BOUNDS_TEST_ENABLE, - LVP_CMD_SET_STENCIL_TEST_ENABLE, - LVP_CMD_SET_STENCIL_OP, - LVP_CMD_SET_LINE_STIPPLE, - LVP_CMD_SET_DEPTH_BIAS_ENABLE, - LVP_CMD_SET_LOGIC_OP, - LVP_CMD_SET_PATCH_CONTROL_POINTS, - LVP_CMD_SET_PRIMITIVE_RESTART_ENABLE, - LVP_CMD_SET_RASTERIZER_DISCARD_ENABLE, - LVP_CMD_SET_COLOR_WRITE_ENABLE, -}; - -struct lvp_cmd_bind_pipeline { - VkPipelineBindPoint bind_point; - struct lvp_pipeline *pipeline; -}; - -struct lvp_cmd_set_viewport { - uint32_t first_viewport; - uint32_t viewport_count; - VkViewport viewports[16]; -}; - -struct lvp_cmd_set_scissor { - uint32_t first_scissor; - uint32_t scissor_count; - VkRect2D scissors[16]; -}; - -struct lvp_cmd_set_line_width { - float line_width; -}; - -struct lvp_cmd_set_depth_bias { - float constant_factor; - float clamp; - float slope_factor; -}; - -struct lvp_cmd_set_blend_constants { - float blend_constants[4]; -}; - -struct lvp_cmd_set_depth_bounds { - float min_depth; - float max_depth; -}; - -struct lvp_cmd_set_stencil_vals { - VkStencilFaceFlags face_mask; - uint32_t value; -}; - -struct lvp_cmd_bind_descriptor_sets { - VkPipelineBindPoint bind_point; - struct lvp_descriptor_set_layout *set_layout[MAX_SETS]; - uint32_t first; - uint32_t count; - struct lvp_descriptor_set **sets; - uint32_t dynamic_offset_count; - const uint32_t *dynamic_offsets; -}; - -struct lvp_cmd_bind_index_buffer { - const struct lvp_buffer *buffer; - VkDeviceSize offset; - VkIndexType index_type; -}; - -struct lvp_cmd_bind_vertex_buffers { - uint32_t first; - uint32_t binding_count; - struct lvp_buffer **buffers; - const VkDeviceSize *offsets; - const VkDeviceSize *sizes; - const VkDeviceSize *strides; -}; - -struct lvp_cmd_draw { - uint32_t instance_count; - uint32_t first_instance; - uint32_t draw_count; - struct pipe_draw_start_count_bias draws[0]; -}; - -struct lvp_cmd_draw_indexed { - uint32_t instance_count; - uint32_t first_instance; - bool calc_start; - uint32_t draw_count; - bool vertex_offset_changes; - struct pipe_draw_start_count_bias draws[0]; -}; - -struct lvp_cmd_draw_indirect { - VkDeviceSize offset; - struct lvp_buffer *buffer; - uint32_t draw_count; - uint32_t stride; -}; - -struct lvp_cmd_dispatch { - uint32_t x; - uint32_t y; - uint32_t z; - uint32_t base_x; - uint32_t base_y; - uint32_t base_z; -}; - -struct lvp_cmd_dispatch_indirect { - const struct lvp_buffer *buffer; - VkDeviceSize offset; -}; - -struct lvp_cmd_copy_buffer { - struct lvp_buffer *src; - struct lvp_buffer *dst; - uint32_t region_count; - const VkBufferCopy *regions; -}; - -struct lvp_cmd_copy_image { - struct lvp_image *src; - struct lvp_image *dst; - VkImageLayout src_layout; - VkImageLayout dst_layout; - uint32_t region_count; - const VkImageCopy *regions; -}; - -struct lvp_cmd_blit_image { - struct lvp_image *src; - struct lvp_image *dst; - VkImageLayout src_layout; - VkImageLayout dst_layout; - uint32_t region_count; - const VkImageBlit *regions; - VkFilter filter; -}; - -struct lvp_cmd_copy_buffer_to_image { - struct lvp_buffer *src; - struct lvp_image *dst; - VkImageLayout dst_layout; - uint32_t region_count; - const VkBufferImageCopy *regions; -}; - -struct lvp_cmd_copy_image_to_buffer { - struct lvp_image *src; - struct lvp_buffer *dst; - VkImageLayout src_layout; - uint32_t region_count; - const VkBufferImageCopy *regions; -}; - -struct lvp_cmd_update_buffer { - struct lvp_buffer *buffer; - VkDeviceSize offset; - VkDeviceSize data_size; - char data[0]; -}; - -struct lvp_cmd_fill_buffer { - struct lvp_buffer *buffer; - VkDeviceSize offset; - VkDeviceSize fill_size; - uint32_t data; -}; - -struct lvp_cmd_clear_color_image { - struct lvp_image *image; - VkImageLayout layout; - VkClearColorValue clear_val; - uint32_t range_count; - VkImageSubresourceRange *ranges; -}; - -struct lvp_cmd_clear_ds_image { - struct lvp_image *image; - VkImageLayout layout; - VkClearDepthStencilValue clear_val; - uint32_t range_count; - VkImageSubresourceRange *ranges; -}; - -struct lvp_cmd_clear_attachments { - uint32_t attachment_count; - VkClearAttachment *attachments; - uint32_t rect_count; - VkClearRect *rects; -}; - -struct lvp_cmd_resolve_image { - struct lvp_image *src; - struct lvp_image *dst; - VkImageLayout src_layout; - VkImageLayout dst_layout; - uint32_t region_count; - VkImageResolve *regions; -}; - -struct lvp_cmd_event_set { - struct lvp_event *event; - bool value; - bool flush; -}; - -struct lvp_cmd_wait_events { - uint32_t event_count; - struct lvp_event **events; - VkPipelineStageFlags src_stage_mask; - VkPipelineStageFlags dst_stage_mask; - uint32_t memory_barrier_count; - VkMemoryBarrier *memory_barriers; - uint32_t buffer_memory_barrier_count; - VkBufferMemoryBarrier *buffer_memory_barriers; - uint32_t image_memory_barrier_count; - VkImageMemoryBarrier *image_memory_barriers; -}; - -struct lvp_cmd_pipeline_barrier { - VkPipelineStageFlags src_stage_mask; - VkPipelineStageFlags dst_stage_mask; - bool by_region; - uint32_t memory_barrier_count; - VkMemoryBarrier *memory_barriers; - uint32_t buffer_memory_barrier_count; - VkBufferMemoryBarrier *buffer_memory_barriers; - uint32_t image_memory_barrier_count; - VkImageMemoryBarrier *image_memory_barriers; -}; - -struct lvp_cmd_query_cmd { - struct lvp_query_pool *pool; - uint32_t query; - uint32_t index; - bool precise; - bool flush; -}; - -struct lvp_cmd_copy_query_pool_results { - struct lvp_query_pool *pool; - uint32_t first_query; - uint32_t query_count; - struct lvp_buffer *dst; - VkDeviceSize dst_offset; - VkDeviceSize stride; - VkQueryResultFlags flags; -}; - -struct lvp_cmd_push_constants { - VkShaderStageFlags stage; - uint32_t offset; - uint32_t size; - uint32_t val[1]; -}; - struct lvp_attachment_state { VkImageAspectFlags pending_clear_aspects; VkClearValue clear_value; }; -struct lvp_cmd_begin_render_pass { - struct lvp_framebuffer *framebuffer; - struct lvp_render_pass *render_pass; - VkRect2D render_area; - struct lvp_attachment_state *attachments; - struct lvp_image_view **imageless_views; -}; - -struct lvp_cmd_next_subpass { - VkSubpassContents contents; -}; - -struct lvp_cmd_execute_commands { - uint32_t command_buffer_count; - struct lvp_cmd_buffer *cmd_buffers[0]; -}; - -struct lvp_cmd_draw_indirect_count { - VkDeviceSize offset; - struct lvp_buffer *buffer; - VkDeviceSize count_buffer_offset; - struct lvp_buffer *count_buffer; - uint32_t max_draw_count; - uint32_t stride; -}; - struct lvp_write_descriptor { uint32_t dst_binding; uint32_t dst_array_element; @@ -1021,187 +674,6 @@ struct lvp_cmd_push_descriptor_set { union lvp_descriptor_info *infos; }; -struct lvp_cmd_bind_transform_feedback_buffers { - uint32_t first_binding; - uint32_t binding_count; - struct lvp_buffer **buffers; - VkDeviceSize *offsets; - VkDeviceSize *sizes; -}; - -struct lvp_cmd_begin_transform_feedback { - uint32_t first_counter_buffer; - uint32_t counter_buffer_count; - struct lvp_buffer **counter_buffers; - VkDeviceSize *counter_buffer_offsets; -}; - -struct lvp_cmd_end_transform_feedback { - uint32_t first_counter_buffer; - uint32_t counter_buffer_count; - struct lvp_buffer **counter_buffers; - VkDeviceSize *counter_buffer_offsets; -}; - -struct lvp_cmd_draw_indirect_byte_count { - uint32_t instance_count; - uint32_t first_instance; - struct lvp_buffer *counter_buffer; - VkDeviceSize counter_buffer_offset; - uint32_t counter_offset; - uint32_t vertex_stride; -}; - -struct lvp_cmd_begin_conditional_rendering { - struct lvp_buffer *buffer; - VkDeviceSize offset; - bool inverted; -}; - -struct lvp_cmd_set_vertex_input { - uint32_t binding_count; - uint32_t attr_count; - uint8_t data[0]; - //VkVertexInputBindingDescription2EXT bindings[binding_count]; - //VkVertexInputAttributeDescription2EXT attrs[attr_count]; -}; - -struct lvp_cmd_set_cull_mode { - VkCullModeFlags cull_mode; -}; - -struct lvp_cmd_set_front_face { - VkFrontFace front_face; -}; - -struct lvp_cmd_set_primitive_topology { - VkPrimitiveTopology prim; -}; - -struct lvp_cmd_set_depth_test_enable { - VkBool32 depth_test_enable; -}; - -struct lvp_cmd_set_depth_write_enable { - VkBool32 depth_write_enable; -}; - -struct lvp_cmd_set_depth_bounds_test_enable { - VkBool32 depth_bounds_test_enable; -}; - -struct lvp_cmd_set_depth_compare_op { - VkCompareOp depth_op; -}; - -struct lvp_cmd_set_stencil_test_enable { - VkBool32 stencil_test_enable; -}; - -struct lvp_cmd_set_stencil_op { - VkStencilFaceFlags face_mask; - VkStencilOp fail_op; - VkStencilOp pass_op; - VkStencilOp depth_fail_op; - VkCompareOp compare_op; -}; - -struct lvp_cmd_set_line_stipple { - uint32_t line_stipple_factor; - uint16_t line_stipple_pattern; -}; - -struct lvp_cmd_set_depth_bias_enable { - bool enable; -}; - -struct lvp_cmd_set_logic_op { - VkLogicOp op; -}; - -struct lvp_cmd_set_patch_control_points { - uint32_t vertices_per_patch; -}; - -struct lvp_cmd_set_primitive_restart_enable { - bool enable; -}; - -struct lvp_cmd_set_rasterizer_discard_enable { - bool enable; -}; - -struct lvp_cmd_set_color_write_enable { - uint8_t disable_mask; //PIPE_MAX_COLOR_BUFS is max attachment count -}; - -struct lvp_cmd_buffer_entry { - struct list_head cmd_link; - uint32_t cmd_type; - union { - struct lvp_cmd_bind_pipeline pipeline; - struct lvp_cmd_set_viewport set_viewport; - struct lvp_cmd_set_scissor set_scissor; - struct lvp_cmd_set_line_width set_line_width; - struct lvp_cmd_set_depth_bias set_depth_bias; - struct lvp_cmd_set_blend_constants set_blend_constants; - struct lvp_cmd_set_depth_bounds set_depth_bounds; - struct lvp_cmd_set_stencil_vals stencil_vals; - struct lvp_cmd_bind_descriptor_sets descriptor_sets; - struct lvp_cmd_bind_vertex_buffers vertex_buffers; - struct lvp_cmd_bind_index_buffer index_buffer; - struct lvp_cmd_draw draw; - struct lvp_cmd_draw_indexed draw_indexed; - struct lvp_cmd_draw_indirect draw_indirect; - struct lvp_cmd_dispatch dispatch; - struct lvp_cmd_dispatch_indirect dispatch_indirect; - struct lvp_cmd_copy_buffer copy_buffer; - struct lvp_cmd_copy_image copy_image; - struct lvp_cmd_blit_image blit_image; - struct lvp_cmd_copy_buffer_to_image buffer_to_img; - struct lvp_cmd_copy_image_to_buffer img_to_buffer; - struct lvp_cmd_update_buffer update_buffer; - struct lvp_cmd_fill_buffer fill_buffer; - struct lvp_cmd_clear_color_image clear_color_image; - struct lvp_cmd_clear_ds_image clear_ds_image; - struct lvp_cmd_clear_attachments clear_attachments; - struct lvp_cmd_resolve_image resolve_image; - struct lvp_cmd_event_set event_set; - struct lvp_cmd_wait_events wait_events; - struct lvp_cmd_pipeline_barrier pipeline_barrier; - struct lvp_cmd_query_cmd query; - struct lvp_cmd_copy_query_pool_results copy_query_pool_results; - struct lvp_cmd_push_constants push_constants; - struct lvp_cmd_begin_render_pass begin_render_pass; - struct lvp_cmd_next_subpass next_subpass; - struct lvp_cmd_execute_commands execute_commands; - struct lvp_cmd_draw_indirect_count draw_indirect_count; - struct lvp_cmd_push_descriptor_set push_descriptor_set; - struct lvp_cmd_bind_transform_feedback_buffers bind_transform_feedback_buffers; - struct lvp_cmd_begin_transform_feedback begin_transform_feedback; - struct lvp_cmd_end_transform_feedback end_transform_feedback; - struct lvp_cmd_draw_indirect_byte_count draw_indirect_byte_count; - struct lvp_cmd_begin_conditional_rendering begin_conditional_rendering; - struct lvp_cmd_set_vertex_input set_vertex_input; - struct lvp_cmd_set_cull_mode set_cull_mode; - struct lvp_cmd_set_front_face set_front_face; - struct lvp_cmd_set_primitive_topology set_primitive_topology; - struct lvp_cmd_set_depth_test_enable set_depth_test_enable; - struct lvp_cmd_set_depth_write_enable set_depth_write_enable; - struct lvp_cmd_set_depth_compare_op set_depth_compare_op; - struct lvp_cmd_set_depth_bounds_test_enable set_depth_bounds_test_enable; - struct lvp_cmd_set_stencil_test_enable set_stencil_test_enable; - struct lvp_cmd_set_stencil_op set_stencil_op; - struct lvp_cmd_set_line_stipple set_line_stipple; - struct lvp_cmd_set_depth_bias_enable set_depth_bias_enable; - struct lvp_cmd_set_logic_op set_logic_op; - struct lvp_cmd_set_patch_control_points set_patch_control_points; - struct lvp_cmd_set_primitive_restart_enable set_primitive_restart_enable; - struct lvp_cmd_set_rasterizer_discard_enable set_rasterizer_discard_enable; - struct lvp_cmd_set_color_write_enable set_color_write_enable; - } u; -}; - VkResult lvp_execute_cmds(struct lvp_device *device, struct lvp_queue *queue, struct lvp_cmd_buffer *cmd_buffer); diff --git a/src/gallium/frontends/lavapipe/meson.build b/src/gallium/frontends/lavapipe/meson.build index 66468c5c52f..c7967253d14 100644 --- a/src/gallium/frontends/lavapipe/meson.build +++ b/src/gallium/frontends/lavapipe/meson.build @@ -10,6 +10,17 @@ lvp_entrypoints = custom_target( depend_files : vk_entrypoints_gen_depend_files, ) +lvp_commands = custom_target( + 'lvp_commands', + input : [vk_commands_gen, vk_api_xml], + output : ['lvp_commands.c'], + command : [ + prog_python, '@INPUT0@', '--xml', '@INPUT1@', + '--out-c', '@OUTPUT0@', '--prefix', 'lvp', + ], + depend_files : vk_commands_gen_depend_files, +) + liblvp_files = files( 'lvp_device.c', 'lvp_cmd_buffer.c', @@ -52,7 +63,7 @@ endif liblavapipe_st = static_library( 'lavapipe_st', - [liblvp_files, lvp_entrypoints, sha1_h], + [liblvp_files, lvp_entrypoints, lvp_commands, sha1_h], link_with : [ libvulkan_wsi ], c_args : [ lvp_flags ], gnu_symbol_visibility : 'hidden',