dymokomi/luce-gpu
Source of release 0.5.3
0.5.3 / src / gpu / vulkan / render.lucb
#==============================================================================================
#
# render - Vulkan command recording and uploads
#
# DESCRIPTION:
# Vulkan command recording and uploads for one pass: its vertices, coverage, instances
# and parameters in a span of the draw-data ring (vulkan/ring.lucb), one descriptor set
# per draw naming them and the sampled images, and the encoding shared by presentation and
# offscreen passes.
#
#==============================================================================================
# mark: Vertex and coverage uploads ===========================================================
struct VulkanUpload:
## The ring buffer holding the pass's data, from `base`.
var buffer: u64
var base: u64
var descriptor_pool: u64
var descriptors: u64[]
# Mesh draws' sets (vulkan/mesh.lucb), 0 for other draws.
var mesh_descriptors: u64[]
func vulkan_upload_destroy(device: VulkanDevice*, upload: VulkanUpload):
if upload.descriptor_pool != 0: vkDestroyDescriptorPool(device.device, upload.descriptor_pool, none)
if upload.descriptors.length > 0: free(upload.descriptors) in memory.heap
if upload.mesh_descriptors.length > 0: free(upload.mesh_descriptors) in memory.heap
## Hand the upload's descriptors to `slot`, to be freed when its submission
## completes (its ring span is reused once that submission has finished).
func vulkan_upload_retire(slot: VulkanSlot*, upload: VulkanUpload*) -> !:
if upload.descriptor_pool != 0:
try vulkan_retire(slot, VulkanRetired(kind = vulkan_retired_descriptors, handle = upload.descriptor_pool))
upload.descriptor_pool = 0
func vulkan_vertex_offset(canvas: Canvas) -> usize:
# Vulkan requires storage-buffer offsets to honor the device alignment. A
# dedicated prefix at offset zero avoids imposing any guessed alignment.
return (canvas_max(1, canvas.coverage_count) * 4 + 31) // 32 * 32
## Where a canvas's instances start in its upload: after the vertices.
func vulkan_instance_offset(canvas: Canvas) -> usize:
return (vulkan_vertex_offset(canvas) + canvas_max(1, canvas.vertex_count) * memory.size_of(Vertex) + 63) // 64 * 64
func vulkan_upload(device: VulkanDevice*, canvas: Canvas) -> VulkanUpload!:
var upload: VulkanUpload
errdefer vulkan_upload_destroy(device, upload)
if canvas.draw_count == 0:
return upload
try vulkan_drawing(device)
let vertex_bytes = canvas_max(1, canvas.vertex_count) * memory.size_of(Vertex)
let mask_bytes = canvas_max(1, canvas.coverage_count) * 4
let vertex_offset = vulkan_vertex_offset(canvas)
let instance_offset = vulkan_instance_offset(canvas)
let instance_bytes = canvas.instance_count * memory.size_of(ShadeInstance)
let parameter_offset = (instance_offset + instance_bytes + 255) // 256 * 256
var meshes: usize = 0
for draw in canvas.draws[..<canvas.draw_count]:
if draw.mesh != none: meshes += 1
if meshes > 0: try vulkan_mesh_ready(device)
# Mesh parameter blocks follow, 512 bytes apart.
let mesh_offset = parameter_offset + canvas.draw_count * 256
let bytes = mesh_offset + meshes * 512
let span = try vulkan_ring_take(device, (u64)bytes)
upload.buffer = span.buffer
upload.base = span.offset
let destination = (void*)span.data
let masks = u32[]((u32*)destination, canvas_max(1, canvas.coverage_count))
masks[0] = 0
if canvas.coverage_count > 0:
memory.copy(masks, canvas.coverage, canvas.coverage_count)
if canvas.vertex_count > 0:
memory.copy(u8[]((u8*)destination + vertex_offset, vertex_bytes), u8[]((u8*)canvas.vertices.data, vertex_bytes), vertex_bytes)
if canvas.instance_count > 0:
memory.copy(u8[]((u8*)destination + instance_offset, instance_bytes), u8[]((u8*)canvas.instances.data, instance_bytes), instance_bytes)
for index in 0..<canvas.draw_count:
var uniforms = canvas.draws[index].geometry_uniforms
# A quad draw's vertex stage reads its own parameters there instead.
if let quads = canvas.draws[index].quads:
memory.copy(uniforms[..<4], quads.control, 4)
memory.copy(u8[]((u8*)destination + parameter_offset + index * 256, 112), u8[]((u8*)&uniforms, 112), 112)
var placed: usize = 0
for draw in canvas.draws[..<canvas.draw_count]:
if let mesh = draw.mesh:
var parameters = mesh.parameters
memory.copy(u8[]((u8*)destination + mesh_offset + placed * 512, mesh_parameter_count * 4), u8[]((u8*)¶meters, mesh_parameter_count * 4), mesh_parameter_count * 4)
placed += 1
let count = (u32)canvas.draw_count
var pool_sizes: VkDescriptorPoolSize[2] = [
VkDescriptorPoolSize(descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, descriptorCount = count * 4 + (u32)meshes * 8),
VkDescriptorPoolSize(descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, descriptorCount = count * (u32)image_limit)]
var pool_info = VkDescriptorPoolCreateInfo(sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, maxSets = count + (u32)meshes, poolSizeCount = 2, pPoolSizes = &pool_sizes[0])
try vulkan_check(vkCreateDescriptorPool(device.device, &pool_info, none, &upload.descriptor_pool), "Vulkan draw descriptors could not be created")
upload.descriptors = try new u64[canvas.draw_count] --- in memory.heap
let layouts = try new u64[canvas.draw_count] --- in memory.heap
defer free(layouts) in memory.heap
for index in 0..<canvas.draw_count:
layouts[index] = device.descriptor_layout
var set_info = VkDescriptorSetAllocateInfo(sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, descriptorPool = upload.descriptor_pool, descriptorSetCount = count, pSetLayouts = layouts.data)
try vulkan_check(vkAllocateDescriptorSets(device.device, &set_info, upload.descriptors.data), "Vulkan draw descriptors could not be allocated")
var buffer_info = VkDescriptorBufferInfo(buffer = upload.buffer, offset = upload.base, range = (u64)mask_bytes)
let placeholder = device.placeholder else trap("Vulkan drawing state has no placeholder image")
for index in 0..<canvas.draw_count:
let draw = canvas.draws[index]
var image_infos: VkDescriptorImageInfo[4]
var writes: VkWriteDescriptorSet[8]
for slot in 0..<image_limit:
var image = placeholder
if let texture = draw.images[slot]:
image = (VulkanTexture*)texture.native
image_infos[slot] = VkDescriptorImageInfo(sampler = vulkan_sampler_for(device, draw.filter, image.filterable),
imageView = image.view, imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)
if slot == image_limit - 1 and reads_scene_depth(&draw):
# The scene depth copy, read texel by texel.
image_infos[slot] = VkDescriptorImageInfo(sampler = device.nearest, imageView = device.depth_copy_view, imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)
writes[slot] = VkWriteDescriptorSet(sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, dstSet = upload.descriptors[index], dstBinding = (u32)slot + 1, descriptorCount = 1,
descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, pImageInfo = &image_infos[slot])
writes[4] = VkWriteDescriptorSet(sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, dstSet = upload.descriptors[index], dstBinding = 5, descriptorCount = 1,
descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, pBufferInfo = &buffer_info)
var geometry_info = VkDescriptorBufferInfo(buffer = upload.buffer, offset = upload.base, range = 32)
if let geometry = draw.geometry:
let native = (VulkanGeometry*)geometry.native
geometry_info.buffer = native.buffer
geometry_info.offset = 0
geometry_info.range = native.bytes
# Binding 8 is read only by shade_quads' vertex stage (its order).
var order_info = geometry_info
if let quads = draw.quads:
let records = (VulkanBuffer*)quads.records.native
geometry_info = VkDescriptorBufferInfo(buffer = records.buffer, range = records.bytes)
order_info = geometry_info
if let order = quads.order:
let native = (VulkanBuffer*)order.native
order_info = VkDescriptorBufferInfo(buffer = native.buffer, range = native.bytes)
var parameter_info = VkDescriptorBufferInfo(buffer = upload.buffer, offset = upload.base + (u64)(parameter_offset + index * 256), range = 112)
writes[5] = VkWriteDescriptorSet(sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, dstSet = upload.descriptors[index], dstBinding = 6, descriptorCount = 1, descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, pBufferInfo = &geometry_info)
writes[6] = VkWriteDescriptorSet(sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, dstSet = upload.descriptors[index], dstBinding = 7, descriptorCount = 1, descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, pBufferInfo = ¶meter_info)
writes[7] = VkWriteDescriptorSet(sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, dstSet = upload.descriptors[index], dstBinding = 8, descriptorCount = 1, descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, pBufferInfo = &order_info)
vkUpdateDescriptorSets(device.device, 8, &writes[0], 0, none)
if meshes > 0:
upload.mesh_descriptors = try new u64[canvas.draw_count] --- in memory.heap
placed = 0
for index in 0..<canvas.draw_count:
upload.mesh_descriptors[index] = 0
let mesh = canvas.draws[index].mesh else continue
var mesh_set_info = VkDescriptorSetAllocateInfo(sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, descriptorPool = upload.descriptor_pool, descriptorSetCount = 1, pSetLayouts = &device.mesh_layout)
try vulkan_check(vkAllocateDescriptorSets(device.device, &mesh_set_info, &upload.mesh_descriptors[index]), "Vulkan mesh descriptors could not be allocated")
try vulkan_mesh_descriptors(device, upload.mesh_descriptors[index], mesh, upload.buffer, upload.base + (u64)(mesh_offset + placed * 512))
placed += 1
return upload
# mark: Encoding and rendering ================================================================
## Record `canvas` into `framebuffer` on `command` as `pass`, clearing to
## `color`. Presentation clears opaque; texture passes keep the alpha. A nonzero
## `serial` is the submission the commands belong to: every sampled image
## records it as its last use. One render pass draws everything, unless draws
## read the scene depth: before each that needs a fresh copy
## (`depth_copy_before`), the pass ends storing `depth_image`, the depth is
## copied to the device's depth copy, and a split pass resumes over both
## attachments; the last ends as `pass` would.
func vulkan_encode(device: VulkanDevice*, command: u64, formats: VulkanFormatState*, pass: u64, framebuffer: u64,
canvas: Canvas, upload: VulkanUpload, color: Color, width: u32, height: u32, serial: u64, encoded: bool = false, depth_image: u64 = 0) -> !:
var clears: VkClearValue[2]
let clear = Color(srgb_encoded(color.red), srgb_encoded(color.green), srgb_encoded(color.blue), color.alpha) if encoded else color
clears[0].color = [(f32)(clear.red * clear.alpha), (f32)(clear.green * clear.alpha), (f32)(clear.blue * clear.alpha), (f32)clear.alpha]
clears[1].color[0] = 1.0
# Images sampled before anything was drawn into them get a defined layout
# here, outside the pass.
for index in 0..<canvas.draw_count:
if let mesh = canvas.draws[index].mesh:
vulkan_mesh_used(mesh, serial)
_ = try vulkan_mesh_pipeline(device, formats, mesh.kind)
if let geometry = canvas.draws[index].geometry:
if serial != 0: ((VulkanGeometry*)geometry.native).last_use = serial
if formats.geometry == 0:
formats.geometry = try vulkan_build_pipeline(device, formats.pass_texture, device.fill, Blend.over, true, true)
if let quads = canvas.draws[index].quads:
vulkan_quads_used(quads, serial)
for slot in 0..<image_limit:
if let texture = canvas.draws[index].images[slot]:
let image = (VulkanTexture*)texture.native
vulkan_transition(command, image, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)
if serial != 0:
image.last_use = serial
let split = reads_scene_depth_anywhere(&canvas)
var opening = pass
var middle = pass
var closing = pass
if split:
opening = try vulkan_split_pass(device, formats, vulkan_split_open_load if pass == formats.pass_load else vulkan_split_open_clear)
middle = try vulkan_split_pass(device, formats, vulkan_split_middle)
closing = try vulkan_split_pass(device, formats, vulkan_split_close_present if pass == formats.pass_present else vulkan_split_close_texture)
var begin = VkRenderPassBeginInfo(sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, renderPass = opening, framebuffer = framebuffer,
renderArea = VkRect2D(extent = VkExtent2D(width = width, height = height)), clearValueCount = 2, pClearValues = &clears[0])
var start: usize = 0
var first = true
while true:
# This pass draws start..<end; a depth copy follows unless it is the
# last. Later passes start at a draw whose copy was just made.
var end = canvas.draw_count
if split:
end = start if first else start + 1
while end < canvas.draw_count and not depth_copy_before(&canvas, end): end += 1
let last = end >= canvas.draw_count
if not first: begin.renderPass = closing if last else middle
vkCmdBeginRenderPass(command, &begin, VK_SUBPASS_CONTENTS_INLINE)
if end > start:
# Binding 0: the vertices; binding 1: the instances of shade_instances.
var buffers: u64[2] = [upload.buffer, upload.buffer]
var offsets: u64[2] = [upload.base + (u64)vulkan_vertex_offset(canvas), upload.base + (u64)vulkan_instance_offset(canvas)]
vkCmdBindVertexBuffers(command, 0, 2, &buffers[0], &offsets[0])
for index in start..<end:
let draw = canvas.draws[index]
if draw.clip.x >= width or draw.clip.y >= height:
continue
var scissor = VkRect2D(offset = VkOffset2D(x = (i32)draw.clip.x, y = (i32)draw.clip.y),
extent = VkExtent2D(width = (u32)canvas_min((usize)draw.clip.width, (usize)(width - draw.clip.x)),
height = (u32)canvas_min((usize)draw.clip.height, (usize)(height - draw.clip.y))))
if scissor.extent.width == 0 or scissor.extent.height == 0:
continue
var viewport = VkViewport(width = (f32)width, height = (f32)height, maxDepth = 1.0)
if let region = draw.viewport:
viewport.x = (f32)region.x
viewport.y = (f32)region.y
viewport.width = (f32)region.width
viewport.height = (f32)region.height
vkCmdSetViewport(command, 0, 1, &viewport)
vkCmdSetScissor(command, 0, 1, &scissor)
# Zero clamp requires no optional depthBiasClamp device feature.
vkCmdSetDepthBias(command,0.0,0.0,draw.depth_slope)
if let mesh = draw.mesh:
vkCmdBindPipeline(command, VK_PIPELINE_BIND_POINT_GRAPHICS, formats.mesh[(usize)(u8)mesh.kind])
var mesh_set = upload.mesh_descriptors[index]
vkCmdBindDescriptorSets(command, VK_PIPELINE_BIND_POINT_GRAPHICS, device.mesh_pipeline_layout, 0, 1, &mesh_set, 0, none)
vkCmdDraw(command, (u32)draw.count, 1, 0, 0)
continue
var selected = formats.depth_test if draw.depth else formats.overlay
if let custom = draw.pipeline:
selected = try vulkan_pipeline_for(device, (VulkanPipeline*)custom.native, formats.format, client_variant(draw))
if draw.geometry != none: selected = formats.geometry
vkCmdBindPipeline(command, VK_PIPELINE_BIND_POINT_GRAPHICS, selected)
var descriptor = upload.descriptors[index]
vkCmdBindDescriptorSets(command, VK_PIPELINE_BIND_POINT_GRAPHICS, device.layout, 0, 1, &descriptor, 0, none)
if draw.uniform_count > 0:
var uniforms = draw.uniforms
vkCmdPushConstants(command, device.layout, VK_SHADER_STAGE_FRAGMENT_BIT, 0, (u32)uniform_limit, &uniforms)
else:
var params = draw.params
if encoded:
params.mode = params.mode | draw_encoded
vkCmdPushConstants(command, device.layout, VK_SHADER_STAGE_FRAGMENT_BIT, 0, 48, ¶ms)
if let quads = draw.quads:
# A strip of four vertices per quad, as many as counted.
if let arguments = quads.arguments:
vkCmdDrawIndirect(command, ((VulkanBuffer*)arguments.native).buffer, (u64)quads.arguments_offset, 1, 16)
else:
vkCmdDraw(command, quad_vertex_count, (u32)quads.count, 0, 0)
continue
if draw.instanced:
# Six vertices per rectangle, the draw's run of instances.
vkCmdDraw(command, 6, (u32)draw.count, 0, (u32)draw.first)
else:
vkCmdDraw(command, (u32)draw.count, 1, (u32)draw.first, 0)
vkCmdEndRenderPass(command)
if last: return
vulkan_copy_depth(device, command, depth_image, width, height)
start = end
first = false
## Copy `width` by `height` of the depth attachment `depth_image` (stored by
## the pass that just ended) to the device's depth copy, and make both ready:
## the attachment for the next pass, the copy for sampling.
func vulkan_copy_depth(device: VulkanDevice*, command: u64, depth_image: u64, width: u32, height: u32):
let depth_range = VkImageSubresourceRange(aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT, levelCount = 1, layerCount = 1)
let tests = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT
let depth_access = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT
var before: VkImageMemoryBarrier[2] = [
VkImageMemoryBarrier(sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, srcAccessMask = depth_access, dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT,
oldLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, image = depth_image, subresourceRange = depth_range),
# Draws that sampled the previous copy are done before it is written.
VkImageMemoryBarrier(sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, srcAccessMask = VK_ACCESS_SHADER_READ_BIT, dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
oldLayout = device.depth_copy_layout, newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, image = device.depth_copy_image, subresourceRange = depth_range)]
vkCmdPipelineBarrier(command, tests | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, none, 0, none, 2, &before[0])
let layers = VkImageSubresourceLayers(aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT, layerCount = 1)
var region = VkImageCopy(srcSubresource = layers, dstSubresource = layers, extent = VkExtent3D(width = width, height = height, depth = 1))
vkCmdCopyImage(command, depth_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, device.depth_copy_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ®ion)
var after: VkImageMemoryBarrier[2] = [
VkImageMemoryBarrier(sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT, dstAccessMask = depth_access,
oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, newLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, image = depth_image, subresourceRange = depth_range),
VkImageMemoryBarrier(sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT, dstAccessMask = VK_ACCESS_SHADER_READ_BIT,
oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, image = device.depth_copy_image, subresourceRange = depth_range)]
vkCmdPipelineBarrier(command, VK_PIPELINE_STAGE_TRANSFER_BIT, tests | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, none, 0, none, 2, &after[0])
device.depth_copy_layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
## Record that submission `serial` reads a quad draw's buffers.
func vulkan_quads_used(quads: const QuadDraw*, serial: u64):
if serial == 0: return
((VulkanBuffer*)quads.records.native).last_use = serial
if let order = quads.order: ((VulkanBuffer*)order.native).last_use = serial
if let arguments = quads.arguments: ((VulkanBuffer*)arguments.native).last_use = serial
func vulkan_drain(device: VulkanDevice*):
_ = vkDeviceWaitIdle(device.device)
vulkan_idle(device)
func vulkan_poison(state: VulkanSurface*):
state.poisoned = true
func vulkan_render(device: VulkanDevice*, host: window.Presentation, state: VulkanSurface*, canvas: Canvas, color: Color) -> PresentResult!:
if state.poisoned:
error(execution_failed, "a previous Vulkan submission failed; recreate the surface")
if not try host.visible():
return PresentResult.skipped
let size = try host.size()
if size.pixel_width <= 0.0 or size.pixel_height <= 0.0:
return PresentResult.skipped
if size.pixel_width > 16384.0 or size.pixel_height > 16384.0:
error(surface_too_large, "Vulkan presentation supports at most 16384 pixels per dimension")
let width = (u32)size.pixel_width
let height = (u32)size.pixel_height
if state.dirty or state.width != width or state.height != height:
try vulkan_swapchain(device, state, width, height)
if state.swapchain == 0:
return PresentResult.skipped
let formats = try vulkan_format_state(device, state.format)
# What was recorded before the frame (its textures' passes, uploads) is
# submitted first; the frame's draw data is then for its own submission.
try vulkan_flush(device)
if reads_scene_depth_anywhere(&canvas): try vulkan_depth_copy_for(device, width, height)
let upload = try vulkan_upload(device, canvas)
defer vulkan_upload_destroy(device, upload)
try vulkan_check(vkResetCommandPool(device.device, state.pool, 0), "the Vulkan command pool could not be reset")
var index: u32 = 0
let acquired = vkAcquireNextImageKHR(device.device, state.swapchain, 1000000000, state.acquired, 0, &index)
if acquired == VK_NOT_READY or acquired == VK_TIMEOUT:
return PresentResult.skipped
if acquired == VK_ERROR_OUT_OF_DATE_KHR:
state.dirty = true
return PresentResult.skipped
if acquired != VK_SUCCESS and acquired != VK_SUBOPTIMAL_KHR:
error(execution_failed, "Vulkan could not acquire a presentation image")
# Never reuse synchronization after a partially failed submission.
errdefer vulkan_poison(state)
# A failure after queue submission still waits before releasing upload memory.
errdefer vulkan_drain(device)
# The frame takes the next serial and fence of the device's ring, and is
# timed like every submission.
let slot = try vulkan_reserve(device)
var begin = VkCommandBufferBeginInfo(sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT)
try vulkan_check(vkBeginCommandBuffer(state.command, &begin), "Vulkan command recording could not begin")
vulkan_time_start(device, state.command)
# Presentation waits for the queue below, so the images it samples need no serial.
try vulkan_encode(device, state.command, formats, formats.pass_present, state.images[(usize)index].framebuffer, canvas, upload,
Color(color.red, color.green, color.blue, 1.0), state.width, state.height, 0, state.encoded, state.depth_image)
vulkan_time_end(device, state.command)
try vulkan_check(vkEndCommandBuffer(state.command), "Vulkan command recording could not finish")
var wait_stage: u32 = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
var signal = state.images[(usize)index].presented
var submit = VkSubmitInfo(sType = VK_STRUCTURE_TYPE_SUBMIT_INFO, waitSemaphoreCount = 1, pWaitSemaphores = &state.acquired,
pWaitDstStageMask = &wait_stage, commandBufferCount = 1, pCommandBuffers = &state.command,
signalSemaphoreCount = 1, pSignalSemaphores = &signal)
_ = try vulkan_submit_reserved(device, slot, &submit)
var present = VkPresentInfoKHR(sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, waitSemaphoreCount = 1, pWaitSemaphores = &signal,
swapchainCount = 1, pSwapchains = &state.swapchain, pImageIndices = &index)
let result = vkQueuePresentKHR(device.queue, &present)
try vulkan_check(vkQueueWaitIdle(device.queue), "Vulkan execution failed")
vulkan_idle(device)
if result == VK_ERROR_OUT_OF_DATE_KHR or result == VK_SUBOPTIMAL_KHR or acquired == VK_SUBOPTIMAL_KHR:
state.dirty = true
if result != VK_SUCCESS and result != VK_ERROR_OUT_OF_DATE_KHR and result != VK_SUBOPTIMAL_KHR:
error(execution_failed, "Vulkan presentation failed")
return PresentResult.submitted