* 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.
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
*/
#include "tu_private.h"
+
#include "vk_format.h"
+static void
+tu_bo_list_init(struct tu_bo_list *list)
+{
+ list->count = list->capacity = 0;
+ list->handles = NULL;
+}
+
+static void
+tu_bo_list_destroy(struct tu_bo_list *list)
+{
+ free(list->handles);
+}
+
+static void
+tu_bo_list_reset(struct tu_bo_list *list)
+{
+ list->count = 0;
+}
+
+static uint32_t
+tu_bo_list_add(struct tu_bo_list *list,
+ const struct tu_bo *bo)
+{
+ uint32_t handle = bo->gem_handle;
+ for (uint32_t i = 0; i < list->count; ++i) {
+ if (list->handles[i] == handle)
+ return i;
+ }
+
+ if (list->count == list->capacity) {
+ uint32_t new_capacity = MAX2(2 * list->count, 16);
+ uint32_t *new_handles = realloc(list->handles, new_capacity * sizeof(uint32_t));
+ if (!new_handles)
+ return ~0;
+ list->handles = new_handles;
+ list->capacity = new_capacity;
+ }
+
+ uint32_t ret = list->count;
+ list->handles[list->count] = handle;
+ ++list->count;
+
+ return ret;
+}
+
+static void
+tu_cmd_stream_init(struct tu_cmd_stream *stream)
+{
+ stream->start = stream->cur = stream->end = NULL;
+
+ stream->entry_count = stream->entry_capacity = 0;
+ stream->entries = NULL;
+
+ stream->bo_count = stream->bo_capacity = 0;
+ stream->bos = NULL;
+}
+
+static void
+tu_cmd_stream_finish(struct tu_device *dev,
+ struct tu_cmd_stream *stream)
+{
+ for (uint32_t i = 0; i < stream->bo_count; ++i) {
+ tu_bo_finish(dev, stream->bos[i]);
+ free(stream->bos[i]);
+ }
+
+ free(stream->entries);
+ free(stream->bos);
+}
+
+static VkResult
+tu_cmd_stream_begin(struct tu_device *dev,
+ struct tu_cmd_stream *stream,
+ uint32_t reserve_size)
+{
+ assert(reserve_size);
+
+ if (stream->end - stream->cur < reserve_size) {
+ if (stream->bo_count == stream->bo_capacity) {
+ uint32_t new_capacity = MAX2(4, 2 * stream->bo_capacity);
+ struct tu_bo **new_bos = realloc(stream->bos,
+ new_capacity * sizeof(struct tu_bo*));
+ if (!new_bos)
+ abort();
+
+ stream->bo_capacity = new_capacity;
+ stream->bos = new_bos;
+ }
+
+ uint32_t new_size = MAX2(16384, reserve_size * sizeof(uint32_t));
+ if (stream->bo_count)
+ new_size = MAX2(new_size, stream->bos[stream->bo_count - 1]->size * 2);
+
+ struct tu_bo *new_bo = malloc(sizeof(struct tu_bo));
+ if (!new_bo)
+ abort();
+
+ VkResult result = tu_bo_init_new(dev, new_bo, new_size);
+ if (result != VK_SUCCESS) {
+ free(new_bo);
+ return result;
+ }
+
+ result = tu_bo_map(dev, new_bo);
+ if (result != VK_SUCCESS) {
+ tu_bo_finish(dev, new_bo);
+ free(new_bo);
+ return result;
+ }
+
+ stream->bos[stream->bo_count] = new_bo;
+ ++stream->bo_count;
+
+ stream->start = stream->cur = (uint32_t*)new_bo->map;
+ stream->end = stream->start + new_bo->size / sizeof(uint32_t);
+ }
+ stream->start = stream->cur;
+
+ return VK_SUCCESS;
+}
+
+static VkResult
+tu_cmd_stream_end(struct tu_cmd_stream *stream)
+{
+ if (stream->start == stream->cur)
+ return VK_SUCCESS;
+
+ if (stream->entry_capacity == stream->entry_count) {
+ uint32_t new_capacity = MAX2(stream->entry_capacity * 2, 4);
+ struct tu_cmd_stream_entry *new_entries =
+ realloc(stream->entries, new_capacity * sizeof(struct tu_cmd_stream_entry));
+ if (!new_entries)
+ abort(); /* TODO */
+
+ stream->entries = new_entries;
+ stream->entry_capacity = new_capacity;
+ }
+
+ assert (stream->bo_count);
+
+ struct tu_cmd_stream_entry entry;
+ entry.bo = stream->bos[stream->bo_count - 1];
+ entry.size = (stream->cur - stream->start) * sizeof(uint32_t);
+ entry.offset = (stream->start - (uint32_t*)entry.bo->map) * sizeof(uint32_t);
+
+ stream->entries[stream->entry_count] = entry;
+ ++stream->entry_count;
+
+ return VK_SUCCESS;
+}
+
+static void
+tu_cmd_stream_reset(struct tu_device *dev,
+ struct tu_cmd_stream *stream)
+{
+ for (uint32_t i = 0; i + 1 < stream->bo_count; ++i) {
+ tu_bo_finish(dev, stream->bos[i]);
+ free(stream->bos[i]);
+ }
+
+ if (stream->bo_count) {
+ stream->bos[0] = stream->bos[stream->bo_count - 1];
+ stream->bo_count = 1;
+
+ stream->start = stream->cur = (uint32_t*)stream->bos[0]->map;
+ stream->end = stream->start + stream->bos[0]->size / sizeof(uint32_t);
+ }
+
+ stream->entry_count = 0;
+}
+
const struct tu_dynamic_state default_dynamic_state = {
.viewport =
{
},
};
-static void
+static void UNUSED /* FINISHME */
tu_bind_dynamic_state(struct tu_cmd_buffer *cmd_buffer,
- const struct tu_dynamic_state *src)
+ const struct tu_dynamic_state *src)
{
struct tu_dynamic_state *dest = &cmd_buffer->state.dynamic;
uint32_t copy_mask = src->mask;
uint32_t dest_mask = 0;
+ tu_use_args(cmd_buffer); /* FINISHME */
+
/* Make sure to copy the number of viewports/scissors because they can
* only be specified at pipeline creation time.
*/
dest->discard_rectangle.count = src->discard_rectangle.count;
if (copy_mask & TU_DYNAMIC_VIEWPORT) {
- if (memcmp(&dest->viewport.viewports,
- &src->viewport.viewports,
+ if (memcmp(&dest->viewport.viewports, &src->viewport.viewports,
src->viewport.count * sizeof(VkViewport))) {
- typed_memcpy(dest->viewport.viewports,
- src->viewport.viewports,
+ typed_memcpy(dest->viewport.viewports, src->viewport.viewports,
src->viewport.count);
dest_mask |= TU_DYNAMIC_VIEWPORT;
}
}
if (copy_mask & TU_DYNAMIC_SCISSOR) {
- if (memcmp(&dest->scissor.scissors,
- &src->scissor.scissors,
+ if (memcmp(&dest->scissor.scissors, &src->scissor.scissors,
src->scissor.count * sizeof(VkRect2D))) {
- typed_memcpy(
- dest->scissor.scissors, src->scissor.scissors, src->scissor.count);
+ typed_memcpy(dest->scissor.scissors, src->scissor.scissors,
+ src->scissor.count);
dest_mask |= TU_DYNAMIC_SCISSOR;
}
}
}
if (copy_mask & TU_DYNAMIC_DEPTH_BIAS) {
- if (memcmp(
- &dest->depth_bias, &src->depth_bias, sizeof(src->depth_bias))) {
+ if (memcmp(&dest->depth_bias, &src->depth_bias,
+ sizeof(src->depth_bias))) {
dest->depth_bias = src->depth_bias;
dest_mask |= TU_DYNAMIC_DEPTH_BIAS;
}
}
if (copy_mask & TU_DYNAMIC_BLEND_CONSTANTS) {
- if (memcmp(&dest->blend_constants,
- &src->blend_constants,
+ if (memcmp(&dest->blend_constants, &src->blend_constants,
sizeof(src->blend_constants))) {
typed_memcpy(dest->blend_constants, src->blend_constants, 4);
dest_mask |= TU_DYNAMIC_BLEND_CONSTANTS;
}
if (copy_mask & TU_DYNAMIC_DEPTH_BOUNDS) {
- if (memcmp(&dest->depth_bounds,
- &src->depth_bounds,
+ if (memcmp(&dest->depth_bounds, &src->depth_bounds,
sizeof(src->depth_bounds))) {
dest->depth_bounds = src->depth_bounds;
dest_mask |= TU_DYNAMIC_DEPTH_BOUNDS;
}
if (copy_mask & TU_DYNAMIC_STENCIL_COMPARE_MASK) {
- if (memcmp(&dest->stencil_compare_mask,
- &src->stencil_compare_mask,
+ if (memcmp(&dest->stencil_compare_mask, &src->stencil_compare_mask,
sizeof(src->stencil_compare_mask))) {
dest->stencil_compare_mask = src->stencil_compare_mask;
dest_mask |= TU_DYNAMIC_STENCIL_COMPARE_MASK;
}
if (copy_mask & TU_DYNAMIC_STENCIL_WRITE_MASK) {
- if (memcmp(&dest->stencil_write_mask,
- &src->stencil_write_mask,
+ if (memcmp(&dest->stencil_write_mask, &src->stencil_write_mask,
sizeof(src->stencil_write_mask))) {
dest->stencil_write_mask = src->stencil_write_mask;
dest_mask |= TU_DYNAMIC_STENCIL_WRITE_MASK;
}
if (copy_mask & TU_DYNAMIC_STENCIL_REFERENCE) {
- if (memcmp(&dest->stencil_reference,
- &src->stencil_reference,
+ if (memcmp(&dest->stencil_reference, &src->stencil_reference,
sizeof(src->stencil_reference))) {
dest->stencil_reference = src->stencil_reference;
dest_mask |= TU_DYNAMIC_STENCIL_REFERENCE;
static VkResult
tu_create_cmd_buffer(struct tu_device *device,
- struct tu_cmd_pool *pool,
- VkCommandBufferLevel level,
- VkCommandBuffer *pCommandBuffer)
+ struct tu_cmd_pool *pool,
+ VkCommandBufferLevel level,
+ VkCommandBuffer *pCommandBuffer)
{
struct tu_cmd_buffer *cmd_buffer;
- cmd_buffer = vk_zalloc(
- &pool->alloc, sizeof(*cmd_buffer), 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
+ cmd_buffer = vk_zalloc(&pool->alloc, sizeof(*cmd_buffer), 8,
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (cmd_buffer == NULL)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
cmd_buffer->queue_family_index = TU_QUEUE_GENERAL;
}
+ tu_bo_list_init(&cmd_buffer->bo_list);
+ tu_cmd_stream_init(&cmd_buffer->primary_cmd_stream);
+
*pCommandBuffer = tu_cmd_buffer_to_handle(cmd_buffer);
list_inithead(&cmd_buffer->upload.list);
for (unsigned i = 0; i < VK_PIPELINE_BIND_POINT_RANGE_SIZE; i++)
free(cmd_buffer->descriptors[i].push_set.set.mapped_ptr);
+ tu_cmd_stream_finish(cmd_buffer->device, &cmd_buffer->primary_cmd_stream);
+ tu_bo_list_destroy(&cmd_buffer->bo_list);
vk_free(&cmd_buffer->pool->alloc, cmd_buffer);
}
{
cmd_buffer->record_result = VK_SUCCESS;
+ tu_bo_list_reset(&cmd_buffer->bo_list);
+ tu_cmd_stream_reset(cmd_buffer->device, &cmd_buffer->primary_cmd_stream);
+
for (unsigned i = 0; i < VK_PIPELINE_BIND_POINT_RANGE_SIZE; i++) {
cmd_buffer->descriptors[i].dirty = 0;
cmd_buffer->descriptors[i].valid = 0;
VkResult
tu_AllocateCommandBuffers(VkDevice _device,
- const VkCommandBufferAllocateInfo *pAllocateInfo,
- VkCommandBuffer *pCommandBuffers)
+ const VkCommandBufferAllocateInfo *pAllocateInfo,
+ VkCommandBuffer *pCommandBuffers)
{
TU_FROM_HANDLE(tu_device, device, _device);
TU_FROM_HANDLE(tu_cmd_pool, pool, pAllocateInfo->commandPool);
if (!list_empty(&pool->free_cmd_buffers)) {
struct tu_cmd_buffer *cmd_buffer = list_first_entry(
- &pool->free_cmd_buffers, struct tu_cmd_buffer, pool_link);
+ &pool->free_cmd_buffers, struct tu_cmd_buffer, pool_link);
list_del(&cmd_buffer->pool_link);
list_addtail(&cmd_buffer->pool_link, &pool->cmd_buffers);
pCommandBuffers[i] = tu_cmd_buffer_to_handle(cmd_buffer);
} else {
- result = tu_create_cmd_buffer(
- device, pool, pAllocateInfo->level, &pCommandBuffers[i]);
+ result = tu_create_cmd_buffer(device, pool, pAllocateInfo->level,
+ &pCommandBuffers[i]);
}
if (result != VK_SUCCESS)
break;
}
if (result != VK_SUCCESS) {
- tu_FreeCommandBuffers(
- _device, pAllocateInfo->commandPool, i, pCommandBuffers);
+ tu_FreeCommandBuffers(_device, pAllocateInfo->commandPool, i,
+ pCommandBuffers);
/* From the Vulkan 1.0.66 spec:
*
* command, set all entries of the pCommandBuffers array to
* NULL and return the error."
*/
- memset(pCommandBuffers,
- 0,
+ memset(pCommandBuffers, 0,
sizeof(*pCommandBuffers) * pAllocateInfo->commandBufferCount);
}
void
tu_FreeCommandBuffers(VkDevice device,
- VkCommandPool commandPool,
- uint32_t commandBufferCount,
- const VkCommandBuffer *pCommandBuffers)
+ VkCommandPool commandPool,
+ uint32_t commandBufferCount,
+ const VkCommandBuffer *pCommandBuffers)
{
for (uint32_t i = 0; i < commandBufferCount; i++) {
TU_FROM_HANDLE(tu_cmd_buffer, cmd_buffer, pCommandBuffers[i]);
VkResult
tu_ResetCommandBuffer(VkCommandBuffer commandBuffer,
- VkCommandBufferResetFlags flags)
+ VkCommandBufferResetFlags flags)
{
TU_FROM_HANDLE(tu_cmd_buffer, cmd_buffer, commandBuffer);
return tu_reset_cmd_buffer(cmd_buffer);
VkResult
tu_BeginCommandBuffer(VkCommandBuffer commandBuffer,
- const VkCommandBufferBeginInfo *pBeginInfo)
+ const VkCommandBufferBeginInfo *pBeginInfo)
{
TU_FROM_HANDLE(tu_cmd_buffer, cmd_buffer, commandBuffer);
VkResult result = VK_SUCCESS;
/* setup initial configuration into command buffer */
if (cmd_buffer->level == VK_COMMAND_BUFFER_LEVEL_PRIMARY) {
switch (cmd_buffer->queue_family_index) {
- case TU_QUEUE_GENERAL:
- /* init */
- break;
- default:
- break;
+ case TU_QUEUE_GENERAL:
+ /* init */
+ break;
+ default:
+ break;
}
}
void
tu_CmdBindVertexBuffers(VkCommandBuffer commandBuffer,
- uint32_t firstBinding,
- uint32_t bindingCount,
- const VkBuffer *pBuffers,
- const VkDeviceSize *pOffsets)
+ uint32_t firstBinding,
+ uint32_t bindingCount,
+ const VkBuffer *pBuffers,
+ const VkDeviceSize *pOffsets)
{
}
void
tu_CmdBindIndexBuffer(VkCommandBuffer commandBuffer,
- VkBuffer buffer,
- VkDeviceSize offset,
- VkIndexType indexType)
+ VkBuffer buffer,
+ VkDeviceSize offset,
+ VkIndexType indexType)
{
}
void
tu_CmdBindDescriptorSets(VkCommandBuffer commandBuffer,
- VkPipelineBindPoint pipelineBindPoint,
- VkPipelineLayout _layout,
- uint32_t firstSet,
- uint32_t descriptorSetCount,
- const VkDescriptorSet *pDescriptorSets,
- uint32_t dynamicOffsetCount,
- const uint32_t *pDynamicOffsets)
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipelineLayout _layout,
+ uint32_t firstSet,
+ uint32_t descriptorSetCount,
+ const VkDescriptorSet *pDescriptorSets,
+ uint32_t dynamicOffsetCount,
+ const uint32_t *pDynamicOffsets)
{
}
void
tu_CmdPushConstants(VkCommandBuffer commandBuffer,
- VkPipelineLayout layout,
- VkShaderStageFlags stageFlags,
- uint32_t offset,
- uint32_t size,
- const void *pValues)
+ VkPipelineLayout layout,
+ VkShaderStageFlags stageFlags,
+ uint32_t offset,
+ uint32_t size,
+ const void *pValues)
{
}
void
tu_CmdBindPipeline(VkCommandBuffer commandBuffer,
- VkPipelineBindPoint pipelineBindPoint,
- VkPipeline _pipeline)
+ VkPipelineBindPoint pipelineBindPoint,
+ VkPipeline _pipeline)
{
}
void
tu_CmdSetViewport(VkCommandBuffer commandBuffer,
- uint32_t firstViewport,
- uint32_t viewportCount,
- const VkViewport *pViewports)
+ uint32_t firstViewport,
+ uint32_t viewportCount,
+ const VkViewport *pViewports)
{
}
void
tu_CmdSetScissor(VkCommandBuffer commandBuffer,
- uint32_t firstScissor,
- uint32_t scissorCount,
- const VkRect2D *pScissors)
+ uint32_t firstScissor,
+ uint32_t scissorCount,
+ const VkRect2D *pScissors)
{
}
void
tu_CmdSetDepthBias(VkCommandBuffer commandBuffer,
- float depthBiasConstantFactor,
- float depthBiasClamp,
- float depthBiasSlopeFactor)
+ float depthBiasConstantFactor,
+ float depthBiasClamp,
+ float depthBiasSlopeFactor)
{
}
void
tu_CmdSetBlendConstants(VkCommandBuffer commandBuffer,
- const float blendConstants[4])
+ const float blendConstants[4])
{
}
void
tu_CmdSetDepthBounds(VkCommandBuffer commandBuffer,
- float minDepthBounds,
- float maxDepthBounds)
+ float minDepthBounds,
+ float maxDepthBounds)
{
}
void
tu_CmdSetStencilCompareMask(VkCommandBuffer commandBuffer,
- VkStencilFaceFlags faceMask,
- uint32_t compareMask)
+ VkStencilFaceFlags faceMask,
+ uint32_t compareMask)
{
}
void
tu_CmdSetStencilWriteMask(VkCommandBuffer commandBuffer,
- VkStencilFaceFlags faceMask,
- uint32_t writeMask)
+ VkStencilFaceFlags faceMask,
+ uint32_t writeMask)
{
}
void
tu_CmdSetStencilReference(VkCommandBuffer commandBuffer,
- VkStencilFaceFlags faceMask,
- uint32_t reference)
+ VkStencilFaceFlags faceMask,
+ uint32_t reference)
{
}
void
tu_CmdExecuteCommands(VkCommandBuffer commandBuffer,
- uint32_t commandBufferCount,
- const VkCommandBuffer *pCmdBuffers)
+ uint32_t commandBufferCount,
+ const VkCommandBuffer *pCmdBuffers)
{
}
VkResult
tu_CreateCommandPool(VkDevice _device,
- const VkCommandPoolCreateInfo *pCreateInfo,
- const VkAllocationCallbacks *pAllocator,
- VkCommandPool *pCmdPool)
+ const VkCommandPoolCreateInfo *pCreateInfo,
+ const VkAllocationCallbacks *pAllocator,
+ VkCommandPool *pCmdPool)
{
TU_FROM_HANDLE(tu_device, device, _device);
struct tu_cmd_pool *pool;
- pool = vk_alloc2(&device->alloc,
- pAllocator,
- sizeof(*pool),
- 8,
+ pool = vk_alloc2(&device->alloc, pAllocator, sizeof(*pool), 8,
VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (pool == NULL)
return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
void
tu_DestroyCommandPool(VkDevice _device,
- VkCommandPool commandPool,
- const VkAllocationCallbacks *pAllocator)
+ VkCommandPool commandPool,
+ const VkAllocationCallbacks *pAllocator)
{
TU_FROM_HANDLE(tu_device, device, _device);
TU_FROM_HANDLE(tu_cmd_pool, pool, commandPool);
if (!pool)
return;
- list_for_each_entry_safe(
- struct tu_cmd_buffer, cmd_buffer, &pool->cmd_buffers, pool_link)
+ list_for_each_entry_safe(struct tu_cmd_buffer, cmd_buffer,
+ &pool->cmd_buffers, pool_link)
{
tu_cmd_buffer_destroy(cmd_buffer);
}
- list_for_each_entry_safe(
- struct tu_cmd_buffer, cmd_buffer, &pool->free_cmd_buffers, pool_link)
+ list_for_each_entry_safe(struct tu_cmd_buffer, cmd_buffer,
+ &pool->free_cmd_buffers, pool_link)
{
tu_cmd_buffer_destroy(cmd_buffer);
}
VkResult
tu_ResetCommandPool(VkDevice device,
- VkCommandPool commandPool,
- VkCommandPoolResetFlags flags)
+ VkCommandPool commandPool,
+ VkCommandPoolResetFlags flags)
{
TU_FROM_HANDLE(tu_cmd_pool, pool, commandPool);
VkResult result;
- list_for_each_entry(
- struct tu_cmd_buffer, cmd_buffer, &pool->cmd_buffers, pool_link)
+ list_for_each_entry(struct tu_cmd_buffer, cmd_buffer, &pool->cmd_buffers,
+ pool_link)
{
result = tu_reset_cmd_buffer(cmd_buffer);
if (result != VK_SUCCESS)
void
tu_TrimCommandPool(VkDevice device,
- VkCommandPool commandPool,
- VkCommandPoolTrimFlagsKHR flags)
+ VkCommandPool commandPool,
+ VkCommandPoolTrimFlagsKHR flags)
{
TU_FROM_HANDLE(tu_cmd_pool, pool, commandPool);
if (!pool)
return;
- list_for_each_entry_safe(
- struct tu_cmd_buffer, cmd_buffer, &pool->free_cmd_buffers, pool_link)
+ list_for_each_entry_safe(struct tu_cmd_buffer, cmd_buffer,
+ &pool->free_cmd_buffers, pool_link)
{
tu_cmd_buffer_destroy(cmd_buffer);
}
void
tu_CmdBeginRenderPass(VkCommandBuffer commandBuffer,
- const VkRenderPassBeginInfo *pRenderPassBegin,
- VkSubpassContents contents)
+ const VkRenderPassBeginInfo *pRenderPassBegin,
+ VkSubpassContents contents)
{
}
void
tu_CmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer,
- const VkRenderPassBeginInfo *pRenderPassBeginInfo,
- const VkSubpassBeginInfoKHR *pSubpassBeginInfo)
+ const VkRenderPassBeginInfo *pRenderPassBeginInfo,
+ const VkSubpassBeginInfoKHR *pSubpassBeginInfo)
{
- tu_CmdBeginRenderPass(
- commandBuffer, pRenderPassBeginInfo, pSubpassBeginInfo->contents);
+ tu_CmdBeginRenderPass(commandBuffer, pRenderPassBeginInfo,
+ pSubpassBeginInfo->contents);
}
void
void
tu_CmdNextSubpass2KHR(VkCommandBuffer commandBuffer,
- const VkSubpassBeginInfoKHR *pSubpassBeginInfo,
- const VkSubpassEndInfoKHR *pSubpassEndInfo)
+ const VkSubpassBeginInfoKHR *pSubpassBeginInfo,
+ const VkSubpassEndInfoKHR *pSubpassEndInfo)
{
tu_CmdNextSubpass(commandBuffer, pSubpassBeginInfo->contents);
}
void
tu_CmdDraw(VkCommandBuffer commandBuffer,
- uint32_t vertexCount,
- uint32_t instanceCount,
- uint32_t firstVertex,
- uint32_t firstInstance)
+ uint32_t vertexCount,
+ uint32_t instanceCount,
+ uint32_t firstVertex,
+ uint32_t firstInstance)
{
TU_FROM_HANDLE(tu_cmd_buffer, cmd_buffer, commandBuffer);
struct tu_draw_info info = {};
void
tu_CmdDrawIndexed(VkCommandBuffer commandBuffer,
- uint32_t indexCount,
- uint32_t instanceCount,
- uint32_t firstIndex,
- int32_t vertexOffset,
- uint32_t firstInstance)
+ uint32_t indexCount,
+ uint32_t instanceCount,
+ uint32_t firstIndex,
+ int32_t vertexOffset,
+ uint32_t firstInstance)
{
TU_FROM_HANDLE(tu_cmd_buffer, cmd_buffer, commandBuffer);
struct tu_draw_info info = {};
void
tu_CmdDrawIndirect(VkCommandBuffer commandBuffer,
- VkBuffer _buffer,
- VkDeviceSize offset,
- uint32_t drawCount,
- uint32_t stride)
+ VkBuffer _buffer,
+ VkDeviceSize offset,
+ uint32_t drawCount,
+ uint32_t stride)
{
TU_FROM_HANDLE(tu_cmd_buffer, cmd_buffer, commandBuffer);
TU_FROM_HANDLE(tu_buffer, buffer, _buffer);
void
tu_CmdDrawIndexedIndirect(VkCommandBuffer commandBuffer,
- VkBuffer _buffer,
- VkDeviceSize offset,
- uint32_t drawCount,
- uint32_t stride)
+ VkBuffer _buffer,
+ VkDeviceSize offset,
+ uint32_t drawCount,
+ uint32_t stride)
{
TU_FROM_HANDLE(tu_cmd_buffer, cmd_buffer, commandBuffer);
TU_FROM_HANDLE(tu_buffer, buffer, _buffer);
static void
tu_dispatch(struct tu_cmd_buffer *cmd_buffer,
- const struct tu_dispatch_info *info)
+ const struct tu_dispatch_info *info)
{
}
void
tu_CmdDispatchBase(VkCommandBuffer commandBuffer,
- uint32_t base_x,
- uint32_t base_y,
- uint32_t base_z,
- uint32_t x,
- uint32_t y,
- uint32_t z)
+ uint32_t base_x,
+ uint32_t base_y,
+ uint32_t base_z,
+ uint32_t x,
+ uint32_t y,
+ uint32_t z)
{
TU_FROM_HANDLE(tu_cmd_buffer, cmd_buffer, commandBuffer);
struct tu_dispatch_info info = {};
void
tu_CmdDispatch(VkCommandBuffer commandBuffer,
- uint32_t x,
- uint32_t y,
- uint32_t z)
+ uint32_t x,
+ uint32_t y,
+ uint32_t z)
{
tu_CmdDispatchBase(commandBuffer, 0, 0, 0, x, y, z);
}
void
tu_CmdDispatchIndirect(VkCommandBuffer commandBuffer,
- VkBuffer _buffer,
- VkDeviceSize offset)
+ VkBuffer _buffer,
+ VkDeviceSize offset)
{
TU_FROM_HANDLE(tu_cmd_buffer, cmd_buffer, commandBuffer);
TU_FROM_HANDLE(tu_buffer, buffer, _buffer);
void
tu_CmdEndRenderPass2KHR(VkCommandBuffer commandBuffer,
- const VkSubpassEndInfoKHR *pSubpassEndInfo)
+ const VkSubpassEndInfoKHR *pSubpassEndInfo)
{
tu_CmdEndRenderPass(commandBuffer);
}
static void
tu_barrier(struct tu_cmd_buffer *cmd_buffer,
- uint32_t memoryBarrierCount,
- const VkMemoryBarrier *pMemoryBarriers,
- uint32_t bufferMemoryBarrierCount,
- const VkBufferMemoryBarrier *pBufferMemoryBarriers,
- uint32_t imageMemoryBarrierCount,
- const VkImageMemoryBarrier *pImageMemoryBarriers,
- const struct tu_barrier_info *info)
+ uint32_t memoryBarrierCount,
+ const VkMemoryBarrier *pMemoryBarriers,
+ uint32_t bufferMemoryBarrierCount,
+ const VkBufferMemoryBarrier *pBufferMemoryBarriers,
+ uint32_t imageMemoryBarrierCount,
+ const VkImageMemoryBarrier *pImageMemoryBarriers,
+ const struct tu_barrier_info *info)
{
}
void
tu_CmdPipelineBarrier(VkCommandBuffer commandBuffer,
- VkPipelineStageFlags srcStageMask,
- VkPipelineStageFlags destStageMask,
- VkBool32 byRegion,
- uint32_t memoryBarrierCount,
- const VkMemoryBarrier *pMemoryBarriers,
- uint32_t bufferMemoryBarrierCount,
- const VkBufferMemoryBarrier *pBufferMemoryBarriers,
- uint32_t imageMemoryBarrierCount,
- const VkImageMemoryBarrier *pImageMemoryBarriers)
+ VkPipelineStageFlags srcStageMask,
+ VkPipelineStageFlags destStageMask,
+ VkBool32 byRegion,
+ uint32_t memoryBarrierCount,
+ const VkMemoryBarrier *pMemoryBarriers,
+ uint32_t bufferMemoryBarrierCount,
+ const VkBufferMemoryBarrier *pBufferMemoryBarriers,
+ uint32_t imageMemoryBarrierCount,
+ const VkImageMemoryBarrier *pImageMemoryBarriers)
{
TU_FROM_HANDLE(tu_cmd_buffer, cmd_buffer, commandBuffer);
struct tu_barrier_info info;
info.pEvents = NULL;
info.srcStageMask = srcStageMask;
- tu_barrier(cmd_buffer,
- memoryBarrierCount,
- pMemoryBarriers,
- bufferMemoryBarrierCount,
- pBufferMemoryBarriers,
- imageMemoryBarrierCount,
- pImageMemoryBarriers,
- &info);
+ tu_barrier(cmd_buffer, memoryBarrierCount, pMemoryBarriers,
+ bufferMemoryBarrierCount, pBufferMemoryBarriers,
+ imageMemoryBarrierCount, pImageMemoryBarriers, &info);
}
static void
void
tu_CmdSetEvent(VkCommandBuffer commandBuffer,
- VkEvent _event,
- VkPipelineStageFlags stageMask)
+ VkEvent _event,
+ VkPipelineStageFlags stageMask)
{
TU_FROM_HANDLE(tu_cmd_buffer, cmd_buffer, commandBuffer);
TU_FROM_HANDLE(tu_event, event, _event);
void
tu_CmdResetEvent(VkCommandBuffer commandBuffer,
- VkEvent _event,
- VkPipelineStageFlags stageMask)
+ VkEvent _event,
+ VkPipelineStageFlags stageMask)
{
TU_FROM_HANDLE(tu_cmd_buffer, cmd_buffer, commandBuffer);
TU_FROM_HANDLE(tu_event, event, _event);
void
tu_CmdWaitEvents(VkCommandBuffer commandBuffer,
- uint32_t eventCount,
- const VkEvent *pEvents,
- VkPipelineStageFlags srcStageMask,
- VkPipelineStageFlags dstStageMask,
- uint32_t memoryBarrierCount,
- const VkMemoryBarrier *pMemoryBarriers,
- uint32_t bufferMemoryBarrierCount,
- const VkBufferMemoryBarrier *pBufferMemoryBarriers,
- uint32_t imageMemoryBarrierCount,
- const VkImageMemoryBarrier *pImageMemoryBarriers)
+ uint32_t eventCount,
+ const VkEvent *pEvents,
+ VkPipelineStageFlags srcStageMask,
+ VkPipelineStageFlags dstStageMask,
+ uint32_t memoryBarrierCount,
+ const VkMemoryBarrier *pMemoryBarriers,
+ uint32_t bufferMemoryBarrierCount,
+ const VkBufferMemoryBarrier *pBufferMemoryBarriers,
+ uint32_t imageMemoryBarrierCount,
+ const VkImageMemoryBarrier *pImageMemoryBarriers)
{
TU_FROM_HANDLE(tu_cmd_buffer, cmd_buffer, commandBuffer);
struct tu_barrier_info info;
info.pEvents = pEvents;
info.srcStageMask = 0;
- tu_barrier(cmd_buffer,
- memoryBarrierCount,
- pMemoryBarriers,
- bufferMemoryBarrierCount,
- pBufferMemoryBarriers,
- imageMemoryBarrierCount,
- pImageMemoryBarriers,
- &info);
+ tu_barrier(cmd_buffer, memoryBarrierCount, pMemoryBarriers,
+ bufferMemoryBarrierCount, pBufferMemoryBarriers,
+ imageMemoryBarrierCount, pImageMemoryBarriers, &info);
}
void
projects / mesa.git / blobdiff