lavapipe: rename vallium to lavapipe
Just a cooler name, and a lot easier to search for. thanks Marek
Acked-by: Marek Olšák <marek.olsak@amd.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/6921>
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 @@
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 @@
*/
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 @@
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 @@
}
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 @@
}
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 @@
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 @@
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 @@
}
}
-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 @@
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 @@
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 @@
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 @@
cmd_buf_queue(cmd_buffer, cmd);
}
-void val_CmdBindDescriptorSets(
+void lvp_CmdBindDescriptorSets(
VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint,
VkPipelineLayout _layout,
@@ -427,15 +427,15 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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_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 @@
cmd_buf_queue(cmd_buffer, cmd);
}
-void val_CmdPushConstants(
+void lvp_CmdPushConstants(
VkCommandBuffer commandBuffer,
VkPipelineLayout layout,
VkShaderStageFlags stageFlags,
@@ -671,10 +671,10 @@
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 @@
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 @@
cmd_buf_queue(cmd_buffer, cmd);
}
-void val_CmdDrawIndexed(
+void lvp_CmdDrawIndexed(
VkCommandBuffer commandBuffer,
uint32_t indexCount,
uint32_t instanceCount,
@@ -715,10 +715,10 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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_CmdWaitEvents(VkCommandBuffer commandBuffer,
+void lvp_CmdWaitEvents(VkCommandBuffer commandBuffer,
uint32_t eventCount,
const VkEvent* pEvents,
VkPipelineStageFlags srcStageMask,
@@ -886,25 +886,25 @@
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_CmdCopyBufferToImage(
+void lvp_CmdCopyBufferToImage(
VkCommandBuffer commandBuffer,
VkBuffer srcBuffer,
VkImage destImage,
@@ -922,13 +922,13 @@
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 @@
cmd_buf_queue(cmd_buffer, cmd);
}
-void val_CmdCopyImageToBuffer(
+void lvp_CmdCopyImageToBuffer(
VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
@@ -956,13 +956,13 @@
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 @@
cmd_buf_queue(cmd_buffer, cmd);
}
-void val_CmdCopyImage(
+void lvp_CmdCopyImage(
VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
@@ -991,13 +991,13 @@
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_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 @@
cmd_buf_queue(cmd_buffer, cmd);
}
-void val_CmdBlitImage(
+void lvp_CmdBlitImage(
VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
@@ -1061,13 +1061,13 @@
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 @@
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 @@
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 @@
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 @@
cmd_buf_queue(cmd_buffer, cmd);
}
-void val_CmdClearColorImage(
+void lvp_CmdClearColorImage(
VkCommandBuffer commandBuffer,
VkImage image_h,
VkImageLayout imageLayout,
@@ -1170,12 +1170,12 @@
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 @@
cmd_buf_queue(cmd_buffer, cmd);
}
-void val_CmdClearDepthStencilImage(
+void lvp_CmdClearDepthStencilImage(
VkCommandBuffer commandBuffer,
VkImage image_h,
VkImageLayout imageLayout,
@@ -1198,12 +1198,12 @@
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_CmdResolveImage(
+void lvp_CmdResolveImage(
VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
@@ -1228,13 +1228,13 @@
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 @@
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 @@
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 @@
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 @@
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 @@
cmd_buf_queue(cmd_buffer, cmd);
}
-void val_CmdCopyQueryPoolResults(
+void lvp_CmdCopyQueryPoolResults(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t firstQuery,
@@ -1363,12 +1363,12 @@
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 @@
cmd_buf_queue(cmd_buffer, cmd);
}
-void val_CmdPipelineBarrier(
+void lvp_CmdPipelineBarrier(
VkCommandBuffer commandBuffer,
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags destStageMask,
@@ -1395,15 +1395,15 @@
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 77%
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
}
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 @@
{
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
}
-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 @@
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 @@
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 @@
}
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 @@
.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 @@
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 @@
* 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 @@
* 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 @@
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 @@
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 @@
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 @@
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 @@
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_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_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 @@
};
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_GetPhysicalDeviceQueueFamilyProperties(
+void lvp_GetPhysicalDeviceQueueFamilyProperties(
VkPhysicalDevice physicalDevice,
uint32_t* pCount,
VkQueueFamilyProperties* pQueueFamilyProperties)
@@ -590,7 +590,7 @@
};
}
-void val_GetPhysicalDeviceMemoryProperties(
+void lvp_GetPhysicalDeviceMemoryProperties(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceMemoryProperties* pMemoryProperties)
{
@@ -610,11 +610,11 @@
};
}
-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 @@
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 @@
VkInstance instance,
const char* pName)
{
- return val_GetInstanceProcAddr(instance, pName);
+ return lvp_GetInstanceProcAddr(instance, pName);
}
PUBLIC
@@ -683,27 +683,27 @@
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 @@
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 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 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
.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 @@
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 @@
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 @@
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 @@
}
-VkResult val_MapMemory(
+VkResult lvp_MapMemory(
VkDevice _device,
VkDeviceMemory _memory,
VkDeviceSize offset,
@@ -1117,8 +1117,8 @@
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 @@
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 @@
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 @@
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 @@
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_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_GetImageSparseMemoryRequirements(
+void lvp_GetImageSparseMemoryRequirements(
VkDevice device,
VkImage image,
uint32_t* pSparseMemoryRequirementCount,
@@ -1247,7 +1247,7 @@
stub();
}
-void val_GetImageSparseMemoryRequirements2(
+void lvp_GetImageSparseMemoryRequirements2(
VkDevice device,
const VkImageSparseMemoryRequirementsInfo2* pInfo,
uint32_t* pSparseMemoryRequirementCount,
@@ -1256,7 +1256,7 @@
stub();
}
-void val_GetDeviceMemoryCommitment(
+void lvp_GetDeviceMemoryCommitment(
VkDevice device,
VkDeviceMemory memory,
VkDeviceSize* pCommittedMemoryInBytes)
@@ -1264,14 +1264,14 @@
*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 @@
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 @@
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 @@
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 @@
return VK_SUCCESS;
}
-VkResult val_QueueBindSparse(
+VkResult lvp_QueueBindSparse(
VkQueue queue,
uint32_t bindInfoCount,
const VkBindSparseInfo* pBindInfo,
@@ -1342,14 +1342,14 @@
}
-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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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_physical_device_dispatch_table {
+struct lvp_physical_device_dispatch_table {
union {
void *entrypoints[${len(physical_device_entrypoints)}];
struct {
@@ -85,7 +85,7 @@
};
};
-struct val_device_dispatch_table {
+struct lvp_device_dispatch_table {
union {
void *entrypoints[${len(device_entrypoints)}];
struct {
@@ -104,12 +104,12 @@
};
};
-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 @@
% 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 @@
/* 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 @@
% 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 @@
% 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 @@
% 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 @@
% 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 @@
* 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 @@
* 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 @@
* 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 @@
}
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 @@
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 89%
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 @@
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 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 @@
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_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 @@
};
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 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_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 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 @@
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_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 @@
}
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 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 @@
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 @@
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 @@
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 @@
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 @@
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_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 @@
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 @@
}
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 @@
&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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
}
-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_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_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_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_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_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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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_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_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 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 @@
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 @@
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_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 @@
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 @@
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_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_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 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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
return VK_ERROR_FORMAT_NOT_SUPPORTED;
}
-VkResult val_GetPhysicalDeviceImageFormatProperties(
+VkResult lvp_GetPhysicalDeviceImageFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkImageType type,
@@ -386,7 +386,7 @@
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 @@
.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 @@
return VK_SUCCESS;
}
-void val_GetPhysicalDeviceSparseImageFormatProperties(
+void lvp_GetPhysicalDeviceSparseImageFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkImageType type,
@@ -431,7 +431,7 @@
*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 @@
&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 @@
}
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 @@
}
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 @@
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 @@
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 @@
}
}
-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 @@
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 @@
}
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 @@
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 96%
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 @@
}
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 93%
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 @@
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 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 @@
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 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 @@
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 @@
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 83%
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 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
(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 @@
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 @@
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 @@
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 @@
} 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
})
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 @@
}
}
}
- 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 @@
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 @@
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 @@
}
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 @@
}
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 @@
}
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
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/lavapipe/lvp_private.h b/src/gallium/frontends/lavapipe/lvp_private.h
new file mode 100644
index 0000000..ff1edcd
--- /dev/null
+++ b/src/gallium/frontends/lavapipe/lvp_private.h
@@ -0,0 +1,989 @@
+/*
+ * Copyright © 2019 Red Hat.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#pragma once
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <string.h>
+#include <strings.h>
+#include <pthread.h>
+#include <assert.h>
+#include <stdint.h>
+
+#include "util/macros.h"
+#include "util/list.h"
+
+#include "compiler/shader_enums.h"
+#include "pipe/p_screen.h"
+#include "pipe/p_state.h"
+#include "nir.h"
+
+/* Pre-declarations needed for WSI entrypoints */
+struct wl_surface;
+struct wl_display;
+typedef struct xcb_connection_t xcb_connection_t;
+typedef uint32_t xcb_visualid_t;
+typedef uint32_t xcb_window_t;
+
+#define VK_PROTOTYPES
+#include <vulkan/vulkan.h>
+#include <vulkan/vk_icd.h>
+
+#include "lvp_extensions.h"
+#include "lvp_entrypoints.h"
+#include "vk_object.h"
+
+#include "wsi_common.h"
+
+#include <assert.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define MAX_SETS 8
+#define MAX_PUSH_CONSTANTS_SIZE 128
+
+#define lvp_printflike(a, b) __attribute__((__format__(__printf__, a, b)))
+
+#define typed_memcpy(dest, src, count) ({ \
+ memcpy((dest), (src), (count) * sizeof(*(src))); \
+})
+
+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 *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 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 *lvp_lookup_entrypoint(const char *name);
+
+#define LVP_DEFINE_HANDLE_CASTS(__lvp_type, __VkType) \
+ \
+ static inline struct __lvp_type * \
+ __lvp_type ## _from_handle(__VkType _handle) \
+ { \
+ return (struct __lvp_type *) _handle; \
+ } \
+ \
+ static inline __VkType \
+ __lvp_type ## _to_handle(struct __lvp_type *_obj) \
+ { \
+ return (__VkType) _obj; \
+ }
+
+#define LVP_DEFINE_NONDISP_HANDLE_CASTS(__lvp_type, __VkType) \
+ \
+ static inline struct __lvp_type * \
+ __lvp_type ## _from_handle(__VkType _handle) \
+ { \
+ return (struct __lvp_type *)(uintptr_t) _handle; \
+ } \
+ \
+ static inline __VkType \
+ __lvp_type ## _to_handle(struct __lvp_type *_obj) \
+ { \
+ return (__VkType)(uintptr_t) _obj; \
+ }
+
+#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 lvp_instance *instance, VkResult error, const char *file, int line, const char *format, ...);
+
+#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 __lvp_finishme(const char *file, int line, const char *format, ...)
+ lvp_printflike(3, 4);
+
+#define lvp_finishme(format, ...) \
+ __lvp_finishme(__FILE__, __LINE__, format, ##__VA_ARGS__);
+
+#define stub_return(v) \
+ do { \
+ lvp_finishme("stub %s", __func__); \
+ return (v); \
+ } while (0)
+
+#define stub() \
+ do { \
+ lvp_finishme("stub %s", __func__); \
+ return; \
+ } while (0)
+
+struct lvp_shader_module {
+ struct vk_object_base base;
+ uint32_t size;
+ char data[0];
+};
+
+static inline gl_shader_stage
+vk_to_mesa_shader_stage(VkShaderStageFlagBits vk_stage)
+{
+ assert(__builtin_popcount(vk_stage) == 1);
+ return ffs(vk_stage) - 1;
+}
+
+static inline VkShaderStageFlagBits
+mesa_to_vk_shader_stage(gl_shader_stage mesa_stage)
+{
+ return (1 << mesa_stage);
+}
+
+#define LVP_STAGE_MASK ((1 << MESA_SHADER_STAGES) - 1)
+
+#define lvp_foreach_stage(stage, stage_bits) \
+ for (gl_shader_stage stage, \
+ __tmp = (gl_shader_stage)((stage_bits) & LVP_STAGE_MASK); \
+ stage = __builtin_ffs(__tmp) - 1, __tmp; \
+ __tmp &= ~(1 << (stage)))
+
+struct lvp_physical_device {
+ VK_LOADER_DATA _loader_data;
+ struct lvp_instance * instance;
+
+ struct pipe_loader_device *pld;
+ struct pipe_screen *pscreen;
+ uint32_t max_images;
+
+ struct wsi_device wsi_device;
+ struct lvp_device_extension_table supported_extensions;
+};
+
+struct lvp_instance {
+ struct vk_object_base base;
+
+ VkAllocationCallbacks alloc;
+
+ uint32_t apiVersion;
+ int physicalDeviceCount;
+ struct lvp_physical_device physicalDevice;
+
+ uint64_t debug_flags;
+
+ struct pipe_loader_device *devs;
+ int num_devices;
+
+ 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 lvp_init_wsi(struct lvp_physical_device *physical_device);
+void lvp_finish_wsi(struct lvp_physical_device *physical_device);
+
+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 lvp_queue {
+ VK_LOADER_DATA _loader_data;
+ VkDeviceQueueCreateFlags flags;
+ struct lvp_device * device;
+ struct pipe_context *ctx;
+ bool shutdown;
+ thrd_t exec_thread;
+ mtx_t m;
+ cnd_t new_work;
+ struct list_head workqueue;
+ uint32_t count;
+};
+
+struct lvp_queue_work {
+ struct list_head list;
+ uint32_t cmd_buffer_count;
+ struct lvp_cmd_buffer **cmd_buffers;
+ struct lvp_fence *fence;
+};
+
+struct lvp_pipeline_cache {
+ struct vk_object_base base;
+ struct lvp_device * device;
+ VkAllocationCallbacks alloc;
+};
+
+struct lvp_device {
+ struct vk_device vk;
+
+ VkAllocationCallbacks alloc;
+
+ struct lvp_queue queue;
+ struct lvp_instance * instance;
+ struct lvp_physical_device *physical_device;
+ struct pipe_screen *pscreen;
+
+ mtx_t fence_lock;
+ struct lvp_device_extension_table enabled_extensions;
+ struct lvp_device_dispatch_table dispatch;
+};
+
+void lvp_device_get_cache_uuid(void *uuid);
+
+struct lvp_device_memory {
+ struct vk_object_base base;
+ struct pipe_memory_allocation *pmem;
+ uint32_t type_index;
+ VkDeviceSize map_size;
+ void * map;
+};
+
+struct lvp_image {
+ struct vk_object_base base;
+ VkImageType type;
+ VkFormat vk_format;
+ VkDeviceSize size;
+ uint32_t alignment;
+ struct pipe_resource *bo;
+};
+
+static inline uint32_t
+lvp_get_layerCount(const struct lvp_image *image,
+ const VkImageSubresourceRange *range)
+{
+ return range->layerCount == VK_REMAINING_ARRAY_LAYERS ?
+ image->bo->array_size - range->baseArrayLayer : range->layerCount;
+}
+
+static inline uint32_t
+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 lvp_image_create_info {
+ const VkImageCreateInfo *vk_info;
+ uint32_t bind_flags;
+ uint32_t stride;
+};
+
+VkResult
+lvp_image_create(VkDevice _device,
+ const struct lvp_image_create_info *create_info,
+ const VkAllocationCallbacks* alloc,
+ VkImage *pImage);
+
+struct lvp_image_view {
+ struct vk_object_base base;
+ const struct lvp_image *image; /**< VkImageViewCreateInfo::image */
+
+ VkImageViewType view_type;
+ VkFormat format;
+ enum pipe_format pformat;
+ VkComponentMapping components;
+ VkImageSubresourceRange subresourceRange;
+
+ struct pipe_surface *surface; /* have we created a pipe surface for this? */
+};
+
+struct lvp_subpass_attachment {
+ uint32_t attachment;
+ VkImageLayout layout;
+ bool in_render_loop;
+};
+
+struct lvp_subpass {
+ uint32_t attachment_count;
+ struct lvp_subpass_attachment * attachments;
+
+ uint32_t input_count;
+ uint32_t color_count;
+ 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;
+
+ /** Subpass has at least one color attachment */
+ bool has_color_att;
+
+ VkSampleCountFlagBits max_sample_count;
+};
+
+struct lvp_render_pass_attachment {
+ VkFormat format;
+ uint32_t samples;
+ VkAttachmentLoadOp load_op;
+ VkAttachmentLoadOp stencil_load_op;
+ VkImageLayout initial_layout;
+ VkImageLayout final_layout;
+
+ /* The subpass id in which the attachment will be used first/last. */
+ uint32_t first_subpass_idx;
+ uint32_t last_subpass_idx;
+};
+
+struct lvp_render_pass {
+ struct vk_object_base base;
+ uint32_t attachment_count;
+ uint32_t subpass_count;
+ struct lvp_subpass_attachment * subpass_attachments;
+ struct lvp_render_pass_attachment * attachments;
+ struct lvp_subpass subpasses[0];
+};
+
+struct lvp_sampler {
+ struct vk_object_base base;
+ VkSamplerCreateInfo create_info;
+ uint32_t state[4];
+};
+
+struct lvp_framebuffer {
+ struct vk_object_base base;
+ uint32_t width;
+ uint32_t height;
+ uint32_t layers;
+
+ uint32_t attachment_count;
+ struct lvp_image_view * attachments[0];
+};
+
+struct lvp_descriptor_set_binding_layout {
+ uint16_t descriptor_index;
+ /* Number of array elements in this binding */
+ VkDescriptorType type;
+ uint16_t array_size;
+ bool valid;
+
+ int16_t dynamic_index;
+ struct {
+ int16_t const_buffer_index;
+ int16_t shader_buffer_index;
+ int16_t sampler_index;
+ int16_t sampler_view_index;
+ int16_t image_index;
+ } stage[MESA_SHADER_STAGES];
+
+ /* Immutable samplers (or NULL if no immutable samplers) */
+ struct lvp_sampler **immutable_samplers;
+};
+
+struct lvp_descriptor_set_layout {
+ struct vk_object_base base;
+ /* Number of bindings in this descriptor set */
+ uint16_t binding_count;
+
+ /* Total size of the descriptor set with room for all array entries */
+ uint16_t size;
+
+ /* Shader stages affected by this descriptor set */
+ uint16_t shader_stages;
+
+ struct {
+ uint16_t const_buffer_count;
+ uint16_t shader_buffer_count;
+ uint16_t sampler_count;
+ uint16_t sampler_view_count;
+ uint16_t image_count;
+ } stage[MESA_SHADER_STAGES];
+
+ /* Number of dynamic offsets used by this descriptor set */
+ uint16_t dynamic_offset_count;
+
+ /* Bindings in this descriptor set */
+ struct lvp_descriptor_set_binding_layout binding[0];
+};
+
+struct lvp_descriptor {
+ VkDescriptorType type;
+
+ union {
+ struct {
+ struct lvp_image_view *image_view;
+ struct lvp_sampler *sampler;
+ };
+ struct {
+ uint64_t offset;
+ uint64_t range;
+ struct lvp_buffer *buffer;
+ } buf;
+ struct lvp_buffer_view *buffer_view;
+ };
+};
+
+struct lvp_descriptor_set {
+ struct vk_object_base base;
+ const struct lvp_descriptor_set_layout *layout;
+ struct list_head link;
+ struct lvp_descriptor descriptors[0];
+};
+
+struct lvp_descriptor_pool {
+ struct vk_object_base base;
+ VkDescriptorPoolCreateFlags flags;
+ uint32_t max_sets;
+
+ struct list_head sets;
+};
+
+VkResult
+lvp_descriptor_set_create(struct lvp_device *device,
+ const struct lvp_descriptor_set_layout *layout,
+ struct lvp_descriptor_set **out_set);
+
+void
+lvp_descriptor_set_destroy(struct lvp_device *device,
+ struct lvp_descriptor_set *set);
+
+struct lvp_pipeline_layout {
+ struct vk_object_base base;
+ struct {
+ struct lvp_descriptor_set_layout *layout;
+ uint32_t dynamic_offset_start;
+ } set[MAX_SETS];
+
+ uint32_t num_sets;
+ uint32_t push_constant_size;
+ struct {
+ bool has_dynamic_offsets;
+ } stage[MESA_SHADER_STAGES];
+};
+
+struct lvp_pipeline {
+ struct vk_object_base base;
+ struct lvp_device * device;
+ struct lvp_pipeline_layout * layout;
+
+ bool is_compute_pipeline;
+ bool force_min_sample;
+ nir_shader *pipeline_nir[MESA_SHADER_STAGES];
+ void *shader_cso[PIPE_SHADER_TYPES];
+ VkGraphicsPipelineCreateInfo graphics_create_info;
+ VkComputePipelineCreateInfo compute_create_info;
+};
+
+struct lvp_event {
+ struct vk_object_base base;
+ uint64_t event_storage;
+};
+
+struct lvp_fence {
+ struct vk_object_base base;
+ bool signaled;
+ struct pipe_fence_handle *handle;
+};
+
+struct lvp_semaphore {
+ struct vk_object_base base;
+ bool dummy;
+};
+
+struct lvp_buffer {
+ struct vk_object_base base;
+ struct lvp_device * device;
+ VkDeviceSize size;
+
+ VkBufferUsageFlags usage;
+ VkDeviceSize offset;
+
+ struct pipe_resource *bo;
+ uint64_t total_size;
+};
+
+struct lvp_buffer_view {
+ struct vk_object_base base;
+ VkFormat format;
+ enum pipe_format pformat;
+ struct lvp_buffer *buffer;
+ uint32_t offset;
+ uint64_t range;
+};
+
+struct lvp_query_pool {
+ struct vk_object_base base;
+ VkQueryType type;
+ uint32_t count;
+ enum pipe_query_type base_type;
+ struct pipe_query *queries[0];
+};
+
+struct lvp_cmd_pool {
+ struct vk_object_base base;
+ VkAllocationCallbacks alloc;
+ struct list_head cmd_buffers;
+ struct list_head free_cmd_buffers;
+};
+
+
+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 lvp_cmd_buffer {
+ struct vk_object_base base;
+
+ struct lvp_device * device;
+
+ VkCommandBufferLevel level;
+ enum lvp_cmd_buffer_status status;
+ struct lvp_cmd_pool * pool;
+ struct list_head pool_link;
+
+ struct list_head cmds;
+
+ uint8_t push_constants[MAX_PUSH_CONSTANTS_SIZE];
+};
+
+/* in same order and buffer building commands in spec. */
+enum lvp_cmds {
+ LVP_CMD_BIND_PIPELINE,
+ LVP_CMD_SET_VIEWPORT,
+ LVP_CMD_SET_SCISSOR,
+ LVP_CMD_SET_LINE_WIDTH,
+ LVP_CMD_SET_DEPTH_BIAS,
+ LVP_CMD_SET_BLEND_CONSTANTS,
+ LVP_CMD_SET_DEPTH_BOUNDS,
+ LVP_CMD_SET_STENCIL_COMPARE_MASK,
+ LVP_CMD_SET_STENCIL_WRITE_MASK,
+ LVP_CMD_SET_STENCIL_REFERENCE,
+ LVP_CMD_BIND_DESCRIPTOR_SETS,
+ LVP_CMD_BIND_INDEX_BUFFER,
+ LVP_CMD_BIND_VERTEX_BUFFERS,
+ LVP_CMD_DRAW,
+ LVP_CMD_DRAW_INDEXED,
+ LVP_CMD_DRAW_INDIRECT,
+ LVP_CMD_DRAW_INDEXED_INDIRECT,
+ LVP_CMD_DISPATCH,
+ LVP_CMD_DISPATCH_INDIRECT,
+ LVP_CMD_COPY_BUFFER,
+ LVP_CMD_COPY_IMAGE,
+ LVP_CMD_BLIT_IMAGE,
+ LVP_CMD_COPY_BUFFER_TO_IMAGE,
+ LVP_CMD_COPY_IMAGE_TO_BUFFER,
+ LVP_CMD_UPDATE_BUFFER,
+ LVP_CMD_FILL_BUFFER,
+ LVP_CMD_CLEAR_COLOR_IMAGE,
+ LVP_CMD_CLEAR_DEPTH_STENCIL_IMAGE,
+ LVP_CMD_CLEAR_ATTACHMENTS,
+ LVP_CMD_RESOLVE_IMAGE,
+ LVP_CMD_SET_EVENT,
+ LVP_CMD_RESET_EVENT,
+ LVP_CMD_WAIT_EVENTS,
+ LVP_CMD_PIPELINE_BARRIER,
+ LVP_CMD_BEGIN_QUERY,
+ LVP_CMD_END_QUERY,
+ LVP_CMD_RESET_QUERY_POOL,
+ LVP_CMD_WRITE_TIMESTAMP,
+ LVP_CMD_COPY_QUERY_POOL_RESULTS,
+ LVP_CMD_PUSH_CONSTANTS,
+ LVP_CMD_BEGIN_RENDER_PASS,
+ LVP_CMD_NEXT_SUBPASS,
+ LVP_CMD_END_RENDER_PASS,
+ LVP_CMD_EXECUTE_COMMANDS,
+};
+
+struct lvp_cmd_bind_pipeline {
+ VkPipelineBindPoint bind_point;
+ struct lvp_pipeline *pipeline;
+};
+
+struct lvp_cmd_set_viewport {
+ uint32_t first_viewport;
+ uint32_t viewport_count;
+ VkViewport viewports[16];
+};
+
+struct lvp_cmd_set_scissor {
+ uint32_t first_scissor;
+ uint32_t scissor_count;
+ VkRect2D scissors[16];
+};
+
+struct lvp_cmd_set_line_width {
+ float line_width;
+};
+
+struct lvp_cmd_set_depth_bias {
+ float constant_factor;
+ float clamp;
+ float slope_factor;
+};
+
+struct lvp_cmd_set_blend_constants {
+ float blend_constants[4];
+};
+
+struct lvp_cmd_set_depth_bounds {
+ float min_depth;
+ float max_depth;
+};
+
+struct lvp_cmd_set_stencil_vals {
+ VkStencilFaceFlags face_mask;
+ uint32_t value;
+};
+
+struct lvp_cmd_bind_descriptor_sets {
+ VkPipelineBindPoint bind_point;
+ struct lvp_pipeline_layout *layout;
+ uint32_t first;
+ uint32_t count;
+ struct lvp_descriptor_set **sets;
+ uint32_t dynamic_offset_count;
+ const uint32_t *dynamic_offsets;
+};
+
+struct lvp_cmd_bind_index_buffer {
+ const struct lvp_buffer *buffer;
+ VkDeviceSize offset;
+ VkIndexType index_type;
+};
+
+struct lvp_cmd_bind_vertex_buffers {
+ uint32_t first;
+ uint32_t binding_count;
+ struct lvp_buffer **buffers;
+ const VkDeviceSize *offsets;
+};
+
+struct lvp_cmd_draw {
+ uint32_t vertex_count;
+ uint32_t instance_count;
+ uint32_t first_vertex;
+ uint32_t first_instance;
+};
+
+struct lvp_cmd_draw_indexed {
+ uint32_t index_count;
+ uint32_t instance_count;
+ uint32_t first_index;
+ uint32_t vertex_offset;
+ uint32_t first_instance;
+};
+
+struct lvp_cmd_draw_indirect {
+ VkDeviceSize offset;
+ struct lvp_buffer *buffer;
+ uint32_t draw_count;
+ uint32_t stride;
+};
+
+struct lvp_cmd_dispatch {
+ uint32_t x;
+ uint32_t y;
+ uint32_t z;
+};
+
+struct lvp_cmd_dispatch_indirect {
+ const struct lvp_buffer *buffer;
+ VkDeviceSize offset;
+};
+
+struct lvp_cmd_copy_buffer {
+ struct lvp_buffer *src;
+ struct lvp_buffer *dst;
+ uint32_t region_count;
+ const VkBufferCopy *regions;
+};
+
+struct lvp_cmd_copy_image {
+ struct lvp_image *src;
+ struct lvp_image *dst;
+ VkImageLayout src_layout;
+ VkImageLayout dst_layout;
+ uint32_t region_count;
+ const VkImageCopy *regions;
+};
+
+struct lvp_cmd_blit_image {
+ struct lvp_image *src;
+ struct lvp_image *dst;
+ VkImageLayout src_layout;
+ VkImageLayout dst_layout;
+ uint32_t region_count;
+ const VkImageBlit *regions;
+ VkFilter filter;
+};
+
+struct lvp_cmd_copy_buffer_to_image {
+ struct lvp_buffer *src;
+ struct lvp_image *dst;
+ VkImageLayout dst_layout;
+ uint32_t region_count;
+ const VkBufferImageCopy *regions;
+};
+
+struct lvp_cmd_copy_image_to_buffer {
+ struct lvp_image *src;
+ struct lvp_buffer *dst;
+ VkImageLayout src_layout;
+ uint32_t region_count;
+ const VkBufferImageCopy *regions;
+};
+
+struct lvp_cmd_update_buffer {
+ struct lvp_buffer *buffer;
+ VkDeviceSize offset;
+ VkDeviceSize data_size;
+ char data[0];
+};
+
+struct lvp_cmd_fill_buffer {
+ struct lvp_buffer *buffer;
+ VkDeviceSize offset;
+ VkDeviceSize fill_size;
+ uint32_t data;
+};
+
+struct lvp_cmd_clear_color_image {
+ struct lvp_image *image;
+ VkImageLayout layout;
+ VkClearColorValue clear_val;
+ uint32_t range_count;
+ VkImageSubresourceRange *ranges;
+};
+
+struct lvp_cmd_clear_ds_image {
+ struct lvp_image *image;
+ VkImageLayout layout;
+ VkClearDepthStencilValue clear_val;
+ uint32_t range_count;
+ VkImageSubresourceRange *ranges;
+};
+
+struct lvp_cmd_clear_attachments {
+ uint32_t attachment_count;
+ VkClearAttachment *attachments;
+ uint32_t rect_count;
+ VkClearRect *rects;
+};
+
+struct lvp_cmd_resolve_image {
+ struct lvp_image *src;
+ struct lvp_image *dst;
+ VkImageLayout src_layout;
+ VkImageLayout dst_layout;
+ uint32_t region_count;
+ VkImageResolve *regions;
+};
+
+struct lvp_cmd_event_set {
+ struct lvp_event *event;
+ bool value;
+ bool flush;
+};
+
+struct lvp_cmd_wait_events {
+ uint32_t event_count;
+ struct lvp_event **events;
+ VkPipelineStageFlags src_stage_mask;
+ VkPipelineStageFlags dst_stage_mask;
+ uint32_t memory_barrier_count;
+ VkMemoryBarrier *memory_barriers;
+ uint32_t buffer_memory_barrier_count;
+ VkBufferMemoryBarrier *buffer_memory_barriers;
+ uint32_t image_memory_barrier_count;
+ VkImageMemoryBarrier *image_memory_barriers;
+};
+
+struct lvp_cmd_pipeline_barrier {
+ VkPipelineStageFlags src_stage_mask;
+ VkPipelineStageFlags dst_stage_mask;
+ bool by_region;
+ uint32_t memory_barrier_count;
+ VkMemoryBarrier *memory_barriers;
+ uint32_t buffer_memory_barrier_count;
+ VkBufferMemoryBarrier *buffer_memory_barriers;
+ uint32_t image_memory_barrier_count;
+ VkImageMemoryBarrier *image_memory_barriers;
+};
+
+struct lvp_cmd_query_cmd {
+ struct lvp_query_pool *pool;
+ uint32_t query;
+ uint32_t index;
+ bool precise;
+ bool flush;
+};
+
+struct lvp_cmd_copy_query_pool_results {
+ struct lvp_query_pool *pool;
+ uint32_t first_query;
+ uint32_t query_count;
+ struct lvp_buffer *dst;
+ VkDeviceSize dst_offset;
+ VkDeviceSize stride;
+ VkQueryResultFlags flags;
+};
+
+struct lvp_cmd_push_constants {
+ VkShaderStageFlags stage;
+ uint32_t offset;
+ uint32_t size;
+ uint32_t val[1];
+};
+
+struct lvp_attachment_state {
+ VkImageAspectFlags pending_clear_aspects;
+ VkClearValue clear_value;
+};
+
+struct lvp_cmd_begin_render_pass {
+ struct lvp_framebuffer *framebuffer;
+ struct lvp_render_pass *render_pass;
+ VkRect2D render_area;
+ struct lvp_attachment_state *attachments;
+};
+
+struct lvp_cmd_next_subpass {
+ VkSubpassContents contents;
+};
+
+struct lvp_cmd_execute_commands {
+ uint32_t command_buffer_count;
+ struct lvp_cmd_buffer *cmd_buffers[0];
+};
+
+struct lvp_cmd_buffer_entry {
+ struct list_head cmd_link;
+ uint32_t cmd_type;
+ union {
+ struct lvp_cmd_bind_pipeline pipeline;
+ struct lvp_cmd_set_viewport set_viewport;
+ struct lvp_cmd_set_scissor set_scissor;
+ struct lvp_cmd_set_line_width set_line_width;
+ struct lvp_cmd_set_depth_bias set_depth_bias;
+ struct lvp_cmd_set_blend_constants set_blend_constants;
+ struct lvp_cmd_set_depth_bounds set_depth_bounds;
+ struct lvp_cmd_set_stencil_vals stencil_vals;
+ struct lvp_cmd_bind_descriptor_sets descriptor_sets;
+ struct lvp_cmd_bind_vertex_buffers vertex_buffers;
+ struct lvp_cmd_bind_index_buffer index_buffer;
+ struct lvp_cmd_draw draw;
+ struct lvp_cmd_draw_indexed draw_indexed;
+ struct lvp_cmd_draw_indirect draw_indirect;
+ struct lvp_cmd_dispatch dispatch;
+ struct lvp_cmd_dispatch_indirect dispatch_indirect;
+ struct lvp_cmd_copy_buffer copy_buffer;
+ struct lvp_cmd_copy_image copy_image;
+ struct lvp_cmd_blit_image blit_image;
+ struct lvp_cmd_copy_buffer_to_image buffer_to_img;
+ struct lvp_cmd_copy_image_to_buffer img_to_buffer;
+ struct lvp_cmd_update_buffer update_buffer;
+ struct lvp_cmd_fill_buffer fill_buffer;
+ struct lvp_cmd_clear_color_image clear_color_image;
+ struct lvp_cmd_clear_ds_image clear_ds_image;
+ struct lvp_cmd_clear_attachments clear_attachments;
+ struct lvp_cmd_resolve_image resolve_image;
+ struct lvp_cmd_event_set event_set;
+ struct lvp_cmd_wait_events wait_events;
+ struct lvp_cmd_pipeline_barrier pipeline_barrier;
+ struct lvp_cmd_query_cmd query;
+ struct lvp_cmd_copy_query_pool_results copy_query_pool_results;
+ struct lvp_cmd_push_constants push_constants;
+ struct lvp_cmd_begin_render_pass begin_render_pass;
+ struct lvp_cmd_next_subpass next_subpass;
+ struct lvp_cmd_execute_commands execute_commands;
+ } u;
+};
+
+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);
+
+static inline VkImageAspectFlags
+vk_format_aspects(VkFormat format)
+{
+ switch (format) {
+ case VK_FORMAT_UNDEFINED:
+ return 0;
+
+ case VK_FORMAT_S8_UINT:
+ return VK_IMAGE_ASPECT_STENCIL_BIT;
+
+ case VK_FORMAT_D16_UNORM_S8_UINT:
+ case VK_FORMAT_D24_UNORM_S8_UINT:
+ case VK_FORMAT_D32_SFLOAT_S8_UINT:
+ return VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
+
+ case VK_FORMAT_D16_UNORM:
+ case VK_FORMAT_X8_D24_UNORM_PACK32:
+ case VK_FORMAT_D32_SFLOAT:
+ return VK_IMAGE_ASPECT_DEPTH_BIT;
+
+ default:
+ return VK_IMAGE_ASPECT_COLOR_BIT;
+ }
+}
+
+#ifdef __cplusplus
+}
+#endif
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 @@
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 @@
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 @@
vk_free2(&device->alloc, pAllocator, pool);
}
-VkResult val_GetQueryPoolResults(
+VkResult lvp_GetQueryPoolResults(
VkDevice _device,
VkQueryPool queryPool,
uint32_t firstQuery,
@@ -90,11 +90,11 @@
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 90%
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 @@
}
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 @@
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 @@
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 @@
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 @@
wsi_common_destroy_swapchain(_device, swapchain, alloc);
}
-VkResult val_GetSwapchainImagesKHR(
+VkResult lvp_GetSwapchainImagesKHR(
VkDevice device,
VkSwapchainKHR swapchain,
uint32_t* pSwapchainImageCount,
@@ -181,7 +181,7 @@
pSwapchainImages);
}
-VkResult val_AcquireNextImageKHR(
+VkResult lvp_AcquireNextImageKHR(
VkDevice device,
VkSwapchainKHR swapchain,
uint64_t timeout,
@@ -198,23 +198,23 @@
.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 @@
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 @@
return VK_SUCCESS;
}
-VkResult val_GetDeviceGroupSurfacePresentModesKHR(
+VkResult lvp_GetDeviceGroupSurfacePresentModesKHR(
VkDevice device,
VkSurfaceKHR surface,
VkDeviceGroupPresentModeFlagsKHR* pModes)
@@ -263,13 +263,13 @@
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 86%
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 <xcb/xcb.h>
#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 @@
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 @@
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 @@
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/frontends/vallium/val_private.h b/src/gallium/frontends/vallium/val_private.h
deleted file mode 100644
index 7a41c9f..0000000
--- a/src/gallium/frontends/vallium/val_private.h
+++ /dev/null
@@ -1,989 +0,0 @@
-/*
- * Copyright © 2019 Red Hat.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
-
-#pragma once
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdbool.h>
-#include <string.h>
-#include <strings.h>
-#include <pthread.h>
-#include <assert.h>
-#include <stdint.h>
-
-#include "util/macros.h"
-#include "util/list.h"
-
-#include "compiler/shader_enums.h"
-#include "pipe/p_screen.h"
-#include "pipe/p_state.h"
-#include "nir.h"
-
-/* Pre-declarations needed for WSI entrypoints */
-struct wl_surface;
-struct wl_display;
-typedef struct xcb_connection_t xcb_connection_t;
-typedef uint32_t xcb_visualid_t;
-typedef uint32_t xcb_window_t;
-
-#define VK_PROTOTYPES
-#include <vulkan/vulkan.h>
-#include <vulkan/vk_icd.h>
-
-#include "val_extensions.h"
-#include "val_entrypoints.h"
-#include "vk_object.h"
-
-#include "wsi_common.h"
-
-#include <assert.h>
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define MAX_SETS 8
-#define MAX_PUSH_CONSTANTS_SIZE 128
-
-#define val_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);
-
-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);
-
-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);
-
-void *val_lookup_entrypoint(const char *name);
-
-#define VAL_DEFINE_HANDLE_CASTS(__val_type, __VkType) \
- \
- static inline struct __val_type * \
- __val_type ## _from_handle(__VkType _handle) \
- { \
- return (struct __val_type *) _handle; \
- } \
- \
- static inline __VkType \
- __val_type ## _to_handle(struct __val_type *_obj) \
- { \
- return (__VkType) _obj; \
- }
-
-#define VAL_DEFINE_NONDISP_HANDLE_CASTS(__val_type, __VkType) \
- \
- static inline struct __val_type * \
- __val_type ## _from_handle(__VkType _handle) \
- { \
- return (struct __val_type *)(uintptr_t) _handle; \
- } \
- \
- static inline __VkType \
- __val_type ## _to_handle(struct __val_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);
-
-/* 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, ...);
-
-#define VAL_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);
-
-#define val_finishme(format, ...) \
- __val_finishme(__FILE__, __LINE__, format, ##__VA_ARGS__);
-
-#define stub_return(v) \
- do { \
- val_finishme("stub %s", __func__); \
- return (v); \
- } while (0)
-
-#define stub() \
- do { \
- val_finishme("stub %s", __func__); \
- return; \
- } while (0)
-
-struct val_shader_module {
- struct vk_object_base base;
- uint32_t size;
- char data[0];
-};
-
-static inline gl_shader_stage
-vk_to_mesa_shader_stage(VkShaderStageFlagBits vk_stage)
-{
- assert(__builtin_popcount(vk_stage) == 1);
- return ffs(vk_stage) - 1;
-}
-
-static inline VkShaderStageFlagBits
-mesa_to_vk_shader_stage(gl_shader_stage mesa_stage)
-{
- return (1 << mesa_stage);
-}
-
-#define VAL_STAGE_MASK ((1 << MESA_SHADER_STAGES) - 1)
-
-#define val_foreach_stage(stage, stage_bits) \
- for (gl_shader_stage stage, \
- __tmp = (gl_shader_stage)((stage_bits) & VAL_STAGE_MASK); \
- stage = __builtin_ffs(__tmp) - 1, __tmp; \
- __tmp &= ~(1 << (stage)))
-
-struct val_physical_device {
- VK_LOADER_DATA _loader_data;
- struct val_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 val_instance {
- struct vk_object_base base;
-
- VkAllocationCallbacks alloc;
-
- uint32_t apiVersion;
- int physicalDeviceCount;
- struct val_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;
-};
-
-VkResult val_init_wsi(struct val_physical_device *physical_device);
-void val_finish_wsi(struct val_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,
- const char *name);
-
-struct val_queue {
- VK_LOADER_DATA _loader_data;
- VkDeviceQueueCreateFlags flags;
- struct val_device * device;
- struct pipe_context *ctx;
- bool shutdown;
- thrd_t exec_thread;
- mtx_t m;
- cnd_t new_work;
- struct list_head workqueue;
- uint32_t count;
-};
-
-struct val_queue_work {
- struct list_head list;
- uint32_t cmd_buffer_count;
- struct val_cmd_buffer **cmd_buffers;
- struct val_fence *fence;
-};
-
-struct val_pipeline_cache {
- struct vk_object_base base;
- struct val_device * device;
- VkAllocationCallbacks alloc;
-};
-
-struct val_device {
- struct vk_device vk;
-
- VkAllocationCallbacks alloc;
-
- struct val_queue queue;
- struct val_instance * instance;
- struct val_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;
-};
-
-void val_device_get_cache_uuid(void *uuid);
-
-struct val_device_memory {
- struct vk_object_base base;
- struct pipe_memory_allocation *pmem;
- uint32_t type_index;
- VkDeviceSize map_size;
- void * map;
-};
-
-struct val_image {
- struct vk_object_base base;
- VkImageType type;
- VkFormat vk_format;
- VkDeviceSize size;
- uint32_t alignment;
- struct pipe_resource *bo;
-};
-
-static inline uint32_t
-val_get_layerCount(const struct val_image *image,
- const VkImageSubresourceRange *range)
-{
- return range->layerCount == VK_REMAINING_ARRAY_LAYERS ?
- image->bo->array_size - range->baseArrayLayer : range->layerCount;
-}
-
-static inline uint32_t
-val_get_levelCount(const struct val_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 {
- 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,
- const VkAllocationCallbacks* alloc,
- VkImage *pImage);
-
-struct val_image_view {
- struct vk_object_base base;
- const struct val_image *image; /**< VkImageViewCreateInfo::image */
-
- VkImageViewType view_type;
- VkFormat format;
- enum pipe_format pformat;
- VkComponentMapping components;
- VkImageSubresourceRange subresourceRange;
-
- struct pipe_surface *surface; /* have we created a pipe surface for this? */
-};
-
-struct val_subpass_attachment {
- uint32_t attachment;
- VkImageLayout layout;
- bool in_render_loop;
-};
-
-struct val_subpass {
- uint32_t attachment_count;
- struct val_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;
-
- /** Subpass has at least one color resolve attachment */
- bool has_color_resolve;
-
- /** Subpass has at least one color attachment */
- bool has_color_att;
-
- VkSampleCountFlagBits max_sample_count;
-};
-
-struct val_render_pass_attachment {
- VkFormat format;
- uint32_t samples;
- VkAttachmentLoadOp load_op;
- VkAttachmentLoadOp stencil_load_op;
- VkImageLayout initial_layout;
- VkImageLayout final_layout;
-
- /* The subpass id in which the attachment will be used first/last. */
- uint32_t first_subpass_idx;
- uint32_t last_subpass_idx;
-};
-
-struct val_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 val_sampler {
- struct vk_object_base base;
- VkSamplerCreateInfo create_info;
- uint32_t state[4];
-};
-
-struct val_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 val_descriptor_set_binding_layout {
- uint16_t descriptor_index;
- /* Number of array elements in this binding */
- VkDescriptorType type;
- uint16_t array_size;
- bool valid;
-
- int16_t dynamic_index;
- struct {
- int16_t const_buffer_index;
- int16_t shader_buffer_index;
- int16_t sampler_index;
- int16_t sampler_view_index;
- int16_t image_index;
- } stage[MESA_SHADER_STAGES];
-
- /* Immutable samplers (or NULL if no immutable samplers) */
- struct val_sampler **immutable_samplers;
-};
-
-struct val_descriptor_set_layout {
- struct vk_object_base base;
- /* Number of bindings in this descriptor set */
- uint16_t binding_count;
-
- /* Total size of the descriptor set with room for all array entries */
- uint16_t size;
-
- /* Shader stages affected by this descriptor set */
- uint16_t shader_stages;
-
- struct {
- uint16_t const_buffer_count;
- uint16_t shader_buffer_count;
- uint16_t sampler_count;
- uint16_t sampler_view_count;
- uint16_t image_count;
- } stage[MESA_SHADER_STAGES];
-
- /* Number of dynamic offsets used by this descriptor set */
- uint16_t dynamic_offset_count;
-
- /* Bindings in this descriptor set */
- struct val_descriptor_set_binding_layout binding[0];
-};
-
-struct val_descriptor {
- VkDescriptorType type;
-
- union {
- struct {
- struct val_image_view *image_view;
- struct val_sampler *sampler;
- };
- struct {
- uint64_t offset;
- uint64_t range;
- struct val_buffer *buffer;
- } buf;
- struct val_buffer_view *buffer_view;
- };
-};
-
-struct val_descriptor_set {
- struct vk_object_base base;
- const struct val_descriptor_set_layout *layout;
- struct list_head link;
- struct val_descriptor descriptors[0];
-};
-
-struct val_descriptor_pool {
- struct vk_object_base base;
- VkDescriptorPoolCreateFlags flags;
- uint32_t max_sets;
-
- struct list_head sets;
-};
-
-VkResult
-val_descriptor_set_create(struct val_device *device,
- const struct val_descriptor_set_layout *layout,
- struct val_descriptor_set **out_set);
-
-void
-val_descriptor_set_destroy(struct val_device *device,
- struct val_descriptor_set *set);
-
-struct val_pipeline_layout {
- struct vk_object_base base;
- struct {
- struct val_descriptor_set_layout *layout;
- uint32_t dynamic_offset_start;
- } set[MAX_SETS];
-
- uint32_t num_sets;
- uint32_t push_constant_size;
- struct {
- bool has_dynamic_offsets;
- } stage[MESA_SHADER_STAGES];
-};
-
-struct val_pipeline {
- struct vk_object_base base;
- struct val_device * device;
- struct val_pipeline_layout * layout;
-
- bool is_compute_pipeline;
- bool force_min_sample;
- nir_shader *pipeline_nir[MESA_SHADER_STAGES];
- void *shader_cso[PIPE_SHADER_TYPES];
- VkGraphicsPipelineCreateInfo graphics_create_info;
- VkComputePipelineCreateInfo compute_create_info;
-};
-
-struct val_event {
- struct vk_object_base base;
- uint64_t event_storage;
-};
-
-struct val_fence {
- struct vk_object_base base;
- bool signaled;
- struct pipe_fence_handle *handle;
-};
-
-struct val_semaphore {
- struct vk_object_base base;
- bool dummy;
-};
-
-struct val_buffer {
- struct vk_object_base base;
- struct val_device * device;
- VkDeviceSize size;
-
- VkBufferUsageFlags usage;
- VkDeviceSize offset;
-
- struct pipe_resource *bo;
- uint64_t total_size;
-};
-
-struct val_buffer_view {
- struct vk_object_base base;
- VkFormat format;
- enum pipe_format pformat;
- struct val_buffer *buffer;
- uint32_t offset;
- uint64_t range;
-};
-
-struct val_query_pool {
- struct vk_object_base base;
- VkQueryType type;
- uint32_t count;
- enum pipe_query_type base_type;
- struct pipe_query *queries[0];
-};
-
-struct val_cmd_pool {
- struct vk_object_base base;
- VkAllocationCallbacks alloc;
- struct list_head cmd_buffers;
- struct list_head free_cmd_buffers;
-};
-
-
-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,
-};
-
-struct val_cmd_buffer {
- struct vk_object_base base;
-
- struct val_device * device;
-
- VkCommandBufferLevel level;
- enum val_cmd_buffer_status status;
- struct val_cmd_pool * pool;
- struct list_head pool_link;
-
- struct list_head cmds;
-
- uint8_t push_constants[MAX_PUSH_CONSTANTS_SIZE];
-};
-
-/* 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 {
- VkPipelineBindPoint bind_point;
- struct val_pipeline *pipeline;
-};
-
-struct val_cmd_set_viewport {
- uint32_t first_viewport;
- uint32_t viewport_count;
- VkViewport viewports[16];
-};
-
-struct val_cmd_set_scissor {
- uint32_t first_scissor;
- uint32_t scissor_count;
- VkRect2D scissors[16];
-};
-
-struct val_cmd_set_line_width {
- float line_width;
-};
-
-struct val_cmd_set_depth_bias {
- float constant_factor;
- float clamp;
- float slope_factor;
-};
-
-struct val_cmd_set_blend_constants {
- float blend_constants[4];
-};
-
-struct val_cmd_set_depth_bounds {
- float min_depth;
- float max_depth;
-};
-
-struct val_cmd_set_stencil_vals {
- VkStencilFaceFlags face_mask;
- uint32_t value;
-};
-
-struct val_cmd_bind_descriptor_sets {
- VkPipelineBindPoint bind_point;
- struct val_pipeline_layout *layout;
- uint32_t first;
- uint32_t count;
- struct val_descriptor_set **sets;
- uint32_t dynamic_offset_count;
- const uint32_t *dynamic_offsets;
-};
-
-struct val_cmd_bind_index_buffer {
- const struct val_buffer *buffer;
- VkDeviceSize offset;
- VkIndexType index_type;
-};
-
-struct val_cmd_bind_vertex_buffers {
- uint32_t first;
- uint32_t binding_count;
- struct val_buffer **buffers;
- const VkDeviceSize *offsets;
-};
-
-struct val_cmd_draw {
- uint32_t vertex_count;
- uint32_t instance_count;
- uint32_t first_vertex;
- uint32_t first_instance;
-};
-
-struct val_cmd_draw_indexed {
- uint32_t index_count;
- uint32_t instance_count;
- uint32_t first_index;
- uint32_t vertex_offset;
- uint32_t first_instance;
-};
-
-struct val_cmd_draw_indirect {
- VkDeviceSize offset;
- struct val_buffer *buffer;
- uint32_t draw_count;
- uint32_t stride;
-};
-
-struct val_cmd_dispatch {
- uint32_t x;
- uint32_t y;
- uint32_t z;
-};
-
-struct val_cmd_dispatch_indirect {
- const struct val_buffer *buffer;
- VkDeviceSize offset;
-};
-
-struct val_cmd_copy_buffer {
- struct val_buffer *src;
- struct val_buffer *dst;
- uint32_t region_count;
- const VkBufferCopy *regions;
-};
-
-struct val_cmd_copy_image {
- struct val_image *src;
- struct val_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;
- VkImageLayout src_layout;
- VkImageLayout dst_layout;
- uint32_t region_count;
- const VkImageBlit *regions;
- VkFilter filter;
-};
-
-struct val_cmd_copy_buffer_to_image {
- struct val_buffer *src;
- struct val_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;
- VkImageLayout src_layout;
- uint32_t region_count;
- const VkBufferImageCopy *regions;
-};
-
-struct val_cmd_update_buffer {
- struct val_buffer *buffer;
- VkDeviceSize offset;
- VkDeviceSize data_size;
- char data[0];
-};
-
-struct val_cmd_fill_buffer {
- struct val_buffer *buffer;
- VkDeviceSize offset;
- VkDeviceSize fill_size;
- uint32_t data;
-};
-
-struct val_cmd_clear_color_image {
- struct val_image *image;
- VkImageLayout layout;
- VkClearColorValue clear_val;
- uint32_t range_count;
- VkImageSubresourceRange *ranges;
-};
-
-struct val_cmd_clear_ds_image {
- struct val_image *image;
- VkImageLayout layout;
- VkClearDepthStencilValue clear_val;
- uint32_t range_count;
- VkImageSubresourceRange *ranges;
-};
-
-struct val_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;
- VkImageLayout src_layout;
- VkImageLayout dst_layout;
- uint32_t region_count;
- VkImageResolve *regions;
-};
-
-struct val_cmd_event_set {
- struct val_event *event;
- bool value;
- bool flush;
-};
-
-struct val_cmd_wait_events {
- uint32_t event_count;
- struct val_event **events;
- VkPipelineStageFlags src_stage_mask;
- VkPipelineStageFlags dst_stage_mask;
- uint32_t memory_barrier_count;
- VkMemoryBarrier *memory_barriers;
- uint32_t buffer_memory_barrier_count;
- VkBufferMemoryBarrier *buffer_memory_barriers;
- uint32_t image_memory_barrier_count;
- VkImageMemoryBarrier *image_memory_barriers;
-};
-
-struct val_cmd_pipeline_barrier {
- VkPipelineStageFlags src_stage_mask;
- VkPipelineStageFlags dst_stage_mask;
- bool by_region;
- uint32_t memory_barrier_count;
- VkMemoryBarrier *memory_barriers;
- uint32_t buffer_memory_barrier_count;
- VkBufferMemoryBarrier *buffer_memory_barriers;
- uint32_t image_memory_barrier_count;
- VkImageMemoryBarrier *image_memory_barriers;
-};
-
-struct val_cmd_query_cmd {
- struct val_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;
- uint32_t first_query;
- uint32_t query_count;
- struct val_buffer *dst;
- VkDeviceSize dst_offset;
- VkDeviceSize stride;
- VkQueryResultFlags flags;
-};
-
-struct val_cmd_push_constants {
- VkShaderStageFlags stage;
- uint32_t offset;
- uint32_t size;
- uint32_t val[1];
-};
-
-struct val_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;
- VkRect2D render_area;
- struct val_attachment_state *attachments;
-};
-
-struct val_cmd_next_subpass {
- VkSubpassContents contents;
-};
-
-struct val_cmd_execute_commands {
- uint32_t command_buffer_count;
- struct val_cmd_buffer *cmd_buffers[0];
-};
-
-struct val_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;
- } u;
-};
-
-VkResult val_execute_cmds(struct val_device *device,
- struct val_queue *queue,
- struct val_fence *fence,
- struct val_cmd_buffer *cmd_buffer);
-
-enum pipe_format vk_format_to_pipe(VkFormat format);
-
-static inline VkImageAspectFlags
-vk_format_aspects(VkFormat format)
-{
- switch (format) {
- case VK_FORMAT_UNDEFINED:
- return 0;
-
- case VK_FORMAT_S8_UINT:
- return VK_IMAGE_ASPECT_STENCIL_BIT;
-
- case VK_FORMAT_D16_UNORM_S8_UINT:
- case VK_FORMAT_D24_UNORM_S8_UINT:
- case VK_FORMAT_D32_SFLOAT_S8_UINT:
- return VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
-
- case VK_FORMAT_D16_UNORM:
- case VK_FORMAT_X8_D24_UNORM_PACK32:
- case VK_FORMAT_D32_SFLOAT:
- return VK_IMAGE_ASPECT_DEPTH_BIT;
-
- default:
- return VK_IMAGE_ASPECT_COLOR_BIT;
- }
-}
-
-#ifdef __cplusplus
-}
-#endif
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 @@
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 93%
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 @@
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 @@
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
