From e94fd4cc65899bccceb4642363bc4376c6831580 Mon Sep 17 00:00:00 2001 From: Dave Airlie Date: Wed, 30 Sep 2020 05:29:04 +1000 Subject: [PATCH] lavapipe: rename vallium to lavapipe MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit Just a cooler name, and a lot easier to search for. thanks Marek Acked-by: Marek Olšák Part-of: --- .../val_cmd_buffer.c => lavapipe/lvp_cmd_buffer.c} | 584 +++++++++---------- .../{vallium/val_conv.h => lavapipe/lvp_conv.h} | 0 .../lvp_descriptor_set.c} | 164 +++--- .../val_device.c => lavapipe/lvp_device.c} | 450 +++++++-------- .../lvp_entrypoints_gen.py} | 102 ++-- .../val_execute.c => lavapipe/lvp_execute.c} | 374 ++++++------ .../lvp_extensions.py} | 12 +- .../val_formats.c => lavapipe/lvp_formats.c} | 36 +- .../{vallium/val_image.c => lavapipe/lvp_image.c} | 76 +-- .../lvp_lower_input_attachments.c} | 4 +- .../lvp_lower_vulkan_resource.c} | 20 +- .../lvp_lower_vulkan_resource.h} | 14 +- .../{vallium/val_pass.c => lavapipe/lvp_pass.c} | 66 +-- .../val_pipeline.c => lavapipe/lvp_pipeline.c} | 106 ++-- .../lvp_pipeline_cache.c} | 24 +- .../val_private.h => lavapipe/lvp_private.h} | 640 ++++++++++----------- .../{vallium/val_query.c => lavapipe/lvp_query.c} | 24 +- .../{vallium/val_util.c => lavapipe/lvp_util.c} | 8 +- .../{vallium/val_wsi.c => lavapipe/lvp_wsi.c} | 80 +-- .../{vallium/val_wsi.h => lavapipe/lvp_wsi.h} | 44 +- .../lvp_wsi_wayland.c} | 10 +- .../val_wsi_x11.c => lavapipe/lvp_wsi_x11.c} | 18 +- src/gallium/frontends/lavapipe/meson.build | 66 +++ src/gallium/frontends/vallium/meson.build | 66 --- src/gallium/meson.build | 4 +- .../{vallium/val_icd.py => lavapipe/lvp_icd.py} | 4 +- .../targets/{vallium => lavapipe}/meson.build | 16 +- src/gallium/targets/{vallium => lavapipe}/target.c | 0 28 files changed, 1506 insertions(+), 1506 deletions(-) rename src/gallium/frontends/{vallium/val_cmd_buffer.c => lavapipe/lvp_cmd_buffer.c} (70%) rename src/gallium/frontends/{vallium/val_conv.h => lavapipe/lvp_conv.h} (100%) rename src/gallium/frontends/{vallium/val_descriptor_set.c => lavapipe/lvp_descriptor_set.c} (78%) rename src/gallium/frontends/{vallium/val_device.c => lavapipe/lvp_device.c} (83%) rename src/gallium/frontends/{vallium/val_entrypoints_gen.py => lavapipe/lvp_entrypoints_gen.py} (88%) rename src/gallium/frontends/{vallium/val_execute.c => lavapipe/lvp_execute.c} (90%) rename src/gallium/frontends/{vallium/val_extensions.py => lavapipe/lvp_extensions.py} (94%) rename src/gallium/frontends/{vallium/val_formats.c => lavapipe/lvp_formats.c} (93%) rename src/gallium/frontends/{vallium/val_image.c => lavapipe/lvp_image.c} (83%) rename src/gallium/frontends/{vallium/val_lower_input_attachments.c => lavapipe/lvp_lower_input_attachments.c} (97%) rename src/gallium/frontends/{vallium/val_lower_vulkan_resource.c => lavapipe/lvp_lower_vulkan_resource.c} (94%) rename src/gallium/frontends/{vallium/val_lower_vulkan_resource.h => lavapipe/lvp_lower_vulkan_resource.h} (79%) rename src/gallium/frontends/{vallium/val_pass.c => lavapipe/lvp_pass.c} (84%) rename src/gallium/frontends/{vallium/val_pipeline.c => lavapipe/lvp_pipeline.c} (92%) rename src/gallium/frontends/{vallium/val_pipeline_cache.c => lavapipe/lvp_pipeline_cache.c} (86%) rename src/gallium/frontends/{vallium/val_private.h => lavapipe/lvp_private.h} (55%) rename src/gallium/frontends/{vallium/val_query.c => lavapipe/lvp_query.c} (90%) rename src/gallium/frontends/{vallium/val_util.c => lavapipe/lvp_util.c} (91%) rename src/gallium/frontends/{vallium/val_wsi.c => lavapipe/lvp_wsi.c} (80%) rename src/gallium/frontends/{vallium/val_wsi.h => lavapipe/lvp_wsi.h} (67%) rename src/gallium/frontends/{vallium/val_wsi_wayland.c => lavapipe/lvp_wsi_wayland.c} (89%) rename src/gallium/frontends/{vallium/val_wsi_x11.c => lavapipe/lvp_wsi_x11.c} (87%) create mode 100644 src/gallium/frontends/lavapipe/meson.build delete mode 100644 src/gallium/frontends/vallium/meson.build rename src/gallium/targets/{vallium/val_icd.py => lavapipe/lvp_icd.py} (94%) rename src/gallium/targets/{vallium => lavapipe}/meson.build (71%) rename src/gallium/targets/{vallium => lavapipe}/target.c (100%) diff --git a/src/gallium/frontends/vallium/val_cmd_buffer.c b/src/gallium/frontends/lavapipe/lvp_cmd_buffer.c similarity index 70% rename from src/gallium/frontends/vallium/val_cmd_buffer.c rename to src/gallium/frontends/lavapipe/lvp_cmd_buffer.c index fd0f8cd..71a2820 100644 --- a/src/gallium/frontends/vallium/val_cmd_buffer.c +++ b/src/gallium/frontends/lavapipe/lvp_cmd_buffer.c @@ -21,16 +21,16 @@ * IN THE SOFTWARE. */ -#include "val_private.h" +#include "lvp_private.h" #include "pipe/p_context.h" -static VkResult val_create_cmd_buffer( - struct val_device * device, - struct val_cmd_pool * pool, +static VkResult lvp_create_cmd_buffer( + struct lvp_device * device, + struct lvp_cmd_pool * pool, VkCommandBufferLevel level, VkCommandBuffer* pCommandBuffer) { - struct val_cmd_buffer *cmd_buffer; + struct lvp_cmd_buffer *cmd_buffer; cmd_buffer = vk_alloc(&pool->alloc, sizeof(*cmd_buffer), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); @@ -42,7 +42,7 @@ static VkResult val_create_cmd_buffer( cmd_buffer->device = device; cmd_buffer->pool = pool; list_inithead(&cmd_buffer->cmds); - cmd_buffer->status = VAL_CMD_BUFFER_STATUS_INITIAL; + cmd_buffer->status = LVP_CMD_BUFFER_STATUS_INITIAL; if (pool) { list_addtail(&cmd_buffer->pool_link, &pool->cmd_buffers); } else { @@ -51,36 +51,36 @@ static VkResult val_create_cmd_buffer( */ list_inithead(&cmd_buffer->pool_link); } - *pCommandBuffer = val_cmd_buffer_to_handle(cmd_buffer); + *pCommandBuffer = lvp_cmd_buffer_to_handle(cmd_buffer); return VK_SUCCESS; } static void -val_cmd_buffer_free_all_cmds(struct val_cmd_buffer *cmd_buffer) +lvp_cmd_buffer_free_all_cmds(struct lvp_cmd_buffer *cmd_buffer) { - struct val_cmd_buffer_entry *tmp, *cmd; + 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 val_reset_cmd_buffer(struct val_cmd_buffer *cmd_buffer) +static VkResult lvp_reset_cmd_buffer(struct lvp_cmd_buffer *cmd_buffer) { - val_cmd_buffer_free_all_cmds(cmd_buffer); + lvp_cmd_buffer_free_all_cmds(cmd_buffer); list_inithead(&cmd_buffer->cmds); - cmd_buffer->status = VAL_CMD_BUFFER_STATUS_INITIAL; + cmd_buffer->status = LVP_CMD_BUFFER_STATUS_INITIAL; return VK_SUCCESS; } -VkResult val_AllocateCommandBuffers( +VkResult lvp_AllocateCommandBuffers( VkDevice _device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_cmd_pool, pool, pAllocateInfo->commandPool); + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_cmd_pool, pool, pAllocateInfo->commandPool); VkResult result = VK_SUCCESS; uint32_t i; @@ -88,17 +88,17 @@ VkResult val_AllocateCommandBuffers( for (i = 0; i < pAllocateInfo->commandBufferCount; i++) { if (!list_is_empty(&pool->free_cmd_buffers)) { - struct val_cmd_buffer *cmd_buffer = list_first_entry(&pool->free_cmd_buffers, struct val_cmd_buffer, pool_link); + struct lvp_cmd_buffer *cmd_buffer = list_first_entry(&pool->free_cmd_buffers, struct lvp_cmd_buffer, pool_link); list_del(&cmd_buffer->pool_link); list_addtail(&cmd_buffer->pool_link, &pool->cmd_buffers); - result = val_reset_cmd_buffer(cmd_buffer); + result = lvp_reset_cmd_buffer(cmd_buffer); cmd_buffer->level = pAllocateInfo->level; - pCommandBuffers[i] = val_cmd_buffer_to_handle(cmd_buffer); + pCommandBuffers[i] = lvp_cmd_buffer_to_handle(cmd_buffer); } else { - result = val_create_cmd_buffer(device, pool, pAllocateInfo->level, + result = lvp_create_cmd_buffer(device, pool, pAllocateInfo->level, &pCommandBuffers[i]); if (result != VK_SUCCESS) break; @@ -106,7 +106,7 @@ VkResult val_AllocateCommandBuffers( } if (result != VK_SUCCESS) { - val_FreeCommandBuffers(_device, pAllocateInfo->commandPool, + lvp_FreeCommandBuffers(_device, pAllocateInfo->commandPool, i, pCommandBuffers); memset(pCommandBuffers, 0, sizeof(*pCommandBuffers) * pAllocateInfo->commandBufferCount); @@ -116,73 +116,73 @@ VkResult val_AllocateCommandBuffers( } static void -val_cmd_buffer_destroy(struct val_cmd_buffer *cmd_buffer) +lvp_cmd_buffer_destroy(struct lvp_cmd_buffer *cmd_buffer) { - val_cmd_buffer_free_all_cmds(cmd_buffer); + lvp_cmd_buffer_free_all_cmds(cmd_buffer); list_del(&cmd_buffer->pool_link); vk_object_base_finish(&cmd_buffer->base); vk_free(&cmd_buffer->pool->alloc, cmd_buffer); } -void val_FreeCommandBuffers( +void lvp_FreeCommandBuffers( VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) { for (uint32_t i = 0; i < commandBufferCount; i++) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, pCommandBuffers[i]); + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, pCommandBuffers[i]); if (cmd_buffer) { if (cmd_buffer->pool) { list_del(&cmd_buffer->pool_link); list_addtail(&cmd_buffer->pool_link, &cmd_buffer->pool->free_cmd_buffers); } else - val_cmd_buffer_destroy(cmd_buffer); + lvp_cmd_buffer_destroy(cmd_buffer); } } } -VkResult val_ResetCommandBuffer( +VkResult lvp_ResetCommandBuffer( VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); - return val_reset_cmd_buffer(cmd_buffer); + return lvp_reset_cmd_buffer(cmd_buffer); } -VkResult val_BeginCommandBuffer( +VkResult lvp_BeginCommandBuffer( VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); VkResult result; - if (cmd_buffer->status != VAL_CMD_BUFFER_STATUS_INITIAL) { - result = val_reset_cmd_buffer(cmd_buffer); + if (cmd_buffer->status != LVP_CMD_BUFFER_STATUS_INITIAL) { + result = lvp_reset_cmd_buffer(cmd_buffer); if (result != VK_SUCCESS) return result; } - cmd_buffer->status = VAL_CMD_BUFFER_STATUS_RECORDING; + cmd_buffer->status = LVP_CMD_BUFFER_STATUS_RECORDING; return VK_SUCCESS; } -VkResult val_EndCommandBuffer( +VkResult lvp_EndCommandBuffer( VkCommandBuffer commandBuffer) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - cmd_buffer->status = VAL_CMD_BUFFER_STATUS_EXECUTABLE; + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); + cmd_buffer->status = LVP_CMD_BUFFER_STATUS_EXECUTABLE; return VK_SUCCESS; } -VkResult val_CreateCommandPool( +VkResult lvp_CreateCommandPool( VkDevice _device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCmdPool) { - VAL_FROM_HANDLE(val_device, device, _device); - struct val_cmd_pool *pool; + LVP_FROM_HANDLE(lvp_device, device, _device); + struct lvp_cmd_pool *pool; pool = vk_alloc2(&device->alloc, pAllocator, sizeof(*pool), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); @@ -199,74 +199,74 @@ VkResult val_CreateCommandPool( list_inithead(&pool->cmd_buffers); list_inithead(&pool->free_cmd_buffers); - *pCmdPool = val_cmd_pool_to_handle(pool); + *pCmdPool = lvp_cmd_pool_to_handle(pool); return VK_SUCCESS; } -void val_DestroyCommandPool( +void lvp_DestroyCommandPool( VkDevice _device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_cmd_pool, pool, commandPool); + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_cmd_pool, pool, commandPool); if (!pool) return; - list_for_each_entry_safe(struct val_cmd_buffer, cmd_buffer, + list_for_each_entry_safe(struct lvp_cmd_buffer, cmd_buffer, &pool->cmd_buffers, pool_link) { - val_cmd_buffer_destroy(cmd_buffer); + lvp_cmd_buffer_destroy(cmd_buffer); } - list_for_each_entry_safe(struct val_cmd_buffer, cmd_buffer, + list_for_each_entry_safe(struct lvp_cmd_buffer, cmd_buffer, &pool->free_cmd_buffers, pool_link) { - val_cmd_buffer_destroy(cmd_buffer); + lvp_cmd_buffer_destroy(cmd_buffer); } vk_object_base_finish(&pool->base); vk_free2(&device->alloc, pAllocator, pool); } -VkResult val_ResetCommandPool( +VkResult lvp_ResetCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) { - VAL_FROM_HANDLE(val_cmd_pool, pool, commandPool); + LVP_FROM_HANDLE(lvp_cmd_pool, pool, commandPool); VkResult result; - list_for_each_entry(struct val_cmd_buffer, cmd_buffer, + list_for_each_entry(struct lvp_cmd_buffer, cmd_buffer, &pool->cmd_buffers, pool_link) { - result = val_reset_cmd_buffer(cmd_buffer); + result = lvp_reset_cmd_buffer(cmd_buffer); if (result != VK_SUCCESS) return result; } return VK_SUCCESS; } -void val_TrimCommandPool( +void lvp_TrimCommandPool( VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) { - VAL_FROM_HANDLE(val_cmd_pool, pool, commandPool); + LVP_FROM_HANDLE(lvp_cmd_pool, pool, commandPool); if (!pool) return; - list_for_each_entry_safe(struct val_cmd_buffer, cmd_buffer, + list_for_each_entry_safe(struct lvp_cmd_buffer, cmd_buffer, &pool->free_cmd_buffers, pool_link) { - val_cmd_buffer_destroy(cmd_buffer); + lvp_cmd_buffer_destroy(cmd_buffer); } } -static struct val_cmd_buffer_entry *cmd_buf_entry_alloc_size(struct val_cmd_buffer *cmd_buffer, +static struct lvp_cmd_buffer_entry *cmd_buf_entry_alloc_size(struct lvp_cmd_buffer *cmd_buffer, uint32_t extra_size, - enum val_cmds type) + enum lvp_cmds type) { - struct val_cmd_buffer_entry *cmd; + struct lvp_cmd_buffer_entry *cmd; uint32_t cmd_size = sizeof(*cmd) + extra_size; cmd = vk_alloc(&cmd_buffer->pool->alloc, cmd_size, @@ -278,25 +278,25 @@ static struct val_cmd_buffer_entry *cmd_buf_entry_alloc_size(struct val_cmd_buff return cmd; } -static struct val_cmd_buffer_entry *cmd_buf_entry_alloc(struct val_cmd_buffer *cmd_buffer, - enum val_cmds type) +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 val_cmd_buffer *cmd_buffer, - struct val_cmd_buffer_entry *cmd) +static void cmd_buf_queue(struct lvp_cmd_buffer *cmd_buffer, + struct lvp_cmd_buffer_entry *cmd) { list_addtail(&cmd->cmd_link, &cmd_buffer->cmds); } static void -state_setup_attachments(struct val_attachment_state *attachments, - struct val_render_pass *pass, +state_setup_attachments(struct lvp_attachment_state *attachments, + struct lvp_render_pass *pass, const VkClearValue *clear_values) { for (uint32_t i = 0; i < pass->attachment_count; ++i) { - struct val_render_pass_attachment *att = &pass->attachments[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) { @@ -324,18 +324,18 @@ state_setup_attachments(struct val_attachment_state *attachments, } } -void val_CmdBeginRenderPass( +void lvp_CmdBeginRenderPass( VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - VAL_FROM_HANDLE(val_render_pass, pass, pRenderPassBegin->renderPass); - VAL_FROM_HANDLE(val_framebuffer, framebuffer, pRenderPassBegin->framebuffer); - struct val_cmd_buffer_entry *cmd; - uint32_t cmd_size = pass->attachment_count * sizeof(struct val_attachment_state); + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); + LVP_FROM_HANDLE(lvp_render_pass, pass, pRenderPassBegin->renderPass); + LVP_FROM_HANDLE(lvp_framebuffer, framebuffer, pRenderPassBegin->framebuffer); + struct lvp_cmd_buffer_entry *cmd; + uint32_t cmd_size = pass->attachment_count * sizeof(struct lvp_attachment_state); - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, VAL_CMD_BEGIN_RENDER_PASS); + cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_BEGIN_RENDER_PASS); if (!cmd) return; @@ -343,20 +343,20 @@ void val_CmdBeginRenderPass( cmd->u.begin_render_pass.framebuffer = framebuffer; cmd->u.begin_render_pass.render_area = pRenderPassBegin->renderArea; - cmd->u.begin_render_pass.attachments = (struct val_attachment_state *)(cmd + 1); + cmd->u.begin_render_pass.attachments = (struct lvp_attachment_state *)(cmd + 1); state_setup_attachments(cmd->u.begin_render_pass.attachments, pass, pRenderPassBegin->pClearValues); cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdNextSubpass( +void lvp_CmdNextSubpass( VkCommandBuffer commandBuffer, VkSubpassContents contents) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - struct val_cmd_buffer_entry *cmd; + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); + struct lvp_cmd_buffer_entry *cmd; - cmd = cmd_buf_entry_alloc(cmd_buffer, VAL_CMD_NEXT_SUBPASS); + cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_NEXT_SUBPASS); if (!cmd) return; @@ -365,31 +365,31 @@ void val_CmdNextSubpass( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdBindVertexBuffers( +void lvp_CmdBindVertexBuffers( VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - struct val_cmd_buffer_entry *cmd; - struct val_buffer **buffers; + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); + struct lvp_cmd_buffer_entry *cmd; + struct lvp_buffer **buffers; VkDeviceSize *offsets; int i; - uint32_t cmd_size = bindingCount * sizeof(struct val_buffer *) + bindingCount * sizeof(VkDeviceSize); + uint32_t cmd_size = bindingCount * sizeof(struct lvp_buffer *) + bindingCount * sizeof(VkDeviceSize); - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, VAL_CMD_BIND_VERTEX_BUFFERS); + 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 val_buffer **)(cmd + 1); + buffers = (struct lvp_buffer **)(cmd + 1); offsets = (VkDeviceSize *)(buffers + bindingCount); for (i = 0; i < bindingCount; i++) { - buffers[i] = val_buffer_from_handle(pBuffers[i]); + buffers[i] = lvp_buffer_from_handle(pBuffers[i]); offsets[i] = pOffsets[i]; } cmd->u.vertex_buffers.buffers = buffers; @@ -398,16 +398,16 @@ void val_CmdBindVertexBuffers( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdBindPipeline( +void lvp_CmdBindPipeline( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline _pipeline) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - VAL_FROM_HANDLE(val_pipeline, pipeline, _pipeline); - struct val_cmd_buffer_entry *cmd; + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); + LVP_FROM_HANDLE(lvp_pipeline, pipeline, _pipeline); + struct lvp_cmd_buffer_entry *cmd; - cmd = cmd_buf_entry_alloc(cmd_buffer, VAL_CMD_BIND_PIPELINE); + cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_BIND_PIPELINE); if (!cmd) return; @@ -417,7 +417,7 @@ void val_CmdBindPipeline( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdBindDescriptorSets( +void lvp_CmdBindDescriptorSets( VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout _layout, @@ -427,15 +427,15 @@ void val_CmdBindDescriptorSets( uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - VAL_FROM_HANDLE(val_pipeline_layout, layout, _layout); - struct val_cmd_buffer_entry *cmd; - struct val_descriptor_set **sets; + 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 val_descriptor_set *) + dynamicOffsetCount * sizeof(uint32_t); + uint32_t cmd_size = descriptorSetCount * sizeof(struct lvp_descriptor_set *) + dynamicOffsetCount * sizeof(uint32_t); - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, VAL_CMD_BIND_DESCRIPTOR_SETS); + cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_BIND_DESCRIPTOR_SETS); if (!cmd) return; @@ -444,9 +444,9 @@ void val_CmdBindDescriptorSets( cmd->u.descriptor_sets.first = firstSet; cmd->u.descriptor_sets.count = descriptorSetCount; - sets = (struct val_descriptor_set **)(cmd + 1); + sets = (struct lvp_descriptor_set **)(cmd + 1); for (i = 0; i < descriptorSetCount; i++) { - sets[i] = val_descriptor_set_from_handle(pDescriptorSets[i]); + sets[i] = lvp_descriptor_set_from_handle(pDescriptorSets[i]); } cmd->u.descriptor_sets.sets = sets; @@ -459,17 +459,17 @@ void val_CmdBindDescriptorSets( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdDraw( +void lvp_CmdDraw( VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - struct val_cmd_buffer_entry *cmd; + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); + struct lvp_cmd_buffer_entry *cmd; - cmd = cmd_buf_entry_alloc(cmd_buffer, VAL_CMD_DRAW); + cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_DRAW); if (!cmd) return; @@ -481,30 +481,30 @@ void val_CmdDraw( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdEndRenderPass( +void lvp_CmdEndRenderPass( VkCommandBuffer commandBuffer) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - struct val_cmd_buffer_entry *cmd; + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); + struct lvp_cmd_buffer_entry *cmd; - cmd = cmd_buf_entry_alloc(cmd_buffer, VAL_CMD_END_RENDER_PASS); + cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_END_RENDER_PASS); if (!cmd) return; cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdSetViewport( +void lvp_CmdSetViewport( VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - struct val_cmd_buffer_entry *cmd; + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); + struct lvp_cmd_buffer_entry *cmd; int i; - cmd = cmd_buf_entry_alloc(cmd_buffer, VAL_CMD_SET_VIEWPORT); + cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_VIEWPORT); if (!cmd) return; @@ -516,17 +516,17 @@ void val_CmdSetViewport( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdSetScissor( +void lvp_CmdSetScissor( VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - struct val_cmd_buffer_entry *cmd; + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); + struct lvp_cmd_buffer_entry *cmd; int i; - cmd = cmd_buf_entry_alloc(cmd_buffer, VAL_CMD_SET_SCISSOR); + cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_SCISSOR); if (!cmd) return; @@ -538,14 +538,14 @@ void val_CmdSetScissor( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdSetLineWidth( +void lvp_CmdSetLineWidth( VkCommandBuffer commandBuffer, float lineWidth) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - struct val_cmd_buffer_entry *cmd; + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); + struct lvp_cmd_buffer_entry *cmd; - cmd = cmd_buf_entry_alloc(cmd_buffer, VAL_CMD_SET_LINE_WIDTH); + cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_LINE_WIDTH); if (!cmd) return; @@ -554,16 +554,16 @@ void val_CmdSetLineWidth( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdSetDepthBias( +void lvp_CmdSetDepthBias( VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - struct val_cmd_buffer_entry *cmd; + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); + struct lvp_cmd_buffer_entry *cmd; - cmd = cmd_buf_entry_alloc(cmd_buffer, VAL_CMD_SET_DEPTH_BIAS); + cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_DEPTH_BIAS); if (!cmd) return; @@ -574,14 +574,14 @@ void val_CmdSetDepthBias( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdSetBlendConstants( +void lvp_CmdSetBlendConstants( VkCommandBuffer commandBuffer, const float blendConstants[4]) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - struct val_cmd_buffer_entry *cmd; + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); + struct lvp_cmd_buffer_entry *cmd; - cmd = cmd_buf_entry_alloc(cmd_buffer, VAL_CMD_SET_BLEND_CONSTANTS); + cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_BLEND_CONSTANTS); if (!cmd) return; @@ -590,15 +590,15 @@ void val_CmdSetBlendConstants( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdSetDepthBounds( +void lvp_CmdSetDepthBounds( VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - struct val_cmd_buffer_entry *cmd; + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); + struct lvp_cmd_buffer_entry *cmd; - cmd = cmd_buf_entry_alloc(cmd_buffer, VAL_CMD_SET_DEPTH_BOUNDS); + cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_DEPTH_BOUNDS); if (!cmd) return; @@ -608,15 +608,15 @@ void val_CmdSetDepthBounds( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdSetStencilCompareMask( +void lvp_CmdSetStencilCompareMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - struct val_cmd_buffer_entry *cmd; + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); + struct lvp_cmd_buffer_entry *cmd; - cmd = cmd_buf_entry_alloc(cmd_buffer, VAL_CMD_SET_STENCIL_COMPARE_MASK); + cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_STENCIL_COMPARE_MASK); if (!cmd) return; @@ -626,15 +626,15 @@ void val_CmdSetStencilCompareMask( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdSetStencilWriteMask( +void lvp_CmdSetStencilWriteMask( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - struct val_cmd_buffer_entry *cmd; + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); + struct lvp_cmd_buffer_entry *cmd; - cmd = cmd_buf_entry_alloc(cmd_buffer, VAL_CMD_SET_STENCIL_WRITE_MASK); + cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_STENCIL_WRITE_MASK); if (!cmd) return; @@ -645,15 +645,15 @@ void val_CmdSetStencilWriteMask( } -void val_CmdSetStencilReference( +void lvp_CmdSetStencilReference( VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - struct val_cmd_buffer_entry *cmd; + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); + struct lvp_cmd_buffer_entry *cmd; - cmd = cmd_buf_entry_alloc(cmd_buffer, VAL_CMD_SET_STENCIL_REFERENCE); + cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_STENCIL_REFERENCE); if (!cmd) return; @@ -663,7 +663,7 @@ void val_CmdSetStencilReference( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdPushConstants( +void lvp_CmdPushConstants( VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, @@ -671,10 +671,10 @@ void val_CmdPushConstants( uint32_t size, const void* pValues) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - struct val_cmd_buffer_entry *cmd; + 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), VAL_CMD_PUSH_CONSTANTS); + cmd = cmd_buf_entry_alloc_size(cmd_buffer, (size - 4), LVP_CMD_PUSH_CONSTANTS); if (!cmd) return; @@ -686,17 +686,17 @@ void val_CmdPushConstants( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdBindIndexBuffer( +void lvp_CmdBindIndexBuffer( VkCommandBuffer commandBuffer, VkBuffer _buffer, VkDeviceSize offset, VkIndexType indexType) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - VAL_FROM_HANDLE(val_buffer, buffer, _buffer); - struct val_cmd_buffer_entry *cmd; + 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, VAL_CMD_BIND_INDEX_BUFFER); + cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_BIND_INDEX_BUFFER); if (!cmd) return; @@ -707,7 +707,7 @@ void val_CmdBindIndexBuffer( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdDrawIndexed( +void lvp_CmdDrawIndexed( VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, @@ -715,10 +715,10 @@ void val_CmdDrawIndexed( int32_t vertexOffset, uint32_t firstInstance) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - struct val_cmd_buffer_entry *cmd; + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); + struct lvp_cmd_buffer_entry *cmd; - cmd = cmd_buf_entry_alloc(cmd_buffer, VAL_CMD_DRAW_INDEXED); + cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_DRAW_INDEXED); if (!cmd) return; @@ -731,18 +731,18 @@ void val_CmdDrawIndexed( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdDrawIndirect( +void lvp_CmdDrawIndirect( VkCommandBuffer commandBuffer, VkBuffer _buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - VAL_FROM_HANDLE(val_buffer, buf, _buffer); - struct val_cmd_buffer_entry *cmd; + 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, VAL_CMD_DRAW_INDIRECT); + cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_DRAW_INDIRECT); if (!cmd) return; @@ -754,18 +754,18 @@ void val_CmdDrawIndirect( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdDrawIndexedIndirect( +void lvp_CmdDrawIndexedIndirect( VkCommandBuffer commandBuffer, VkBuffer _buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - VAL_FROM_HANDLE(val_buffer, buf, _buffer); - struct val_cmd_buffer_entry *cmd; + 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, VAL_CMD_DRAW_INDEXED_INDIRECT); + cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_DRAW_INDEXED_INDIRECT); if (!cmd) return; @@ -777,16 +777,16 @@ void val_CmdDrawIndexedIndirect( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdDispatch( +void lvp_CmdDispatch( VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - struct val_cmd_buffer_entry *cmd; + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); + struct lvp_cmd_buffer_entry *cmd; - cmd = cmd_buf_entry_alloc(cmd_buffer, VAL_CMD_DISPATCH); + cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_DISPATCH); if (!cmd) return; @@ -797,53 +797,53 @@ void val_CmdDispatch( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdDispatchIndirect( +void lvp_CmdDispatchIndirect( VkCommandBuffer commandBuffer, VkBuffer _buffer, VkDeviceSize offset) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - struct val_cmd_buffer_entry *cmd; + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); + struct lvp_cmd_buffer_entry *cmd; - cmd = cmd_buf_entry_alloc(cmd_buffer, VAL_CMD_DISPATCH_INDIRECT); + cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_DISPATCH_INDIRECT); if (!cmd) return; - cmd->u.dispatch_indirect.buffer = val_buffer_from_handle(_buffer); + cmd->u.dispatch_indirect.buffer = lvp_buffer_from_handle(_buffer); cmd->u.dispatch_indirect.offset = offset; cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdExecuteCommands( +void lvp_CmdExecuteCommands( VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCmdBuffers) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - struct val_cmd_buffer_entry *cmd; - uint32_t cmd_size = commandBufferCount * sizeof(struct val_cmd_buffer *); + 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, VAL_CMD_EXECUTE_COMMANDS); + 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] = val_cmd_buffer_from_handle(pCmdBuffers[i]); + cmd->u.execute_commands.cmd_buffers[i] = lvp_cmd_buffer_from_handle(pCmdBuffers[i]); cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdSetEvent(VkCommandBuffer commandBuffer, +void lvp_CmdSetEvent(VkCommandBuffer commandBuffer, VkEvent _event, VkPipelineStageFlags stageMask) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - VAL_FROM_HANDLE(val_event, event, _event); - struct val_cmd_buffer_entry *cmd; + 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, VAL_CMD_SET_EVENT); + cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_EVENT); if (!cmd) return; @@ -854,15 +854,15 @@ void val_CmdSetEvent(VkCommandBuffer commandBuffer, cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdResetEvent(VkCommandBuffer commandBuffer, +void lvp_CmdResetEvent(VkCommandBuffer commandBuffer, VkEvent _event, VkPipelineStageFlags stageMask) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - VAL_FROM_HANDLE(val_event, event, _event); - struct val_cmd_buffer_entry *cmd; + 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, VAL_CMD_SET_EVENT); + cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_SET_EVENT); if (!cmd) return; @@ -874,7 +874,7 @@ void val_CmdResetEvent(VkCommandBuffer commandBuffer, } -void val_CmdWaitEvents(VkCommandBuffer commandBuffer, +void lvp_CmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, @@ -886,25 +886,25 @@ void val_CmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - struct val_cmd_buffer_entry *cmd; + 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 val_event *); + 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, VAL_CMD_WAIT_EVENTS); + 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 val_event **)(cmd + 1); + cmd->u.wait_events.events = (struct lvp_event **)(cmd + 1); for (unsigned i = 0; i < eventCount; i++) - cmd->u.wait_events.events[i] = val_event_from_handle(pEvents[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; @@ -914,7 +914,7 @@ void val_CmdWaitEvents(VkCommandBuffer commandBuffer, } -void val_CmdCopyBufferToImage( +void lvp_CmdCopyBufferToImage( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage destImage, @@ -922,13 +922,13 @@ void val_CmdCopyBufferToImage( uint32_t regionCount, const VkBufferImageCopy* pRegions) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - VAL_FROM_HANDLE(val_buffer, src_buffer, srcBuffer); - VAL_FROM_HANDLE(val_image, dst_image, destImage); - struct val_cmd_buffer_entry *cmd; + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); + LVP_FROM_HANDLE(lvp_buffer, src_buffer, srcBuffer); + LVP_FROM_HANDLE(lvp_image, dst_image, destImage); + struct lvp_cmd_buffer_entry *cmd; uint32_t cmd_size = regionCount * sizeof(VkBufferImageCopy); - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, VAL_CMD_COPY_BUFFER_TO_IMAGE); + cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_COPY_BUFFER_TO_IMAGE); if (!cmd) return; @@ -948,7 +948,7 @@ void val_CmdCopyBufferToImage( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdCopyImageToBuffer( +void lvp_CmdCopyImageToBuffer( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, @@ -956,13 +956,13 @@ void val_CmdCopyImageToBuffer( uint32_t regionCount, const VkBufferImageCopy* pRegions) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - VAL_FROM_HANDLE(val_image, src_image, srcImage); - VAL_FROM_HANDLE(val_buffer, dst_buffer, destBuffer); - struct val_cmd_buffer_entry *cmd; + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); + LVP_FROM_HANDLE(lvp_image, src_image, srcImage); + LVP_FROM_HANDLE(lvp_buffer, dst_buffer, destBuffer); + struct lvp_cmd_buffer_entry *cmd; uint32_t cmd_size = regionCount * sizeof(VkBufferImageCopy); - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, VAL_CMD_COPY_IMAGE_TO_BUFFER); + cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_COPY_IMAGE_TO_BUFFER); if (!cmd) return; @@ -982,7 +982,7 @@ void val_CmdCopyImageToBuffer( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdCopyImage( +void lvp_CmdCopyImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, @@ -991,13 +991,13 @@ void val_CmdCopyImage( uint32_t regionCount, const VkImageCopy* pRegions) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - VAL_FROM_HANDLE(val_image, src_image, srcImage); - VAL_FROM_HANDLE(val_image, dest_image, destImage); - struct val_cmd_buffer_entry *cmd; + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); + LVP_FROM_HANDLE(lvp_image, src_image, srcImage); + LVP_FROM_HANDLE(lvp_image, dest_image, destImage); + struct lvp_cmd_buffer_entry *cmd; uint32_t cmd_size = regionCount * sizeof(VkImageCopy); - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, VAL_CMD_COPY_IMAGE); + cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_COPY_IMAGE); if (!cmd) return; @@ -1019,20 +1019,20 @@ void val_CmdCopyImage( } -void val_CmdCopyBuffer( +void lvp_CmdCopyBuffer( VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - VAL_FROM_HANDLE(val_buffer, src_buffer, srcBuffer); - VAL_FROM_HANDLE(val_buffer, dest_buffer, destBuffer); - struct val_cmd_buffer_entry *cmd; + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); + LVP_FROM_HANDLE(lvp_buffer, src_buffer, srcBuffer); + LVP_FROM_HANDLE(lvp_buffer, dest_buffer, destBuffer); + struct lvp_cmd_buffer_entry *cmd; uint32_t cmd_size = regionCount * sizeof(VkBufferCopy); - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, VAL_CMD_COPY_BUFFER); + cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_COPY_BUFFER); if (!cmd) return; @@ -1051,7 +1051,7 @@ void val_CmdCopyBuffer( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdBlitImage( +void lvp_CmdBlitImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, @@ -1061,13 +1061,13 @@ void val_CmdBlitImage( const VkImageBlit* pRegions, VkFilter filter) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - VAL_FROM_HANDLE(val_image, src_image, srcImage); - VAL_FROM_HANDLE(val_image, dest_image, destImage); - struct val_cmd_buffer_entry *cmd; + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); + LVP_FROM_HANDLE(lvp_image, src_image, srcImage); + LVP_FROM_HANDLE(lvp_image, dest_image, destImage); + struct lvp_cmd_buffer_entry *cmd; uint32_t cmd_size = regionCount * sizeof(VkImageBlit); - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, VAL_CMD_BLIT_IMAGE); + cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_BLIT_IMAGE); if (!cmd) return; @@ -1089,18 +1089,18 @@ void val_CmdBlitImage( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdClearAttachments( +void lvp_CmdClearAttachments( VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - struct val_cmd_buffer_entry *cmd; + 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, VAL_CMD_CLEAR_ATTACHMENTS); + cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_CLEAR_ATTACHMENTS); if (!cmd) return; @@ -1116,18 +1116,18 @@ void val_CmdClearAttachments( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdFillBuffer( +void lvp_CmdFillBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize fillSize, uint32_t data) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - VAL_FROM_HANDLE(val_buffer, dst_buffer, dstBuffer); - struct val_cmd_buffer_entry *cmd; + 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, VAL_CMD_FILL_BUFFER); + cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_FILL_BUFFER); if (!cmd) return; @@ -1139,18 +1139,18 @@ void val_CmdFillBuffer( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdUpdateBuffer( +void lvp_CmdUpdateBuffer( VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - VAL_FROM_HANDLE(val_buffer, dst_buffer, dstBuffer); - struct val_cmd_buffer_entry *cmd; + 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, VAL_CMD_UPDATE_BUFFER); + cmd = cmd_buf_entry_alloc_size(cmd_buffer, dataSize, LVP_CMD_UPDATE_BUFFER); if (!cmd) return; @@ -1162,7 +1162,7 @@ void val_CmdUpdateBuffer( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdClearColorImage( +void lvp_CmdClearColorImage( VkCommandBuffer commandBuffer, VkImage image_h, VkImageLayout imageLayout, @@ -1170,12 +1170,12 @@ void val_CmdClearColorImage( uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - VAL_FROM_HANDLE(val_image, image, image_h); - struct val_cmd_buffer_entry *cmd; + 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, VAL_CMD_CLEAR_COLOR_IMAGE); + cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_CLEAR_COLOR_IMAGE); if (!cmd) return; @@ -1190,7 +1190,7 @@ void val_CmdClearColorImage( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdClearDepthStencilImage( +void lvp_CmdClearDepthStencilImage( VkCommandBuffer commandBuffer, VkImage image_h, VkImageLayout imageLayout, @@ -1198,12 +1198,12 @@ void val_CmdClearDepthStencilImage( uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - VAL_FROM_HANDLE(val_image, image, image_h); - struct val_cmd_buffer_entry *cmd; + 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, VAL_CMD_CLEAR_DEPTH_STENCIL_IMAGE); + cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_CLEAR_DEPTH_STENCIL_IMAGE); if (!cmd) return; @@ -1219,7 +1219,7 @@ void val_CmdClearDepthStencilImage( } -void val_CmdResolveImage( +void lvp_CmdResolveImage( VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, @@ -1228,13 +1228,13 @@ void val_CmdResolveImage( uint32_t regionCount, const VkImageResolve* regions) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - VAL_FROM_HANDLE(val_image, src_image, srcImage); - VAL_FROM_HANDLE(val_image, dst_image, destImage); - struct val_cmd_buffer_entry *cmd; + LVP_FROM_HANDLE(lvp_cmd_buffer, cmd_buffer, commandBuffer); + LVP_FROM_HANDLE(lvp_image, src_image, srcImage); + LVP_FROM_HANDLE(lvp_image, dst_image, destImage); + struct lvp_cmd_buffer_entry *cmd; uint32_t cmd_size = regionCount * sizeof(VkImageResolve); - cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, VAL_CMD_RESOLVE_IMAGE); + cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_RESOLVE_IMAGE); if (!cmd) return; @@ -1250,17 +1250,17 @@ void val_CmdResolveImage( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdResetQueryPool( +void lvp_CmdResetQueryPool( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - VAL_FROM_HANDLE(val_query_pool, query_pool, queryPool); - struct val_cmd_buffer_entry *cmd; + 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, VAL_CMD_RESET_QUERY_POOL); + cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_RESET_QUERY_POOL); if (!cmd) return; @@ -1271,18 +1271,18 @@ void val_CmdResetQueryPool( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdBeginQueryIndexedEXT( +void lvp_CmdBeginQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - VAL_FROM_HANDLE(val_query_pool, query_pool, queryPool); - struct val_cmd_buffer_entry *cmd; + 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, VAL_CMD_BEGIN_QUERY); + cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_BEGIN_QUERY); if (!cmd) return; @@ -1294,26 +1294,26 @@ void val_CmdBeginQueryIndexedEXT( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdBeginQuery( +void lvp_CmdBeginQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) { - val_CmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, 0); + lvp_CmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, 0); } -void val_CmdEndQueryIndexedEXT( +void lvp_CmdEndQueryIndexedEXT( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - VAL_FROM_HANDLE(val_query_pool, query_pool, queryPool); - struct val_cmd_buffer_entry *cmd; + 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, VAL_CMD_END_QUERY); + cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_END_QUERY); if (!cmd) return; @@ -1324,25 +1324,25 @@ void val_CmdEndQueryIndexedEXT( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdEndQuery( +void lvp_CmdEndQuery( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) { - val_CmdEndQueryIndexedEXT(commandBuffer, queryPool, query, 0); + lvp_CmdEndQueryIndexedEXT(commandBuffer, queryPool, query, 0); } -void val_CmdWriteTimestamp( +void lvp_CmdWriteTimestamp( VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - VAL_FROM_HANDLE(val_query_pool, query_pool, queryPool); - struct val_cmd_buffer_entry *cmd; + 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, VAL_CMD_WRITE_TIMESTAMP); + cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_WRITE_TIMESTAMP); if (!cmd) return; @@ -1353,7 +1353,7 @@ void val_CmdWriteTimestamp( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdCopyQueryPoolResults( +void lvp_CmdCopyQueryPoolResults( VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, @@ -1363,12 +1363,12 @@ void val_CmdCopyQueryPoolResults( VkDeviceSize stride, VkQueryResultFlags flags) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - VAL_FROM_HANDLE(val_query_pool, query_pool, queryPool); - VAL_FROM_HANDLE(val_buffer, buffer, dstBuffer); - struct val_cmd_buffer_entry *cmd; + 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, VAL_CMD_COPY_QUERY_POOL_RESULTS); + cmd = cmd_buf_entry_alloc(cmd_buffer, LVP_CMD_COPY_QUERY_POOL_RESULTS); if (!cmd) return; @@ -1383,7 +1383,7 @@ void val_CmdCopyQueryPoolResults( cmd_buf_queue(cmd_buffer, cmd); } -void val_CmdPipelineBarrier( +void lvp_CmdPipelineBarrier( VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, @@ -1395,15 +1395,15 @@ void val_CmdPipelineBarrier( uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) { - VAL_FROM_HANDLE(val_cmd_buffer, cmd_buffer, commandBuffer); - struct val_cmd_buffer_entry *cmd; + 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, VAL_CMD_PIPELINE_BARRIER); + cmd = cmd_buf_entry_alloc_size(cmd_buffer, cmd_size, LVP_CMD_PIPELINE_BARRIER); if (!cmd) return; diff --git a/src/gallium/frontends/vallium/val_conv.h b/src/gallium/frontends/lavapipe/lvp_conv.h similarity index 100% rename from src/gallium/frontends/vallium/val_conv.h rename to src/gallium/frontends/lavapipe/lvp_conv.h diff --git a/src/gallium/frontends/vallium/val_descriptor_set.c b/src/gallium/frontends/lavapipe/lvp_descriptor_set.c similarity index 78% rename from src/gallium/frontends/vallium/val_descriptor_set.c rename to src/gallium/frontends/lavapipe/lvp_descriptor_set.c index 82c1129..58eeac3 100644 --- a/src/gallium/frontends/vallium/val_descriptor_set.c +++ b/src/gallium/frontends/lavapipe/lvp_descriptor_set.c @@ -21,18 +21,18 @@ * IN THE SOFTWARE. */ -#include "val_private.h" +#include "lvp_private.h" #include "vk_util.h" #include "u_math.h" -VkResult val_CreateDescriptorSetLayout( +VkResult lvp_CreateDescriptorSetLayout( VkDevice _device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) { - VAL_FROM_HANDLE(val_device, device, _device); - struct val_descriptor_set_layout *set_layout; + LVP_FROM_HANDLE(lvp_device, device, _device); + struct lvp_descriptor_set_layout *set_layout; assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO); uint32_t max_binding = 0; @@ -43,9 +43,9 @@ VkResult val_CreateDescriptorSetLayout( immutable_sampler_count += pCreateInfo->pBindings[j].descriptorCount; } - size_t size = sizeof(struct val_descriptor_set_layout) + + size_t size = sizeof(struct lvp_descriptor_set_layout) + (max_binding + 1) * sizeof(set_layout->binding[0]) + - immutable_sampler_count * sizeof(struct val_sampler *); + immutable_sampler_count * sizeof(struct lvp_sampler *); set_layout = vk_zalloc2(&device->alloc, pAllocator, size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); @@ -55,8 +55,8 @@ VkResult val_CreateDescriptorSetLayout( vk_object_base_init(&device->vk, &set_layout->base, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT); /* We just allocate all the samplers at the end of the struct */ - struct val_sampler **samplers = - (struct val_sampler **)&set_layout->binding[max_binding + 1]; + struct lvp_sampler **samplers = + (struct lvp_sampler **)&set_layout->binding[max_binding + 1]; set_layout->binding_count = max_binding + 1; set_layout->shader_stages = 0; @@ -90,7 +90,7 @@ VkResult val_CreateDescriptorSetLayout( switch (binding->descriptorType) { case VK_DESCRIPTOR_TYPE_SAMPLER: case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: - val_foreach_stage(s, binding->stageFlags) { + lvp_foreach_stage(s, binding->stageFlags) { set_layout->binding[b].stage[s].sampler_index = set_layout->stage[s].sampler_count; set_layout->stage[s].sampler_count += binding->descriptorCount; } @@ -102,14 +102,14 @@ VkResult val_CreateDescriptorSetLayout( switch (binding->descriptorType) { case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: - val_foreach_stage(s, binding->stageFlags) { + lvp_foreach_stage(s, binding->stageFlags) { set_layout->binding[b].stage[s].const_buffer_index = set_layout->stage[s].const_buffer_count; set_layout->stage[s].const_buffer_count += binding->descriptorCount; } break; case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: - val_foreach_stage(s, binding->stageFlags) { + lvp_foreach_stage(s, binding->stageFlags) { set_layout->binding[b].stage[s].shader_buffer_index = set_layout->stage[s].shader_buffer_count; set_layout->stage[s].shader_buffer_count += binding->descriptorCount; } @@ -118,7 +118,7 @@ VkResult val_CreateDescriptorSetLayout( case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: - val_foreach_stage(s, binding->stageFlags) { + lvp_foreach_stage(s, binding->stageFlags) { set_layout->binding[b].stage[s].image_index = set_layout->stage[s].image_count; set_layout->stage[s].image_count += binding->descriptorCount; } @@ -126,7 +126,7 @@ VkResult val_CreateDescriptorSetLayout( case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: - val_foreach_stage(s, binding->stageFlags) { + lvp_foreach_stage(s, binding->stageFlags) { set_layout->binding[b].stage[s].sampler_view_index = set_layout->stage[s].sampler_view_count; set_layout->stage[s].sampler_view_count += binding->descriptorCount; } @@ -141,7 +141,7 @@ VkResult val_CreateDescriptorSetLayout( for (uint32_t i = 0; i < binding->descriptorCount; i++) set_layout->binding[b].immutable_samplers[i] = - val_sampler_from_handle(binding->pImmutableSamplers[i]); + lvp_sampler_from_handle(binding->pImmutableSamplers[i]); } else { set_layout->binding[b].immutable_samplers = NULL; } @@ -151,18 +151,18 @@ VkResult val_CreateDescriptorSetLayout( set_layout->dynamic_offset_count = dynamic_offset_count; - *pSetLayout = val_descriptor_set_layout_to_handle(set_layout); + *pSetLayout = lvp_descriptor_set_layout_to_handle(set_layout); return VK_SUCCESS; } -void val_DestroyDescriptorSetLayout( +void lvp_DestroyDescriptorSetLayout( VkDevice _device, VkDescriptorSetLayout _set_layout, const VkAllocationCallbacks* pAllocator) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_descriptor_set_layout, set_layout, _set_layout); + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_descriptor_set_layout, set_layout, _set_layout); if (!_set_layout) return; @@ -170,14 +170,14 @@ void val_DestroyDescriptorSetLayout( vk_free2(&device->alloc, pAllocator, set_layout); } -VkResult val_CreatePipelineLayout( +VkResult lvp_CreatePipelineLayout( VkDevice _device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) { - VAL_FROM_HANDLE(val_device, device, _device); - struct val_pipeline_layout *layout; + LVP_FROM_HANDLE(lvp_device, device, _device); + struct lvp_pipeline_layout *layout; assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO); @@ -191,7 +191,7 @@ VkResult val_CreatePipelineLayout( layout->num_sets = pCreateInfo->setLayoutCount; for (uint32_t set = 0; set < pCreateInfo->setLayoutCount; set++) { - VAL_FROM_HANDLE(val_descriptor_set_layout, set_layout, + LVP_FROM_HANDLE(lvp_descriptor_set_layout, set_layout, pCreateInfo->pSetLayouts[set]); layout->set[set].layout = set_layout; } @@ -203,18 +203,18 @@ VkResult val_CreatePipelineLayout( range->offset + range->size); } layout->push_constant_size = align(layout->push_constant_size, 16); - *pPipelineLayout = val_pipeline_layout_to_handle(layout); + *pPipelineLayout = lvp_pipeline_layout_to_handle(layout); return VK_SUCCESS; } -void val_DestroyPipelineLayout( +void lvp_DestroyPipelineLayout( VkDevice _device, VkPipelineLayout _pipelineLayout, const VkAllocationCallbacks* pAllocator) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_pipeline_layout, pipeline_layout, _pipelineLayout); + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_pipeline_layout, pipeline_layout, _pipelineLayout); if (!_pipelineLayout) return; @@ -223,11 +223,11 @@ void val_DestroyPipelineLayout( } VkResult -val_descriptor_set_create(struct val_device *device, - const struct val_descriptor_set_layout *layout, - struct val_descriptor_set **out_set) +lvp_descriptor_set_create(struct lvp_device *device, + const struct lvp_descriptor_set_layout *layout, + struct lvp_descriptor_set **out_set) { - struct val_descriptor_set *set; + struct lvp_descriptor_set *set; size_t size = sizeof(*set) + layout->size * sizeof(set->descriptors[0]); set = vk_alloc(&device->alloc /* XXX: Use the pool */, size, 8, @@ -245,7 +245,7 @@ val_descriptor_set_create(struct val_device *device, set->layout = layout; /* Go through and fill out immutable samplers if we have any */ - struct val_descriptor *desc = set->descriptors; + struct lvp_descriptor *desc = set->descriptors; for (uint32_t b = 0; b < layout->binding_count; b++) { if (layout->binding[b].immutable_samplers) { for (uint32_t i = 0; i < layout->binding[b].array_size; i++) @@ -260,62 +260,62 @@ val_descriptor_set_create(struct val_device *device, } void -val_descriptor_set_destroy(struct val_device *device, - struct val_descriptor_set *set) +lvp_descriptor_set_destroy(struct lvp_device *device, + struct lvp_descriptor_set *set) { vk_object_base_finish(&set->base); vk_free(&device->alloc, set); } -VkResult val_AllocateDescriptorSets( +VkResult lvp_AllocateDescriptorSets( VkDevice _device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_descriptor_pool, pool, pAllocateInfo->descriptorPool); + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_descriptor_pool, pool, pAllocateInfo->descriptorPool); VkResult result = VK_SUCCESS; - struct val_descriptor_set *set; + struct lvp_descriptor_set *set; uint32_t i; for (i = 0; i < pAllocateInfo->descriptorSetCount; i++) { - VAL_FROM_HANDLE(val_descriptor_set_layout, layout, + LVP_FROM_HANDLE(lvp_descriptor_set_layout, layout, pAllocateInfo->pSetLayouts[i]); - result = val_descriptor_set_create(device, layout, &set); + result = lvp_descriptor_set_create(device, layout, &set); if (result != VK_SUCCESS) break; list_addtail(&set->link, &pool->sets); - pDescriptorSets[i] = val_descriptor_set_to_handle(set); + pDescriptorSets[i] = lvp_descriptor_set_to_handle(set); } if (result != VK_SUCCESS) - val_FreeDescriptorSets(_device, pAllocateInfo->descriptorPool, + lvp_FreeDescriptorSets(_device, pAllocateInfo->descriptorPool, i, pDescriptorSets); return result; } -VkResult val_FreeDescriptorSets( +VkResult lvp_FreeDescriptorSets( VkDevice _device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets) { - VAL_FROM_HANDLE(val_device, device, _device); + LVP_FROM_HANDLE(lvp_device, device, _device); for (uint32_t i = 0; i < count; i++) { - VAL_FROM_HANDLE(val_descriptor_set, set, pDescriptorSets[i]); + LVP_FROM_HANDLE(lvp_descriptor_set, set, pDescriptorSets[i]); if (!set) continue; list_del(&set->link); - val_descriptor_set_destroy(device, set); + lvp_descriptor_set_destroy(device, set); } return VK_SUCCESS; } -void val_UpdateDescriptorSets( +void lvp_UpdateDescriptorSets( VkDevice _device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, @@ -324,20 +324,20 @@ void val_UpdateDescriptorSets( { for (uint32_t i = 0; i < descriptorWriteCount; i++) { const VkWriteDescriptorSet *write = &pDescriptorWrites[i]; - VAL_FROM_HANDLE(val_descriptor_set, set, write->dstSet); - const struct val_descriptor_set_binding_layout *bind_layout = + LVP_FROM_HANDLE(lvp_descriptor_set, set, write->dstSet); + const struct lvp_descriptor_set_binding_layout *bind_layout = &set->layout->binding[write->dstBinding]; - struct val_descriptor *desc = + struct lvp_descriptor *desc = &set->descriptors[bind_layout->descriptor_index]; desc += write->dstArrayElement; switch (write->descriptorType) { case VK_DESCRIPTOR_TYPE_SAMPLER: for (uint32_t j = 0; j < write->descriptorCount; j++) { - VAL_FROM_HANDLE(val_sampler, sampler, + LVP_FROM_HANDLE(lvp_sampler, sampler, write->pImageInfo[j].sampler); - desc[j] = (struct val_descriptor) { + desc[j] = (struct lvp_descriptor) { .type = VK_DESCRIPTOR_TYPE_SAMPLER, .sampler = sampler, }; @@ -346,9 +346,9 @@ void val_UpdateDescriptorSets( case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: for (uint32_t j = 0; j < write->descriptorCount; j++) { - VAL_FROM_HANDLE(val_image_view, iview, + LVP_FROM_HANDLE(lvp_image_view, iview, write->pImageInfo[j].imageView); - VAL_FROM_HANDLE(val_sampler, sampler, + LVP_FROM_HANDLE(lvp_sampler, sampler, write->pImageInfo[j].sampler); desc[j].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; @@ -366,10 +366,10 @@ void val_UpdateDescriptorSets( case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: for (uint32_t j = 0; j < write->descriptorCount; j++) { - VAL_FROM_HANDLE(val_image_view, iview, + LVP_FROM_HANDLE(lvp_image_view, iview, write->pImageInfo[j].imageView); - desc[j] = (struct val_descriptor) { + desc[j] = (struct lvp_descriptor) { .type = write->descriptorType, .image_view = iview, }; @@ -379,10 +379,10 @@ void val_UpdateDescriptorSets( case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: for (uint32_t j = 0; j < write->descriptorCount; j++) { - VAL_FROM_HANDLE(val_buffer_view, bview, + LVP_FROM_HANDLE(lvp_buffer_view, bview, write->pTexelBufferView[j]); - desc[j] = (struct val_descriptor) { + desc[j] = (struct lvp_descriptor) { .type = write->descriptorType, .buffer_view = bview, }; @@ -395,9 +395,9 @@ void val_UpdateDescriptorSets( case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: for (uint32_t j = 0; j < write->descriptorCount; j++) { assert(write->pBufferInfo[j].buffer); - VAL_FROM_HANDLE(val_buffer, buffer, write->pBufferInfo[j].buffer); + LVP_FROM_HANDLE(lvp_buffer, buffer, write->pBufferInfo[j].buffer); assert(buffer); - desc[j] = (struct val_descriptor) { + desc[j] = (struct lvp_descriptor) { .type = write->descriptorType, .buf.offset = write->pBufferInfo[j].offset, .buf.buffer = buffer, @@ -413,18 +413,18 @@ void val_UpdateDescriptorSets( for (uint32_t i = 0; i < descriptorCopyCount; i++) { const VkCopyDescriptorSet *copy = &pDescriptorCopies[i]; - VAL_FROM_HANDLE(val_descriptor_set, src, copy->srcSet); - VAL_FROM_HANDLE(val_descriptor_set, dst, copy->dstSet); + LVP_FROM_HANDLE(lvp_descriptor_set, src, copy->srcSet); + LVP_FROM_HANDLE(lvp_descriptor_set, dst, copy->dstSet); - const struct val_descriptor_set_binding_layout *src_layout = + const struct lvp_descriptor_set_binding_layout *src_layout = &src->layout->binding[copy->srcBinding]; - struct val_descriptor *src_desc = + struct lvp_descriptor *src_desc = &src->descriptors[src_layout->descriptor_index]; src_desc += copy->srcArrayElement; - const struct val_descriptor_set_binding_layout *dst_layout = + const struct lvp_descriptor_set_binding_layout *dst_layout = &dst->layout->binding[copy->dstBinding]; - struct val_descriptor *dst_desc = + struct lvp_descriptor *dst_desc = &dst->descriptors[dst_layout->descriptor_index]; dst_desc += copy->dstArrayElement; @@ -433,15 +433,15 @@ void val_UpdateDescriptorSets( } } -VkResult val_CreateDescriptorPool( +VkResult lvp_CreateDescriptorPool( VkDevice _device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) { - VAL_FROM_HANDLE(val_device, device, _device); - struct val_descriptor_pool *pool; - size_t size = sizeof(struct val_descriptor_pool); + LVP_FROM_HANDLE(lvp_device, device, _device); + struct lvp_descriptor_pool *pool; + size_t size = sizeof(struct lvp_descriptor_pool); pool = vk_zalloc2(&device->alloc, pAllocator, size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (!pool) @@ -451,49 +451,49 @@ VkResult val_CreateDescriptorPool( VK_OBJECT_TYPE_DESCRIPTOR_POOL); pool->flags = pCreateInfo->flags; list_inithead(&pool->sets); - *pDescriptorPool = val_descriptor_pool_to_handle(pool); + *pDescriptorPool = lvp_descriptor_pool_to_handle(pool); return VK_SUCCESS; } -static void val_reset_descriptor_pool(struct val_device *device, - struct val_descriptor_pool *pool) +static void lvp_reset_descriptor_pool(struct lvp_device *device, + struct lvp_descriptor_pool *pool) { - struct val_descriptor_set *set, *tmp; + struct lvp_descriptor_set *set, *tmp; LIST_FOR_EACH_ENTRY_SAFE(set, tmp, &pool->sets, link) { list_del(&set->link); vk_free(&device->alloc, set); } } -void val_DestroyDescriptorPool( +void lvp_DestroyDescriptorPool( VkDevice _device, VkDescriptorPool _pool, const VkAllocationCallbacks* pAllocator) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_descriptor_pool, pool, _pool); + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_descriptor_pool, pool, _pool); if (!_pool) return; - val_reset_descriptor_pool(device, pool); + lvp_reset_descriptor_pool(device, pool); vk_object_base_finish(&pool->base); vk_free2(&device->alloc, pAllocator, pool); } -VkResult val_ResetDescriptorPool( +VkResult lvp_ResetDescriptorPool( VkDevice _device, VkDescriptorPool _pool, VkDescriptorPoolResetFlags flags) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_descriptor_pool, pool, _pool); + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_descriptor_pool, pool, _pool); - val_reset_descriptor_pool(device, pool); + lvp_reset_descriptor_pool(device, pool); return VK_SUCCESS; } -void val_GetDescriptorSetLayoutSupport(VkDevice device, +void lvp_GetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) { diff --git a/src/gallium/frontends/vallium/val_device.c b/src/gallium/frontends/lavapipe/lvp_device.c similarity index 83% rename from src/gallium/frontends/vallium/val_device.c rename to src/gallium/frontends/lavapipe/lvp_device.c index b04a369..86dcb1f 100644 --- a/src/gallium/frontends/vallium/val_device.c +++ b/src/gallium/frontends/lavapipe/lvp_device.c @@ -21,7 +21,7 @@ * IN THE SOFTWARE. */ -#include "val_private.h" +#include "lvp_private.h" #include "pipe-loader/pipe_loader.h" #include "git_sha1.h" @@ -38,8 +38,8 @@ #include "util/timespec.h" static VkResult -val_physical_device_init(struct val_physical_device *device, - struct val_instance *instance, +lvp_physical_device_init(struct lvp_physical_device *device, + struct lvp_instance *instance, struct pipe_loader_device *pld) { VkResult result; @@ -51,11 +51,11 @@ val_physical_device_init(struct val_physical_device *device, if (!device->pscreen) return vk_error(instance, VK_ERROR_OUT_OF_HOST_MEMORY); - fprintf(stderr, "WARNING: vallium/llvmpipe is not a conformant vulkan implementation, testing use only.\n"); + fprintf(stderr, "WARNING: lavapipe is not a conformant vulkan implementation, testing use only.\n"); device->max_images = device->pscreen->get_shader_param(device->pscreen, PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_MAX_SHADER_IMAGES); - val_physical_device_get_supported_extensions(device, &device->supported_extensions); - result = val_init_wsi(device); + lvp_physical_device_get_supported_extensions(device, &device->supported_extensions); + result = lvp_init_wsi(device); if (result != VK_SUCCESS) { vk_error(instance, result); goto fail; @@ -67,9 +67,9 @@ val_physical_device_init(struct val_physical_device *device, } static void -val_physical_device_finish(struct val_physical_device *device) +lvp_physical_device_finish(struct lvp_physical_device *device) { - val_finish_wsi(device); + lvp_finish_wsi(device); device->pscreen->destroy(device->pscreen); } @@ -100,12 +100,12 @@ static const VkAllocationCallbacks default_alloc = { .pfnFree = default_free_func, }; -VkResult val_CreateInstance( +VkResult lvp_CreateInstance( const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) { - struct val_instance *instance; + struct lvp_instance *instance; assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO); @@ -134,32 +134,32 @@ VkResult val_CreateInstance( for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) { int idx; - for (idx = 0; idx < VAL_INSTANCE_EXTENSION_COUNT; idx++) { + for (idx = 0; idx < LVP_INSTANCE_EXTENSION_COUNT; idx++) { if (!strcmp(pCreateInfo->ppEnabledExtensionNames[i], - val_instance_extensions[idx].extensionName)) + lvp_instance_extensions[idx].extensionName)) break; } - if (idx >= VAL_INSTANCE_EXTENSION_COUNT || - !val_instance_extensions_supported.extensions[idx]) { + if (idx >= LVP_INSTANCE_EXTENSION_COUNT || + !lvp_instance_extensions_supported.extensions[idx]) { vk_free2(&default_alloc, pAllocator, instance); return vk_error(instance, VK_ERROR_EXTENSION_NOT_PRESENT); } instance->enabled_extensions.extensions[idx] = true; } - bool unchecked = instance->debug_flags & VAL_DEBUG_ALL_ENTRYPOINTS; + bool unchecked = instance->debug_flags & LVP_DEBUG_ALL_ENTRYPOINTS; for (unsigned i = 0; i < ARRAY_SIZE(instance->dispatch.entrypoints); i++) { /* Vulkan requires that entrypoints for extensions which have * not been enabled must not be advertised. */ if (!unchecked && - !val_instance_entrypoint_is_enabled(i, instance->apiVersion, + !lvp_instance_entrypoint_is_enabled(i, instance->apiVersion, &instance->enabled_extensions)) { instance->dispatch.entrypoints[i] = NULL; } else { instance->dispatch.entrypoints[i] = - val_instance_dispatch_table.entrypoints[i]; + lvp_instance_dispatch_table.entrypoints[i]; } } @@ -168,12 +168,12 @@ VkResult val_CreateInstance( * not been enabled must not be advertised. */ if (!unchecked && - !val_physical_device_entrypoint_is_enabled(i, instance->apiVersion, + !lvp_physical_device_entrypoint_is_enabled(i, instance->apiVersion, &instance->enabled_extensions)) { instance->physical_device_dispatch.entrypoints[i] = NULL; } else { instance->physical_device_dispatch.entrypoints[i] = - val_physical_device_dispatch_table.entrypoints[i]; + lvp_physical_device_dispatch_table.entrypoints[i]; } } @@ -182,12 +182,12 @@ VkResult val_CreateInstance( * not been enabled must not be advertised. */ if (!unchecked && - !val_device_entrypoint_is_enabled(i, instance->apiVersion, + !lvp_device_entrypoint_is_enabled(i, instance->apiVersion, &instance->enabled_extensions, NULL)) { instance->device_dispatch.entrypoints[i] = NULL; } else { instance->device_dispatch.entrypoints[i] = - val_device_dispatch_table.entrypoints[i]; + lvp_device_dispatch_table.entrypoints[i]; } } @@ -195,22 +195,22 @@ VkResult val_CreateInstance( glsl_type_singleton_init_or_ref(); // VG(VALGRIND_CREATE_MEMPOOL(instance, 0, false)); - *pInstance = val_instance_to_handle(instance); + *pInstance = lvp_instance_to_handle(instance); return VK_SUCCESS; } -void val_DestroyInstance( +void lvp_DestroyInstance( VkInstance _instance, const VkAllocationCallbacks* pAllocator) { - VAL_FROM_HANDLE(val_instance, instance, _instance); + LVP_FROM_HANDLE(lvp_instance, instance, _instance); if (!instance) return; glsl_type_singleton_decref(); if (instance->physicalDeviceCount > 0) - val_physical_device_finish(&instance->physicalDevice); + lvp_physical_device_finish(&instance->physicalDevice); // _mesa_locale_fini(); pipe_loader_release(&instance->devs, instance->num_devices); @@ -219,38 +219,38 @@ void val_DestroyInstance( vk_free(&instance->alloc, instance); } -static void val_get_image(struct dri_drawable *dri_drawable, +static void lvp_get_image(struct dri_drawable *dri_drawable, int x, int y, unsigned width, unsigned height, unsigned stride, void *data) { } -static void val_put_image(struct dri_drawable *dri_drawable, +static void lvp_put_image(struct dri_drawable *dri_drawable, void *data, unsigned width, unsigned height) { fprintf(stderr, "put image %dx%d\n", width, height); } -static void val_put_image2(struct dri_drawable *dri_drawable, +static void lvp_put_image2(struct dri_drawable *dri_drawable, void *data, int x, int y, unsigned width, unsigned height, unsigned stride) { fprintf(stderr, "put image 2 %d,%d %dx%d\n", x, y, width, height); } -static struct drisw_loader_funcs val_sw_lf = { - .get_image = val_get_image, - .put_image = val_put_image, - .put_image2 = val_put_image2, +static struct drisw_loader_funcs lvp_sw_lf = { + .get_image = lvp_get_image, + .put_image = lvp_put_image, + .put_image2 = lvp_put_image2, }; -VkResult val_EnumeratePhysicalDevices( +VkResult lvp_EnumeratePhysicalDevices( VkInstance _instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) { - VAL_FROM_HANDLE(val_instance, instance, _instance); + LVP_FROM_HANDLE(lvp_instance, instance, _instance); VkResult result; if (instance->physicalDeviceCount < 0) { @@ -260,10 +260,10 @@ VkResult val_EnumeratePhysicalDevices( assert(instance->num_devices == 1); - pipe_loader_sw_probe_dri(&instance->devs, &val_sw_lf); + pipe_loader_sw_probe_dri(&instance->devs, &lvp_sw_lf); - result = val_physical_device_init(&instance->physicalDevice, + result = lvp_physical_device_init(&instance->physicalDevice, instance, &instance->devs[0]); if (result == VK_ERROR_INCOMPATIBLE_DRIVER) { instance->physicalDeviceCount = 0; @@ -277,7 +277,7 @@ VkResult val_EnumeratePhysicalDevices( if (!pPhysicalDevices) { *pPhysicalDeviceCount = instance->physicalDeviceCount; } else if (*pPhysicalDeviceCount >= 1) { - pPhysicalDevices[0] = val_physical_device_to_handle(&instance->physicalDevice); + pPhysicalDevices[0] = lvp_physical_device_to_handle(&instance->physicalDevice); *pPhysicalDeviceCount = 1; } else { *pPhysicalDeviceCount = 0; @@ -286,11 +286,11 @@ VkResult val_EnumeratePhysicalDevices( return VK_SUCCESS; } -void val_GetPhysicalDeviceFeatures( +void lvp_GetPhysicalDeviceFeatures( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) { - VAL_FROM_HANDLE(val_physical_device, pdevice, physicalDevice); + LVP_FROM_HANDLE(lvp_physical_device, pdevice, physicalDevice); bool indirect = false;//pdevice->pscreen->get_param(pdevice->pscreen, PIPE_CAP_GLSL_FEATURE_LEVEL) >= 400; memset(pFeatures, 0, sizeof(*pFeatures)); *pFeatures = (VkPhysicalDeviceFeatures) { @@ -342,11 +342,11 @@ void val_GetPhysicalDeviceFeatures( }; } -void val_GetPhysicalDeviceFeatures2( +void lvp_GetPhysicalDeviceFeatures2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2 *pFeatures) { - val_GetPhysicalDeviceFeatures(physicalDevice, &pFeatures->features); + lvp_GetPhysicalDeviceFeatures(physicalDevice, &pFeatures->features); vk_foreach_struct(ext, pFeatures->pNext) { switch (ext->sType) { @@ -372,16 +372,16 @@ void val_GetPhysicalDeviceFeatures2( } void -val_device_get_cache_uuid(void *uuid) +lvp_device_get_cache_uuid(void *uuid) { memset(uuid, 0, VK_UUID_SIZE); snprintf(uuid, VK_UUID_SIZE, "val-%s", MESA_GIT_SHA1 + 4); } -void val_GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, +void lvp_GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties) { - VAL_FROM_HANDLE(val_physical_device, pdevice, physicalDevice); + LVP_FROM_HANDLE(lvp_physical_device, pdevice, physicalDevice); VkSampleCountFlags sample_counts = VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT; @@ -519,15 +519,15 @@ void val_GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, }; strcpy(pProperties->deviceName, pdevice->pscreen->get_name(pdevice->pscreen)); - val_device_get_cache_uuid(pProperties->pipelineCacheUUID); + lvp_device_get_cache_uuid(pProperties->pipelineCacheUUID); } -void val_GetPhysicalDeviceProperties2( +void lvp_GetPhysicalDeviceProperties2( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2 *pProperties) { - val_GetPhysicalDeviceProperties(physicalDevice, &pProperties->properties); + lvp_GetPhysicalDeviceProperties(physicalDevice, &pProperties->properties); vk_foreach_struct(ext, pProperties->pNext) { switch (ext->sType) { @@ -568,7 +568,7 @@ void val_GetPhysicalDeviceProperties2( } } -void val_GetPhysicalDeviceQueueFamilyProperties( +void lvp_GetPhysicalDeviceQueueFamilyProperties( VkPhysicalDevice physicalDevice, uint32_t* pCount, VkQueueFamilyProperties* pQueueFamilyProperties) @@ -590,7 +590,7 @@ void val_GetPhysicalDeviceQueueFamilyProperties( }; } -void val_GetPhysicalDeviceMemoryProperties( +void lvp_GetPhysicalDeviceMemoryProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) { @@ -610,11 +610,11 @@ void val_GetPhysicalDeviceMemoryProperties( }; } -PFN_vkVoidFunction val_GetInstanceProcAddr( +PFN_vkVoidFunction lvp_GetInstanceProcAddr( VkInstance _instance, const char* pName) { - VAL_FROM_HANDLE(val_instance, instance, _instance); + LVP_FROM_HANDLE(lvp_instance, instance, _instance); /* The Vulkan 1.0 spec for vkGetInstanceProcAddr has a table of exactly * when we have to return valid function pointers, NULL, or it's left @@ -623,34 +623,34 @@ PFN_vkVoidFunction val_GetInstanceProcAddr( if (pName == NULL) return NULL; -#define LOOKUP_VAL_ENTRYPOINT(entrypoint) \ +#define LOOKUP_LVP_ENTRYPOINT(entrypoint) \ if (strcmp(pName, "vk" #entrypoint) == 0) \ - return (PFN_vkVoidFunction)val_##entrypoint + return (PFN_vkVoidFunction)lvp_##entrypoint - LOOKUP_VAL_ENTRYPOINT(EnumerateInstanceExtensionProperties); - LOOKUP_VAL_ENTRYPOINT(EnumerateInstanceLayerProperties); - LOOKUP_VAL_ENTRYPOINT(EnumerateInstanceVersion); - LOOKUP_VAL_ENTRYPOINT(CreateInstance); + LOOKUP_LVP_ENTRYPOINT(EnumerateInstanceExtensionProperties); + LOOKUP_LVP_ENTRYPOINT(EnumerateInstanceLayerProperties); + LOOKUP_LVP_ENTRYPOINT(EnumerateInstanceVersion); + LOOKUP_LVP_ENTRYPOINT(CreateInstance); /* GetInstanceProcAddr() can also be called with a NULL instance. * See https://gitlab.khronos.org/vulkan/vulkan/issues/2057 */ - LOOKUP_VAL_ENTRYPOINT(GetInstanceProcAddr); + LOOKUP_LVP_ENTRYPOINT(GetInstanceProcAddr); -#undef LOOKUP_VAL_ENTRYPOINT +#undef LOOKUP_LVP_ENTRYPOINT if (instance == NULL) return NULL; - int idx = val_get_instance_entrypoint_index(pName); + int idx = lvp_get_instance_entrypoint_index(pName); if (idx >= 0) return instance->dispatch.entrypoints[idx]; - idx = val_get_physical_device_entrypoint_index(pName); + idx = lvp_get_physical_device_entrypoint_index(pName); if (idx >= 0) return instance->physical_device_dispatch.entrypoints[idx]; - idx = val_get_device_entrypoint_index(pName); + idx = lvp_get_device_entrypoint_index(pName); if (idx >= 0) return instance->device_dispatch.entrypoints[idx]; @@ -670,7 +670,7 @@ VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetInstanceProcAddr( VkInstance instance, const char* pName) { - return val_GetInstanceProcAddr(instance, pName); + return lvp_GetInstanceProcAddr(instance, pName); } PUBLIC @@ -683,27 +683,27 @@ VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetPhysicalDeviceProcAddr( VkInstance _instance, const char* pName) { - VAL_FROM_HANDLE(val_instance, instance, _instance); + LVP_FROM_HANDLE(lvp_instance, instance, _instance); if (!pName || !instance) return NULL; - int idx = val_get_physical_device_entrypoint_index(pName); + int idx = lvp_get_physical_device_entrypoint_index(pName); if (idx < 0) return NULL; return instance->physical_device_dispatch.entrypoints[idx]; } -PFN_vkVoidFunction val_GetDeviceProcAddr( +PFN_vkVoidFunction lvp_GetDeviceProcAddr( VkDevice _device, const char* pName) { - VAL_FROM_HANDLE(val_device, device, _device); + LVP_FROM_HANDLE(lvp_device, device, _device); if (!device || !pName) return NULL; - int idx = val_get_device_entrypoint_index(pName); + int idx = lvp_get_device_entrypoint_index(pName); if (idx < 0) return NULL; @@ -712,24 +712,24 @@ PFN_vkVoidFunction val_GetDeviceProcAddr( static int queue_thread(void *data) { - struct val_queue *queue = data; + struct lvp_queue *queue = data; mtx_lock(&queue->m); while (!queue->shutdown) { - struct val_queue_work *task; + struct lvp_queue_work *task; while (list_is_empty(&queue->workqueue) && !queue->shutdown) cnd_wait(&queue->new_work, &queue->m); if (queue->shutdown) break; - task = list_first_entry(&queue->workqueue, struct val_queue_work, + task = list_first_entry(&queue->workqueue, struct lvp_queue_work, list); mtx_unlock(&queue->m); //execute for (unsigned i = 0; i < task->cmd_buffer_count; i++) { - val_execute_cmds(queue->device, queue, task->fence, task->cmd_buffers[i]); + lvp_execute_cmds(queue->device, queue, task->fence, task->cmd_buffers[i]); } if (!task->cmd_buffer_count && task->fence) task->fence->signaled = true; @@ -743,7 +743,7 @@ static int queue_thread(void *data) } static VkResult -val_queue_init(struct val_device *device, struct val_queue *queue) +lvp_queue_init(struct lvp_device *device, struct lvp_queue *queue) { queue->_loader_data.loaderMagic = ICD_LOADER_MAGIC; queue->device = device; @@ -759,7 +759,7 @@ val_queue_init(struct val_device *device, struct val_queue *queue) } static void -val_queue_finish(struct val_queue *queue) +lvp_queue_finish(struct lvp_queue *queue) { mtx_lock(&queue->m); queue->shutdown = true; @@ -773,28 +773,28 @@ val_queue_finish(struct val_queue *queue) queue->ctx->destroy(queue->ctx); } -static int val_get_device_extension_index(const char *name) +static int lvp_get_device_extension_index(const char *name) { - for (unsigned i = 0; i < VAL_DEVICE_EXTENSION_COUNT; ++i) { - if (strcmp(name, val_device_extensions[i].extensionName) == 0) + for (unsigned i = 0; i < LVP_DEVICE_EXTENSION_COUNT; ++i) { + if (strcmp(name, lvp_device_extensions[i].extensionName) == 0) return i; } return -1; } static void -val_device_init_dispatch(struct val_device *device) +lvp_device_init_dispatch(struct lvp_device *device) { - const struct val_instance *instance = device->physical_device->instance; - const struct val_device_dispatch_table *dispatch_table_layer = NULL; - bool unchecked = instance->debug_flags & VAL_DEBUG_ALL_ENTRYPOINTS; + const struct lvp_instance *instance = device->physical_device->instance; + const struct lvp_device_dispatch_table *dispatch_table_layer = NULL; + bool unchecked = instance->debug_flags & LVP_DEBUG_ALL_ENTRYPOINTS; for (unsigned i = 0; i < ARRAY_SIZE(device->dispatch.entrypoints); i++) { /* Vulkan requires that entrypoints for extensions which have not been * enabled must not be advertised. */ if (!unchecked && - !val_device_entrypoint_is_enabled(i, instance->apiVersion, + !lvp_device_entrypoint_is_enabled(i, instance->apiVersion, &instance->enabled_extensions, &device->enabled_extensions)) { device->dispatch.entrypoints[i] = NULL; @@ -804,26 +804,26 @@ val_device_init_dispatch(struct val_device *device) dispatch_table_layer->entrypoints[i]; } else { device->dispatch.entrypoints[i] = - val_device_dispatch_table.entrypoints[i]; + lvp_device_dispatch_table.entrypoints[i]; } } } -VkResult val_CreateDevice( +VkResult lvp_CreateDevice( VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) { - VAL_FROM_HANDLE(val_physical_device, physical_device, physicalDevice); - struct val_device *device; + LVP_FROM_HANDLE(lvp_physical_device, physical_device, physicalDevice); + struct lvp_device *device; assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO); /* Check enabled features */ if (pCreateInfo->pEnabledFeatures) { VkPhysicalDeviceFeatures supported_features; - val_GetPhysicalDeviceFeatures(physicalDevice, &supported_features); + lvp_GetPhysicalDeviceFeatures(physicalDevice, &supported_features); VkBool32 *supported_feature = (VkBool32 *)&supported_features; VkBool32 *enabled_feature = (VkBool32 *)pCreateInfo->pEnabledFeatures; unsigned num_features = sizeof(VkPhysicalDeviceFeatures) / sizeof(VkBool32); @@ -849,7 +849,7 @@ VkResult val_CreateDevice( for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) { const char *ext_name = pCreateInfo->ppEnabledExtensionNames[i]; - int index = val_get_device_extension_index(ext_name); + int index = lvp_get_device_extension_index(ext_name); if (index < 0 || !physical_device->supported_extensions.extensions[index]) { vk_free(&device->alloc, device); return vk_error(physical_device->instance, VK_ERROR_EXTENSION_NOT_PRESENT); @@ -857,40 +857,40 @@ VkResult val_CreateDevice( device->enabled_extensions.extensions[index] = true; } - val_device_init_dispatch(device); + lvp_device_init_dispatch(device); mtx_init(&device->fence_lock, mtx_plain); device->pscreen = physical_device->pscreen; - val_queue_init(device, &device->queue); + lvp_queue_init(device, &device->queue); - *pDevice = val_device_to_handle(device); + *pDevice = lvp_device_to_handle(device); return VK_SUCCESS; } -void val_DestroyDevice( +void lvp_DestroyDevice( VkDevice _device, const VkAllocationCallbacks* pAllocator) { - VAL_FROM_HANDLE(val_device, device, _device); + LVP_FROM_HANDLE(lvp_device, device, _device); - val_queue_finish(&device->queue); + lvp_queue_finish(&device->queue); vk_free(&device->alloc, device); } -VkResult val_EnumerateInstanceExtensionProperties( +VkResult lvp_EnumerateInstanceExtensionProperties( const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) { VK_OUTARRAY_MAKE(out, pProperties, pPropertyCount); - for (int i = 0; i < VAL_INSTANCE_EXTENSION_COUNT; i++) { - if (val_instance_extensions_supported.extensions[i]) { + for (int i = 0; i < LVP_INSTANCE_EXTENSION_COUNT; i++) { + if (lvp_instance_extensions_supported.extensions[i]) { vk_outarray_append(&out, prop) { - *prop = val_instance_extensions[i]; + *prop = lvp_instance_extensions[i]; } } } @@ -898,26 +898,26 @@ VkResult val_EnumerateInstanceExtensionProperties( return vk_outarray_status(&out); } -VkResult val_EnumerateDeviceExtensionProperties( +VkResult lvp_EnumerateDeviceExtensionProperties( VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) { - VAL_FROM_HANDLE(val_physical_device, device, physicalDevice); + LVP_FROM_HANDLE(lvp_physical_device, device, physicalDevice); VK_OUTARRAY_MAKE(out, pProperties, pPropertyCount); - for (int i = 0; i < VAL_DEVICE_EXTENSION_COUNT; i++) { + for (int i = 0; i < LVP_DEVICE_EXTENSION_COUNT; i++) { if (device->supported_extensions.extensions[i]) { vk_outarray_append(&out, prop) { - *prop = val_device_extensions[i]; + *prop = lvp_device_extensions[i]; } } } return vk_outarray_status(&out); } -VkResult val_EnumerateInstanceLayerProperties( +VkResult lvp_EnumerateInstanceLayerProperties( uint32_t* pPropertyCount, VkLayerProperties* pProperties) { @@ -930,7 +930,7 @@ VkResult val_EnumerateInstanceLayerProperties( return vk_error(NULL, VK_ERROR_LAYER_NOT_PRESENT); } -VkResult val_EnumerateDeviceLayerProperties( +VkResult lvp_EnumerateDeviceLayerProperties( VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) @@ -944,13 +944,13 @@ VkResult val_EnumerateDeviceLayerProperties( return vk_error(NULL, VK_ERROR_LAYER_NOT_PRESENT); } -void val_GetDeviceQueue2( +void lvp_GetDeviceQueue2( VkDevice _device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) { - VAL_FROM_HANDLE(val_device, device, _device); - struct val_queue *queue; + LVP_FROM_HANDLE(lvp_device, device, _device); + struct lvp_queue *queue; queue = &device->queue; if (pQueueInfo->flags != queue->flags) { @@ -966,11 +966,11 @@ void val_GetDeviceQueue2( return; } - *pQueue = val_queue_to_handle(queue); + *pQueue = lvp_queue_to_handle(queue); } -void val_GetDeviceQueue( +void lvp_GetDeviceQueue( VkDevice _device, uint32_t queueFamilyIndex, uint32_t queueIndex, @@ -982,30 +982,30 @@ void val_GetDeviceQueue( .queueIndex = queueIndex }; - val_GetDeviceQueue2(_device, &info, pQueue); + lvp_GetDeviceQueue2(_device, &info, pQueue); } -VkResult val_QueueSubmit( +VkResult lvp_QueueSubmit( VkQueue _queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence _fence) { - VAL_FROM_HANDLE(val_queue, queue, _queue); - VAL_FROM_HANDLE(val_fence, fence, _fence); + LVP_FROM_HANDLE(lvp_queue, queue, _queue); + LVP_FROM_HANDLE(lvp_fence, fence, _fence); if (submitCount == 0) goto just_signal_fence; for (uint32_t i = 0; i < submitCount; i++) { - uint32_t task_size = sizeof(struct val_queue_work) + pSubmits[i].commandBufferCount * sizeof(struct val_cmd_buffer *); - struct val_queue_work *task = malloc(task_size); + uint32_t task_size = sizeof(struct lvp_queue_work) + pSubmits[i].commandBufferCount * sizeof(struct lvp_cmd_buffer *); + struct lvp_queue_work *task = malloc(task_size); task->cmd_buffer_count = pSubmits[i].commandBufferCount; task->fence = fence; - task->cmd_buffers = (struct val_cmd_buffer **)(task + 1); + task->cmd_buffers = (struct lvp_cmd_buffer **)(task + 1); for (uint32_t j = 0; j < pSubmits[i].commandBufferCount; j++) { - task->cmd_buffers[j] = val_cmd_buffer_from_handle(pSubmits[i].pCommandBuffers[j]); + task->cmd_buffers[j] = lvp_cmd_buffer_from_handle(pSubmits[i].pCommandBuffers[j]); } mtx_lock(&queue->m); @@ -1020,7 +1020,7 @@ VkResult val_QueueSubmit( return VK_SUCCESS; } -static VkResult queue_wait_idle(struct val_queue *queue, uint64_t timeout) +static VkResult queue_wait_idle(struct lvp_queue *queue, uint64_t timeout) { if (timeout == 0) return p_atomic_read(&queue->count) == 0 ? VK_SUCCESS : VK_TIMEOUT; @@ -1040,30 +1040,30 @@ static VkResult queue_wait_idle(struct val_queue *queue, uint64_t timeout) return VK_SUCCESS; } -VkResult val_QueueWaitIdle( +VkResult lvp_QueueWaitIdle( VkQueue _queue) { - VAL_FROM_HANDLE(val_queue, queue, _queue); + LVP_FROM_HANDLE(lvp_queue, queue, _queue); return queue_wait_idle(queue, UINT64_MAX); } -VkResult val_DeviceWaitIdle( +VkResult lvp_DeviceWaitIdle( VkDevice _device) { - VAL_FROM_HANDLE(val_device, device, _device); + LVP_FROM_HANDLE(lvp_device, device, _device); return queue_wait_idle(&device->queue, UINT64_MAX); } -VkResult val_AllocateMemory( +VkResult lvp_AllocateMemory( VkDevice _device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMem) { - VAL_FROM_HANDLE(val_device, device, _device); - struct val_device_memory *mem; + LVP_FROM_HANDLE(lvp_device, device, _device); + struct lvp_device_memory *mem; assert(pAllocateInfo->sType == VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO); if (pAllocateInfo->allocationSize == 0) { @@ -1087,18 +1087,18 @@ VkResult val_AllocateMemory( mem->type_index = pAllocateInfo->memoryTypeIndex; - *pMem = val_device_memory_to_handle(mem); + *pMem = lvp_device_memory_to_handle(mem); return VK_SUCCESS; } -void val_FreeMemory( +void lvp_FreeMemory( VkDevice _device, VkDeviceMemory _mem, const VkAllocationCallbacks* pAllocator) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_device_memory, mem, _mem); + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_device_memory, mem, _mem); if (mem == NULL) return; @@ -1109,7 +1109,7 @@ void val_FreeMemory( } -VkResult val_MapMemory( +VkResult lvp_MapMemory( VkDevice _device, VkDeviceMemory _memory, VkDeviceSize offset, @@ -1117,8 +1117,8 @@ VkResult val_MapMemory( VkMemoryMapFlags flags, void** ppData) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_device_memory, mem, _memory); + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_device_memory, mem, _memory); void *map; if (mem == NULL) { *ppData = NULL; @@ -1131,12 +1131,12 @@ VkResult val_MapMemory( return VK_SUCCESS; } -void val_UnmapMemory( +void lvp_UnmapMemory( VkDevice _device, VkDeviceMemory _memory) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_device_memory, mem, _memory); + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_device_memory, mem, _memory); if (mem == NULL) return; @@ -1144,14 +1144,14 @@ void val_UnmapMemory( device->pscreen->unmap_memory(device->pscreen, mem->pmem); } -VkResult val_FlushMappedMemoryRanges( +VkResult lvp_FlushMappedMemoryRanges( VkDevice _device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) { return VK_SUCCESS; } -VkResult val_InvalidateMappedMemoryRanges( +VkResult lvp_InvalidateMappedMemoryRanges( VkDevice _device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) @@ -1159,12 +1159,12 @@ VkResult val_InvalidateMappedMemoryRanges( return VK_SUCCESS; } -void val_GetBufferMemoryRequirements( +void lvp_GetBufferMemoryRequirements( VkDevice device, VkBuffer _buffer, VkMemoryRequirements* pMemoryRequirements) { - VAL_FROM_HANDLE(val_buffer, buffer, _buffer); + LVP_FROM_HANDLE(lvp_buffer, buffer, _buffer); /* The Vulkan spec (git aaed022) says: * @@ -1181,12 +1181,12 @@ void val_GetBufferMemoryRequirements( pMemoryRequirements->alignment = 64; } -void val_GetBufferMemoryRequirements2( +void lvp_GetBufferMemoryRequirements2( VkDevice device, const VkBufferMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements) { - val_GetBufferMemoryRequirements(device, pInfo->buffer, + lvp_GetBufferMemoryRequirements(device, pInfo->buffer, &pMemoryRequirements->memoryRequirements); vk_foreach_struct(ext, pMemoryRequirements->pNext) { switch (ext->sType) { @@ -1203,24 +1203,24 @@ void val_GetBufferMemoryRequirements2( } } -void val_GetImageMemoryRequirements( +void lvp_GetImageMemoryRequirements( VkDevice device, VkImage _image, VkMemoryRequirements* pMemoryRequirements) { - VAL_FROM_HANDLE(val_image, image, _image); + LVP_FROM_HANDLE(lvp_image, image, _image); pMemoryRequirements->memoryTypeBits = 1; pMemoryRequirements->size = image->size; pMemoryRequirements->alignment = image->alignment; } -void val_GetImageMemoryRequirements2( +void lvp_GetImageMemoryRequirements2( VkDevice device, const VkImageMemoryRequirementsInfo2 *pInfo, VkMemoryRequirements2 *pMemoryRequirements) { - val_GetImageMemoryRequirements(device, pInfo->image, + lvp_GetImageMemoryRequirements(device, pInfo->image, &pMemoryRequirements->memoryRequirements); vk_foreach_struct(ext, pMemoryRequirements->pNext) { @@ -1238,7 +1238,7 @@ void val_GetImageMemoryRequirements2( } } -void val_GetImageSparseMemoryRequirements( +void lvp_GetImageSparseMemoryRequirements( VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, @@ -1247,7 +1247,7 @@ void val_GetImageSparseMemoryRequirements( stub(); } -void val_GetImageSparseMemoryRequirements2( +void lvp_GetImageSparseMemoryRequirements2( VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, @@ -1256,7 +1256,7 @@ void val_GetImageSparseMemoryRequirements2( stub(); } -void val_GetDeviceMemoryCommitment( +void lvp_GetDeviceMemoryCommitment( VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) @@ -1264,14 +1264,14 @@ void val_GetDeviceMemoryCommitment( *pCommittedMemoryInBytes = 0; } -VkResult val_BindBufferMemory2(VkDevice _device, +VkResult lvp_BindBufferMemory2(VkDevice _device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo *pBindInfos) { - VAL_FROM_HANDLE(val_device, device, _device); + LVP_FROM_HANDLE(lvp_device, device, _device); for (uint32_t i = 0; i < bindInfoCount; ++i) { - VAL_FROM_HANDLE(val_device_memory, mem, pBindInfos[i].memory); - VAL_FROM_HANDLE(val_buffer, buffer, pBindInfos[i].buffer); + LVP_FROM_HANDLE(lvp_device_memory, mem, pBindInfos[i].memory); + LVP_FROM_HANDLE(lvp_buffer, buffer, pBindInfos[i].buffer); device->pscreen->resource_bind_backing(device->pscreen, buffer->bo, @@ -1281,15 +1281,15 @@ VkResult val_BindBufferMemory2(VkDevice _device, return VK_SUCCESS; } -VkResult val_BindBufferMemory( +VkResult lvp_BindBufferMemory( VkDevice _device, VkBuffer _buffer, VkDeviceMemory _memory, VkDeviceSize memoryOffset) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_device_memory, mem, _memory); - VAL_FROM_HANDLE(val_buffer, buffer, _buffer); + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_device_memory, mem, _memory); + LVP_FROM_HANDLE(lvp_buffer, buffer, _buffer); device->pscreen->resource_bind_backing(device->pscreen, buffer->bo, @@ -1298,14 +1298,14 @@ VkResult val_BindBufferMemory( return VK_SUCCESS; } -VkResult val_BindImageMemory2(VkDevice _device, +VkResult lvp_BindImageMemory2(VkDevice _device, uint32_t bindInfoCount, const VkBindImageMemoryInfo *pBindInfos) { - VAL_FROM_HANDLE(val_device, device, _device); + LVP_FROM_HANDLE(lvp_device, device, _device); for (uint32_t i = 0; i < bindInfoCount; ++i) { - VAL_FROM_HANDLE(val_device_memory, mem, pBindInfos[i].memory); - VAL_FROM_HANDLE(val_image, image, pBindInfos[i].image); + LVP_FROM_HANDLE(lvp_device_memory, mem, pBindInfos[i].memory); + LVP_FROM_HANDLE(lvp_image, image, pBindInfos[i].image); device->pscreen->resource_bind_backing(device->pscreen, image->bo, @@ -1315,15 +1315,15 @@ VkResult val_BindImageMemory2(VkDevice _device, return VK_SUCCESS; } -VkResult val_BindImageMemory( +VkResult lvp_BindImageMemory( VkDevice _device, VkImage _image, VkDeviceMemory _memory, VkDeviceSize memoryOffset) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_device_memory, mem, _memory); - VAL_FROM_HANDLE(val_image, image, _image); + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_device_memory, mem, _memory); + LVP_FROM_HANDLE(lvp_image, image, _image); device->pscreen->resource_bind_backing(device->pscreen, image->bo, @@ -1332,7 +1332,7 @@ VkResult val_BindImageMemory( return VK_SUCCESS; } -VkResult val_QueueBindSparse( +VkResult lvp_QueueBindSparse( VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, @@ -1342,14 +1342,14 @@ VkResult val_QueueBindSparse( } -VkResult val_CreateFence( +VkResult lvp_CreateFence( VkDevice _device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) { - VAL_FROM_HANDLE(val_device, device, _device); - struct val_fence *fence; + LVP_FROM_HANDLE(lvp_device, device, _device); + struct lvp_fence *fence; fence = vk_alloc2(&device->alloc, pAllocator, sizeof(*fence), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); @@ -1360,18 +1360,18 @@ VkResult val_CreateFence( fence->signaled = pCreateInfo->flags & VK_FENCE_CREATE_SIGNALED_BIT; fence->handle = NULL; - *pFence = val_fence_to_handle(fence); + *pFence = lvp_fence_to_handle(fence); return VK_SUCCESS; } -void val_DestroyFence( +void lvp_DestroyFence( VkDevice _device, VkFence _fence, const VkAllocationCallbacks* pAllocator) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_fence, fence, _fence); + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_fence, fence, _fence); if (!_fence) return; @@ -1382,14 +1382,14 @@ void val_DestroyFence( vk_free2(&device->alloc, pAllocator, fence); } -VkResult val_ResetFences( +VkResult lvp_ResetFences( VkDevice _device, uint32_t fenceCount, const VkFence* pFences) { - VAL_FROM_HANDLE(val_device, device, _device); + LVP_FROM_HANDLE(lvp_device, device, _device); for (unsigned i = 0; i < fenceCount; i++) { - struct val_fence *fence = val_fence_from_handle(pFences[i]); + struct lvp_fence *fence = lvp_fence_from_handle(pFences[i]); fence->signaled = false; @@ -1401,12 +1401,12 @@ VkResult val_ResetFences( return VK_SUCCESS; } -VkResult val_GetFenceStatus( +VkResult lvp_GetFenceStatus( VkDevice _device, VkFence _fence) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_fence, fence, _fence); + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_fence, fence, _fence); if (fence->signaled) return VK_SUCCESS; @@ -1429,19 +1429,19 @@ VkResult val_GetFenceStatus( return VK_NOT_READY; } -VkResult val_CreateFramebuffer( +VkResult lvp_CreateFramebuffer( VkDevice _device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) { - VAL_FROM_HANDLE(val_device, device, _device); - struct val_framebuffer *framebuffer; + LVP_FROM_HANDLE(lvp_device, device, _device); + struct lvp_framebuffer *framebuffer; assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO); size_t size = sizeof(*framebuffer) + - sizeof(struct val_image_view *) * pCreateInfo->attachmentCount; + sizeof(struct lvp_image_view *) * pCreateInfo->attachmentCount; framebuffer = vk_alloc2(&device->alloc, pAllocator, size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (framebuffer == NULL) @@ -1452,25 +1452,25 @@ VkResult val_CreateFramebuffer( framebuffer->attachment_count = pCreateInfo->attachmentCount; for (uint32_t i = 0; i < pCreateInfo->attachmentCount; i++) { VkImageView _iview = pCreateInfo->pAttachments[i]; - framebuffer->attachments[i] = val_image_view_from_handle(_iview); + framebuffer->attachments[i] = lvp_image_view_from_handle(_iview); } framebuffer->width = pCreateInfo->width; framebuffer->height = pCreateInfo->height; framebuffer->layers = pCreateInfo->layers; - *pFramebuffer = val_framebuffer_to_handle(framebuffer); + *pFramebuffer = lvp_framebuffer_to_handle(framebuffer); return VK_SUCCESS; } -void val_DestroyFramebuffer( +void lvp_DestroyFramebuffer( VkDevice _device, VkFramebuffer _fb, const VkAllocationCallbacks* pAllocator) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_framebuffer, fb, _fb); + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_framebuffer, fb, _fb); if (!fb) return; @@ -1478,14 +1478,14 @@ void val_DestroyFramebuffer( vk_free2(&device->alloc, pAllocator, fb); } -VkResult val_WaitForFences( +VkResult lvp_WaitForFences( VkDevice _device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) { - VAL_FROM_HANDLE(val_device, device, _device); + LVP_FROM_HANDLE(lvp_device, device, _device); VkResult qret = queue_wait_idle(&device->queue, timeout); bool timeout_status = false; @@ -1494,7 +1494,7 @@ VkResult val_WaitForFences( mtx_lock(&device->fence_lock); for (unsigned i = 0; i < fenceCount; i++) { - struct val_fence *fence = val_fence_from_handle(pFences[i]); + struct lvp_fence *fence = lvp_fence_from_handle(pFences[i]); if (fence->signaled) continue; @@ -1518,15 +1518,15 @@ VkResult val_WaitForFences( return timeout_status ? VK_TIMEOUT : VK_SUCCESS; } -VkResult val_CreateSemaphore( +VkResult lvp_CreateSemaphore( VkDevice _device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) { - VAL_FROM_HANDLE(val_device, device, _device); + LVP_FROM_HANDLE(lvp_device, device, _device); - struct val_semaphore *sema = vk_alloc2(&device->alloc, pAllocator, + struct lvp_semaphore *sema = vk_alloc2(&device->alloc, pAllocator, sizeof(*sema), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); @@ -1534,18 +1534,18 @@ VkResult val_CreateSemaphore( return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); vk_object_base_init(&device->vk, &sema->base, VK_OBJECT_TYPE_SEMAPHORE); - *pSemaphore = val_semaphore_to_handle(sema); + *pSemaphore = lvp_semaphore_to_handle(sema); return VK_SUCCESS; } -void val_DestroySemaphore( +void lvp_DestroySemaphore( VkDevice _device, VkSemaphore _semaphore, const VkAllocationCallbacks* pAllocator) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_semaphore, semaphore, _semaphore); + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_semaphore, semaphore, _semaphore); if (!_semaphore) return; @@ -1553,14 +1553,14 @@ void val_DestroySemaphore( vk_free2(&device->alloc, pAllocator, semaphore); } -VkResult val_CreateEvent( +VkResult lvp_CreateEvent( VkDevice _device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) { - VAL_FROM_HANDLE(val_device, device, _device); - struct val_event *event = vk_alloc2(&device->alloc, pAllocator, + LVP_FROM_HANDLE(lvp_device, device, _device); + struct lvp_event *event = vk_alloc2(&device->alloc, pAllocator, sizeof(*event), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); @@ -1568,18 +1568,18 @@ VkResult val_CreateEvent( return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); vk_object_base_init(&device->vk, &event->base, VK_OBJECT_TYPE_EVENT); - *pEvent = val_event_to_handle(event); + *pEvent = lvp_event_to_handle(event); return VK_SUCCESS; } -void val_DestroyEvent( +void lvp_DestroyEvent( VkDevice _device, VkEvent _event, const VkAllocationCallbacks* pAllocator) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_event, event, _event); + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_event, event, _event); if (!event) return; @@ -1588,44 +1588,44 @@ void val_DestroyEvent( vk_free2(&device->alloc, pAllocator, event); } -VkResult val_GetEventStatus( +VkResult lvp_GetEventStatus( VkDevice _device, VkEvent _event) { - VAL_FROM_HANDLE(val_event, event, _event); + LVP_FROM_HANDLE(lvp_event, event, _event); if (event->event_storage == 1) return VK_EVENT_SET; return VK_EVENT_RESET; } -VkResult val_SetEvent( +VkResult lvp_SetEvent( VkDevice _device, VkEvent _event) { - VAL_FROM_HANDLE(val_event, event, _event); + LVP_FROM_HANDLE(lvp_event, event, _event); event->event_storage = 1; return VK_SUCCESS; } -VkResult val_ResetEvent( +VkResult lvp_ResetEvent( VkDevice _device, VkEvent _event) { - VAL_FROM_HANDLE(val_event, event, _event); + LVP_FROM_HANDLE(lvp_event, event, _event); event->event_storage = 0; return VK_SUCCESS; } -VkResult val_CreateSampler( +VkResult lvp_CreateSampler( VkDevice _device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) { - VAL_FROM_HANDLE(val_device, device, _device); - struct val_sampler *sampler; + LVP_FROM_HANDLE(lvp_device, device, _device); + struct lvp_sampler *sampler; assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO); @@ -1637,18 +1637,18 @@ VkResult val_CreateSampler( vk_object_base_init(&device->vk, &sampler->base, VK_OBJECT_TYPE_SAMPLER); sampler->create_info = *pCreateInfo; - *pSampler = val_sampler_to_handle(sampler); + *pSampler = lvp_sampler_to_handle(sampler); return VK_SUCCESS; } -void val_DestroySampler( +void lvp_DestroySampler( VkDevice _device, VkSampler _sampler, const VkAllocationCallbacks* pAllocator) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_sampler, sampler, _sampler); + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_sampler, sampler, _sampler); if (!_sampler) return; @@ -1656,47 +1656,47 @@ void val_DestroySampler( vk_free2(&device->alloc, pAllocator, sampler); } -VkResult val_CreatePrivateDataSlotEXT( +VkResult lvp_CreatePrivateDataSlotEXT( VkDevice _device, const VkPrivateDataSlotCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlotEXT* pPrivateDataSlot) { - VAL_FROM_HANDLE(val_device, device, _device); + LVP_FROM_HANDLE(lvp_device, device, _device); return vk_private_data_slot_create(&device->vk, pCreateInfo, pAllocator, pPrivateDataSlot); } -void val_DestroyPrivateDataSlotEXT( +void lvp_DestroyPrivateDataSlotEXT( VkDevice _device, VkPrivateDataSlotEXT privateDataSlot, const VkAllocationCallbacks* pAllocator) { - VAL_FROM_HANDLE(val_device, device, _device); + LVP_FROM_HANDLE(lvp_device, device, _device); vk_private_data_slot_destroy(&device->vk, privateDataSlot, pAllocator); } -VkResult val_SetPrivateDataEXT( +VkResult lvp_SetPrivateDataEXT( VkDevice _device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t data) { - VAL_FROM_HANDLE(val_device, device, _device); + LVP_FROM_HANDLE(lvp_device, device, _device); return vk_object_base_set_private_data(&device->vk, objectType, objectHandle, privateDataSlot, data); } -void val_GetPrivateDataEXT( +void lvp_GetPrivateDataEXT( VkDevice _device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t* pData) { - VAL_FROM_HANDLE(val_device, device, _device); + LVP_FROM_HANDLE(lvp_device, device, _device); vk_object_base_get_private_data(&device->vk, objectType, objectHandle, privateDataSlot, pData); } diff --git a/src/gallium/frontends/vallium/val_entrypoints_gen.py b/src/gallium/frontends/lavapipe/lvp_entrypoints_gen.py similarity index 88% rename from src/gallium/frontends/vallium/val_entrypoints_gen.py rename to src/gallium/frontends/lavapipe/lvp_entrypoints_gen.py index c44ac6f..84ccd90 100644 --- a/src/gallium/frontends/vallium/val_entrypoints_gen.py +++ b/src/gallium/frontends/lavapipe/lvp_entrypoints_gen.py @@ -31,23 +31,23 @@ import xml.etree.ElementTree as et from collections import OrderedDict, namedtuple from mako.template import Template -from val_extensions import * +from lvp_extensions import * # We generate a static hash table for entry point lookup # (vkGetProcAddress). We use a linear congruential generator for our hash # function and a power-of-two size table. The prime numbers are determined # experimentally. -# We currently don't use layers in val, but keeping the ability for anv +# We currently don't use layers in lvp, but keeping the ability for anv # anyways, so we can use it for device groups. LAYERS = [ - 'val' + 'lvp' ] TEMPLATE_H = Template("""\ /* This file generated from ${filename}, don't edit directly. */ -struct val_instance_dispatch_table { +struct lvp_instance_dispatch_table { union { void *entrypoints[${len(instance_entrypoints)}]; struct { @@ -66,7 +66,7 @@ struct val_instance_dispatch_table { }; }; -struct val_physical_device_dispatch_table { +struct lvp_physical_device_dispatch_table { union { void *entrypoints[${len(physical_device_entrypoints)}]; struct { @@ -85,7 +85,7 @@ struct val_physical_device_dispatch_table { }; }; -struct val_device_dispatch_table { +struct lvp_device_dispatch_table { union { void *entrypoints[${len(device_entrypoints)}]; struct { @@ -104,12 +104,12 @@ struct val_device_dispatch_table { }; }; -extern const struct val_instance_dispatch_table val_instance_dispatch_table; +extern const struct lvp_instance_dispatch_table lvp_instance_dispatch_table; %for layer in LAYERS: -extern const struct val_physical_device_dispatch_table ${layer}_physical_device_dispatch_table; +extern const struct lvp_physical_device_dispatch_table ${layer}_physical_device_dispatch_table; %endfor %for layer in LAYERS: -extern const struct val_device_dispatch_table ${layer}_device_dispatch_table; +extern const struct lvp_device_dispatch_table ${layer}_device_dispatch_table; %endfor % for e in instance_entrypoints: @@ -119,7 +119,7 @@ extern const struct val_device_dispatch_table ${layer}_device_dispatch_table; % if e.guard is not None: #ifdef ${e.guard} % endif - ${e.return_type} ${e.prefixed_name('val')}(${e.decl_params()}); + ${e.return_type} ${e.prefixed_name('lvp')}(${e.decl_params()}); % if e.guard is not None: #endif // ${e.guard} % endif @@ -182,7 +182,7 @@ TEMPLATE_C = Template(u"""\ /* This file generated from ${filename}, don't edit directly. */ -#include "val_private.h" +#include "lvp_private.h" #include "util/macros.h" struct string_map_entry { @@ -279,18 +279,18 @@ ${strmap(device_strmap, 'device')} % if e.guard is not None: #ifdef ${e.guard} % endif - ${e.return_type} ${e.prefixed_name('val')}(${e.decl_params()}) __attribute__ ((weak)); + ${e.return_type} ${e.prefixed_name('lvp')}(${e.decl_params()}) __attribute__ ((weak)); % if e.guard is not None: #endif // ${e.guard} % endif % endfor -const struct val_instance_dispatch_table val_instance_dispatch_table = { +const struct lvp_instance_dispatch_table lvp_instance_dispatch_table = { % for e in instance_entrypoints: % if e.guard is not None: #ifdef ${e.guard} % endif - .${e.name} = ${e.prefixed_name('val')}, + .${e.name} = ${e.prefixed_name('lvp')}, % if e.guard is not None: #endif // ${e.guard} % endif @@ -304,18 +304,18 @@ const struct val_instance_dispatch_table val_instance_dispatch_table = { % if e.guard is not None: #ifdef ${e.guard} % endif - ${e.return_type} ${e.prefixed_name('val')}(${e.decl_params()}) __attribute__ ((weak)); + ${e.return_type} ${e.prefixed_name('lvp')}(${e.decl_params()}) __attribute__ ((weak)); % if e.guard is not None: #endif // ${e.guard} % endif % endfor -const struct val_physical_device_dispatch_table val_physical_device_dispatch_table = { +const struct lvp_physical_device_dispatch_table lvp_physical_device_dispatch_table = { % for e in physical_device_entrypoints: % if e.guard is not None: #ifdef ${e.guard} % endif - .${e.name} = ${e.prefixed_name('val')}, + .${e.name} = ${e.prefixed_name('lvp')}, % if e.guard is not None: #endif // ${e.guard} % endif @@ -331,19 +331,19 @@ const struct val_physical_device_dispatch_table val_physical_device_dispatch_tab % if e.guard is not None: #ifdef ${e.guard} % endif - % if layer == 'val': + % if layer == 'lvp': ${e.return_type} __attribute__ ((weak)) - ${e.prefixed_name('val')}(${e.decl_params()}) + ${e.prefixed_name('lvp')}(${e.decl_params()}) { % if e.params[0].type == 'VkDevice': - VAL_FROM_HANDLE(val_device, val_device, ${e.params[0].name}); - return val_device->dispatch.${e.name}(${e.call_params()}); + LVP_FROM_HANDLE(lvp_device, lvp_device, ${e.params[0].name}); + return lvp_device->dispatch.${e.name}(${e.call_params()}); % elif e.params[0].type == 'VkCommandBuffer': - VAL_FROM_HANDLE(val_cmd_buffer, val_cmd_buffer, ${e.params[0].name}); - return val_cmd_buffer->device->dispatch.${e.name}(${e.call_params()}); + LVP_FROM_HANDLE(lvp_cmd_buffer, lvp_cmd_buffer, ${e.params[0].name}); + return lvp_cmd_buffer->device->dispatch.${e.name}(${e.call_params()}); % elif e.params[0].type == 'VkQueue': - VAL_FROM_HANDLE(val_queue, val_queue, ${e.params[0].name}); - return val_queue->device->dispatch.${e.name}(${e.call_params()}); + LVP_FROM_HANDLE(lvp_queue, lvp_queue, ${e.params[0].name}); + return lvp_queue->device->dispatch.${e.name}(${e.call_params()}); % else: assert(!"Unhandled device child trampoline case: ${e.params[0].type}"); % endif @@ -356,7 +356,7 @@ const struct val_physical_device_dispatch_table val_physical_device_dispatch_tab % endif % endfor - const struct val_device_dispatch_table ${layer}_device_dispatch_table = { + const struct lvp_device_dispatch_table ${layer}_device_dispatch_table = { % for e in device_entrypoints: % if e.guard is not None: #ifdef ${e.guard} @@ -376,8 +376,8 @@ const struct val_physical_device_dispatch_table val_physical_device_dispatch_tab * If device is NULL, all device extensions are considered enabled. */ bool -val_instance_entrypoint_is_enabled(int index, uint32_t core_version, - const struct val_instance_extension_table *instance) +lvp_instance_entrypoint_is_enabled(int index, uint32_t core_version, + const struct lvp_instance_extension_table *instance) { switch (index) { % for e in instance_entrypoints: @@ -410,8 +410,8 @@ val_instance_entrypoint_is_enabled(int index, uint32_t core_version, * If device is NULL, all device extensions are considered enabled. */ bool -val_physical_device_entrypoint_is_enabled(int index, uint32_t core_version, - const struct val_instance_extension_table *instance) +lvp_physical_device_entrypoint_is_enabled(int index, uint32_t core_version, + const struct lvp_instance_extension_table *instance) { switch (index) { % for e in physical_device_entrypoints: @@ -444,9 +444,9 @@ val_physical_device_entrypoint_is_enabled(int index, uint32_t core_version, * If device is NULL, all device extensions are considered enabled. */ bool -val_device_entrypoint_is_enabled(int index, uint32_t core_version, - const struct val_instance_extension_table *instance, - const struct val_device_extension_table *device) +lvp_device_entrypoint_is_enabled(int index, uint32_t core_version, + const struct lvp_instance_extension_table *instance, + const struct lvp_device_extension_table *device) { switch (index) { % for e in device_entrypoints: @@ -473,61 +473,61 @@ val_device_entrypoint_is_enabled(int index, uint32_t core_version, } int -val_get_instance_entrypoint_index(const char *name) +lvp_get_instance_entrypoint_index(const char *name) { return instance_string_map_lookup(name); } int -val_get_physical_device_entrypoint_index(const char *name) +lvp_get_physical_device_entrypoint_index(const char *name) { return physical_device_string_map_lookup(name); } int -val_get_device_entrypoint_index(const char *name) +lvp_get_device_entrypoint_index(const char *name) { return device_string_map_lookup(name); } const char * -val_get_instance_entry_name(int index) +lvp_get_instance_entry_name(int index) { return instance_entry_name(index); } const char * -val_get_physical_device_entry_name(int index) +lvp_get_physical_device_entry_name(int index) { return physical_device_entry_name(index); } const char * -val_get_device_entry_name(int index) +lvp_get_device_entry_name(int index) { return device_entry_name(index); } static void * __attribute__ ((noinline)) -val_resolve_device_entrypoint(uint32_t index) +lvp_resolve_device_entrypoint(uint32_t index) { - return val_device_dispatch_table.entrypoints[index]; + return lvp_device_dispatch_table.entrypoints[index]; } void * -val_lookup_entrypoint(const char *name) +lvp_lookup_entrypoint(const char *name) { - int idx = val_get_instance_entrypoint_index(name); + int idx = lvp_get_instance_entrypoint_index(name); if (idx >= 0) - return val_instance_dispatch_table.entrypoints[idx]; + return lvp_instance_dispatch_table.entrypoints[idx]; - idx = val_get_physical_device_entrypoint_index(name); + idx = lvp_get_physical_device_entrypoint_index(name); if (idx >= 0) - return val_physical_device_dispatch_table.entrypoints[idx]; + return lvp_physical_device_dispatch_table.entrypoints[idx]; - idx = val_get_device_entrypoint_index(name); + idx = lvp_get_device_entrypoint_index(name); if (idx >= 0) - return val_resolve_device_entrypoint(idx); + return lvp_resolve_device_entrypoint(idx); return NULL; }""", output_encoding='utf-8') @@ -781,16 +781,16 @@ def main(): e.num = num instance_strmap.bake() - # For outputting entrypoints.h we generate a val_EntryPoint() prototype + # For outputting entrypoints.h we generate a lvp_EntryPoint() prototype # per entry point. try: - with open(os.path.join(args.outdir, 'val_entrypoints.h'), 'wb') as f: + with open(os.path.join(args.outdir, 'lvp_entrypoints.h'), 'wb') as f: f.write(TEMPLATE_H.render(instance_entrypoints=instance_entrypoints, physical_device_entrypoints=physical_device_entrypoints, device_entrypoints=device_entrypoints, LAYERS=LAYERS, filename=os.path.basename(__file__))) - with open(os.path.join(args.outdir, 'val_entrypoints.c'), 'wb') as f: + with open(os.path.join(args.outdir, 'lvp_entrypoints.c'), 'wb') as f: f.write(TEMPLATE_C.render(instance_entrypoints=instance_entrypoints, physical_device_entrypoints=physical_device_entrypoints, device_entrypoints=device_entrypoints, diff --git a/src/gallium/frontends/vallium/val_execute.c b/src/gallium/frontends/lavapipe/lvp_execute.c similarity index 90% rename from src/gallium/frontends/vallium/val_execute.c rename to src/gallium/frontends/lavapipe/lvp_execute.c index d7f3cad..419e631 100644 --- a/src/gallium/frontends/vallium/val_execute.c +++ b/src/gallium/frontends/lavapipe/lvp_execute.c @@ -23,11 +23,11 @@ /* use a gallium context to execute a command buffer */ -#include "val_private.h" +#include "lvp_private.h" #include "pipe/p_context.h" #include "pipe/p_state.h" -#include "val_conv.h" +#include "lvp_conv.h" #include "pipe/p_shader_tokens.h" #include "tgsi/tgsi_text.h" @@ -111,15 +111,15 @@ struct rendering_state { uint8_t push_constants[128 * 4]; - struct val_render_pass *pass; + struct lvp_render_pass *pass; uint32_t subpass; - struct val_framebuffer *vk_framebuffer; + struct lvp_framebuffer *vk_framebuffer; VkRect2D render_area; uint32_t sample_mask; unsigned min_samples; - struct val_attachment_state *attachments; + struct lvp_attachment_state *attachments; }; static void emit_compute_state(struct rendering_state *state) @@ -312,10 +312,10 @@ static void emit_state(struct rendering_state *state) } } -static void handle_compute_pipeline(struct val_cmd_buffer_entry *cmd, +static void handle_compute_pipeline(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { - struct val_pipeline *pipeline = cmd->u.pipeline.pipeline; + struct lvp_pipeline *pipeline = cmd->u.pipeline.pipeline; state->dispatch_info.block[0] = pipeline->pipeline_nir[MESA_SHADER_COMPUTE]->info.cs.local_size[0]; state->dispatch_info.block[1] = pipeline->pipeline_nir[MESA_SHADER_COMPUTE]->info.cs.local_size[1]; @@ -343,10 +343,10 @@ get_viewport_xform(const VkViewport *viewport, translate[2] = n; } -static void handle_graphics_pipeline(struct val_cmd_buffer_entry *cmd, +static void handle_graphics_pipeline(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { - struct val_pipeline *pipeline = cmd->u.pipeline.pipeline; + struct lvp_pipeline *pipeline = cmd->u.pipeline.pipeline; bool dynamic_states[VK_DYNAMIC_STATE_STENCIL_REFERENCE+1]; unsigned fb_samples = 0; @@ -618,21 +618,21 @@ static void handle_graphics_pipeline(struct val_cmd_buffer_entry *cmd, } } -static void handle_pipeline(struct val_cmd_buffer_entry *cmd, +static void handle_pipeline(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { - struct val_pipeline *pipeline = cmd->u.pipeline.pipeline; + struct lvp_pipeline *pipeline = cmd->u.pipeline.pipeline; if (pipeline->is_compute_pipeline) handle_compute_pipeline(cmd, state); else handle_graphics_pipeline(cmd, state); } -static void handle_vertex_buffers(struct val_cmd_buffer_entry *cmd, +static void handle_vertex_buffers(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { int i; - struct val_cmd_bind_vertex_buffers *vcb = &cmd->u.vertex_buffers; + struct lvp_cmd_bind_vertex_buffers *vcb = &cmd->u.vertex_buffers; for (i = 0; i < vcb->binding_count; i++) { int idx = i + vcb->first; @@ -661,7 +661,7 @@ struct dyn_info { }; static void fill_sampler(struct pipe_sampler_state *ss, - struct val_sampler *samp) + struct lvp_sampler *samp) { ss->wrap_s = vk_conv_wrap_mode(samp->create_info.addressModeU); ss->wrap_t = vk_conv_wrap_mode(samp->create_info.addressModeV); @@ -708,8 +708,8 @@ static void fill_sampler_stage(struct rendering_state *state, gl_shader_stage stage, enum pipe_shader_type p_stage, int array_idx, - const struct val_descriptor *descriptor, - const struct val_descriptor_set_binding_layout *binding) + const struct lvp_descriptor *descriptor, + const struct lvp_descriptor_set_binding_layout *binding) { int ss_idx = binding->stage[stage].sampler_index; if (ss_idx == -1) @@ -727,15 +727,15 @@ static void fill_sampler_view_stage(struct rendering_state *state, gl_shader_stage stage, enum pipe_shader_type p_stage, int array_idx, - const struct val_descriptor *descriptor, - const struct val_descriptor_set_binding_layout *binding) + const struct lvp_descriptor *descriptor, + const struct lvp_descriptor_set_binding_layout *binding) { int sv_idx = binding->stage[stage].sampler_view_index; if (sv_idx == -1) return; sv_idx += array_idx; sv_idx += dyn_info->stage[stage].sampler_view_count; - struct val_image_view *iv = descriptor->image_view; + struct lvp_image_view *iv = descriptor->image_view; struct pipe_sampler_view templ; enum pipe_format pformat; @@ -755,9 +755,9 @@ static void fill_sampler_view_stage(struct rendering_state *state, if (iv->view_type == VK_IMAGE_VIEW_TYPE_CUBE) templ.target = PIPE_TEXTURE_CUBE; templ.u.tex.first_layer = iv->subresourceRange.baseArrayLayer; - templ.u.tex.last_layer = iv->subresourceRange.baseArrayLayer + val_get_layerCount(iv->image, &iv->subresourceRange) - 1; + templ.u.tex.last_layer = iv->subresourceRange.baseArrayLayer + lvp_get_layerCount(iv->image, &iv->subresourceRange) - 1; templ.u.tex.first_level = iv->subresourceRange.baseMipLevel; - templ.u.tex.last_level = iv->subresourceRange.baseMipLevel + val_get_levelCount(iv->image, &iv->subresourceRange) - 1; + templ.u.tex.last_level = iv->subresourceRange.baseMipLevel + lvp_get_levelCount(iv->image, &iv->subresourceRange) - 1; if (iv->components.r != VK_COMPONENT_SWIZZLE_IDENTITY) templ.swizzle_r = vk_conv_swizzle(iv->components.r); if (iv->components.g != VK_COMPONENT_SWIZZLE_IDENTITY) @@ -786,15 +786,15 @@ static void fill_sampler_buffer_view_stage(struct rendering_state *state, gl_shader_stage stage, enum pipe_shader_type p_stage, int array_idx, - const struct val_descriptor *descriptor, - const struct val_descriptor_set_binding_layout *binding) + const struct lvp_descriptor *descriptor, + const struct lvp_descriptor_set_binding_layout *binding) { int sv_idx = binding->stage[stage].sampler_view_index; if (sv_idx == -1) return; sv_idx += array_idx; sv_idx += dyn_info->stage[stage].sampler_view_count; - struct val_buffer_view *bv = descriptor->buffer_view; + struct lvp_buffer_view *bv = descriptor->buffer_view; struct pipe_sampler_view templ; memset(&templ, 0, sizeof(templ)); templ.target = PIPE_BUFFER; @@ -821,10 +821,10 @@ static void fill_image_view_stage(struct rendering_state *state, gl_shader_stage stage, enum pipe_shader_type p_stage, int array_idx, - const struct val_descriptor *descriptor, - const struct val_descriptor_set_binding_layout *binding) + const struct lvp_descriptor *descriptor, + const struct lvp_descriptor_set_binding_layout *binding) { - struct val_image_view *iv = descriptor->image_view; + struct lvp_image_view *iv = descriptor->image_view; int idx = binding->stage[stage].image_index; if (idx == -1) return; @@ -843,7 +843,7 @@ static void fill_image_view_stage(struct rendering_state *state, state->iv[p_stage][idx].u.tex.last_layer = u_minify(iv->image->bo->depth0, iv->subresourceRange.baseMipLevel) - 1; } else { state->iv[p_stage][idx].u.tex.first_layer = iv->subresourceRange.baseArrayLayer; - state->iv[p_stage][idx].u.tex.last_layer = iv->subresourceRange.baseArrayLayer + val_get_layerCount(iv->image, &iv->subresourceRange) - 1; + state->iv[p_stage][idx].u.tex.last_layer = iv->subresourceRange.baseArrayLayer + lvp_get_layerCount(iv->image, &iv->subresourceRange) - 1; } state->iv[p_stage][idx].u.tex.level = iv->subresourceRange.baseMipLevel; if (state->num_shader_images[p_stage] <= idx) @@ -856,10 +856,10 @@ static void fill_image_buffer_view_stage(struct rendering_state *state, gl_shader_stage stage, enum pipe_shader_type p_stage, int array_idx, - const struct val_descriptor *descriptor, - const struct val_descriptor_set_binding_layout *binding) + const struct lvp_descriptor *descriptor, + const struct lvp_descriptor_set_binding_layout *binding) { - struct val_buffer_view *bv = descriptor->buffer_view; + struct lvp_buffer_view *bv = descriptor->buffer_view; int idx = binding->stage[stage].image_index; if (idx == -1) return; @@ -876,11 +876,11 @@ static void fill_image_buffer_view_stage(struct rendering_state *state, static void handle_descriptor(struct rendering_state *state, struct dyn_info *dyn_info, - const struct val_descriptor_set_binding_layout *binding, + const struct lvp_descriptor_set_binding_layout *binding, gl_shader_stage stage, enum pipe_shader_type p_stage, int array_idx, - const struct val_descriptor *descriptor) + const struct lvp_descriptor *descriptor) { bool is_dynamic = descriptor->type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC || descriptor->type == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; @@ -961,14 +961,14 @@ static void handle_descriptor(struct rendering_state *state, static void handle_set_stage(struct rendering_state *state, struct dyn_info *dyn_info, - const struct val_descriptor_set *set, + const struct lvp_descriptor_set *set, gl_shader_stage stage, enum pipe_shader_type p_stage) { int j; for (j = 0; j < set->layout->binding_count; j++) { - const struct val_descriptor_set_binding_layout *binding; - const struct val_descriptor *descriptor; + const struct lvp_descriptor_set_binding_layout *binding; + const struct lvp_descriptor *descriptor; binding = &set->layout->binding[j]; if (binding->valid) { @@ -981,7 +981,7 @@ static void handle_set_stage(struct rendering_state *state, } static void increment_dyn_info(struct dyn_info *dyn_info, - struct val_descriptor_set_layout *layout, bool inc_dyn) + struct lvp_descriptor_set_layout *layout, bool inc_dyn) { for (gl_shader_stage stage = MESA_SHADER_VERTEX; stage < MESA_SHADER_STAGES; stage++) { dyn_info->stage[stage].const_buffer_count += layout->stage[stage].const_buffer_count; @@ -994,18 +994,18 @@ 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 val_cmd_buffer_entry *cmd, +static void handle_compute_descriptor_sets(struct lvp_cmd_buffer_entry *cmd, struct dyn_info *dyn_info, struct rendering_state *state) { - struct val_cmd_bind_descriptor_sets *bds = &cmd->u.descriptor_sets; + struct lvp_cmd_bind_descriptor_sets *bds = &cmd->u.descriptor_sets; int i; for (i = 0; i < bds->first; i++) { increment_dyn_info(dyn_info, bds->layout->set[i].layout, false); } for (i = 0; i < bds->count; i++) { - const struct val_descriptor_set *set = bds->sets[i]; + const struct lvp_descriptor_set *set = bds->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); @@ -1013,10 +1013,10 @@ static void handle_compute_descriptor_sets(struct val_cmd_buffer_entry *cmd, } } -static void handle_descriptor_sets(struct val_cmd_buffer_entry *cmd, +static void handle_descriptor_sets(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { - struct val_cmd_bind_descriptor_sets *bds = &cmd->u.descriptor_sets; + struct lvp_cmd_bind_descriptor_sets *bds = &cmd->u.descriptor_sets; int i; struct dyn_info dyn_info; @@ -1035,7 +1035,7 @@ static void handle_descriptor_sets(struct val_cmd_buffer_entry *cmd, } for (i = 0; i < bds->count; i++) { - const struct val_descriptor_set *set = bds->sets[i]; + const struct lvp_descriptor_set *set = bds->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); @@ -1056,7 +1056,7 @@ static void handle_descriptor_sets(struct val_cmd_buffer_entry *cmd, } static void add_img_view_surface(struct rendering_state *state, - struct val_image_view *imgv, VkFormat format, int width, int height) + struct lvp_image_view *imgv, VkFormat format, int width, int height) { if (!imgv->surface) { struct pipe_surface template; @@ -1067,7 +1067,7 @@ static void add_img_view_surface(struct rendering_state *state, template.width = width; template.height = height; template.u.tex.first_layer = imgv->subresourceRange.baseArrayLayer; - template.u.tex.last_layer = imgv->subresourceRange.baseArrayLayer + val_get_layerCount(imgv->image, &imgv->subresourceRange) - 1; + template.u.tex.last_layer = imgv->subresourceRange.baseArrayLayer + lvp_get_layerCount(imgv->image, &imgv->subresourceRange) - 1; template.u.tex.level = imgv->subresourceRange.baseMipLevel; if (template.format == PIPE_FORMAT_NONE) @@ -1089,7 +1089,7 @@ static bool subpass_needs_clear(struct rendering_state *state) { uint32_t a; - struct val_subpass *subpass = &state->pass->subpasses[state->subpass]; + struct lvp_subpass *subpass = &state->pass->subpasses[state->subpass]; for (uint32_t i = 0; i < subpass->color_count; i++) { a = subpass->color_attachments[i].attachment; if (attachment_needs_clear(state, a)) @@ -1105,7 +1105,7 @@ subpass_needs_clear(struct rendering_state *state) static void render_subpass_clear(struct rendering_state *state) { - struct val_subpass *subpass = &state->pass->subpasses[state->subpass]; + struct lvp_subpass *subpass = &state->pass->subpasses[state->subpass]; if (!subpass_needs_clear(state)) return; @@ -1116,8 +1116,8 @@ static void render_subpass_clear(struct rendering_state *state) if (!attachment_needs_clear(state, a)) continue; - struct val_render_pass_attachment *att = &state->pass->attachments[a]; - struct val_image_view *imgv = state->vk_framebuffer->attachments[a]; + struct lvp_render_pass_attachment *att = &state->pass->attachments[a]; + struct lvp_image_view *imgv = state->vk_framebuffer->attachments[a]; add_img_view_surface(state, imgv, att->format, state->framebuffer.width, state->framebuffer.height); @@ -1143,8 +1143,8 @@ static void render_subpass_clear(struct rendering_state *state) if (!attachment_needs_clear(state, ds)) return; - struct val_render_pass_attachment *att = &state->pass->attachments[ds]; - struct val_image_view *imgv = state->vk_framebuffer->attachments[ds]; + struct lvp_render_pass_attachment *att = &state->pass->attachments[ds]; + struct lvp_image_view *imgv = state->vk_framebuffer->attachments[ds]; add_img_view_surface(state, imgv, att->format, state->framebuffer.width, state->framebuffer.height); @@ -1179,18 +1179,18 @@ static void render_subpass_clear(struct rendering_state *state) static void render_pass_resolve(struct rendering_state *state) { - struct val_subpass *subpass = &state->pass->subpasses[state->subpass]; + struct lvp_subpass *subpass = &state->pass->subpasses[state->subpass]; if (!subpass->has_color_resolve) return; for (uint32_t i = 0; i < subpass->color_count; i++) { - struct val_subpass_attachment src_att = subpass->color_attachments[i]; - struct val_subpass_attachment dst_att = subpass->resolve_attachments[i]; + struct lvp_subpass_attachment src_att = subpass->color_attachments[i]; + struct lvp_subpass_attachment dst_att = subpass->resolve_attachments[i]; if (dst_att.attachment == VK_ATTACHMENT_UNUSED) continue; - struct val_image_view *src_imgv = state->vk_framebuffer->attachments[src_att.attachment]; - struct val_image_view *dst_imgv = state->vk_framebuffer->attachments[dst_att.attachment]; + struct lvp_image_view *src_imgv = state->vk_framebuffer->attachments[src_att.attachment]; + struct lvp_image_view *dst_imgv = state->vk_framebuffer->attachments[dst_att.attachment]; struct pipe_blit_info info; memset(&info, 0, sizeof(info)); @@ -1222,11 +1222,11 @@ static void begin_render_subpass(struct rendering_state *state, state->framebuffer.nr_cbufs = 0; - struct val_subpass *subpass = &state->pass->subpasses[subpass_idx]; + struct lvp_subpass *subpass = &state->pass->subpasses[subpass_idx]; for (unsigned i = 0; i < subpass->color_count; i++) { - struct val_subpass_attachment *color_att = &subpass->color_attachments[i]; + struct lvp_subpass_attachment *color_att = &subpass->color_attachments[i]; if (color_att->attachment != VK_ATTACHMENT_UNUSED) { - struct val_image_view *imgv = state->vk_framebuffer->attachments[color_att->attachment]; + struct lvp_image_view *imgv = state->vk_framebuffer->attachments[color_att->attachment]; add_img_view_surface(state, imgv, state->pass->attachments[color_att->attachment].format, state->framebuffer.width, state->framebuffer.height); state->framebuffer.cbufs[state->framebuffer.nr_cbufs] = imgv->surface; @@ -1236,10 +1236,10 @@ static void begin_render_subpass(struct rendering_state *state, } if (subpass->depth_stencil_attachment) { - struct val_subpass_attachment *ds_att = subpass->depth_stencil_attachment; + struct lvp_subpass_attachment *ds_att = subpass->depth_stencil_attachment; if (ds_att->attachment != VK_ATTACHMENT_UNUSED) { - struct val_image_view *imgv = state->vk_framebuffer->attachments[ds_att->attachment]; + struct lvp_image_view *imgv = state->vk_framebuffer->attachments[ds_att->attachment]; add_img_view_surface(state, imgv, state->pass->attachments[ds_att->attachment].format, state->framebuffer.width, state->framebuffer.height); state->framebuffer.zsbuf = imgv->surface; } @@ -1249,7 +1249,7 @@ static void begin_render_subpass(struct rendering_state *state, &state->framebuffer); } -static void handle_begin_render_pass(struct val_cmd_buffer_entry *cmd, +static void handle_begin_render_pass(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { state->pass = cmd->u.begin_render_pass.render_pass; @@ -1265,7 +1265,7 @@ static void handle_begin_render_pass(struct val_cmd_buffer_entry *cmd, begin_render_subpass(state, 0); } -static void handle_end_render_pass(struct val_cmd_buffer_entry *cmd, +static void handle_end_render_pass(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { state->pctx->flush(state->pctx, NULL, 0); @@ -1277,7 +1277,7 @@ static void handle_end_render_pass(struct val_cmd_buffer_entry *cmd, state->subpass = 0; } -static void handle_next_subpass(struct val_cmd_buffer_entry *cmd, +static void handle_next_subpass(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { state->pctx->flush(state->pctx, NULL, 0); @@ -1286,7 +1286,7 @@ static void handle_next_subpass(struct val_cmd_buffer_entry *cmd, begin_render_subpass(state, state->subpass); } -static void handle_draw(struct val_cmd_buffer_entry *cmd, +static void handle_draw(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { state->info.index_size = 0; @@ -1299,7 +1299,7 @@ static void handle_draw(struct val_cmd_buffer_entry *cmd, state->pctx->draw_vbo(state->pctx, &state->info); } -static void handle_set_viewport(struct val_cmd_buffer_entry *cmd, +static void handle_set_viewport(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { int i; @@ -1312,7 +1312,7 @@ static void handle_set_viewport(struct val_cmd_buffer_entry *cmd, state->vp_dirty = true; } -static void handle_set_scissor(struct val_cmd_buffer_entry *cmd, +static void handle_set_scissor(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { int i; @@ -1328,14 +1328,14 @@ static void handle_set_scissor(struct val_cmd_buffer_entry *cmd, state->scissor_dirty = true; } -static void handle_set_line_width(struct val_cmd_buffer_entry *cmd, +static void handle_set_line_width(struct lvp_cmd_buffer_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 val_cmd_buffer_entry *cmd, +static void handle_set_depth_bias(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { state->rs_state.offset_units = cmd->u.set_depth_bias.constant_factor; @@ -1344,14 +1344,14 @@ static void handle_set_depth_bias(struct val_cmd_buffer_entry *cmd, state->rs_dirty = true; } -static void handle_set_blend_constants(struct val_cmd_buffer_entry *cmd, +static void handle_set_blend_constants(struct lvp_cmd_buffer_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 val_cmd_buffer_entry *cmd, +static void handle_set_depth_bounds(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { state->dsa_state.depth.bounds_min = cmd->u.set_depth_bounds.min_depth; @@ -1359,7 +1359,7 @@ static void handle_set_depth_bounds(struct val_cmd_buffer_entry *cmd, state->dsa_dirty = true; } -static void handle_set_stencil_compare_mask(struct val_cmd_buffer_entry *cmd, +static void handle_set_stencil_compare_mask(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { if (cmd->u.stencil_vals.face_mask & VK_STENCIL_FACE_FRONT_BIT) @@ -1369,7 +1369,7 @@ static void handle_set_stencil_compare_mask(struct val_cmd_buffer_entry *cmd, state->dsa_dirty = true; } -static void handle_set_stencil_write_mask(struct val_cmd_buffer_entry *cmd, +static void handle_set_stencil_write_mask(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { if (cmd->u.stencil_vals.face_mask & VK_STENCIL_FACE_FRONT_BIT) @@ -1379,7 +1379,7 @@ static void handle_set_stencil_write_mask(struct val_cmd_buffer_entry *cmd, state->dsa_dirty = true; } -static void handle_set_stencil_reference(struct val_cmd_buffer_entry *cmd, +static void handle_set_stencil_reference(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { if (cmd->u.stencil_vals.face_mask & VK_STENCIL_FACE_FRONT_BIT) @@ -1499,11 +1499,11 @@ copy_depth_box(ubyte *dst, } } -static void handle_copy_image_to_buffer(struct val_cmd_buffer_entry *cmd, +static void handle_copy_image_to_buffer(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { int i; - struct val_cmd_copy_image_to_buffer *copycmd = &cmd->u.img_to_buffer; + struct lvp_cmd_copy_image_to_buffer *copycmd = &cmd->u.img_to_buffer; struct pipe_box box, dbox; struct pipe_transfer *src_t, *dst_t; ubyte *src_data, *dst_data; @@ -1578,11 +1578,11 @@ static void handle_copy_image_to_buffer(struct val_cmd_buffer_entry *cmd, } } -static void handle_copy_buffer_to_image(struct val_cmd_buffer_entry *cmd, +static void handle_copy_buffer_to_image(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { int i; - struct val_cmd_copy_buffer_to_image *copycmd = &cmd->u.buffer_to_img; + struct lvp_cmd_copy_buffer_to_image *copycmd = &cmd->u.buffer_to_img; struct pipe_box box, sbox; struct pipe_transfer *src_t, *dst_t; void *src_data, *dst_data; @@ -1660,11 +1660,11 @@ static void handle_copy_buffer_to_image(struct val_cmd_buffer_entry *cmd, } } -static void handle_copy_image(struct val_cmd_buffer_entry *cmd, +static void handle_copy_image(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { int i; - struct val_cmd_copy_image *copycmd = &cmd->u.copy_image; + struct lvp_cmd_copy_image *copycmd = &cmd->u.copy_image; state->pctx->flush(state->pctx, NULL, 0); @@ -1688,11 +1688,11 @@ static void handle_copy_image(struct val_cmd_buffer_entry *cmd, } } -static void handle_copy_buffer(struct val_cmd_buffer_entry *cmd, +static void handle_copy_buffer(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { int i; - struct val_cmd_copy_buffer *copycmd = &cmd->u.copy_buffer; + struct lvp_cmd_copy_buffer *copycmd = &cmd->u.copy_buffer; for (i = 0; i < copycmd->region_count; i++) { struct pipe_box box = { 0 }; @@ -1703,11 +1703,11 @@ static void handle_copy_buffer(struct val_cmd_buffer_entry *cmd, } } -static void handle_blit_image(struct val_cmd_buffer_entry *cmd, +static void handle_blit_image(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { int i; - struct val_cmd_blit_image *blitcmd = &cmd->u.blit_image; + struct lvp_cmd_blit_image *blitcmd = &cmd->u.blit_image; struct pipe_blit_info info; memset(&info, 0, sizeof(info)); @@ -1773,10 +1773,10 @@ static void handle_blit_image(struct val_cmd_buffer_entry *cmd, } } -static void handle_fill_buffer(struct val_cmd_buffer_entry *cmd, +static void handle_fill_buffer(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { - struct val_cmd_fill_buffer *fillcmd = &cmd->u.fill_buffer; + struct lvp_cmd_fill_buffer *fillcmd = &cmd->u.fill_buffer; uint32_t *dst; struct pipe_transfer *dst_t; struct pipe_box box; @@ -1798,10 +1798,10 @@ static void handle_fill_buffer(struct val_cmd_buffer_entry *cmd, state->pctx->transfer_unmap(state->pctx, dst_t); } -static void handle_update_buffer(struct val_cmd_buffer_entry *cmd, +static void handle_update_buffer(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { - struct val_cmd_update_buffer *updcmd = &cmd->u.update_buffer; + struct lvp_cmd_update_buffer *updcmd = &cmd->u.update_buffer; uint32_t *dst; struct pipe_transfer *dst_t; struct pipe_box box; @@ -1818,7 +1818,7 @@ static void handle_update_buffer(struct val_cmd_buffer_entry *cmd, state->pctx->transfer_unmap(state->pctx, dst_t); } -static void handle_draw_indexed(struct val_cmd_buffer_entry *cmd, +static void handle_draw_indexed(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { state->info.indirect = NULL; @@ -1842,7 +1842,7 @@ static void handle_draw_indexed(struct val_cmd_buffer_entry *cmd, state->pctx->draw_vbo(state->pctx, &state->info); } -static void handle_draw_indirect(struct val_cmd_buffer_entry *cmd, +static void handle_draw_indirect(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state, bool indexed) { if (indexed) { @@ -1859,10 +1859,10 @@ static void handle_draw_indirect(struct val_cmd_buffer_entry *cmd, state->pctx->draw_vbo(state->pctx, &state->info); } -static void handle_index_buffer(struct val_cmd_buffer_entry *cmd, +static void handle_index_buffer(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { - struct val_cmd_bind_index_buffer *ib = &cmd->u.index_buffer; + struct lvp_cmd_bind_index_buffer *ib = &cmd->u.index_buffer; switch (ib->index_type) { case VK_INDEX_TYPE_UINT16: state->index_size = 2; @@ -1882,7 +1882,7 @@ static void handle_index_buffer(struct val_cmd_buffer_entry *cmd, state->ib_dirty = true; } -static void handle_dispatch(struct val_cmd_buffer_entry *cmd, +static void handle_dispatch(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { state->dispatch_info.grid[0] = cmd->u.dispatch.x; @@ -1892,7 +1892,7 @@ static void handle_dispatch(struct val_cmd_buffer_entry *cmd, state->pctx->launch_grid(state->pctx, &state->dispatch_info); } -static void handle_dispatch_indirect(struct val_cmd_buffer_entry *cmd, +static void handle_dispatch_indirect(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { state->dispatch_info.indirect = cmd->u.dispatch_indirect.buffer->bo; @@ -1900,7 +1900,7 @@ static void handle_dispatch_indirect(struct val_cmd_buffer_entry *cmd, state->pctx->launch_grid(state->pctx, &state->dispatch_info); } -static void handle_push_constants(struct val_cmd_buffer_entry *cmd, +static void handle_push_constants(struct lvp_cmd_buffer_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); @@ -1931,50 +1931,50 @@ static void handle_push_constants(struct val_cmd_buffer_entry *cmd, state->pcbuf_dirty[PIPE_SHADER_COMPUTE] = true; } -static void val_execute_cmd_buffer(struct val_cmd_buffer *cmd_buffer, +static void lvp_execute_cmd_buffer(struct lvp_cmd_buffer *cmd_buffer, struct rendering_state *state); -static void handle_execute_commands(struct val_cmd_buffer_entry *cmd, +static void handle_execute_commands(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { for (unsigned i = 0; i < cmd->u.execute_commands.command_buffer_count; i++) { - struct val_cmd_buffer *secondary_buf = cmd->u.execute_commands.cmd_buffers[i]; - val_execute_cmd_buffer(secondary_buf, state); + struct lvp_cmd_buffer *secondary_buf = cmd->u.execute_commands.cmd_buffers[i]; + lvp_execute_cmd_buffer(secondary_buf, state); } } -static void handle_event_set(struct val_cmd_buffer_entry *cmd, +static void handle_event_set(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { - struct val_event *event = cmd->u.event_set.event; + struct lvp_event *event = cmd->u.event_set.event; if (cmd->u.event_set.flush) state->pctx->flush(state->pctx, NULL, 0); event->event_storage = (cmd->u.event_set.value == true) ? 1 : 0; } -static void handle_wait_events(struct val_cmd_buffer_entry *cmd, +static void handle_wait_events(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { for (unsigned i = 0; i < cmd->u.wait_events.event_count; i++) { - struct val_event *event = cmd->u.wait_events.events[i]; + struct lvp_event *event = cmd->u.wait_events.events[i]; while (event->event_storage != true); } } -static void handle_pipeline_barrier(struct val_cmd_buffer_entry *cmd, +static void handle_pipeline_barrier(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { /* why hello nail, I'm a hammer. - TODO */ state->pctx->flush(state->pctx, NULL, 0); } -static void handle_begin_query(struct val_cmd_buffer_entry *cmd, +static void handle_begin_query(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { - struct val_cmd_query_cmd *qcmd = &cmd->u.query; - struct val_query_pool *pool = qcmd->pool; + struct lvp_cmd_query_cmd *qcmd = &cmd->u.query; + struct lvp_query_pool *pool = qcmd->pool; if (!pool->queries[qcmd->query]) { enum pipe_query_type qtype = pool->base_type; @@ -1987,21 +1987,21 @@ static void handle_begin_query(struct val_cmd_buffer_entry *cmd, state->pctx->begin_query(state->pctx, pool->queries[qcmd->query]); } -static void handle_end_query(struct val_cmd_buffer_entry *cmd, +static void handle_end_query(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { - struct val_cmd_query_cmd *qcmd = &cmd->u.query; - struct val_query_pool *pool = qcmd->pool; + struct lvp_cmd_query_cmd *qcmd = &cmd->u.query; + struct lvp_query_pool *pool = qcmd->pool; assert(pool->queries[qcmd->query]); state->pctx->end_query(state->pctx, pool->queries[qcmd->query]); } -static void handle_reset_query_pool(struct val_cmd_buffer_entry *cmd, +static void handle_reset_query_pool(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { - struct val_cmd_query_cmd *qcmd = &cmd->u.query; - struct val_query_pool *pool = qcmd->pool; + 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++) { if (pool->queries[i]) { state->pctx->destroy_query(state->pctx, pool->queries[i]); @@ -2010,11 +2010,11 @@ static void handle_reset_query_pool(struct val_cmd_buffer_entry *cmd, } } -static void handle_write_timestamp(struct val_cmd_buffer_entry *cmd, +static void handle_write_timestamp(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { - struct val_cmd_query_cmd *qcmd = &cmd->u.query; - struct val_query_pool *pool = qcmd->pool; + struct lvp_cmd_query_cmd *qcmd = &cmd->u.query; + struct lvp_query_pool *pool = qcmd->pool; if (!pool->queries[qcmd->query]) { pool->queries[qcmd->query] = state->pctx->create_query(state->pctx, PIPE_QUERY_TIMESTAMP, 0); @@ -2026,11 +2026,11 @@ static void handle_write_timestamp(struct val_cmd_buffer_entry *cmd, } -static void handle_copy_query_pool_results(struct val_cmd_buffer_entry *cmd, +static void handle_copy_query_pool_results(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { - struct val_cmd_copy_query_pool_results *copycmd = &cmd->u.copy_query_pool_results; - struct val_query_pool *pool = copycmd->pool; + struct lvp_cmd_copy_query_pool_results *copycmd = &cmd->u.copy_query_pool_results; + struct lvp_query_pool *pool = copycmd->pool; for (unsigned i = copycmd->first_query; i < copycmd->first_query + copycmd->query_count; i++) { unsigned offset = copycmd->dst->offset + (copycmd->stride * (i - copycmd->first_query)); @@ -2102,10 +2102,10 @@ static void pack_clear_color(enum pipe_format pformat, VkClearColorValue *in_val } } -static void handle_clear_color_image(struct val_cmd_buffer_entry *cmd, +static void handle_clear_color_image(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { - struct val_image *image = cmd->u.clear_color_image.image; + struct 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); for (unsigned i = 0; i < cmd->u.clear_color_image.range_count; i++) { @@ -2115,7 +2115,7 @@ static void handle_clear_color_image(struct val_cmd_buffer_entry *cmd, box.y = 0; box.z = 0; - uint32_t level_count = val_get_levelCount(image, range); + uint32_t level_count = lvp_get_levelCount(image, range); for (unsigned j = range->baseMipLevel; j < range->baseMipLevel + level_count; j++) { box.width = u_minify(image->bo->width0, j); box.height = u_minify(image->bo->height0, j); @@ -2124,11 +2124,11 @@ static void handle_clear_color_image(struct val_cmd_buffer_entry *cmd, box.depth = u_minify(image->bo->depth0, j); else if (image->bo->target == PIPE_TEXTURE_1D_ARRAY) { box.y = range->baseArrayLayer; - box.height = val_get_layerCount(image, range); + box.height = lvp_get_layerCount(image, range); box.depth = 1; } else { box.z = range->baseArrayLayer; - box.depth = val_get_layerCount(image, range); + box.depth = lvp_get_layerCount(image, range); } state->pctx->clear_texture(state->pctx, image->bo, @@ -2137,10 +2137,10 @@ static void handle_clear_color_image(struct val_cmd_buffer_entry *cmd, } } -static void handle_clear_ds_image(struct val_cmd_buffer_entry *cmd, +static void handle_clear_ds_image(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { - struct val_image *image = cmd->u.clear_ds_image.image; + struct lvp_image *image = cmd->u.clear_ds_image.image; uint64_t col_val; col_val = util_pack64_z_stencil(image->bo->format, cmd->u.clear_ds_image.clear_val.depth, cmd->u.clear_ds_image.clear_val.stencil); for (unsigned i = 0; i < cmd->u.clear_ds_image.range_count; i++) { @@ -2150,7 +2150,7 @@ static void handle_clear_ds_image(struct val_cmd_buffer_entry *cmd, box.y = 0; box.z = 0; - uint32_t level_count = val_get_levelCount(image, range); + uint32_t level_count = lvp_get_levelCount(image, range); for (unsigned j = range->baseMipLevel; j < range->baseMipLevel + level_count; j++) { box.width = u_minify(image->bo->width0, j); box.height = u_minify(image->bo->height0, j); @@ -2159,11 +2159,11 @@ static void handle_clear_ds_image(struct val_cmd_buffer_entry *cmd, box.depth = u_minify(image->bo->depth0, j); else if (image->bo->target == PIPE_TEXTURE_1D_ARRAY) { box.y = range->baseArrayLayer; - box.height = val_get_layerCount(image, range); + box.height = lvp_get_layerCount(image, range); box.depth = 1; } else { box.z = range->baseArrayLayer; - box.depth = val_get_layerCount(image, range); + box.depth = lvp_get_layerCount(image, range); } state->pctx->clear_texture(state->pctx, image->bo, @@ -2172,21 +2172,21 @@ static void handle_clear_ds_image(struct val_cmd_buffer_entry *cmd, } } -static void handle_clear_attachments(struct val_cmd_buffer_entry *cmd, +static void handle_clear_attachments(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { for (uint32_t a = 0; a < cmd->u.clear_attachments.attachment_count; a++) { VkClearAttachment *att = &cmd->u.clear_attachments.attachments[a]; - struct val_subpass *subpass = &state->pass->subpasses[state->subpass]; - struct val_image_view *imgv; + struct lvp_subpass *subpass = &state->pass->subpasses[state->subpass]; + struct lvp_image_view *imgv; if (att->aspectMask == VK_IMAGE_ASPECT_COLOR_BIT) { - struct val_subpass_attachment *color_att = &subpass->color_attachments[att->colorAttachment]; + struct lvp_subpass_attachment *color_att = &subpass->color_attachments[att->colorAttachment]; if (!color_att || color_att->attachment == VK_ATTACHMENT_UNUSED) continue; imgv = state->vk_framebuffer->attachments[color_att->attachment]; } else { - struct val_subpass_attachment *ds_att = subpass->depth_stencil_attachment; + struct lvp_subpass_attachment *ds_att = subpass->depth_stencil_attachment; if (!ds_att || ds_att->attachment == VK_ATTACHMENT_UNUSED) continue; imgv = state->vk_framebuffer->attachments[ds_att->attachment]; @@ -2214,11 +2214,11 @@ static void handle_clear_attachments(struct val_cmd_buffer_entry *cmd, } } -static void handle_resolve_image(struct val_cmd_buffer_entry *cmd, +static void handle_resolve_image(struct lvp_cmd_buffer_entry *cmd, struct rendering_state *state) { int i; - struct val_cmd_resolve_image *resolvecmd = &cmd->u.resolve_image; + struct lvp_cmd_resolve_image *resolvecmd = &cmd->u.resolve_image; struct pipe_blit_info info; memset(&info, 0, sizeof(info)); @@ -2263,157 +2263,157 @@ static void handle_resolve_image(struct val_cmd_buffer_entry *cmd, } } -static void val_execute_cmd_buffer(struct val_cmd_buffer *cmd_buffer, +static void lvp_execute_cmd_buffer(struct lvp_cmd_buffer *cmd_buffer, struct rendering_state *state) { - struct val_cmd_buffer_entry *cmd; + struct lvp_cmd_buffer_entry *cmd; LIST_FOR_EACH_ENTRY(cmd, &cmd_buffer->cmds, cmd_link) { switch (cmd->cmd_type) { - case VAL_CMD_BIND_PIPELINE: + case LVP_CMD_BIND_PIPELINE: handle_pipeline(cmd, state); break; - case VAL_CMD_SET_VIEWPORT: + case LVP_CMD_SET_VIEWPORT: handle_set_viewport(cmd, state); break; - case VAL_CMD_SET_SCISSOR: + case LVP_CMD_SET_SCISSOR: handle_set_scissor(cmd, state); break; - case VAL_CMD_SET_LINE_WIDTH: + case LVP_CMD_SET_LINE_WIDTH: handle_set_line_width(cmd, state); break; - case VAL_CMD_SET_DEPTH_BIAS: + case LVP_CMD_SET_DEPTH_BIAS: handle_set_depth_bias(cmd, state); break; - case VAL_CMD_SET_BLEND_CONSTANTS: + case LVP_CMD_SET_BLEND_CONSTANTS: handle_set_blend_constants(cmd, state); break; - case VAL_CMD_SET_DEPTH_BOUNDS: + case LVP_CMD_SET_DEPTH_BOUNDS: handle_set_depth_bounds(cmd, state); break; - case VAL_CMD_SET_STENCIL_COMPARE_MASK: + case LVP_CMD_SET_STENCIL_COMPARE_MASK: handle_set_stencil_compare_mask(cmd, state); break; - case VAL_CMD_SET_STENCIL_WRITE_MASK: + case LVP_CMD_SET_STENCIL_WRITE_MASK: handle_set_stencil_write_mask(cmd, state); break; - case VAL_CMD_SET_STENCIL_REFERENCE: + case LVP_CMD_SET_STENCIL_REFERENCE: handle_set_stencil_reference(cmd, state); break; - case VAL_CMD_BIND_DESCRIPTOR_SETS: + case LVP_CMD_BIND_DESCRIPTOR_SETS: handle_descriptor_sets(cmd, state); break; - case VAL_CMD_BIND_INDEX_BUFFER: + case LVP_CMD_BIND_INDEX_BUFFER: handle_index_buffer(cmd, state); break; - case VAL_CMD_BIND_VERTEX_BUFFERS: + case LVP_CMD_BIND_VERTEX_BUFFERS: handle_vertex_buffers(cmd, state); break; - case VAL_CMD_DRAW: + case LVP_CMD_DRAW: emit_state(state); handle_draw(cmd, state); break; - case VAL_CMD_DRAW_INDEXED: + case LVP_CMD_DRAW_INDEXED: emit_state(state); handle_draw_indexed(cmd, state); break; - case VAL_CMD_DRAW_INDIRECT: + case LVP_CMD_DRAW_INDIRECT: emit_state(state); handle_draw_indirect(cmd, state, false); break; - case VAL_CMD_DRAW_INDEXED_INDIRECT: + case LVP_CMD_DRAW_INDEXED_INDIRECT: emit_state(state); handle_draw_indirect(cmd, state, true); break; - case VAL_CMD_DISPATCH: + case LVP_CMD_DISPATCH: emit_compute_state(state); handle_dispatch(cmd, state); break; - case VAL_CMD_DISPATCH_INDIRECT: + case LVP_CMD_DISPATCH_INDIRECT: emit_compute_state(state); handle_dispatch_indirect(cmd, state); break; - case VAL_CMD_COPY_BUFFER: + case LVP_CMD_COPY_BUFFER: handle_copy_buffer(cmd, state); break; - case VAL_CMD_COPY_IMAGE: + case LVP_CMD_COPY_IMAGE: handle_copy_image(cmd, state); break; - case VAL_CMD_BLIT_IMAGE: + case LVP_CMD_BLIT_IMAGE: handle_blit_image(cmd, state); break; - case VAL_CMD_COPY_BUFFER_TO_IMAGE: + case LVP_CMD_COPY_BUFFER_TO_IMAGE: handle_copy_buffer_to_image(cmd, state); break; - case VAL_CMD_COPY_IMAGE_TO_BUFFER: + case LVP_CMD_COPY_IMAGE_TO_BUFFER: handle_copy_image_to_buffer(cmd, state); break; - case VAL_CMD_UPDATE_BUFFER: + case LVP_CMD_UPDATE_BUFFER: handle_update_buffer(cmd, state); break; - case VAL_CMD_FILL_BUFFER: + case LVP_CMD_FILL_BUFFER: handle_fill_buffer(cmd, state); break; - case VAL_CMD_CLEAR_COLOR_IMAGE: + case LVP_CMD_CLEAR_COLOR_IMAGE: handle_clear_color_image(cmd, state); break; - case VAL_CMD_CLEAR_DEPTH_STENCIL_IMAGE: + case LVP_CMD_CLEAR_DEPTH_STENCIL_IMAGE: handle_clear_ds_image(cmd, state); break; - case VAL_CMD_CLEAR_ATTACHMENTS: + case LVP_CMD_CLEAR_ATTACHMENTS: handle_clear_attachments(cmd, state); break; - case VAL_CMD_RESOLVE_IMAGE: + case LVP_CMD_RESOLVE_IMAGE: handle_resolve_image(cmd, state); break; - case VAL_CMD_SET_EVENT: - case VAL_CMD_RESET_EVENT: + case LVP_CMD_SET_EVENT: + case LVP_CMD_RESET_EVENT: handle_event_set(cmd, state); break; - case VAL_CMD_WAIT_EVENTS: + case LVP_CMD_WAIT_EVENTS: handle_wait_events(cmd, state); break; - case VAL_CMD_PIPELINE_BARRIER: + case LVP_CMD_PIPELINE_BARRIER: handle_pipeline_barrier(cmd, state); break; - case VAL_CMD_BEGIN_QUERY: + case LVP_CMD_BEGIN_QUERY: handle_begin_query(cmd, state); break; - case VAL_CMD_END_QUERY: + case LVP_CMD_END_QUERY: handle_end_query(cmd, state); break; - case VAL_CMD_RESET_QUERY_POOL: + case LVP_CMD_RESET_QUERY_POOL: handle_reset_query_pool(cmd, state); break; - case VAL_CMD_WRITE_TIMESTAMP: + case LVP_CMD_WRITE_TIMESTAMP: handle_write_timestamp(cmd, state); break; - case VAL_CMD_COPY_QUERY_POOL_RESULTS: + case LVP_CMD_COPY_QUERY_POOL_RESULTS: handle_copy_query_pool_results(cmd, state); break; - case VAL_CMD_PUSH_CONSTANTS: + case LVP_CMD_PUSH_CONSTANTS: handle_push_constants(cmd, state); break; - case VAL_CMD_BEGIN_RENDER_PASS: + case LVP_CMD_BEGIN_RENDER_PASS: handle_begin_render_pass(cmd, state); break; - case VAL_CMD_NEXT_SUBPASS: + case LVP_CMD_NEXT_SUBPASS: handle_next_subpass(cmd, state); break; - case VAL_CMD_END_RENDER_PASS: + case LVP_CMD_END_RENDER_PASS: handle_end_render_pass(cmd, state); break; - case VAL_CMD_EXECUTE_COMMANDS: + case LVP_CMD_EXECUTE_COMMANDS: handle_execute_commands(cmd, state); break; } } } -VkResult val_execute_cmds(struct val_device *device, - struct val_queue *queue, - struct val_fence *fence, - struct val_cmd_buffer *cmd_buffer) +VkResult lvp_execute_cmds(struct lvp_device *device, + struct lvp_queue *queue, + struct lvp_fence *fence, + struct lvp_cmd_buffer *cmd_buffer) { struct rendering_state state; struct pipe_fence_handle *handle = NULL; @@ -2423,7 +2423,7 @@ VkResult val_execute_cmds(struct val_device *device, state.dsa_dirty = true; state.rs_dirty = true; /* create a gallium context */ - val_execute_cmd_buffer(cmd_buffer, &state); + lvp_execute_cmd_buffer(cmd_buffer, &state); state.pctx->flush(state.pctx, fence ? &handle : NULL, 0); if (fence) { diff --git a/src/gallium/frontends/vallium/val_extensions.py b/src/gallium/frontends/lavapipe/lvp_extensions.py similarity index 94% rename from src/gallium/frontends/vallium/val_extensions.py rename to src/gallium/frontends/lavapipe/lvp_extensions.py index bb6cacf..ca0441c 100644 --- a/src/gallium/frontends/vallium/val_extensions.py +++ b/src/gallium/frontends/lavapipe/lvp_extensions.py @@ -79,10 +79,10 @@ EXTENSIONS = [ Extension('VK_KHR_get_display_properties2', 1, 'VK_USE_PLATFORM_DISPLAY_KHR'), Extension('VK_KHR_get_memory_requirements2', 1, True), Extension('VK_KHR_get_physical_device_properties2', 1, True), - Extension('VK_KHR_get_surface_capabilities2', 1, 'VAL_HAS_SURFACE'), + Extension('VK_KHR_get_surface_capabilities2', 1, 'LVP_HAS_SURFACE'), Extension('VK_KHR_image_format_list', 1, False), Extension('VK_KHR_imageless_framebuffer', 1, False), - Extension('VK_KHR_incremental_present', 1, 'VAL_HAS_SURFACE'), + Extension('VK_KHR_incremental_present', 1, 'LVP_HAS_SURFACE'), Extension('VK_KHR_maintenance1', 1, True), Extension('VK_KHR_maintenance2', 1, False), Extension('VK_KHR_maintenance3', 1, False), @@ -95,9 +95,9 @@ EXTENSIONS = [ Extension('VK_KHR_shader_draw_parameters', 1, False), Extension('VK_KHR_shader_float16_int8', 1, False), Extension('VK_KHR_storage_buffer_storage_class', 1, True), - Extension('VK_KHR_surface', 25, 'VAL_HAS_SURFACE'), - Extension('VK_KHR_surface_protected_capabilities', 1, 'VAL_HAS_SURFACE'), - Extension('VK_KHR_swapchain', 68, 'VAL_HAS_SURFACE'), + Extension('VK_KHR_surface', 25, 'LVP_HAS_SURFACE'), + Extension('VK_KHR_surface_protected_capabilities', 1, 'LVP_HAS_SURFACE'), + Extension('VK_KHR_swapchain', 68, 'LVP_HAS_SURFACE'), Extension('VK_KHR_uniform_buffer_standard_layout', 1, False), Extension('VK_KHR_variable_pointers', 1, False), Extension('VK_KHR_wayland_surface', 6, 'VK_USE_PLATFORM_WAYLAND_KHR'), @@ -163,4 +163,4 @@ if __name__ == '__main__': dest='xml_files') args = parser.parse_args() - gen_extensions('val', args.xml_files, API_VERSIONS, MAX_API_VERSION, EXTENSIONS, args.out_c, args.out_h) + gen_extensions('lvp', args.xml_files, API_VERSIONS, MAX_API_VERSION, EXTENSIONS, args.out_c, args.out_h) diff --git a/src/gallium/frontends/vallium/val_formats.c b/src/gallium/frontends/lavapipe/lvp_formats.c similarity index 93% rename from src/gallium/frontends/vallium/val_formats.c rename to src/gallium/frontends/lavapipe/lvp_formats.c index f0f9620..c05863d 100644 --- a/src/gallium/frontends/vallium/val_formats.c +++ b/src/gallium/frontends/lavapipe/lvp_formats.c @@ -21,7 +21,7 @@ * IN THE SOFTWARE. */ -#include "val_private.h" +#include "lvp_private.h" #include "util/format/u_format.h" #include "util/u_math.h" #define COMMON_NAME(x) [VK_FORMAT_##x] = PIPE_FORMAT_##x @@ -148,7 +148,7 @@ enum pipe_format vk_format_to_pipe(VkFormat format) } static void -val_physical_device_get_format_properties(struct val_physical_device *physical_device, +lvp_physical_device_get_format_properties(struct lvp_physical_device *physical_device, VkFormat format, VkFormatProperties *out_properties) { @@ -231,30 +231,30 @@ val_physical_device_get_format_properties(struct val_physical_device *physical_d return; } -void val_GetPhysicalDeviceFormatProperties( +void lvp_GetPhysicalDeviceFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) { - VAL_FROM_HANDLE(val_physical_device, physical_device, physicalDevice); + LVP_FROM_HANDLE(lvp_physical_device, physical_device, physicalDevice); - val_physical_device_get_format_properties(physical_device, + lvp_physical_device_get_format_properties(physical_device, format, pFormatProperties); } -void val_GetPhysicalDeviceFormatProperties2( +void lvp_GetPhysicalDeviceFormatProperties2( VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) { - VAL_FROM_HANDLE(val_physical_device, physical_device, physicalDevice); + LVP_FROM_HANDLE(lvp_physical_device, physical_device, physicalDevice); - val_physical_device_get_format_properties(physical_device, + lvp_physical_device_get_format_properties(physical_device, format, &pFormatProperties->formatProperties); } -static VkResult val_get_image_format_properties(struct val_physical_device *physical_device, +static VkResult lvp_get_image_format_properties(struct lvp_physical_device *physical_device, const VkPhysicalDeviceImageFormatInfo2 *info, VkImageFormatProperties *pImageFormatProperties) { @@ -265,7 +265,7 @@ static VkResult val_get_image_format_properties(struct val_physical_device *phys uint32_t maxArraySize; VkSampleCountFlags sampleCounts = VK_SAMPLE_COUNT_1_BIT; enum pipe_format pformat = vk_format_to_pipe(info->format); - val_physical_device_get_format_properties(physical_device, info->format, + lvp_physical_device_get_format_properties(physical_device, info->format, &format_props); if (info->tiling == VK_IMAGE_TILING_LINEAR) { format_feature_flags = format_props.linearTilingFeatures; @@ -377,7 +377,7 @@ static VkResult val_get_image_format_properties(struct val_physical_device *phys return VK_ERROR_FORMAT_NOT_SUPPORTED; } -VkResult val_GetPhysicalDeviceImageFormatProperties( +VkResult lvp_GetPhysicalDeviceImageFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, @@ -386,7 +386,7 @@ VkResult val_GetPhysicalDeviceImageFormatProperties( VkImageCreateFlags createFlags, VkImageFormatProperties* pImageFormatProperties) { - VAL_FROM_HANDLE(val_physical_device, physical_device, physicalDevice); + LVP_FROM_HANDLE(lvp_physical_device, physical_device, physicalDevice); const VkPhysicalDeviceImageFormatInfo2 info = { .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, @@ -398,18 +398,18 @@ VkResult val_GetPhysicalDeviceImageFormatProperties( .flags = createFlags, }; - return val_get_image_format_properties(physical_device, &info, + return lvp_get_image_format_properties(physical_device, &info, pImageFormatProperties); } -VkResult val_GetPhysicalDeviceImageFormatProperties2( +VkResult lvp_GetPhysicalDeviceImageFormatProperties2( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *base_info, VkImageFormatProperties2 *base_props) { - VAL_FROM_HANDLE(val_physical_device, physical_device, physicalDevice); + LVP_FROM_HANDLE(lvp_physical_device, physical_device, physicalDevice); VkResult result; - result = val_get_image_format_properties(physical_device, base_info, + result = lvp_get_image_format_properties(physical_device, base_info, &base_props->imageFormatProperties); if (result != VK_SUCCESS) return result; @@ -417,7 +417,7 @@ VkResult val_GetPhysicalDeviceImageFormatProperties2( return VK_SUCCESS; } -void val_GetPhysicalDeviceSparseImageFormatProperties( +void lvp_GetPhysicalDeviceSparseImageFormatProperties( VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, @@ -431,7 +431,7 @@ void val_GetPhysicalDeviceSparseImageFormatProperties( *pNumProperties = 0; } -void val_GetPhysicalDeviceSparseImageFormatProperties2( +void lvp_GetPhysicalDeviceSparseImageFormatProperties2( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo, uint32_t *pPropertyCount, diff --git a/src/gallium/frontends/vallium/val_image.c b/src/gallium/frontends/lavapipe/lvp_image.c similarity index 83% rename from src/gallium/frontends/vallium/val_image.c rename to src/gallium/frontends/lavapipe/lvp_image.c index b40e5b9..39c63aa 100644 --- a/src/gallium/frontends/vallium/val_image.c +++ b/src/gallium/frontends/lavapipe/lvp_image.c @@ -21,20 +21,20 @@ * IN THE SOFTWARE. */ -#include "val_private.h" +#include "lvp_private.h" #include "util/format/u_format.h" #include "util/u_inlines.h" #include "pipe/p_state.h" VkResult -val_image_create(VkDevice _device, - const struct val_image_create_info *create_info, +lvp_image_create(VkDevice _device, + const struct lvp_image_create_info *create_info, const VkAllocationCallbacks* alloc, VkImage *pImage) { - VAL_FROM_HANDLE(val_device, device, _device); + LVP_FROM_HANDLE(lvp_device, device, _device); const VkImageCreateInfo *pCreateInfo = create_info->vk_info; - struct val_image *image; + struct lvp_image *image; assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO); @@ -81,19 +81,19 @@ val_image_create(VkDevice _device, &template, &image->size); } - *pImage = val_image_to_handle(image); + *pImage = lvp_image_to_handle(image); return VK_SUCCESS; } VkResult -val_CreateImage(VkDevice device, +lvp_CreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImage *pImage) { - return val_image_create(device, - &(struct val_image_create_info) { + return lvp_image_create(device, + &(struct lvp_image_create_info) { .vk_info = pCreateInfo, .bind_flags = 0, }, @@ -102,11 +102,11 @@ val_CreateImage(VkDevice device, } void -val_DestroyImage(VkDevice _device, VkImage _image, +lvp_DestroyImage(VkDevice _device, VkImage _image, const VkAllocationCallbacks *pAllocator) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_image, image, _image); + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_image, image, _image); if (!_image) return; @@ -116,14 +116,14 @@ val_DestroyImage(VkDevice _device, VkImage _image, } VkResult -val_CreateImageView(VkDevice _device, +lvp_CreateImageView(VkDevice _device, const VkImageViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkImageView *pView) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_image, image, pCreateInfo->image); - struct val_image_view *view; + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_image, image, pCreateInfo->image); + struct lvp_image_view *view; view = vk_alloc2(&device->alloc, pAllocator, sizeof(*view), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); @@ -139,17 +139,17 @@ val_CreateImageView(VkDevice _device, view->subresourceRange = pCreateInfo->subresourceRange; view->image = image; view->surface = NULL; - *pView = val_image_view_to_handle(view); + *pView = lvp_image_view_to_handle(view); return VK_SUCCESS; } void -val_DestroyImageView(VkDevice _device, VkImageView _iview, +lvp_DestroyImageView(VkDevice _device, VkImageView _iview, const VkAllocationCallbacks *pAllocator) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_image_view, iview, _iview); + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_image_view, iview, _iview); if (!_iview) return; @@ -159,14 +159,14 @@ val_DestroyImageView(VkDevice _device, VkImageView _iview, vk_free2(&device->alloc, pAllocator, iview); } -void val_GetImageSubresourceLayout( +void lvp_GetImageSubresourceLayout( VkDevice _device, VkImage _image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_image, image, _image); + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_image, image, _image); uint32_t stride, offset; device->pscreen->resource_get_info(device->pscreen, image->bo, @@ -187,14 +187,14 @@ void val_GetImageSubresourceLayout( } } -VkResult val_CreateBuffer( +VkResult lvp_CreateBuffer( VkDevice _device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) { - VAL_FROM_HANDLE(val_device, device, _device); - struct val_buffer *buffer; + LVP_FROM_HANDLE(lvp_device, device, _device); + struct lvp_buffer *buffer; assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO); @@ -231,18 +231,18 @@ VkResult val_CreateBuffer( return vk_error(device->instance, VK_ERROR_OUT_OF_DEVICE_MEMORY); } } - *pBuffer = val_buffer_to_handle(buffer); + *pBuffer = lvp_buffer_to_handle(buffer); return VK_SUCCESS; } -void val_DestroyBuffer( +void lvp_DestroyBuffer( VkDevice _device, VkBuffer _buffer, const VkAllocationCallbacks* pAllocator) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_buffer, buffer, _buffer); + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_buffer, buffer, _buffer); if (!_buffer) return; @@ -253,14 +253,14 @@ void val_DestroyBuffer( } VkResult -val_CreateBufferView(VkDevice _device, +lvp_CreateBufferView(VkDevice _device, const VkBufferViewCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkBufferView *pView) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_buffer, buffer, pCreateInfo->buffer); - struct val_buffer_view *view; + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_buffer, buffer, pCreateInfo->buffer); + struct lvp_buffer_view *view; view = vk_alloc2(&device->alloc, pAllocator, sizeof(*view), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (!view) @@ -273,17 +273,17 @@ val_CreateBufferView(VkDevice _device, view->pformat = vk_format_to_pipe(pCreateInfo->format); view->offset = pCreateInfo->offset; view->range = pCreateInfo->range; - *pView = val_buffer_view_to_handle(view); + *pView = lvp_buffer_view_to_handle(view); return VK_SUCCESS; } void -val_DestroyBufferView(VkDevice _device, VkBufferView bufferView, +lvp_DestroyBufferView(VkDevice _device, VkBufferView bufferView, const VkAllocationCallbacks *pAllocator) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_buffer_view, view, bufferView); + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_buffer_view, view, bufferView); if (!bufferView) return; diff --git a/src/gallium/frontends/vallium/val_lower_input_attachments.c b/src/gallium/frontends/lavapipe/lvp_lower_input_attachments.c similarity index 97% rename from src/gallium/frontends/vallium/val_lower_input_attachments.c rename to src/gallium/frontends/lavapipe/lvp_lower_input_attachments.c index 532f71d..98d4e2a 100644 --- a/src/gallium/frontends/vallium/val_lower_input_attachments.c +++ b/src/gallium/frontends/lavapipe/lvp_lower_input_attachments.c @@ -23,7 +23,7 @@ #include "nir.h" #include "nir_builder.h" -#include "val_lower_vulkan_resource.h" +#include "lvp_lower_vulkan_resource.h" static nir_ssa_def * load_frag_coord(nir_builder *b) @@ -80,7 +80,7 @@ try_lower_input_load(nir_function_impl *impl, nir_intrinsic_instr *load, } bool -val_lower_input_attachments(nir_shader *shader, bool use_fragcoord_sysval) +lvp_lower_input_attachments(nir_shader *shader, bool use_fragcoord_sysval) { assert(shader->info.stage == MESA_SHADER_FRAGMENT); bool progress = false; diff --git a/src/gallium/frontends/vallium/val_lower_vulkan_resource.c b/src/gallium/frontends/lavapipe/lvp_lower_vulkan_resource.c similarity index 94% rename from src/gallium/frontends/vallium/val_lower_vulkan_resource.c rename to src/gallium/frontends/lavapipe/lvp_lower_vulkan_resource.c index 131aa9c..221e841 100644 --- a/src/gallium/frontends/vallium/val_lower_vulkan_resource.c +++ b/src/gallium/frontends/lavapipe/lvp_lower_vulkan_resource.c @@ -21,10 +21,10 @@ * IN THE SOFTWARE. */ -#include "val_private.h" +#include "lvp_private.h" #include "nir.h" #include "nir_builder.h" -#include "val_lower_vulkan_resource.h" +#include "lvp_lower_vulkan_resource.h" static bool lower_vulkan_resource_index(const nir_instr *instr, const void *data_cb) @@ -53,8 +53,8 @@ static nir_ssa_def *lower_vri_intrin_vri(struct nir_builder *b, nir_intrinsic_instr *intrin = nir_instr_as_intrinsic(instr); unsigned desc_set_idx = nir_intrinsic_desc_set(intrin); unsigned binding_idx = nir_intrinsic_binding(intrin); - struct val_pipeline_layout *layout = data_cb; - struct val_descriptor_set_binding_layout *binding = &layout->set[desc_set_idx].layout->binding[binding_idx]; + struct lvp_pipeline_layout *layout = data_cb; + struct lvp_descriptor_set_binding_layout *binding = &layout->set[desc_set_idx].layout->binding[binding_idx]; int value = 0; bool is_ubo = (binding->type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER || binding->type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC); @@ -103,7 +103,7 @@ static nir_ssa_def *lower_vri_intrin_lvd(struct nir_builder *b, static int lower_vri_instr_tex_deref(nir_tex_instr *tex, nir_tex_src_type deref_src_type, gl_shader_stage stage, - struct val_pipeline_layout *layout) + struct lvp_pipeline_layout *layout) { int deref_src_idx = nir_tex_instr_src_index(tex, deref_src_type); @@ -115,7 +115,7 @@ static int lower_vri_instr_tex_deref(nir_tex_instr *tex, unsigned desc_set_idx = var->data.descriptor_set; unsigned binding_idx = var->data.binding; int value = 0; - struct val_descriptor_set_binding_layout *binding = &layout->set[desc_set_idx].layout->binding[binding_idx]; + struct lvp_descriptor_set_binding_layout *binding = &layout->set[desc_set_idx].layout->binding[binding_idx]; nir_tex_instr_remove_src(tex, deref_src_idx); for (unsigned s = 0; s < desc_set_idx; s++) { if (deref_src_type == nir_tex_src_sampler_deref) @@ -148,7 +148,7 @@ static int lower_vri_instr_tex_deref(nir_tex_instr *tex, static void lower_vri_instr_tex(struct nir_builder *b, nir_tex_instr *tex, void *data_cb) { - struct val_pipeline_layout *layout = data_cb; + struct lvp_pipeline_layout *layout = data_cb; int tex_value = 0; lower_vri_instr_tex_deref(tex, nir_tex_src_sampler_deref, b->shader->info.stage, layout); @@ -192,8 +192,8 @@ static nir_ssa_def *lower_vri_instr(struct nir_builder *b, return NULL; } -void val_lower_pipeline_layout(const struct val_device *device, - struct val_pipeline_layout *layout, +void lvp_lower_pipeline_layout(const struct lvp_device *device, + struct lvp_pipeline_layout *layout, nir_shader *shader) { nir_shader_lower_instructions(shader, lower_vulkan_resource_index, lower_vri_instr, layout); @@ -203,7 +203,7 @@ void val_lower_pipeline_layout(const struct val_device *device, glsl_get_base_type(glsl_without_array(type)); unsigned desc_set_idx = var->data.descriptor_set; unsigned binding_idx = var->data.binding; - struct val_descriptor_set_binding_layout *binding = &layout->set[desc_set_idx].layout->binding[binding_idx]; + struct lvp_descriptor_set_binding_layout *binding = &layout->set[desc_set_idx].layout->binding[binding_idx]; int value = 0; var->data.descriptor_set = 0; if (base_type == GLSL_TYPE_SAMPLER) { diff --git a/src/gallium/frontends/vallium/val_lower_vulkan_resource.h b/src/gallium/frontends/lavapipe/lvp_lower_vulkan_resource.h similarity index 79% rename from src/gallium/frontends/vallium/val_lower_vulkan_resource.h rename to src/gallium/frontends/lavapipe/lvp_lower_vulkan_resource.h index d325d7c..af3aab7 100644 --- a/src/gallium/frontends/vallium/val_lower_vulkan_resource.h +++ b/src/gallium/frontends/lavapipe/lvp_lower_vulkan_resource.h @@ -21,16 +21,16 @@ * IN THE SOFTWARE. */ -#ifndef VAL_LOWER_VULKAN_RESOURCE_H -#define VAL_LOWER_VULKAN_RESOURCE_H +#ifndef LVP_LOWER_VULKAN_RESOURCE_H +#define LVP_LOWER_VULKAN_RESOURCE_H -struct val_pipeline_layout; -struct val_device; -void val_lower_pipeline_layout(const struct val_device *device, - struct val_pipeline_layout *layout, +struct lvp_pipeline_layout; +struct lvp_device; +void lvp_lower_pipeline_layout(const struct lvp_device *device, + struct lvp_pipeline_layout *layout, nir_shader *shader); bool -val_lower_input_attachments(nir_shader *shader, bool use_fragcoord_sysval); +lvp_lower_input_attachments(nir_shader *shader, bool use_fragcoord_sysval); #endif diff --git a/src/gallium/frontends/vallium/val_pass.c b/src/gallium/frontends/lavapipe/lvp_pass.c similarity index 84% rename from src/gallium/frontends/vallium/val_pass.c rename to src/gallium/frontends/lavapipe/lvp_pass.c index a2f9cb4..83f671d 100644 --- a/src/gallium/frontends/vallium/val_pass.c +++ b/src/gallium/frontends/lavapipe/lvp_pass.c @@ -21,21 +21,21 @@ * IN THE SOFTWARE. */ -#include "val_private.h" +#include "lvp_private.h" static void -val_render_pass_compile(struct val_render_pass *pass) +lvp_render_pass_compile(struct lvp_render_pass *pass) { for (uint32_t i = 0; i < pass->subpass_count; i++) { - struct val_subpass *subpass = &pass->subpasses[i]; + struct lvp_subpass *subpass = &pass->subpasses[i]; for (uint32_t j = 0; j < subpass->attachment_count; j++) { - struct val_subpass_attachment *subpass_att = + struct lvp_subpass_attachment *subpass_att = &subpass->attachments[j]; if (subpass_att->attachment == VK_ATTACHMENT_UNUSED) continue; - struct val_render_pass_attachment *pass_att = + struct lvp_render_pass_attachment *pass_att = &pass->attachments[subpass_att->attachment]; pass_att->first_subpass_idx = UINT32_MAX; @@ -43,7 +43,7 @@ val_render_pass_compile(struct val_render_pass *pass) } for (uint32_t i = 0; i < pass->subpass_count; i++) { - struct val_subpass *subpass = &pass->subpasses[i]; + struct lvp_subpass *subpass = &pass->subpasses[i]; uint32_t color_sample_count = 1, depth_sample_count = 1; /* We don't allow depth_stencil_attachment to be non-NULL and @@ -60,12 +60,12 @@ val_render_pass_compile(struct val_render_pass *pass) subpass->ds_resolve_attachment = NULL; for (uint32_t j = 0; j < subpass->attachment_count; j++) { - struct val_subpass_attachment *subpass_att = + struct lvp_subpass_attachment *subpass_att = &subpass->attachments[j]; if (subpass_att->attachment == VK_ATTACHMENT_UNUSED) continue; - struct val_render_pass_attachment *pass_att = + struct lvp_render_pass_attachment *pass_att = &pass->attachments[subpass_att->attachment]; if (i < pass_att->first_subpass_idx) @@ -75,14 +75,14 @@ val_render_pass_compile(struct val_render_pass *pass) subpass->has_color_att = false; for (uint32_t j = 0; j < subpass->color_count; j++) { - struct val_subpass_attachment *subpass_att = + struct lvp_subpass_attachment *subpass_att = &subpass->color_attachments[j]; if (subpass_att->attachment == VK_ATTACHMENT_UNUSED) continue; subpass->has_color_att = true; - struct val_render_pass_attachment *pass_att = + struct lvp_render_pass_attachment *pass_att = &pass->attachments[subpass_att->attachment]; color_sample_count = pass_att->samples; @@ -91,7 +91,7 @@ val_render_pass_compile(struct val_render_pass *pass) if (subpass->depth_stencil_attachment) { const uint32_t a = subpass->depth_stencil_attachment->attachment; - struct val_render_pass_attachment *pass_att = + struct lvp_render_pass_attachment *pass_att = &pass->attachments[a]; depth_sample_count = pass_att->samples; } @@ -103,7 +103,7 @@ val_render_pass_compile(struct val_render_pass *pass) subpass->has_color_resolve = false; if (subpass->resolve_attachments) { for (uint32_t j = 0; j < subpass->color_count; j++) { - struct val_subpass_attachment *resolve_att = + struct lvp_subpass_attachment *resolve_att = &subpass->resolve_attachments[j]; if (resolve_att->attachment == VK_ATTACHMENT_UNUSED) @@ -134,7 +134,7 @@ val_render_pass_compile(struct val_render_pass *pass) } static unsigned -val_num_subpass_attachments(const VkSubpassDescription *desc) +lvp_num_subpass_attachments(const VkSubpassDescription *desc) { return desc->inputAttachmentCount + desc->colorAttachmentCount + @@ -142,14 +142,14 @@ val_num_subpass_attachments(const VkSubpassDescription *desc) (desc->pDepthStencilAttachment != NULL); } -VkResult val_CreateRenderPass( +VkResult lvp_CreateRenderPass( VkDevice _device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { - VAL_FROM_HANDLE(val_device, device, _device); - struct val_render_pass *pass; + LVP_FROM_HANDLE(lvp_device, device, _device); + struct lvp_render_pass *pass; size_t size; size_t attachments_offset; @@ -166,7 +166,7 @@ VkResult val_CreateRenderPass( return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY); /* Clear the subpasses along with the parent pass. This required because - * each array member of val_subpass must be a valid pointer if not NULL. + * each array member of lvp_subpass must be a valid pointer if not NULL. */ memset(pass, 0, size); @@ -177,7 +177,7 @@ VkResult val_CreateRenderPass( pass->attachments = (void *) pass + attachments_offset; for (uint32_t i = 0; i < pCreateInfo->attachmentCount; i++) { - struct val_render_pass_attachment *att = &pass->attachments[i]; + struct lvp_render_pass_attachment *att = &pass->attachments[i]; att->format = pCreateInfo->pAttachments[i].format; att->samples = pCreateInfo->pAttachments[i].samples; @@ -189,13 +189,13 @@ VkResult val_CreateRenderPass( uint32_t subpass_attachment_count = 0; for (uint32_t i = 0; i < pCreateInfo->subpassCount; i++) { - subpass_attachment_count += val_num_subpass_attachments(&pCreateInfo->pSubpasses[i]); + subpass_attachment_count += lvp_num_subpass_attachments(&pCreateInfo->pSubpasses[i]); } if (subpass_attachment_count) { pass->subpass_attachments = vk_alloc2(&device->alloc, pAllocator, - subpass_attachment_count * sizeof(struct val_subpass_attachment), 8, + subpass_attachment_count * sizeof(struct lvp_subpass_attachment), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (pass->subpass_attachments == NULL) { vk_free2(&device->alloc, pAllocator, pass); @@ -204,14 +204,14 @@ VkResult val_CreateRenderPass( } else pass->subpass_attachments = NULL; - struct val_subpass_attachment *p = pass->subpass_attachments; + struct lvp_subpass_attachment *p = pass->subpass_attachments; for (uint32_t i = 0; i < pCreateInfo->subpassCount; i++) { const VkSubpassDescription *desc = &pCreateInfo->pSubpasses[i]; - struct val_subpass *subpass = &pass->subpasses[i]; + struct lvp_subpass *subpass = &pass->subpasses[i]; subpass->input_count = desc->inputAttachmentCount; subpass->color_count = desc->colorAttachmentCount; - subpass->attachment_count = val_num_subpass_attachments(desc); + subpass->attachment_count = lvp_num_subpass_attachments(desc); subpass->attachments = p; if (desc->inputAttachmentCount > 0) { @@ -219,7 +219,7 @@ VkResult val_CreateRenderPass( p += desc->inputAttachmentCount; for (uint32_t j = 0; j < desc->inputAttachmentCount; j++) { - subpass->input_attachments[j] = (struct val_subpass_attachment) { + subpass->input_attachments[j] = (struct lvp_subpass_attachment) { .attachment = desc->pInputAttachments[j].attachment, .layout = desc->pInputAttachments[j].layout, }; @@ -231,7 +231,7 @@ VkResult val_CreateRenderPass( p += desc->colorAttachmentCount; for (uint32_t j = 0; j < desc->colorAttachmentCount; j++) { - subpass->color_attachments[j] = (struct val_subpass_attachment) { + subpass->color_attachments[j] = (struct lvp_subpass_attachment) { .attachment = desc->pColorAttachments[j].attachment, .layout = desc->pColorAttachments[j].layout, }; @@ -243,7 +243,7 @@ VkResult val_CreateRenderPass( p += desc->colorAttachmentCount; for (uint32_t j = 0; j < desc->colorAttachmentCount; j++) { - subpass->resolve_attachments[j] = (struct val_subpass_attachment) { + subpass->resolve_attachments[j] = (struct lvp_subpass_attachment) { .attachment = desc->pResolveAttachments[j].attachment, .layout = desc->pResolveAttachments[j].layout, }; @@ -253,26 +253,26 @@ VkResult val_CreateRenderPass( if (desc->pDepthStencilAttachment) { subpass->depth_stencil_attachment = p++; - *subpass->depth_stencil_attachment = (struct val_subpass_attachment) { + *subpass->depth_stencil_attachment = (struct lvp_subpass_attachment) { .attachment = desc->pDepthStencilAttachment->attachment, .layout = desc->pDepthStencilAttachment->layout, }; } } - val_render_pass_compile(pass); - *pRenderPass = val_render_pass_to_handle(pass); + lvp_render_pass_compile(pass); + *pRenderPass = lvp_render_pass_to_handle(pass); return VK_SUCCESS; } -void val_DestroyRenderPass( +void lvp_DestroyRenderPass( VkDevice _device, VkRenderPass _pass, const VkAllocationCallbacks* pAllocator) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_render_pass, pass, _pass); + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_render_pass, pass, _pass); if (!_pass) return; @@ -281,7 +281,7 @@ void val_DestroyRenderPass( vk_free2(&device->alloc, pAllocator, pass); } -void val_GetRenderAreaGranularity( +void lvp_GetRenderAreaGranularity( VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) diff --git a/src/gallium/frontends/vallium/val_pipeline.c b/src/gallium/frontends/lavapipe/lvp_pipeline.c similarity index 92% rename from src/gallium/frontends/vallium/val_pipeline.c rename to src/gallium/frontends/lavapipe/lvp_pipeline.c index dc0465d..fb9a891 100644 --- a/src/gallium/frontends/vallium/val_pipeline.c +++ b/src/gallium/frontends/lavapipe/lvp_pipeline.c @@ -21,25 +21,25 @@ * IN THE SOFTWARE. */ -#include "val_private.h" +#include "lvp_private.h" #include "glsl_types.h" #include "spirv/nir_spirv.h" #include "nir/nir_builder.h" -#include "val_lower_vulkan_resource.h" +#include "lvp_lower_vulkan_resource.h" #include "pipe/p_state.h" #include "pipe/p_context.h" #define SPIR_V_MAGIC_NUMBER 0x07230203 -VkResult val_CreateShaderModule( +VkResult lvp_CreateShaderModule( VkDevice _device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) { - VAL_FROM_HANDLE(val_device, device, _device); - struct val_shader_module *module; + LVP_FROM_HANDLE(lvp_device, device, _device); + struct lvp_shader_module *module; assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO); assert(pCreateInfo->flags == 0); @@ -55,19 +55,19 @@ VkResult val_CreateShaderModule( module->size = pCreateInfo->codeSize; memcpy(module->data, pCreateInfo->pCode, module->size); - *pShaderModule = val_shader_module_to_handle(module); + *pShaderModule = lvp_shader_module_to_handle(module); return VK_SUCCESS; } -void val_DestroyShaderModule( +void lvp_DestroyShaderModule( VkDevice _device, VkShaderModule _module, const VkAllocationCallbacks* pAllocator) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_shader_module, module, _module); + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_shader_module, module, _module); if (!_module) return; @@ -75,13 +75,13 @@ void val_DestroyShaderModule( vk_free2(&device->alloc, pAllocator, module); } -void val_DestroyPipeline( +void lvp_DestroyPipeline( VkDevice _device, VkPipeline _pipeline, const VkAllocationCallbacks* pAllocator) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_pipeline, pipeline, _pipeline); + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_pipeline, pipeline, _pipeline); if (!_pipeline) return; @@ -463,8 +463,8 @@ shared_var_info(const struct glsl_type *type, unsigned *size, unsigned *align) }) static void -val_shader_compile_to_ir(struct val_pipeline *pipeline, - struct val_shader_module *module, +lvp_shader_compile_to_ir(struct lvp_pipeline *pipeline, + struct lvp_shader_module *module, const char *entrypoint_name, gl_shader_stage stage, const VkSpecializationInfo *spec_info) @@ -508,7 +508,7 @@ val_shader_compile_to_ir(struct val_pipeline *pipeline, } } } - struct val_device *pdevice = pipeline->device; + struct lvp_device *pdevice = pipeline->device; const struct spirv_to_nir_options spirv_options = { .environment = NIR_SPIRV_VULKAN, .caps = { @@ -559,14 +559,14 @@ val_shader_compile_to_ir(struct val_pipeline *pipeline, nir_var_shader_in | nir_var_shader_out | nir_var_system_value, NULL); if (stage == MESA_SHADER_FRAGMENT) - val_lower_input_attachments(nir, false); + lvp_lower_input_attachments(nir, false); NIR_PASS_V(nir, nir_lower_system_values); NIR_PASS_V(nir, nir_lower_compute_system_values, NULL); NIR_PASS_V(nir, nir_lower_clip_cull_distance_arrays); nir_remove_dead_variables(nir, nir_var_uniform, NULL); - val_lower_pipeline_layout(pipeline->device, pipeline->layout, nir); + lvp_lower_pipeline_layout(pipeline->device, pipeline->layout, nir); NIR_PASS_V(nir, nir_lower_io_to_temporaries, nir_shader_get_entrypoint(nir), true, true); NIR_PASS_V(nir, nir_split_var_copies); @@ -633,7 +633,7 @@ val_shader_compile_to_ir(struct val_pipeline *pipeline, pipeline->pipeline_nir[stage] = nir; } -static void fill_shader_prog(struct pipe_shader_state *state, gl_shader_stage stage, struct val_pipeline *pipeline) +static void fill_shader_prog(struct pipe_shader_state *state, gl_shader_stage stage, struct lvp_pipeline *pipeline) { state->type = PIPE_SHADER_IR_NIR; state->ir.nir = pipeline->pipeline_nir[stage]; @@ -679,7 +679,7 @@ merge_tess_info(struct shader_info *tes_info, } static gl_shader_stage -val_shader_stage(VkShaderStageFlagBits stage) +lvp_shader_stage(VkShaderStageFlagBits stage) { switch (stage) { case VK_SHADER_STAGE_VERTEX_BIT: @@ -701,10 +701,10 @@ val_shader_stage(VkShaderStageFlagBits stage) } static VkResult -val_pipeline_compile(struct val_pipeline *pipeline, +lvp_pipeline_compile(struct lvp_pipeline *pipeline, gl_shader_stage stage) { - struct val_device *device = pipeline->device; + struct lvp_device *device = pipeline->device; device->physical_device->pscreen->finalize_nir(device->physical_device->pscreen, pipeline->pipeline_nir[stage], true); if (stage == MESA_SHADER_COMPUTE) { struct pipe_compute_state shstate = {}; @@ -740,16 +740,16 @@ val_pipeline_compile(struct val_pipeline *pipeline, } static VkResult -val_graphics_pipeline_init(struct val_pipeline *pipeline, - struct val_device *device, - struct val_pipeline_cache *cache, +lvp_graphics_pipeline_init(struct lvp_pipeline *pipeline, + struct lvp_device *device, + struct lvp_pipeline_cache *cache, const VkGraphicsPipelineCreateInfo *pCreateInfo, const VkAllocationCallbacks *alloc) { if (alloc == NULL) alloc = &device->alloc; pipeline->device = device; - pipeline->layout = val_pipeline_layout_from_handle(pCreateInfo->layout); + pipeline->layout = lvp_pipeline_layout_from_handle(pCreateInfo->layout); pipeline->force_min_sample = false; /* recreate createinfo */ @@ -757,10 +757,10 @@ val_graphics_pipeline_init(struct val_pipeline *pipeline, pipeline->is_compute_pipeline = false; for (uint32_t i = 0; i < pCreateInfo->stageCount; i++) { - VAL_FROM_HANDLE(val_shader_module, module, + LVP_FROM_HANDLE(lvp_shader_module, module, pCreateInfo->pStages[i].module); - gl_shader_stage stage = val_shader_stage(pCreateInfo->pStages[i].stage); - val_shader_compile_to_ir(pipeline, module, + gl_shader_stage stage = lvp_shader_stage(pCreateInfo->pStages[i].stage); + lvp_shader_compile_to_ir(pipeline, module, pCreateInfo->pStages[i].pName, stage, pCreateInfo->pStages[i].pSpecializationInfo); @@ -781,8 +781,8 @@ val_graphics_pipeline_init(struct val_pipeline *pipeline, bool has_fragment_shader = false; for (uint32_t i = 0; i < pCreateInfo->stageCount; i++) { - gl_shader_stage stage = val_shader_stage(pCreateInfo->pStages[i].stage); - val_pipeline_compile(pipeline, stage); + gl_shader_stage stage = lvp_shader_stage(pCreateInfo->pStages[i].stage); + lvp_pipeline_compile(pipeline, stage); if (stage == MESA_SHADER_FRAGMENT) has_fragment_shader = true; } @@ -804,16 +804,16 @@ val_graphics_pipeline_init(struct val_pipeline *pipeline, } static VkResult -val_graphics_pipeline_create( +lvp_graphics_pipeline_create( VkDevice _device, VkPipelineCache _cache, const VkGraphicsPipelineCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipeline) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_pipeline_cache, cache, _cache); - struct val_pipeline *pipeline; + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_pipeline_cache, cache, _cache); + struct lvp_pipeline *pipeline; VkResult result; assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO); @@ -825,19 +825,19 @@ val_graphics_pipeline_create( vk_object_base_init(&device->vk, &pipeline->base, VK_OBJECT_TYPE_PIPELINE); - result = val_graphics_pipeline_init(pipeline, device, cache, pCreateInfo, + result = lvp_graphics_pipeline_init(pipeline, device, cache, pCreateInfo, pAllocator); if (result != VK_SUCCESS) { vk_free2(&device->alloc, pAllocator, pipeline); return result; } - *pPipeline = val_pipeline_to_handle(pipeline); + *pPipeline = lvp_pipeline_to_handle(pipeline); return VK_SUCCESS; } -VkResult val_CreateGraphicsPipelines( +VkResult lvp_CreateGraphicsPipelines( VkDevice _device, VkPipelineCache pipelineCache, uint32_t count, @@ -850,7 +850,7 @@ VkResult val_CreateGraphicsPipelines( for (; i < count; i++) { VkResult r; - r = val_graphics_pipeline_create(_device, + r = lvp_graphics_pipeline_create(_device, pipelineCache, &pCreateInfos[i], pAllocator, &pPipelines[i]); @@ -864,42 +864,42 @@ VkResult val_CreateGraphicsPipelines( } static VkResult -val_compute_pipeline_init(struct val_pipeline *pipeline, - struct val_device *device, - struct val_pipeline_cache *cache, +lvp_compute_pipeline_init(struct lvp_pipeline *pipeline, + struct lvp_device *device, + struct lvp_pipeline_cache *cache, const VkComputePipelineCreateInfo *pCreateInfo, const VkAllocationCallbacks *alloc) { - VAL_FROM_HANDLE(val_shader_module, module, + LVP_FROM_HANDLE(lvp_shader_module, module, pCreateInfo->stage.module); if (alloc == NULL) alloc = &device->alloc; pipeline->device = device; - pipeline->layout = val_pipeline_layout_from_handle(pCreateInfo->layout); + pipeline->layout = lvp_pipeline_layout_from_handle(pCreateInfo->layout); pipeline->force_min_sample = false; deep_copy_compute_create_info(&pipeline->compute_create_info, pCreateInfo); pipeline->is_compute_pipeline = true; - val_shader_compile_to_ir(pipeline, module, + lvp_shader_compile_to_ir(pipeline, module, pCreateInfo->stage.pName, MESA_SHADER_COMPUTE, pCreateInfo->stage.pSpecializationInfo); - val_pipeline_compile(pipeline, MESA_SHADER_COMPUTE); + lvp_pipeline_compile(pipeline, MESA_SHADER_COMPUTE); return VK_SUCCESS; } static VkResult -val_compute_pipeline_create( +lvp_compute_pipeline_create( VkDevice _device, VkPipelineCache _cache, const VkComputePipelineCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipeline) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_pipeline_cache, cache, _cache); - struct val_pipeline *pipeline; + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_pipeline_cache, cache, _cache); + struct lvp_pipeline *pipeline; VkResult result; assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO); @@ -911,19 +911,19 @@ val_compute_pipeline_create( vk_object_base_init(&device->vk, &pipeline->base, VK_OBJECT_TYPE_PIPELINE); - result = val_compute_pipeline_init(pipeline, device, cache, pCreateInfo, + result = lvp_compute_pipeline_init(pipeline, device, cache, pCreateInfo, pAllocator); if (result != VK_SUCCESS) { vk_free2(&device->alloc, pAllocator, pipeline); return result; } - *pPipeline = val_pipeline_to_handle(pipeline); + *pPipeline = lvp_pipeline_to_handle(pipeline); return VK_SUCCESS; } -VkResult val_CreateComputePipelines( +VkResult lvp_CreateComputePipelines( VkDevice _device, VkPipelineCache pipelineCache, uint32_t count, @@ -936,7 +936,7 @@ VkResult val_CreateComputePipelines( for (; i < count; i++) { VkResult r; - r = val_compute_pipeline_create(_device, + r = lvp_compute_pipeline_create(_device, pipelineCache, &pCreateInfos[i], pAllocator, &pPipelines[i]); diff --git a/src/gallium/frontends/vallium/val_pipeline_cache.c b/src/gallium/frontends/lavapipe/lvp_pipeline_cache.c similarity index 86% rename from src/gallium/frontends/vallium/val_pipeline_cache.c rename to src/gallium/frontends/lavapipe/lvp_pipeline_cache.c index b0e519f..1f48186 100644 --- a/src/gallium/frontends/vallium/val_pipeline_cache.c +++ b/src/gallium/frontends/lavapipe/lvp_pipeline_cache.c @@ -21,16 +21,16 @@ * IN THE SOFTWARE. */ -#include "val_private.h" +#include "lvp_private.h" -VkResult val_CreatePipelineCache( +VkResult lvp_CreatePipelineCache( VkDevice _device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) { - VAL_FROM_HANDLE(val_device, device, _device); - struct val_pipeline_cache *cache; + LVP_FROM_HANDLE(lvp_device, device, _device); + struct lvp_pipeline_cache *cache; assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO); assert(pCreateInfo->flags == 0); @@ -49,27 +49,27 @@ VkResult val_CreatePipelineCache( cache->alloc = device->alloc; cache->device = device; - *pPipelineCache = val_pipeline_cache_to_handle(cache); + *pPipelineCache = lvp_pipeline_cache_to_handle(cache); return VK_SUCCESS; } -void val_DestroyPipelineCache( +void lvp_DestroyPipelineCache( VkDevice _device, VkPipelineCache _cache, const VkAllocationCallbacks* pAllocator) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_pipeline_cache, cache, _cache); + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_pipeline_cache, cache, _cache); if (!_cache) return; -// val_pipeline_cache_finish(cache); +// lvp_pipeline_cache_finish(cache); vk_object_base_finish(&cache->base); vk_free2(&device->alloc, pAllocator, cache); } -VkResult val_GetPipelineCacheData( +VkResult lvp_GetPipelineCacheData( VkDevice _device, VkPipelineCache _cache, size_t* pDataSize, @@ -86,14 +86,14 @@ VkResult val_GetPipelineCacheData( hdr[1] = 1; hdr[2] = VK_VENDOR_ID_MESA; hdr[3] = 0; - val_device_get_cache_uuid(&hdr[4]); + lvp_device_get_cache_uuid(&hdr[4]); } } else *pDataSize = 32; return result; } -VkResult val_MergePipelineCaches( +VkResult lvp_MergePipelineCaches( VkDevice _device, VkPipelineCache destCache, uint32_t srcCacheCount, diff --git a/src/gallium/frontends/vallium/val_private.h b/src/gallium/frontends/lavapipe/lvp_private.h similarity index 55% rename from src/gallium/frontends/vallium/val_private.h rename to src/gallium/frontends/lavapipe/lvp_private.h index 7a41c9f..ff1edcd 100644 --- a/src/gallium/frontends/vallium/val_private.h +++ b/src/gallium/frontends/lavapipe/lvp_private.h @@ -50,8 +50,8 @@ typedef uint32_t xcb_window_t; #include #include -#include "val_extensions.h" -#include "val_entrypoints.h" +#include "lvp_extensions.h" +#include "lvp_entrypoints.h" #include "vk_object.h" #include "wsi_common.h" @@ -64,119 +64,119 @@ extern "C" { #define MAX_SETS 8 #define MAX_PUSH_CONSTANTS_SIZE 128 -#define val_printflike(a, b) __attribute__((__format__(__printf__, a, b))) +#define lvp_printflike(a, b) __attribute__((__format__(__printf__, a, b))) #define typed_memcpy(dest, src, count) ({ \ memcpy((dest), (src), (count) * sizeof(*(src))); \ }) -int val_get_instance_entrypoint_index(const char *name); -int val_get_device_entrypoint_index(const char *name); -int val_get_physical_device_entrypoint_index(const char *name); +int lvp_get_instance_entrypoint_index(const char *name); +int lvp_get_device_entrypoint_index(const char *name); +int lvp_get_physical_device_entrypoint_index(const char *name); -const char *val_get_instance_entry_name(int index); -const char *val_get_physical_device_entry_name(int index); -const char *val_get_device_entry_name(int index); +const char *lvp_get_instance_entry_name(int index); +const char *lvp_get_physical_device_entry_name(int index); +const char *lvp_get_device_entry_name(int index); -bool val_instance_entrypoint_is_enabled(int index, uint32_t core_version, - const struct val_instance_extension_table *instance); -bool val_physical_device_entrypoint_is_enabled(int index, uint32_t core_version, - const struct val_instance_extension_table *instance); -bool val_device_entrypoint_is_enabled(int index, uint32_t core_version, - const struct val_instance_extension_table *instance, - const struct val_device_extension_table *device); +bool lvp_instance_entrypoint_is_enabled(int index, uint32_t core_version, + const struct lvp_instance_extension_table *instance); +bool lvp_physical_device_entrypoint_is_enabled(int index, uint32_t core_version, + const struct lvp_instance_extension_table *instance); +bool lvp_device_entrypoint_is_enabled(int index, uint32_t core_version, + const struct lvp_instance_extension_table *instance, + const struct lvp_device_extension_table *device); -void *val_lookup_entrypoint(const char *name); +void *lvp_lookup_entrypoint(const char *name); -#define VAL_DEFINE_HANDLE_CASTS(__val_type, __VkType) \ +#define LVP_DEFINE_HANDLE_CASTS(__lvp_type, __VkType) \ \ - static inline struct __val_type * \ - __val_type ## _from_handle(__VkType _handle) \ + static inline struct __lvp_type * \ + __lvp_type ## _from_handle(__VkType _handle) \ { \ - return (struct __val_type *) _handle; \ + return (struct __lvp_type *) _handle; \ } \ \ static inline __VkType \ - __val_type ## _to_handle(struct __val_type *_obj) \ + __lvp_type ## _to_handle(struct __lvp_type *_obj) \ { \ return (__VkType) _obj; \ } -#define VAL_DEFINE_NONDISP_HANDLE_CASTS(__val_type, __VkType) \ +#define LVP_DEFINE_NONDISP_HANDLE_CASTS(__lvp_type, __VkType) \ \ - static inline struct __val_type * \ - __val_type ## _from_handle(__VkType _handle) \ + static inline struct __lvp_type * \ + __lvp_type ## _from_handle(__VkType _handle) \ { \ - return (struct __val_type *)(uintptr_t) _handle; \ + return (struct __lvp_type *)(uintptr_t) _handle; \ } \ \ static inline __VkType \ - __val_type ## _to_handle(struct __val_type *_obj) \ + __lvp_type ## _to_handle(struct __lvp_type *_obj) \ { \ return (__VkType)(uintptr_t) _obj; \ } -#define VAL_FROM_HANDLE(__val_type, __name, __handle) \ - struct __val_type *__name = __val_type ## _from_handle(__handle) - -VAL_DEFINE_HANDLE_CASTS(val_cmd_buffer, VkCommandBuffer) -VAL_DEFINE_HANDLE_CASTS(val_device, VkDevice) -VAL_DEFINE_HANDLE_CASTS(val_instance, VkInstance) -VAL_DEFINE_HANDLE_CASTS(val_physical_device, VkPhysicalDevice) -VAL_DEFINE_HANDLE_CASTS(val_queue, VkQueue) - -VAL_DEFINE_NONDISP_HANDLE_CASTS(val_cmd_pool, VkCommandPool) -VAL_DEFINE_NONDISP_HANDLE_CASTS(val_buffer, VkBuffer) -VAL_DEFINE_NONDISP_HANDLE_CASTS(val_buffer_view, VkBufferView) -VAL_DEFINE_NONDISP_HANDLE_CASTS(val_descriptor_pool, VkDescriptorPool) -VAL_DEFINE_NONDISP_HANDLE_CASTS(val_descriptor_set, VkDescriptorSet) -VAL_DEFINE_NONDISP_HANDLE_CASTS(val_descriptor_set_layout, VkDescriptorSetLayout) -VAL_DEFINE_NONDISP_HANDLE_CASTS(val_device_memory, VkDeviceMemory) -VAL_DEFINE_NONDISP_HANDLE_CASTS(val_event, VkEvent) -VAL_DEFINE_NONDISP_HANDLE_CASTS(val_framebuffer, VkFramebuffer) -VAL_DEFINE_NONDISP_HANDLE_CASTS(val_image, VkImage) -VAL_DEFINE_NONDISP_HANDLE_CASTS(val_image_view, VkImageView); -VAL_DEFINE_NONDISP_HANDLE_CASTS(val_pipeline_cache, VkPipelineCache) -VAL_DEFINE_NONDISP_HANDLE_CASTS(val_pipeline, VkPipeline) -VAL_DEFINE_NONDISP_HANDLE_CASTS(val_pipeline_layout, VkPipelineLayout) -VAL_DEFINE_NONDISP_HANDLE_CASTS(val_query_pool, VkQueryPool) -VAL_DEFINE_NONDISP_HANDLE_CASTS(val_render_pass, VkRenderPass) -VAL_DEFINE_NONDISP_HANDLE_CASTS(val_sampler, VkSampler) -VAL_DEFINE_NONDISP_HANDLE_CASTS(val_shader_module, VkShaderModule) -VAL_DEFINE_NONDISP_HANDLE_CASTS(val_fence, VkFence); -VAL_DEFINE_NONDISP_HANDLE_CASTS(val_semaphore, VkSemaphore); +#define LVP_FROM_HANDLE(__lvp_type, __name, __handle) \ + struct __lvp_type *__name = __lvp_type ## _from_handle(__handle) + +LVP_DEFINE_HANDLE_CASTS(lvp_cmd_buffer, VkCommandBuffer) +LVP_DEFINE_HANDLE_CASTS(lvp_device, VkDevice) +LVP_DEFINE_HANDLE_CASTS(lvp_instance, VkInstance) +LVP_DEFINE_HANDLE_CASTS(lvp_physical_device, VkPhysicalDevice) +LVP_DEFINE_HANDLE_CASTS(lvp_queue, VkQueue) + +LVP_DEFINE_NONDISP_HANDLE_CASTS(lvp_cmd_pool, VkCommandPool) +LVP_DEFINE_NONDISP_HANDLE_CASTS(lvp_buffer, VkBuffer) +LVP_DEFINE_NONDISP_HANDLE_CASTS(lvp_buffer_view, VkBufferView) +LVP_DEFINE_NONDISP_HANDLE_CASTS(lvp_descriptor_pool, VkDescriptorPool) +LVP_DEFINE_NONDISP_HANDLE_CASTS(lvp_descriptor_set, VkDescriptorSet) +LVP_DEFINE_NONDISP_HANDLE_CASTS(lvp_descriptor_set_layout, VkDescriptorSetLayout) +LVP_DEFINE_NONDISP_HANDLE_CASTS(lvp_device_memory, VkDeviceMemory) +LVP_DEFINE_NONDISP_HANDLE_CASTS(lvp_event, VkEvent) +LVP_DEFINE_NONDISP_HANDLE_CASTS(lvp_framebuffer, VkFramebuffer) +LVP_DEFINE_NONDISP_HANDLE_CASTS(lvp_image, VkImage) +LVP_DEFINE_NONDISP_HANDLE_CASTS(lvp_image_view, VkImageView); +LVP_DEFINE_NONDISP_HANDLE_CASTS(lvp_pipeline_cache, VkPipelineCache) +LVP_DEFINE_NONDISP_HANDLE_CASTS(lvp_pipeline, VkPipeline) +LVP_DEFINE_NONDISP_HANDLE_CASTS(lvp_pipeline_layout, VkPipelineLayout) +LVP_DEFINE_NONDISP_HANDLE_CASTS(lvp_query_pool, VkQueryPool) +LVP_DEFINE_NONDISP_HANDLE_CASTS(lvp_render_pass, VkRenderPass) +LVP_DEFINE_NONDISP_HANDLE_CASTS(lvp_sampler, VkSampler) +LVP_DEFINE_NONDISP_HANDLE_CASTS(lvp_shader_module, VkShaderModule) +LVP_DEFINE_NONDISP_HANDLE_CASTS(lvp_fence, VkFence); +LVP_DEFINE_NONDISP_HANDLE_CASTS(lvp_semaphore, VkSemaphore); /* Whenever we generate an error, pass it through this function. Useful for * debugging, where we can break on it. Only call at error site, not when * propagating errors. Might be useful to plug in a stack trace here. */ -VkResult __vk_errorf(struct val_instance *instance, VkResult error, const char *file, int line, const char *format, ...); +VkResult __vk_errorf(struct lvp_instance *instance, VkResult error, const char *file, int line, const char *format, ...); -#define VAL_DEBUG_ALL_ENTRYPOINTS (1 << 0) +#define LVP_DEBUG_ALL_ENTRYPOINTS (1 << 0) #define vk_error(instance, error) __vk_errorf(instance, error, __FILE__, __LINE__, NULL); #define vk_errorf(instance, error, format, ...) __vk_errorf(instance, error, __FILE__, __LINE__, format, ## __VA_ARGS__); -void __val_finishme(const char *file, int line, const char *format, ...) - val_printflike(3, 4); +void __lvp_finishme(const char *file, int line, const char *format, ...) + lvp_printflike(3, 4); -#define val_finishme(format, ...) \ - __val_finishme(__FILE__, __LINE__, format, ##__VA_ARGS__); +#define lvp_finishme(format, ...) \ + __lvp_finishme(__FILE__, __LINE__, format, ##__VA_ARGS__); #define stub_return(v) \ do { \ - val_finishme("stub %s", __func__); \ + lvp_finishme("stub %s", __func__); \ return (v); \ } while (0) #define stub() \ do { \ - val_finishme("stub %s", __func__); \ + lvp_finishme("stub %s", __func__); \ return; \ } while (0) -struct val_shader_module { +struct lvp_shader_module { struct vk_object_base base; uint32_t size; char data[0]; @@ -195,58 +195,58 @@ mesa_to_vk_shader_stage(gl_shader_stage mesa_stage) return (1 << mesa_stage); } -#define VAL_STAGE_MASK ((1 << MESA_SHADER_STAGES) - 1) +#define LVP_STAGE_MASK ((1 << MESA_SHADER_STAGES) - 1) -#define val_foreach_stage(stage, stage_bits) \ +#define lvp_foreach_stage(stage, stage_bits) \ for (gl_shader_stage stage, \ - __tmp = (gl_shader_stage)((stage_bits) & VAL_STAGE_MASK); \ + __tmp = (gl_shader_stage)((stage_bits) & LVP_STAGE_MASK); \ stage = __builtin_ffs(__tmp) - 1, __tmp; \ __tmp &= ~(1 << (stage))) -struct val_physical_device { +struct lvp_physical_device { VK_LOADER_DATA _loader_data; - struct val_instance * instance; + struct lvp_instance * instance; struct pipe_loader_device *pld; struct pipe_screen *pscreen; uint32_t max_images; struct wsi_device wsi_device; - struct val_device_extension_table supported_extensions; + struct lvp_device_extension_table supported_extensions; }; -struct val_instance { +struct lvp_instance { struct vk_object_base base; VkAllocationCallbacks alloc; uint32_t apiVersion; int physicalDeviceCount; - struct val_physical_device physicalDevice; + struct lvp_physical_device physicalDevice; uint64_t debug_flags; struct pipe_loader_device *devs; int num_devices; - struct val_instance_extension_table enabled_extensions; - struct val_instance_dispatch_table dispatch; - struct val_physical_device_dispatch_table physical_device_dispatch; - struct val_device_dispatch_table device_dispatch; + struct lvp_instance_extension_table enabled_extensions; + struct lvp_instance_dispatch_table dispatch; + struct lvp_physical_device_dispatch_table physical_device_dispatch; + struct lvp_device_dispatch_table device_dispatch; }; -VkResult val_init_wsi(struct val_physical_device *physical_device); -void val_finish_wsi(struct val_physical_device *physical_device); +VkResult lvp_init_wsi(struct lvp_physical_device *physical_device); +void lvp_finish_wsi(struct lvp_physical_device *physical_device); -bool val_instance_extension_supported(const char *name); -uint32_t val_physical_device_api_version(struct val_physical_device *dev); -bool val_physical_device_extension_supported(struct val_physical_device *dev, +bool lvp_instance_extension_supported(const char *name); +uint32_t lvp_physical_device_api_version(struct lvp_physical_device *dev); +bool lvp_physical_device_extension_supported(struct lvp_physical_device *dev, const char *name); -struct val_queue { +struct lvp_queue { VK_LOADER_DATA _loader_data; VkDeviceQueueCreateFlags flags; - struct val_device * device; + struct lvp_device * device; struct pipe_context *ctx; bool shutdown; thrd_t exec_thread; @@ -256,37 +256,37 @@ struct val_queue { uint32_t count; }; -struct val_queue_work { +struct lvp_queue_work { struct list_head list; uint32_t cmd_buffer_count; - struct val_cmd_buffer **cmd_buffers; - struct val_fence *fence; + struct lvp_cmd_buffer **cmd_buffers; + struct lvp_fence *fence; }; -struct val_pipeline_cache { +struct lvp_pipeline_cache { struct vk_object_base base; - struct val_device * device; + struct lvp_device * device; VkAllocationCallbacks alloc; }; -struct val_device { +struct lvp_device { struct vk_device vk; VkAllocationCallbacks alloc; - struct val_queue queue; - struct val_instance * instance; - struct val_physical_device *physical_device; + struct lvp_queue queue; + struct lvp_instance * instance; + struct lvp_physical_device *physical_device; struct pipe_screen *pscreen; mtx_t fence_lock; - struct val_device_extension_table enabled_extensions; - struct val_device_dispatch_table dispatch; + struct lvp_device_extension_table enabled_extensions; + struct lvp_device_dispatch_table dispatch; }; -void val_device_get_cache_uuid(void *uuid); +void lvp_device_get_cache_uuid(void *uuid); -struct val_device_memory { +struct lvp_device_memory { struct vk_object_base base; struct pipe_memory_allocation *pmem; uint32_t type_index; @@ -294,7 +294,7 @@ struct val_device_memory { void * map; }; -struct val_image { +struct lvp_image { struct vk_object_base base; VkImageType type; VkFormat vk_format; @@ -304,7 +304,7 @@ struct val_image { }; static inline uint32_t -val_get_layerCount(const struct val_image *image, +lvp_get_layerCount(const struct lvp_image *image, const VkImageSubresourceRange *range) { return range->layerCount == VK_REMAINING_ARRAY_LAYERS ? @@ -312,28 +312,28 @@ val_get_layerCount(const struct val_image *image, } static inline uint32_t -val_get_levelCount(const struct val_image *image, +lvp_get_levelCount(const struct lvp_image *image, const VkImageSubresourceRange *range) { return range->levelCount == VK_REMAINING_MIP_LEVELS ? (image->bo->last_level + 1) - range->baseMipLevel : range->levelCount; } -struct val_image_create_info { +struct lvp_image_create_info { const VkImageCreateInfo *vk_info; uint32_t bind_flags; uint32_t stride; }; VkResult -val_image_create(VkDevice _device, - const struct val_image_create_info *create_info, +lvp_image_create(VkDevice _device, + const struct lvp_image_create_info *create_info, const VkAllocationCallbacks* alloc, VkImage *pImage); -struct val_image_view { +struct lvp_image_view { struct vk_object_base base; - const struct val_image *image; /**< VkImageViewCreateInfo::image */ + const struct lvp_image *image; /**< VkImageViewCreateInfo::image */ VkImageViewType view_type; VkFormat format; @@ -344,23 +344,23 @@ struct val_image_view { struct pipe_surface *surface; /* have we created a pipe surface for this? */ }; -struct val_subpass_attachment { +struct lvp_subpass_attachment { uint32_t attachment; VkImageLayout layout; bool in_render_loop; }; -struct val_subpass { +struct lvp_subpass { uint32_t attachment_count; - struct val_subpass_attachment * attachments; + struct lvp_subpass_attachment * attachments; uint32_t input_count; uint32_t color_count; - struct val_subpass_attachment * input_attachments; - struct val_subpass_attachment * color_attachments; - struct val_subpass_attachment * resolve_attachments; - struct val_subpass_attachment * depth_stencil_attachment; - struct val_subpass_attachment * ds_resolve_attachment; + struct lvp_subpass_attachment * input_attachments; + struct lvp_subpass_attachment * color_attachments; + struct lvp_subpass_attachment * resolve_attachments; + struct lvp_subpass_attachment * depth_stencil_attachment; + struct lvp_subpass_attachment * ds_resolve_attachment; /** Subpass has at least one color resolve attachment */ bool has_color_resolve; @@ -371,7 +371,7 @@ struct val_subpass { VkSampleCountFlagBits max_sample_count; }; -struct val_render_pass_attachment { +struct lvp_render_pass_attachment { VkFormat format; uint32_t samples; VkAttachmentLoadOp load_op; @@ -384,32 +384,32 @@ struct val_render_pass_attachment { uint32_t last_subpass_idx; }; -struct val_render_pass { +struct lvp_render_pass { struct vk_object_base base; uint32_t attachment_count; uint32_t subpass_count; - struct val_subpass_attachment * subpass_attachments; - struct val_render_pass_attachment * attachments; - struct val_subpass subpasses[0]; + struct lvp_subpass_attachment * subpass_attachments; + struct lvp_render_pass_attachment * attachments; + struct lvp_subpass subpasses[0]; }; -struct val_sampler { +struct lvp_sampler { struct vk_object_base base; VkSamplerCreateInfo create_info; uint32_t state[4]; }; -struct val_framebuffer { +struct lvp_framebuffer { struct vk_object_base base; uint32_t width; uint32_t height; uint32_t layers; uint32_t attachment_count; - struct val_image_view * attachments[0]; + struct lvp_image_view * attachments[0]; }; -struct val_descriptor_set_binding_layout { +struct lvp_descriptor_set_binding_layout { uint16_t descriptor_index; /* Number of array elements in this binding */ VkDescriptorType type; @@ -426,10 +426,10 @@ struct val_descriptor_set_binding_layout { } stage[MESA_SHADER_STAGES]; /* Immutable samplers (or NULL if no immutable samplers) */ - struct val_sampler **immutable_samplers; + struct lvp_sampler **immutable_samplers; }; -struct val_descriptor_set_layout { +struct lvp_descriptor_set_layout { struct vk_object_base base; /* Number of bindings in this descriptor set */ uint16_t binding_count; @@ -452,34 +452,34 @@ struct val_descriptor_set_layout { uint16_t dynamic_offset_count; /* Bindings in this descriptor set */ - struct val_descriptor_set_binding_layout binding[0]; + struct lvp_descriptor_set_binding_layout binding[0]; }; -struct val_descriptor { +struct lvp_descriptor { VkDescriptorType type; union { struct { - struct val_image_view *image_view; - struct val_sampler *sampler; + struct lvp_image_view *image_view; + struct lvp_sampler *sampler; }; struct { uint64_t offset; uint64_t range; - struct val_buffer *buffer; + struct lvp_buffer *buffer; } buf; - struct val_buffer_view *buffer_view; + struct lvp_buffer_view *buffer_view; }; }; -struct val_descriptor_set { +struct lvp_descriptor_set { struct vk_object_base base; - const struct val_descriptor_set_layout *layout; + const struct lvp_descriptor_set_layout *layout; struct list_head link; - struct val_descriptor descriptors[0]; + struct lvp_descriptor descriptors[0]; }; -struct val_descriptor_pool { +struct lvp_descriptor_pool { struct vk_object_base base; VkDescriptorPoolCreateFlags flags; uint32_t max_sets; @@ -488,18 +488,18 @@ struct val_descriptor_pool { }; VkResult -val_descriptor_set_create(struct val_device *device, - const struct val_descriptor_set_layout *layout, - struct val_descriptor_set **out_set); +lvp_descriptor_set_create(struct lvp_device *device, + const struct lvp_descriptor_set_layout *layout, + struct lvp_descriptor_set **out_set); void -val_descriptor_set_destroy(struct val_device *device, - struct val_descriptor_set *set); +lvp_descriptor_set_destroy(struct lvp_device *device, + struct lvp_descriptor_set *set); -struct val_pipeline_layout { +struct lvp_pipeline_layout { struct vk_object_base base; struct { - struct val_descriptor_set_layout *layout; + struct lvp_descriptor_set_layout *layout; uint32_t dynamic_offset_start; } set[MAX_SETS]; @@ -510,10 +510,10 @@ struct val_pipeline_layout { } stage[MESA_SHADER_STAGES]; }; -struct val_pipeline { +struct lvp_pipeline { struct vk_object_base base; - struct val_device * device; - struct val_pipeline_layout * layout; + struct lvp_device * device; + struct lvp_pipeline_layout * layout; bool is_compute_pipeline; bool force_min_sample; @@ -523,25 +523,25 @@ struct val_pipeline { VkComputePipelineCreateInfo compute_create_info; }; -struct val_event { +struct lvp_event { struct vk_object_base base; uint64_t event_storage; }; -struct val_fence { +struct lvp_fence { struct vk_object_base base; bool signaled; struct pipe_fence_handle *handle; }; -struct val_semaphore { +struct lvp_semaphore { struct vk_object_base base; bool dummy; }; -struct val_buffer { +struct lvp_buffer { struct vk_object_base base; - struct val_device * device; + struct lvp_device * device; VkDeviceSize size; VkBufferUsageFlags usage; @@ -551,16 +551,16 @@ struct val_buffer { uint64_t total_size; }; -struct val_buffer_view { +struct lvp_buffer_view { struct vk_object_base base; VkFormat format; enum pipe_format pformat; - struct val_buffer *buffer; + struct lvp_buffer *buffer; uint32_t offset; uint64_t range; }; -struct val_query_pool { +struct lvp_query_pool { struct vk_object_base base; VkQueryType type; uint32_t count; @@ -568,7 +568,7 @@ struct val_query_pool { struct pipe_query *queries[0]; }; -struct val_cmd_pool { +struct lvp_cmd_pool { struct vk_object_base base; VkAllocationCallbacks alloc; struct list_head cmd_buffers; @@ -576,22 +576,22 @@ struct val_cmd_pool { }; -enum val_cmd_buffer_status { - VAL_CMD_BUFFER_STATUS_INVALID, - VAL_CMD_BUFFER_STATUS_INITIAL, - VAL_CMD_BUFFER_STATUS_RECORDING, - VAL_CMD_BUFFER_STATUS_EXECUTABLE, - VAL_CMD_BUFFER_STATUS_PENDING, +enum lvp_cmd_buffer_status { + LVP_CMD_BUFFER_STATUS_INVALID, + LVP_CMD_BUFFER_STATUS_INITIAL, + LVP_CMD_BUFFER_STATUS_RECORDING, + LVP_CMD_BUFFER_STATUS_EXECUTABLE, + LVP_CMD_BUFFER_STATUS_PENDING, }; -struct val_cmd_buffer { +struct lvp_cmd_buffer { struct vk_object_base base; - struct val_device * device; + struct lvp_device * device; VkCommandBufferLevel level; - enum val_cmd_buffer_status status; - struct val_cmd_pool * pool; + enum lvp_cmd_buffer_status status; + struct lvp_cmd_pool * pool; struct list_head pool_link; struct list_head cmds; @@ -600,125 +600,125 @@ struct val_cmd_buffer { }; /* in same order and buffer building commands in spec. */ -enum val_cmds { - VAL_CMD_BIND_PIPELINE, - VAL_CMD_SET_VIEWPORT, - VAL_CMD_SET_SCISSOR, - VAL_CMD_SET_LINE_WIDTH, - VAL_CMD_SET_DEPTH_BIAS, - VAL_CMD_SET_BLEND_CONSTANTS, - VAL_CMD_SET_DEPTH_BOUNDS, - VAL_CMD_SET_STENCIL_COMPARE_MASK, - VAL_CMD_SET_STENCIL_WRITE_MASK, - VAL_CMD_SET_STENCIL_REFERENCE, - VAL_CMD_BIND_DESCRIPTOR_SETS, - VAL_CMD_BIND_INDEX_BUFFER, - VAL_CMD_BIND_VERTEX_BUFFERS, - VAL_CMD_DRAW, - VAL_CMD_DRAW_INDEXED, - VAL_CMD_DRAW_INDIRECT, - VAL_CMD_DRAW_INDEXED_INDIRECT, - VAL_CMD_DISPATCH, - VAL_CMD_DISPATCH_INDIRECT, - VAL_CMD_COPY_BUFFER, - VAL_CMD_COPY_IMAGE, - VAL_CMD_BLIT_IMAGE, - VAL_CMD_COPY_BUFFER_TO_IMAGE, - VAL_CMD_COPY_IMAGE_TO_BUFFER, - VAL_CMD_UPDATE_BUFFER, - VAL_CMD_FILL_BUFFER, - VAL_CMD_CLEAR_COLOR_IMAGE, - VAL_CMD_CLEAR_DEPTH_STENCIL_IMAGE, - VAL_CMD_CLEAR_ATTACHMENTS, - VAL_CMD_RESOLVE_IMAGE, - VAL_CMD_SET_EVENT, - VAL_CMD_RESET_EVENT, - VAL_CMD_WAIT_EVENTS, - VAL_CMD_PIPELINE_BARRIER, - VAL_CMD_BEGIN_QUERY, - VAL_CMD_END_QUERY, - VAL_CMD_RESET_QUERY_POOL, - VAL_CMD_WRITE_TIMESTAMP, - VAL_CMD_COPY_QUERY_POOL_RESULTS, - VAL_CMD_PUSH_CONSTANTS, - VAL_CMD_BEGIN_RENDER_PASS, - VAL_CMD_NEXT_SUBPASS, - VAL_CMD_END_RENDER_PASS, - VAL_CMD_EXECUTE_COMMANDS, -}; - -struct val_cmd_bind_pipeline { +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, +}; + +struct lvp_cmd_bind_pipeline { VkPipelineBindPoint bind_point; - struct val_pipeline *pipeline; + struct lvp_pipeline *pipeline; }; -struct val_cmd_set_viewport { +struct lvp_cmd_set_viewport { uint32_t first_viewport; uint32_t viewport_count; VkViewport viewports[16]; }; -struct val_cmd_set_scissor { +struct lvp_cmd_set_scissor { uint32_t first_scissor; uint32_t scissor_count; VkRect2D scissors[16]; }; -struct val_cmd_set_line_width { +struct lvp_cmd_set_line_width { float line_width; }; -struct val_cmd_set_depth_bias { +struct lvp_cmd_set_depth_bias { float constant_factor; float clamp; float slope_factor; }; -struct val_cmd_set_blend_constants { +struct lvp_cmd_set_blend_constants { float blend_constants[4]; }; -struct val_cmd_set_depth_bounds { +struct lvp_cmd_set_depth_bounds { float min_depth; float max_depth; }; -struct val_cmd_set_stencil_vals { +struct lvp_cmd_set_stencil_vals { VkStencilFaceFlags face_mask; uint32_t value; }; -struct val_cmd_bind_descriptor_sets { +struct lvp_cmd_bind_descriptor_sets { VkPipelineBindPoint bind_point; - struct val_pipeline_layout *layout; + struct lvp_pipeline_layout *layout; uint32_t first; uint32_t count; - struct val_descriptor_set **sets; + struct lvp_descriptor_set **sets; uint32_t dynamic_offset_count; const uint32_t *dynamic_offsets; }; -struct val_cmd_bind_index_buffer { - const struct val_buffer *buffer; +struct lvp_cmd_bind_index_buffer { + const struct lvp_buffer *buffer; VkDeviceSize offset; VkIndexType index_type; }; -struct val_cmd_bind_vertex_buffers { +struct lvp_cmd_bind_vertex_buffers { uint32_t first; uint32_t binding_count; - struct val_buffer **buffers; + struct lvp_buffer **buffers; const VkDeviceSize *offsets; }; -struct val_cmd_draw { +struct lvp_cmd_draw { uint32_t vertex_count; uint32_t instance_count; uint32_t first_vertex; uint32_t first_instance; }; -struct val_cmd_draw_indexed { +struct lvp_cmd_draw_indexed { uint32_t index_count; uint32_t instance_count; uint32_t first_index; @@ -726,43 +726,43 @@ struct val_cmd_draw_indexed { uint32_t first_instance; }; -struct val_cmd_draw_indirect { +struct lvp_cmd_draw_indirect { VkDeviceSize offset; - struct val_buffer *buffer; + struct lvp_buffer *buffer; uint32_t draw_count; uint32_t stride; }; -struct val_cmd_dispatch { +struct lvp_cmd_dispatch { uint32_t x; uint32_t y; uint32_t z; }; -struct val_cmd_dispatch_indirect { - const struct val_buffer *buffer; +struct lvp_cmd_dispatch_indirect { + const struct lvp_buffer *buffer; VkDeviceSize offset; }; -struct val_cmd_copy_buffer { - struct val_buffer *src; - struct val_buffer *dst; +struct lvp_cmd_copy_buffer { + struct lvp_buffer *src; + struct lvp_buffer *dst; uint32_t region_count; const VkBufferCopy *regions; }; -struct val_cmd_copy_image { - struct val_image *src; - struct val_image *dst; +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 val_cmd_blit_image { - struct val_image *src; - struct val_image *dst; +struct lvp_cmd_blit_image { + struct lvp_image *src; + struct lvp_image *dst; VkImageLayout src_layout; VkImageLayout dst_layout; uint32_t region_count; @@ -770,77 +770,77 @@ struct val_cmd_blit_image { VkFilter filter; }; -struct val_cmd_copy_buffer_to_image { - struct val_buffer *src; - struct val_image *dst; +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 val_cmd_copy_image_to_buffer { - struct val_image *src; - struct val_buffer *dst; +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 val_cmd_update_buffer { - struct val_buffer *buffer; +struct lvp_cmd_update_buffer { + struct lvp_buffer *buffer; VkDeviceSize offset; VkDeviceSize data_size; char data[0]; }; -struct val_cmd_fill_buffer { - struct val_buffer *buffer; +struct lvp_cmd_fill_buffer { + struct lvp_buffer *buffer; VkDeviceSize offset; VkDeviceSize fill_size; uint32_t data; }; -struct val_cmd_clear_color_image { - struct val_image *image; +struct lvp_cmd_clear_color_image { + struct lvp_image *image; VkImageLayout layout; VkClearColorValue clear_val; uint32_t range_count; VkImageSubresourceRange *ranges; }; -struct val_cmd_clear_ds_image { - struct val_image *image; +struct lvp_cmd_clear_ds_image { + struct lvp_image *image; VkImageLayout layout; VkClearDepthStencilValue clear_val; uint32_t range_count; VkImageSubresourceRange *ranges; }; -struct val_cmd_clear_attachments { +struct lvp_cmd_clear_attachments { uint32_t attachment_count; VkClearAttachment *attachments; uint32_t rect_count; VkClearRect *rects; }; -struct val_cmd_resolve_image { - struct val_image *src; - struct val_image *dst; +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 val_cmd_event_set { - struct val_event *event; +struct lvp_cmd_event_set { + struct lvp_event *event; bool value; bool flush; }; -struct val_cmd_wait_events { +struct lvp_cmd_wait_events { uint32_t event_count; - struct val_event **events; + struct lvp_event **events; VkPipelineStageFlags src_stage_mask; VkPipelineStageFlags dst_stage_mask; uint32_t memory_barrier_count; @@ -851,7 +851,7 @@ struct val_cmd_wait_events { VkImageMemoryBarrier *image_memory_barriers; }; -struct val_cmd_pipeline_barrier { +struct lvp_cmd_pipeline_barrier { VkPipelineStageFlags src_stage_mask; VkPipelineStageFlags dst_stage_mask; bool by_region; @@ -863,99 +863,99 @@ struct val_cmd_pipeline_barrier { VkImageMemoryBarrier *image_memory_barriers; }; -struct val_cmd_query_cmd { - struct val_query_pool *pool; +struct lvp_cmd_query_cmd { + struct lvp_query_pool *pool; uint32_t query; uint32_t index; bool precise; bool flush; }; -struct val_cmd_copy_query_pool_results { - struct val_query_pool *pool; +struct lvp_cmd_copy_query_pool_results { + struct lvp_query_pool *pool; uint32_t first_query; uint32_t query_count; - struct val_buffer *dst; + struct lvp_buffer *dst; VkDeviceSize dst_offset; VkDeviceSize stride; VkQueryResultFlags flags; }; -struct val_cmd_push_constants { +struct lvp_cmd_push_constants { VkShaderStageFlags stage; uint32_t offset; uint32_t size; uint32_t val[1]; }; -struct val_attachment_state { +struct lvp_attachment_state { VkImageAspectFlags pending_clear_aspects; VkClearValue clear_value; }; -struct val_cmd_begin_render_pass { - struct val_framebuffer *framebuffer; - struct val_render_pass *render_pass; +struct lvp_cmd_begin_render_pass { + struct lvp_framebuffer *framebuffer; + struct lvp_render_pass *render_pass; VkRect2D render_area; - struct val_attachment_state *attachments; + struct lvp_attachment_state *attachments; }; -struct val_cmd_next_subpass { +struct lvp_cmd_next_subpass { VkSubpassContents contents; }; -struct val_cmd_execute_commands { +struct lvp_cmd_execute_commands { uint32_t command_buffer_count; - struct val_cmd_buffer *cmd_buffers[0]; + struct lvp_cmd_buffer *cmd_buffers[0]; }; -struct val_cmd_buffer_entry { +struct lvp_cmd_buffer_entry { struct list_head cmd_link; uint32_t cmd_type; union { - struct val_cmd_bind_pipeline pipeline; - struct val_cmd_set_viewport set_viewport; - struct val_cmd_set_scissor set_scissor; - struct val_cmd_set_line_width set_line_width; - struct val_cmd_set_depth_bias set_depth_bias; - struct val_cmd_set_blend_constants set_blend_constants; - struct val_cmd_set_depth_bounds set_depth_bounds; - struct val_cmd_set_stencil_vals stencil_vals; - struct val_cmd_bind_descriptor_sets descriptor_sets; - struct val_cmd_bind_vertex_buffers vertex_buffers; - struct val_cmd_bind_index_buffer index_buffer; - struct val_cmd_draw draw; - struct val_cmd_draw_indexed draw_indexed; - struct val_cmd_draw_indirect draw_indirect; - struct val_cmd_dispatch dispatch; - struct val_cmd_dispatch_indirect dispatch_indirect; - struct val_cmd_copy_buffer copy_buffer; - struct val_cmd_copy_image copy_image; - struct val_cmd_blit_image blit_image; - struct val_cmd_copy_buffer_to_image buffer_to_img; - struct val_cmd_copy_image_to_buffer img_to_buffer; - struct val_cmd_update_buffer update_buffer; - struct val_cmd_fill_buffer fill_buffer; - struct val_cmd_clear_color_image clear_color_image; - struct val_cmd_clear_ds_image clear_ds_image; - struct val_cmd_clear_attachments clear_attachments; - struct val_cmd_resolve_image resolve_image; - struct val_cmd_event_set event_set; - struct val_cmd_wait_events wait_events; - struct val_cmd_pipeline_barrier pipeline_barrier; - struct val_cmd_query_cmd query; - struct val_cmd_copy_query_pool_results copy_query_pool_results; - struct val_cmd_push_constants push_constants; - struct val_cmd_begin_render_pass begin_render_pass; - struct val_cmd_next_subpass next_subpass; - struct val_cmd_execute_commands execute_commands; + 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; } u; }; -VkResult val_execute_cmds(struct val_device *device, - struct val_queue *queue, - struct val_fence *fence, - struct val_cmd_buffer *cmd_buffer); +VkResult lvp_execute_cmds(struct lvp_device *device, + struct lvp_queue *queue, + struct lvp_fence *fence, + struct lvp_cmd_buffer *cmd_buffer); enum pipe_format vk_format_to_pipe(VkFormat format); diff --git a/src/gallium/frontends/vallium/val_query.c b/src/gallium/frontends/lavapipe/lvp_query.c similarity index 90% rename from src/gallium/frontends/vallium/val_query.c rename to src/gallium/frontends/lavapipe/lvp_query.c index d0a4859..bdcd2a0 100644 --- a/src/gallium/frontends/vallium/val_query.c +++ b/src/gallium/frontends/lavapipe/lvp_query.c @@ -21,16 +21,16 @@ * IN THE SOFTWARE. */ -#include "val_private.h" +#include "lvp_private.h" #include "pipe/p_context.h" -VkResult val_CreateQueryPool( +VkResult lvp_CreateQueryPool( VkDevice _device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) { - VAL_FROM_HANDLE(val_device, device, _device); + LVP_FROM_HANDLE(lvp_device, device, _device); enum pipe_query_type pipeq; switch (pCreateInfo->queryType) { @@ -43,7 +43,7 @@ VkResult val_CreateQueryPool( default: return VK_ERROR_FEATURE_NOT_PRESENT; } - struct val_query_pool *pool; + struct lvp_query_pool *pool; uint32_t pool_size = sizeof(*pool) + pCreateInfo->queryCount * sizeof(struct pipe_query *); pool = vk_zalloc2(&device->alloc, pAllocator, @@ -58,17 +58,17 @@ VkResult val_CreateQueryPool( pool->count = pCreateInfo->queryCount; pool->base_type = pipeq; - *pQueryPool = val_query_pool_to_handle(pool); + *pQueryPool = lvp_query_pool_to_handle(pool); return VK_SUCCESS; } -void val_DestroyQueryPool( +void lvp_DestroyQueryPool( VkDevice _device, VkQueryPool _pool, const VkAllocationCallbacks* pAllocator) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_query_pool, pool, _pool); + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_query_pool, pool, _pool); if (!pool) return; @@ -80,7 +80,7 @@ void val_DestroyQueryPool( vk_free2(&device->alloc, pAllocator, pool); } -VkResult val_GetQueryPoolResults( +VkResult lvp_GetQueryPoolResults( VkDevice _device, VkQueryPool queryPool, uint32_t firstQuery, @@ -90,11 +90,11 @@ VkResult val_GetQueryPoolResults( VkDeviceSize stride, VkQueryResultFlags flags) { - VAL_FROM_HANDLE(val_device, device, _device); - VAL_FROM_HANDLE(val_query_pool, pool, queryPool); + LVP_FROM_HANDLE(lvp_device, device, _device); + LVP_FROM_HANDLE(lvp_query_pool, pool, queryPool); VkResult vk_result = VK_SUCCESS; - val_DeviceWaitIdle(_device); + lvp_DeviceWaitIdle(_device); for (unsigned i = firstQuery; i < firstQuery + queryCount; i++) { uint8_t *dptr = (uint8_t *)((char *)pData + (stride * (i - firstQuery))); diff --git a/src/gallium/frontends/vallium/val_util.c b/src/gallium/frontends/lavapipe/lvp_util.c similarity index 91% rename from src/gallium/frontends/vallium/val_util.c rename to src/gallium/frontends/lavapipe/lvp_util.c index 9e92088..1c47387 100644 --- a/src/gallium/frontends/vallium/val_util.c +++ b/src/gallium/frontends/lavapipe/lvp_util.c @@ -21,10 +21,10 @@ * IN THE SOFTWARE. */ -#include "val_private.h" +#include "lvp_private.h" #include "vk_enum_to_str.h" -void val_printflike(3, 4) -__val_finishme(const char *file, int line, const char *format, ...) +void lvp_printflike(3, 4) +__lvp_finishme(const char *file, int line, const char *format, ...) { va_list ap; char buffer[256]; @@ -37,7 +37,7 @@ __val_finishme(const char *file, int line, const char *format, ...) } VkResult -__vk_errorf(struct val_instance *instance, VkResult error, const char *file, int line, const char *format, ...) +__vk_errorf(struct lvp_instance *instance, VkResult error, const char *file, int line, const char *format, ...) { va_list ap; char buffer[256]; diff --git a/src/gallium/frontends/vallium/val_wsi.c b/src/gallium/frontends/lavapipe/lvp_wsi.c similarity index 80% rename from src/gallium/frontends/vallium/val_wsi.c rename to src/gallium/frontends/lavapipe/lvp_wsi.c index aa56654..5ed131b 100644 --- a/src/gallium/frontends/vallium/val_wsi.c +++ b/src/gallium/frontends/lavapipe/lvp_wsi.c @@ -21,49 +21,49 @@ * IN THE SOFTWARE. */ -#include "val_wsi.h" +#include "lvp_wsi.h" static PFN_vkVoidFunction -val_wsi_proc_addr(VkPhysicalDevice physicalDevice, const char *pName) +lvp_wsi_proc_addr(VkPhysicalDevice physicalDevice, const char *pName) { - return val_lookup_entrypoint(pName); + return lvp_lookup_entrypoint(pName); } VkResult -val_init_wsi(struct val_physical_device *physical_device) +lvp_init_wsi(struct lvp_physical_device *physical_device) { return wsi_device_init(&physical_device->wsi_device, - val_physical_device_to_handle(physical_device), - val_wsi_proc_addr, + lvp_physical_device_to_handle(physical_device), + lvp_wsi_proc_addr, &physical_device->instance->alloc, -1, NULL, true); } void -val_finish_wsi(struct val_physical_device *physical_device) +lvp_finish_wsi(struct lvp_physical_device *physical_device) { wsi_device_finish(&physical_device->wsi_device, &physical_device->instance->alloc); } -void val_DestroySurfaceKHR( +void lvp_DestroySurfaceKHR( VkInstance _instance, VkSurfaceKHR _surface, const VkAllocationCallbacks* pAllocator) { - VAL_FROM_HANDLE(val_instance, instance, _instance); + LVP_FROM_HANDLE(lvp_instance, instance, _instance); ICD_FROM_HANDLE(VkIcdSurfaceBase, surface, _surface); vk_free2(&instance->alloc, pAllocator, surface); } -VkResult val_GetPhysicalDeviceSurfaceSupportKHR( +VkResult lvp_GetPhysicalDeviceSurfaceSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) { - VAL_FROM_HANDLE(val_physical_device, device, physicalDevice); + LVP_FROM_HANDLE(lvp_physical_device, device, physicalDevice); return wsi_common_get_surface_support(&device->wsi_device, queueFamilyIndex, @@ -71,62 +71,62 @@ VkResult val_GetPhysicalDeviceSurfaceSupportKHR( pSupported); } -VkResult val_GetPhysicalDeviceSurfaceCapabilitiesKHR( +VkResult lvp_GetPhysicalDeviceSurfaceCapabilitiesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) { - VAL_FROM_HANDLE(val_physical_device, device, physicalDevice); + LVP_FROM_HANDLE(lvp_physical_device, device, physicalDevice); return wsi_common_get_surface_capabilities(&device->wsi_device, surface, pSurfaceCapabilities); } -VkResult val_GetPhysicalDeviceSurfaceCapabilities2KHR( +VkResult lvp_GetPhysicalDeviceSurfaceCapabilities2KHR( VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities) { - VAL_FROM_HANDLE(val_physical_device, device, physicalDevice); + LVP_FROM_HANDLE(lvp_physical_device, device, physicalDevice); return wsi_common_get_surface_capabilities2(&device->wsi_device, pSurfaceInfo, pSurfaceCapabilities); } -VkResult val_GetPhysicalDeviceSurfaceCapabilities2EXT( +VkResult lvp_GetPhysicalDeviceSurfaceCapabilities2EXT( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities) { - VAL_FROM_HANDLE(val_physical_device, device, physicalDevice); + LVP_FROM_HANDLE(lvp_physical_device, device, physicalDevice); return wsi_common_get_surface_capabilities2ext(&device->wsi_device, surface, pSurfaceCapabilities); } -VkResult val_GetPhysicalDeviceSurfaceFormatsKHR( +VkResult lvp_GetPhysicalDeviceSurfaceFormatsKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) { - VAL_FROM_HANDLE(val_physical_device, device, physicalDevice); + LVP_FROM_HANDLE(lvp_physical_device, device, physicalDevice); return wsi_common_get_surface_formats(&device->wsi_device, surface, pSurfaceFormatCount, pSurfaceFormats); } -VkResult val_GetPhysicalDeviceSurfacePresentModesKHR( +VkResult lvp_GetPhysicalDeviceSurfacePresentModesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) { - VAL_FROM_HANDLE(val_physical_device, device, physicalDevice); + LVP_FROM_HANDLE(lvp_physical_device, device, physicalDevice); return wsi_common_get_surface_present_modes(&device->wsi_device, surface, @@ -134,13 +134,13 @@ VkResult val_GetPhysicalDeviceSurfacePresentModesKHR( pPresentModes); } -VkResult val_CreateSwapchainKHR( +VkResult lvp_CreateSwapchainKHR( VkDevice _device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) { - VAL_FROM_HANDLE(val_device, device, _device); + LVP_FROM_HANDLE(lvp_device, device, _device); const VkAllocationCallbacks *alloc; if (pAllocator) alloc = pAllocator; @@ -148,18 +148,18 @@ VkResult val_CreateSwapchainKHR( alloc = &device->alloc; return wsi_common_create_swapchain(&device->physical_device->wsi_device, - val_device_to_handle(device), + lvp_device_to_handle(device), pCreateInfo, alloc, pSwapchain); } -void val_DestroySwapchainKHR( +void lvp_DestroySwapchainKHR( VkDevice _device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) { - VAL_FROM_HANDLE(val_device, device, _device); + LVP_FROM_HANDLE(lvp_device, device, _device); const VkAllocationCallbacks *alloc; if (pAllocator) @@ -170,7 +170,7 @@ void val_DestroySwapchainKHR( wsi_common_destroy_swapchain(_device, swapchain, alloc); } -VkResult val_GetSwapchainImagesKHR( +VkResult lvp_GetSwapchainImagesKHR( VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, @@ -181,7 +181,7 @@ VkResult val_GetSwapchainImagesKHR( pSwapchainImages); } -VkResult val_AcquireNextImageKHR( +VkResult lvp_AcquireNextImageKHR( VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, @@ -198,23 +198,23 @@ VkResult val_AcquireNextImageKHR( .deviceMask = 0, }; - return val_AcquireNextImage2KHR(device, &acquire_info, pImageIndex); + return lvp_AcquireNextImage2KHR(device, &acquire_info, pImageIndex); } -VkResult val_AcquireNextImage2KHR( +VkResult lvp_AcquireNextImage2KHR( VkDevice _device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) { - VAL_FROM_HANDLE(val_device, device, _device); - struct val_physical_device *pdevice = device->physical_device; + LVP_FROM_HANDLE(lvp_device, device, _device); + struct lvp_physical_device *pdevice = device->physical_device; VkResult result = wsi_common_acquire_next_image2(&pdevice->wsi_device, _device, pAcquireInfo, pImageIndex); #if 0 - VAL_FROM_HANDLE(val_fence, fence, pAcquireInfo->fence); + LVP_FROM_HANDLE(lvp_fence, fence, pAcquireInfo->fence); if (fence && (result == VK_SUCCESS || result == VK_SUBOPTIMAL_KHR)) { if (fence->fence) @@ -229,19 +229,19 @@ VkResult val_AcquireNextImage2KHR( return result; } -VkResult val_QueuePresentKHR( +VkResult lvp_QueuePresentKHR( VkQueue _queue, const VkPresentInfoKHR* pPresentInfo) { - VAL_FROM_HANDLE(val_queue, queue, _queue); + LVP_FROM_HANDLE(lvp_queue, queue, _queue); return wsi_common_queue_present(&queue->device->physical_device->wsi_device, - val_device_to_handle(queue->device), + lvp_device_to_handle(queue->device), _queue, 0, pPresentInfo); } -VkResult val_GetDeviceGroupPresentCapabilitiesKHR( +VkResult lvp_GetDeviceGroupPresentCapabilitiesKHR( VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pCapabilities) { @@ -253,7 +253,7 @@ VkResult val_GetDeviceGroupPresentCapabilitiesKHR( return VK_SUCCESS; } -VkResult val_GetDeviceGroupSurfacePresentModesKHR( +VkResult lvp_GetDeviceGroupSurfacePresentModesKHR( VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) @@ -263,13 +263,13 @@ VkResult val_GetDeviceGroupSurfacePresentModesKHR( return VK_SUCCESS; } -VkResult val_GetPhysicalDevicePresentRectanglesKHR( +VkResult lvp_GetPhysicalDevicePresentRectanglesKHR( VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects) { - VAL_FROM_HANDLE(val_physical_device, device, physicalDevice); + LVP_FROM_HANDLE(lvp_physical_device, device, physicalDevice); return wsi_common_get_present_rectangles(&device->wsi_device, surface, diff --git a/src/gallium/frontends/vallium/val_wsi.h b/src/gallium/frontends/lavapipe/lvp_wsi.h similarity index 67% rename from src/gallium/frontends/vallium/val_wsi.h rename to src/gallium/frontends/lavapipe/lvp_wsi.h index 26fceb0..b3530e4 100644 --- a/src/gallium/frontends/vallium/val_wsi.h +++ b/src/gallium/frontends/lavapipe/lvp_wsi.h @@ -23,52 +23,52 @@ #pragma once -#include "val_private.h" +#include "lvp_private.h" -struct val_swapchain; +struct lvp_swapchain; -struct val_wsi_interface { +struct lvp_wsi_interface { VkResult (*get_support)(VkIcdSurfaceBase *surface, - struct val_physical_device *device, + struct lvp_physical_device *device, uint32_t queueFamilyIndex, VkBool32* pSupported); VkResult (*get_capabilities)(VkIcdSurfaceBase *surface, - struct val_physical_device *device, + struct lvp_physical_device *device, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); VkResult (*get_formats)(VkIcdSurfaceBase *surface, - struct val_physical_device *device, + struct lvp_physical_device *device, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats); VkResult (*get_present_modes)(VkIcdSurfaceBase *surface, - struct val_physical_device *device, + struct lvp_physical_device *device, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes); VkResult (*create_swapchain)(VkIcdSurfaceBase *surface, - struct val_device *device, + struct lvp_device *device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, - struct val_swapchain **swapchain); + struct lvp_swapchain **swapchain); }; -struct val_swapchain { - struct val_device *device; +struct lvp_swapchain { + struct lvp_device *device; - VkResult (*destroy)(struct val_swapchain *swapchain, + VkResult (*destroy)(struct lvp_swapchain *swapchain, const VkAllocationCallbacks *pAllocator); - VkResult (*get_images)(struct val_swapchain *swapchain, + VkResult (*get_images)(struct lvp_swapchain *swapchain, uint32_t *pCount, VkImage *pSwapchainImages); - VkResult (*acquire_next_image)(struct val_swapchain *swap_chain, + VkResult (*acquire_next_image)(struct lvp_swapchain *swap_chain, uint64_t timeout, VkSemaphore semaphore, uint32_t *image_index); - VkResult (*queue_present)(struct val_swapchain *swap_chain, - struct val_queue *queue, + VkResult (*queue_present)(struct lvp_swapchain *swap_chain, + struct lvp_queue *queue, uint32_t image_index); }; -VAL_DEFINE_NONDISP_HANDLE_CASTS(_VkIcdSurfaceBase, VkSurfaceKHR) -VAL_DEFINE_NONDISP_HANDLE_CASTS(val_swapchain, VkSwapchainKHR) +LVP_DEFINE_NONDISP_HANDLE_CASTS(_VkIcdSurfaceBase, VkSurfaceKHR) +LVP_DEFINE_NONDISP_HANDLE_CASTS(lvp_swapchain, VkSwapchainKHR) -VkResult val_x11_init_wsi(struct val_instance *instance); -void val_x11_finish_wsi(struct val_instance *instance); -VkResult val_wl_init_wsi(struct val_instance *instance); -void val_wl_finish_wsi(struct val_instance *instance); +VkResult lvp_x11_init_wsi(struct lvp_instance *instance); +void lvp_x11_finish_wsi(struct lvp_instance *instance); +VkResult lvp_wl_init_wsi(struct lvp_instance *instance); +void lvp_wl_finish_wsi(struct lvp_instance *instance); diff --git a/src/gallium/frontends/vallium/val_wsi_wayland.c b/src/gallium/frontends/lavapipe/lvp_wsi_wayland.c similarity index 89% rename from src/gallium/frontends/vallium/val_wsi_wayland.c rename to src/gallium/frontends/lavapipe/lvp_wsi_wayland.c index 2fb14a6..13f5d87 100644 --- a/src/gallium/frontends/vallium/val_wsi_wayland.c +++ b/src/gallium/frontends/lavapipe/lvp_wsi_wayland.c @@ -24,25 +24,25 @@ */ #include "wsi_common_wayland.h" -#include "val_private.h" +#include "lvp_private.h" -VkBool32 val_GetPhysicalDeviceWaylandPresentationSupportKHR( +VkBool32 lvp_GetPhysicalDeviceWaylandPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display) { - VAL_FROM_HANDLE(val_physical_device, physical_device, physicalDevice); + LVP_FROM_HANDLE(lvp_physical_device, physical_device, physicalDevice); return wsi_wl_get_presentation_support(&physical_device->wsi_device, display); } -VkResult val_CreateWaylandSurfaceKHR( +VkResult lvp_CreateWaylandSurfaceKHR( VkInstance _instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { - VAL_FROM_HANDLE(val_instance, instance, _instance); + LVP_FROM_HANDLE(lvp_instance, instance, _instance); const VkAllocationCallbacks *alloc; assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR); diff --git a/src/gallium/frontends/vallium/val_wsi_x11.c b/src/gallium/frontends/lavapipe/lvp_wsi_x11.c similarity index 87% rename from src/gallium/frontends/vallium/val_wsi_x11.c rename to src/gallium/frontends/lavapipe/lvp_wsi_x11.c index 26a3203..9ba99d6 100644 --- a/src/gallium/frontends/vallium/val_wsi_x11.c +++ b/src/gallium/frontends/lavapipe/lvp_wsi_x11.c @@ -25,15 +25,15 @@ #include #include "wsi_common_x11.h" -#include "val_private.h" +#include "lvp_private.h" -VkBool32 val_GetPhysicalDeviceXcbPresentationSupportKHR( +VkBool32 lvp_GetPhysicalDeviceXcbPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id) { - VAL_FROM_HANDLE(val_physical_device, device, physicalDevice); + LVP_FROM_HANDLE(lvp_physical_device, device, physicalDevice); return wsi_get_physical_device_xcb_presentation_support( &device->wsi_device, @@ -41,13 +41,13 @@ VkBool32 val_GetPhysicalDeviceXcbPresentationSupportKHR( connection, visual_id); } -VkBool32 val_GetPhysicalDeviceXlibPresentationSupportKHR( +VkBool32 lvp_GetPhysicalDeviceXlibPresentationSupportKHR( VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID) { - VAL_FROM_HANDLE(val_physical_device, device, physicalDevice); + LVP_FROM_HANDLE(lvp_physical_device, device, physicalDevice); return wsi_get_physical_device_xcb_presentation_support( &device->wsi_device, @@ -55,13 +55,13 @@ VkBool32 val_GetPhysicalDeviceXlibPresentationSupportKHR( XGetXCBConnection(dpy), visualID); } -VkResult val_CreateXcbSurfaceKHR( +VkResult lvp_CreateXcbSurfaceKHR( VkInstance _instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { - VAL_FROM_HANDLE(val_instance, instance, _instance); + LVP_FROM_HANDLE(lvp_instance, instance, _instance); const VkAllocationCallbacks *alloc; assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR); @@ -73,13 +73,13 @@ VkResult val_CreateXcbSurfaceKHR( return wsi_create_xcb_surface(alloc, pCreateInfo, pSurface); } -VkResult val_CreateXlibSurfaceKHR( +VkResult lvp_CreateXlibSurfaceKHR( VkInstance _instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { - VAL_FROM_HANDLE(val_instance, instance, _instance); + LVP_FROM_HANDLE(lvp_instance, instance, _instance); const VkAllocationCallbacks *alloc; assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR); diff --git a/src/gallium/frontends/lavapipe/meson.build b/src/gallium/frontends/lavapipe/meson.build new file mode 100644 index 0000000..972735f --- /dev/null +++ b/src/gallium/frontends/lavapipe/meson.build @@ -0,0 +1,66 @@ + +lvp_entrypoints = custom_target( + 'lvp_entrypoints.[ch]', + input : ['lvp_entrypoints_gen.py', vk_api_xml], + output : ['lvp_entrypoints.h', 'lvp_entrypoints.c'], + command : [ + prog_python, '@INPUT0@', '--xml', '@INPUT1@', '--outdir', + meson.current_build_dir() + ], + depend_files : files('lvp_extensions.py'), +) + +lvp_extensions_c = custom_target( + 'lvp_extensions.c', + input : ['lvp_extensions.py', vk_api_xml], + output : ['lvp_extensions.c', 'lvp_extensions.h'], + command : [ + prog_python, '@INPUT0@', '--xml', '@INPUT1@', '--out-c', '@OUTPUT0@', + '--out-h', '@OUTPUT1@' + ], +) + +liblvp_files = files( + 'lvp_device.c', + 'lvp_cmd_buffer.c', + 'lvp_descriptor_set.c', + 'lvp_execute.c', + 'lvp_util.c', + 'lvp_image.c', + 'lvp_formats.c', + 'lvp_lower_vulkan_resource.c', + 'lvp_lower_vulkan_resource.h', + 'lvp_lower_input_attachments.c', + 'lvp_pass.c', + 'lvp_pipeline.c', + 'lvp_pipeline_cache.c', + 'lvp_query.c', + 'lvp_wsi.c') + +lvp_deps = [] +lvp_flags = [] + +if with_platform_x11 + lvp_deps += dep_xcb_dri3 + lvp_flags += [ + '-DVK_USE_PLATFORM_XCB_KHR', + '-DVK_USE_PLATFORM_XLIB_KHR', + ] + liblvp_files += files('lvp_wsi_x11.c') +endif + +if with_platform_wayland + lvp_deps += dep_wayland_client + lvp_flags += '-DVK_USE_PLATFORM_WAYLAND_KHR' + liblvp_files += files('lvp_wsi_wayland.c') +endif + +liblavapipe_st = static_library( + 'lavapipe_st', + [liblvp_files, lvp_entrypoints, lvp_extensions_c ], + link_with : [ libvulkan_wsi ], + c_args : [ lvp_flags ], + gnu_symbol_visibility : 'hidden', + include_directories : [ inc_include, inc_src, inc_util, inc_gallium, inc_compiler, inc_gallium_aux, inc_vulkan_wsi ], + dependencies : [ idep_nir, idep_mesautil, idep_vulkan_util ] +) diff --git a/src/gallium/frontends/vallium/meson.build b/src/gallium/frontends/vallium/meson.build deleted file mode 100644 index f0afa89..0000000 --- a/src/gallium/frontends/vallium/meson.build +++ /dev/null @@ -1,66 +0,0 @@ - -val_entrypoints = custom_target( - 'val_entrypoints.[ch]', - input : ['val_entrypoints_gen.py', vk_api_xml], - output : ['val_entrypoints.h', 'val_entrypoints.c'], - command : [ - prog_python, '@INPUT0@', '--xml', '@INPUT1@', '--outdir', - meson.current_build_dir() - ], - depend_files : files('val_extensions.py'), -) - -val_extensions_c = custom_target( - 'val_extensions.c', - input : ['val_extensions.py', vk_api_xml], - output : ['val_extensions.c', 'val_extensions.h'], - command : [ - prog_python, '@INPUT0@', '--xml', '@INPUT1@', '--out-c', '@OUTPUT0@', - '--out-h', '@OUTPUT1@' - ], -) - -libval_files = files( - 'val_device.c', - 'val_cmd_buffer.c', - 'val_descriptor_set.c', - 'val_execute.c', - 'val_util.c', - 'val_image.c', - 'val_formats.c', - 'val_lower_vulkan_resource.c', - 'val_lower_vulkan_resource.h', - 'val_lower_input_attachments.c', - 'val_pass.c', - 'val_pipeline.c', - 'val_pipeline_cache.c', - 'val_query.c', - 'val_wsi.c') - -val_deps = [] -val_flags = [] - -if with_platform_x11 - val_deps += dep_xcb_dri3 - val_flags += [ - '-DVK_USE_PLATFORM_XCB_KHR', - '-DVK_USE_PLATFORM_XLIB_KHR', - ] - libval_files += files('val_wsi_x11.c') -endif - -if with_platform_wayland - val_deps += dep_wayland_client - val_flags += '-DVK_USE_PLATFORM_WAYLAND_KHR' - libval_files += files('val_wsi_wayland.c') -endif - -libvallium_st = static_library( - 'vallium_st', - [libval_files, val_entrypoints, val_extensions_c ], - link_with : [ libvulkan_wsi ], - c_args : [ val_flags ], - gnu_symbol_visibility : 'hidden', - include_directories : [ inc_include, inc_src, inc_util, inc_gallium, inc_compiler, inc_gallium_aux, inc_vulkan_wsi ], - dependencies : [ idep_nir, idep_mesautil, idep_vulkan_util ] -) diff --git a/src/gallium/meson.build b/src/gallium/meson.build index 1681fcd..7d3b6c3 100644 --- a/src/gallium/meson.build +++ b/src/gallium/meson.build @@ -226,6 +226,6 @@ if with_tests subdir('tests') endif if with_swrast_vk - subdir('frontends/vallium') - subdir('targets/vallium') + subdir('frontends/lavapipe') + subdir('targets/lavapipe') endif diff --git a/src/gallium/targets/vallium/val_icd.py b/src/gallium/targets/lavapipe/lvp_icd.py similarity index 94% rename from src/gallium/targets/vallium/val_icd.py rename to src/gallium/targets/lavapipe/lvp_icd.py index 80c7d33..6084058 100644 --- a/src/gallium/targets/vallium/val_icd.py +++ b/src/gallium/targets/lavapipe/lvp_icd.py @@ -28,10 +28,10 @@ import argparse if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument('--out', help='Output json file.', required=True) - parser.add_argument('--lib-path', help='Path to libvulkan_val.so') + parser.add_argument('--lib-path', help='Path to libvulkan_lvp.so') args = parser.parse_args() - path = 'libvulkan_val.so' + path = 'libvulkan_lvp.so' if args.lib_path: path = os.path.join(args.lib_path, path) diff --git a/src/gallium/targets/vallium/meson.build b/src/gallium/targets/lavapipe/meson.build similarity index 71% rename from src/gallium/targets/vallium/meson.build rename to src/gallium/targets/lavapipe/meson.build index 38efd26..b34498e 100644 --- a/src/gallium/targets/vallium/meson.build +++ b/src/gallium/targets/lavapipe/meson.build @@ -1,8 +1,8 @@ -libvulkan_val = shared_library( - 'vulkan_val', +libvulkan_lvp = shared_library( + 'vulkan_lvp', [ 'target.c' ], include_directories : [ inc_src, inc_util, inc_include, inc_gallium, inc_gallium_aux, inc_gallium_winsys, inc_gallium_drivers ], - link_whole : [ libvallium_st ], + link_whole : [ liblavapipe_st ], link_with : [libpipe_loader_static, libmegadriver_stub, libdri, libdricommon ,libgallium, libwsw, libswdri, libws_null, libswkmsdri ], gnu_symbol_visibility : 'hidden', link_args : [ld_args_bsymbolic, ld_args_gc_sections], @@ -11,16 +11,16 @@ libvulkan_val = shared_library( name_suffix : 'so', ) -val_icd = custom_target( - 'val_icd', - input : 'val_icd.py', - output : 'val_icd.@0@.json'.format(host_machine.cpu()), +lvp_icd = custom_target( + 'lvp_icd', + input : 'lvp_icd.py', + output : 'lvp_icd.@0@.json'.format(host_machine.cpu()), command : [ prog_python, '@INPUT@', '--lib-path', join_paths(get_option('prefix'), get_option('libdir')), '--out', '@OUTPUT@', ], - depend_files : files('../../frontends/vallium/val_extensions.py'), + depend_files : files('../../frontends/lavapipe/lvp_extensions.py'), build_by_default : true, install_dir : with_vulkan_icd_dir, install : true, diff --git a/src/gallium/targets/vallium/target.c b/src/gallium/targets/lavapipe/target.c similarity index 100% rename from src/gallium/targets/vallium/target.c rename to src/gallium/targets/lavapipe/target.c -- 2.7.4