dymokomi/luce-gpu
Source of release 0.5.1
0.5.1 / src / gpu / vulkan / render.lucb
#==============================================================================================
#
# render - Vulkan command recording and uploads
#
# DESCRIPTION:
# Vulkan command recording and buffer uploads for one pass: the vertex and coverage
# buffer, one descriptor set per draw naming the coverage buffer and the sampled image,
# and the encoding shared by presentation and offscreen passes.
#
#==============================================================================================
# mark: Vertex and coverage uploads ===========================================================
struct VulkanUpload:
var buffer: u64
var block: 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.buffer != 0: vkDestroyBuffer(device.device, upload.buffer, none)
if upload.block != 0: vkFreeMemory(device.device, upload.block, 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 buffer and descriptors to `slot`, to be freed when its
## submission completes, leaving `upload` holding nothing the device uses.
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
if upload.buffer != 0:
try vulkan_retire(slot, VulkanRetired(kind = vulkan_retired_buffer, handle = upload.buffer, allocation = VulkanAllocation(memory = upload.block)))
upload.buffer = 0
upload.block = 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
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 parameter_offset = (vertex_offset + vertex_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
var info = VkBufferCreateInfo(sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, size = (u64)bytes, usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT)
try vulkan_check(vkCreateBuffer(device.device, &info, none, &upload.buffer), "the Vulkan vertex buffer could not be created")
var requirements: VkMemoryRequirements
vkGetBufferMemoryRequirements(device.device, upload.buffer, &requirements)
upload.block = try vulkan_memory(device, requirements, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT)
try vulkan_check(vkBindBufferMemory(device.device, upload.buffer, upload.block, 0), "Vulkan vertex memory could not be bound")
var mapped: void*? = none
try vulkan_check(vkMapMemory(device.device, upload.block, 0, (u64)bytes, 0, &mapped), "Vulkan vertex memory could not be mapped")
let destination = mapped else error(failed, "Vulkan returned an empty memory mapping")
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)
for index in 0..<canvas.draw_count:
var uniforms = canvas.draws[index].geometry_uniforms
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
vkUnmapMemory(device.device, upload.block)
let count = (u32)canvas.draw_count
var pool_sizes: VkDescriptorPoolSize[2] = [
VkDescriptorPoolSize(descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, descriptorCount = count * 3 + (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, 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[7]
for slot in 0..<image_limit:
var image = placeholder
if let texture = draw.images[slot]:
image = (VulkanTexture*)texture.native
image_infos[slot] = VkDescriptorImageInfo(sampler = device.linear if draw.filter == Filter.linear else device.nearest,
imageView = image.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, range = 32)
if let geometry = draw.geometry:
let native = (VulkanGeometry*)geometry.native
geometry_info.buffer = native.buffer
geometry_info.range = native.bytes
var parameter_info = VkDescriptorBufferInfo(buffer = upload.buffer, offset = (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)
vkUpdateDescriptorSets(device.device, 7, &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, (u64)(mesh_offset + placed * 512))
placed += 1
return upload
# mark: Encoding and rendering ================================================================
## Record one render pass of `canvas` into `framebuffer` on `command`, 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.
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) -> !:
var clears: VkClearValue[2]
clears[0].color = [(f32)(color.red * color.alpha), (f32)(color.green * color.alpha), (f32)(color.blue * color.alpha), (f32)color.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)
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
var begin = VkRenderPassBeginInfo(sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, renderPass = pass, framebuffer = framebuffer,
renderArea = VkRect2D(extent = VkExtent2D(width = width, height = height)), clearValueCount = 2, pClearValues = &clears[0])
vkCmdBeginRenderPass(command, &begin, VK_SUBPASS_CONTENTS_INLINE)
if canvas.draw_count > 0:
var buffer = upload.buffer
var offset: u64 = (u64)vulkan_vertex_offset(canvas)
vkCmdBindVertexBuffers(command, 0, 1, &buffer, &offset)
for index in 0..<canvas.draw_count:
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)
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
vkCmdPushConstants(command, device.layout, VK_SHADER_STAGE_FRAGMENT_BIT, 0, 48, ¶ms)
vkCmdDraw(command, (u32)draw.count, 1, (u32)draw.first, 0)
vkCmdEndRenderPass(command)
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)
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)
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")
# 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)
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_check(vkQueueSubmit(device.queue, 1, &submit, 0), "Vulkan command submission failed")
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