Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-gpu

Source of release 0.5.4

0.5.4 / 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*)&parameters, 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 = &parameter_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, &params)
                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, &region)
    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