Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-gpu

Source of release 0.5.7

0.5.7 / 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

## Make what drawing `canvas` needs on first use: the shared drawing state and,
## for mesh draws, the mesh layouts. Both record uploads of their placeholders
## into the open recording, so a frame makes them before it submits that
## recording and takes the next slot for its own.
func vulkan_upload_ready(device: VulkanDevice*, canvas: Canvas) -> !:
    try vulkan_drawing(device)
    for draw in canvas.draws[..<canvas.draw_count]:
        if draw.mesh != none:
            try vulkan_mesh_ready(device)
            return

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_upload_ready(device, canvas)
    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
    # 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
    # A draw's set names its images, its vertex-stage buffers and the frame's
    # coverage; its parameters are bound at a dynamic offset. A draw whose set
    # would match the draw before's shares it, so a run of fills and text
    # (placeholder images, the same buffers) takes one set, not one each.
    upload.descriptors = try new u64[canvas.draw_count] --- in memory.heap
    let shared = try new usize[canvas.draw_count] --- in memory.heap
    defer free(shared) in memory.heap
    var unique: usize = 0
    var previous = VulkanDrawBindings()
    for index in 0..<canvas.draw_count:
        let bindings = vulkan_draw_bindings(device, &canvas.draws[index], upload.buffer, upload.base)
        if index == 0 or not vulkan_same_bindings(&bindings, &previous):
            unique += 1
        shared[index] = unique - 1
        previous = bindings
    let sets = (u32)unique
    var pool_sizes: VkDescriptorPoolSize[3] = [
        VkDescriptorPoolSize(descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, descriptorCount = sets * 3 + (u32)meshes * 8),
        VkDescriptorPoolSize(descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, descriptorCount = sets),
        VkDescriptorPoolSize(descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, descriptorCount = sets * (u32)image_limit)]
    var pool_info = VkDescriptorPoolCreateInfo(sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, maxSets = sets + (u32)meshes, poolSizeCount = 3, pPoolSizes = &pool_sizes[0])
    try vulkan_check(vkCreateDescriptorPool(device.device, &pool_info, none, &upload.descriptor_pool), "Vulkan draw descriptors could not be created")
    let layouts = try new u64[unique] --- in memory.heap
    defer free(layouts) in memory.heap
    let made = try new u64[unique] --- in memory.heap
    defer free(made) in memory.heap
    for index in 0..<unique:
        layouts[index] = device.descriptor_layout
    var set_info = VkDescriptorSetAllocateInfo(sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, descriptorPool = upload.descriptor_pool, descriptorSetCount = sets, pSetLayouts = layouts.data)
    try vulkan_check(vkAllocateDescriptorSets(device.device, &set_info, made.data), "Vulkan draw descriptors could not be allocated")
    var buffer_info = VkDescriptorBufferInfo(buffer = upload.buffer, offset = upload.base, range = (u64)mask_bytes)
    # Every draw's parameters, from the first draw's block; a draw adds its own offset.
    var parameter_info = VkDescriptorBufferInfo(buffer = upload.buffer, offset = upload.base + (u64)parameter_offset, range = 112)
    for index in 0..<canvas.draw_count:
        upload.descriptors[index] = made[shared[index]]
        if index > 0 and shared[index] == shared[index - 1]:
            continue
        var bindings = vulkan_draw_bindings(device, &canvas.draws[index], upload.buffer, upload.base)
        let set = made[shared[index]]
        var writes: VkWriteDescriptorSet[8]
        for slot in 0..<image_limit:
            writes[slot] = VkWriteDescriptorSet(sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, dstSet = set, dstBinding = (u32)slot + 1, descriptorCount = 1,
                                                descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, pImageInfo = &bindings.images[slot])
        writes[4] = VkWriteDescriptorSet(sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, dstSet = set, dstBinding = 5, descriptorCount = 1,
                                         descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, pBufferInfo = &buffer_info)
        writes[5] = VkWriteDescriptorSet(sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, dstSet = set, dstBinding = 6, descriptorCount = 1, descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, pBufferInfo = &bindings.geometry)
        writes[6] = VkWriteDescriptorSet(sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, dstSet = set, dstBinding = 7, descriptorCount = 1, descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC, pBufferInfo = &parameter_info)
        writes[7] = VkWriteDescriptorSet(sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, dstSet = set, dstBinding = 8, descriptorCount = 1, descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, pBufferInfo = &bindings.order)
        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

## What a draw's set names besides the frame's coverage and parameters: its
## images (the placeholder where it has none, the scene depth copy where it
## reads it) and its vertex stage's geometry and order buffers.
struct VulkanDrawBindings:
    var images: VkDescriptorImageInfo[4]
    var geometry: VkDescriptorBufferInfo
    var order: VkDescriptorBufferInfo

func vulkan_draw_bindings(device: VulkanDevice*, draw: const Draw*, buffer: u64, base: u64) -> VulkanDrawBindings:
    var bindings = VulkanDrawBindings()
    let placeholder = device.placeholder else trap("Vulkan drawing state has no placeholder image")
    for slot in 0..<image_limit:
        var image = placeholder
        if let texture = draw.images[slot]:
            image = (VulkanTexture*)texture.native
        bindings.images[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.
            bindings.images[slot] = VkDescriptorImageInfo(sampler = device.nearest, imageView = device.depth_copy_view, imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL)
    bindings.geometry = VkDescriptorBufferInfo(buffer = buffer, offset = base, range = 32)
    if let geometry = draw.geometry:
        let native = (VulkanGeometry*)geometry.native
        bindings.geometry = VkDescriptorBufferInfo(buffer = native.buffer, offset = 0, range = native.bytes)
    # Binding 8 is read only by shade_quads' vertex stage (its order).
    bindings.order = bindings.geometry
    if let quads = draw.quads:
        let records = (VulkanBuffer*)quads.records.native
        bindings.geometry = VkDescriptorBufferInfo(buffer = records.buffer, range = records.bytes)
        bindings.order = bindings.geometry
        if let order = quads.order:
            let native = (VulkanBuffer*)order.native
            bindings.order = VkDescriptorBufferInfo(buffer = native.buffer, range = native.bytes)
    return bindings

func vulkan_same_bindings(a: const VulkanDrawBindings*, b: const VulkanDrawBindings*) -> bool:
    for slot in 0..<image_limit:
        if a.images[slot].sampler != b.images[slot].sampler or a.images[slot].imageView != b.images[slot].imageView:
            return false
    return vulkan_same_buffer(a.geometry, b.geometry) and vulkan_same_buffer(a.order, b.order)

func vulkan_same_buffer(a: VkDescriptorBufferInfo, b: VkDescriptorBufferInfo) -> bool:
    return a.buffer == b.buffer and a.offset == b.offset and a.range == b.range

# 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)
        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[mesh_variant(mesh)])
                    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]
                var parameters = (u32)(index * 256)
                vkCmdBindDescriptorSets(command, VK_PIPELINE_BIND_POINT_GRAPHICS, device.layout, 0, 1, &descriptor, 1, &parameters)
                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, and
    # the uploads of state its draws make on first use) is submitted first; the
    # frame's draw data is then for its own submission.
    try vulkan_upload_ready(device, canvas)
    try vulkan_flush(device)
    if reads_scene_depth_anywhere(&canvas): try vulkan_depth_copy_for(device, width, height)
    var upload = try vulkan_upload(device, canvas)
    defer vulkan_upload_destroy(device, upload)
    # The frame takes the next serial, fence and command buffer of the device's
    # ring, and is timed like every submission. Taking the slot waits, if the
    # ring is full, for the oldest submission: the only wait on the GPU here.
    let slot = try vulkan_reserve(device)
    let serial = device.submitted + 1
    let semaphore = state.acquired[(usize)(serial % (u64)vulkan_slot_limit)]
    try vulkan_check(vkResetCommandPool(device.device, slot.pool, 0), "the Vulkan command pool could not be reset")
    var index: u32 = 0
    let acquired = vkAcquireNextImageKHR(device.device, state.swapchain, 1000000000, semaphore, 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)
    var begin = VkCommandBufferBeginInfo(sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT)
    try vulkan_check(vkBeginCommandBuffer(slot.command, &begin), "Vulkan command recording could not begin")
    vulkan_time_start(device, slot.command)
    # The images the frame samples carry its serial, so none goes while it runs.
    try vulkan_encode(device, slot.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, serial, state.encoded, state.depth_image)
    vulkan_time_end(device, slot.command)
    try vulkan_check(vkEndCommandBuffer(slot.command), "Vulkan command recording could not finish")
    # Its descriptors are freed when the frame's submission completes.
    try vulkan_upload_retire(slot, &upload)
    var wait_stage: u32 = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT
    var signal = state.images[(usize)index].presented
    var waited = semaphore
    var submit = VkSubmitInfo(sType = VK_STRUCTURE_TYPE_SUBMIT_INFO, waitSemaphoreCount = 1, pWaitSemaphores = &waited,
                              pWaitDstStageMask = &wait_stage, commandBufferCount = 1, pCommandBuffers = &slot.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)
    # No wait for the GPU: the next frame records while this one runs, and
    # acquiring an image paces the loop to the display.
    let result = vkQueuePresentKHR(device.queue, &present)
    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