void VkeDrawCall::initDrawCommands(const uint32_t inCount, const uint32_t inCommandIndex){
VkPipelineLayout layout = m_renderer->getPipelineLayout();
VkPipeline pipeline = m_renderer->getPipeline();
VkDescriptorSet sceneDescriptor = m_renderer->getSceneDescriptorSet();
VkDescriptorSet *textureDescriptors = m_renderer->getTextureDescriptorSets();
VkBuffer sceneIndirectBuffer = m_renderer->getSceneIndirectBuffer();
VulkanDC *dc = VulkanDC::Get();
VulkanDC::Device *device = dc->getDefaultDevice();
VulkanDC::Device::Queue *queue = dc->getDefaultQueue();
VulkanAppContext *ctxt = VulkanAppContext::GetInstance();
vkResetCommandBuffer(m_draw_command[inCommandIndex], 0);
VkCommandBufferBeginInfo cmdBeginInfo = { VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };
cmdBeginInfo.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;
VKA_CHECK_ERROR(vkBeginCommandBuffer(m_draw_command[inCommandIndex], &cmdBeginInfo), "Could not begin command buffer.\n");
vkCmdBindPipeline(m_draw_command[inCommandIndex], VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
VkeVBO *theVBO = ctxt->getVBO();
VkeIBO *theIBO = ctxt->getIBO();
theVBO->bind(&m_draw_command[inCommandIndex]);
theIBO->bind(&m_draw_command[inCommandIndex]);
VkDescriptorSet sets[3] = { sceneDescriptor, textureDescriptors[0], m_transform_descriptor_set };
vkCmdBindDescriptorSets(m_draw_command[inCommandIndex], VK_PIPELINE_BIND_POINT_GRAPHICS, layout, 0, 3, sets, 0, NULL);
vkCmdDrawIndexedIndirect(m_draw_command[inCommandIndex], sceneIndirectBuffer, 0, inCount, sizeof(VkDrawIndexedIndirectCommand));
vkCmdDraw(m_draw_command[inCommandIndex], 1, 1, 0, 0);
vkEndCommandBuffer(m_draw_command[inCommandIndex]);
/*
Lock mutex to update generated call count.
*/
//std::lock_guard<std::mutex> lk(m_renderer->getSecondaryCmdBufferMutex());
/*
Increment the generated call count
*/
m_renderer->incrementDrawCallsGenerated();
}
VkResult CommandBuffers::reset()
{
VkResult result = VK_SUCCESS;
for (size_t i = 0; i < allCommandBuffers.size(); i++)
{
result = vkResetCommandBuffer(allCommandBuffers[i], commandBufferResetFlags);
if (result != VK_SUCCESS)
{
break;
}
}
return result;
}
void CommandBufferManager::ActivateCommandBuffer()
{
// Move to the next command buffer.
m_current_frame = (m_current_frame + 1) % NUM_COMMAND_BUFFERS;
FrameResources& resources = m_frame_resources[m_current_frame];
// Wait for the GPU to finish with all resources for this command buffer.
if (resources.needs_fence_wait)
{
VkResult res =
vkWaitForFences(g_vulkan_context->GetDevice(), 1, &resources.fence, true, UINT64_MAX);
if (res != VK_SUCCESS)
LOG_VULKAN_ERROR(res, "vkWaitForFences failed: ");
OnCommandBufferExecuted(m_current_frame);
}
// Reset fence to unsignaled before starting.
VkResult res = vkResetFences(g_vulkan_context->GetDevice(), 1, &resources.fence);
if (res != VK_SUCCESS)
LOG_VULKAN_ERROR(res, "vkResetFences failed: ");
// Reset command buffer to beginning since we can re-use the memory now
VkCommandBufferBeginInfo begin_info = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, nullptr,
VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, nullptr};
resources.init_command_buffer_used = false;
for (VkCommandBuffer command_buffer : resources.command_buffers)
{
res = vkResetCommandBuffer(command_buffer, 0);
if (res != VK_SUCCESS)
LOG_VULKAN_ERROR(res, "vkResetCommandBuffer failed: ");
res = vkBeginCommandBuffer(command_buffer, &begin_info);
if (res != VK_SUCCESS)
LOG_VULKAN_ERROR(res, "vkBeginCommandBuffer failed: ");
}
// Also can do the same for the descriptor pools
res = vkResetDescriptorPool(g_vulkan_context->GetDevice(), resources.descriptor_pool, 0);
if (res != VK_SUCCESS)
LOG_VULKAN_ERROR(res, "vkResetDescriptorPool failed: ");
}
int sample_main(int argc, char *argv[]) {
VkResult U_ASSERT_ONLY res;
struct sample_info info = {};
char sample_title[] = "Copy/Blit Image";
VkImageCreateInfo image_info;
VkImage bltSrcImage;
VkImage bltDstImage;
VkMemoryRequirements memReq;
VkMemoryAllocateInfo memAllocInfo;
VkDeviceMemory dmem;
unsigned char *pImgMem;
process_command_line_args(info, argc, argv);
init_global_layer_properties(info);
init_instance_extension_names(info);
init_device_extension_names(info);
init_instance(info, sample_title);
init_enumerate_device(info);
init_window_size(info, 640, 640);
init_connection(info);
init_window(info);
init_swapchain_extension(info);
VkSurfaceCapabilitiesKHR surfCapabilities;
res = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(info.gpus[0], info.surface,
&surfCapabilities);
if (!(surfCapabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_DST_BIT)) {
std::cout << "Surface cannot be destination of blit - abort \n";
exit(-1);
}
init_device(info);
init_command_pool(info);
init_command_buffer(info);
execute_begin_command_buffer(info);
init_device_queue(info);
init_swap_chain(info, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
VK_IMAGE_USAGE_TRANSFER_DST_BIT);
/* VULKAN_KEY_START */
VkFormatProperties formatProps;
vkGetPhysicalDeviceFormatProperties(info.gpus[0], info.format,
&formatProps);
assert(
(formatProps.linearTilingFeatures & VK_FORMAT_FEATURE_BLIT_SRC_BIT) &&
"Format cannot be used as transfer source");
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo;
presentCompleteSemaphoreCreateInfo.sType =
VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
presentCompleteSemaphoreCreateInfo.pNext = NULL;
presentCompleteSemaphoreCreateInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
res = vkCreateSemaphore(info.device, &presentCompleteSemaphoreCreateInfo,
NULL, &presentCompleteSemaphore);
assert(res == VK_SUCCESS);
// Get the index of the next available swapchain image:
res = vkAcquireNextImageKHR(info.device, info.swap_chain, UINT64_MAX,
presentCompleteSemaphore, VK_NULL_HANDLE,
&info.current_buffer);
// TODO: Deal with the VK_SUBOPTIMAL_KHR and VK_ERROR_OUT_OF_DATE_KHR
// return codes
assert(res == VK_SUCCESS);
// Create an image, map it, and write some values to the image
image_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
image_info.pNext = NULL;
image_info.imageType = VK_IMAGE_TYPE_2D;
image_info.format = info.format;
image_info.extent.width = info.width;
image_info.extent.height = info.height;
image_info.extent.depth = 1;
image_info.mipLevels = 1;
image_info.arrayLayers = 1;
image_info.samples = NUM_SAMPLES;
image_info.queueFamilyIndexCount = 0;
image_info.pQueueFamilyIndices = NULL;
image_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
image_info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
image_info.flags = 0;
image_info.tiling = VK_IMAGE_TILING_LINEAR;
image_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
res = vkCreateImage(info.device, &image_info, NULL, &bltSrcImage);
memAllocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
memAllocInfo.pNext = NULL;
vkGetImageMemoryRequirements(info.device, bltSrcImage, &memReq);
bool pass = memory_type_from_properties(info, memReq.memoryTypeBits,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
&memAllocInfo.memoryTypeIndex);
assert(pass);
memAllocInfo.allocationSize = memReq.size;
res = vkAllocateMemory(info.device, &memAllocInfo, NULL, &dmem);
res = vkBindImageMemory(info.device, bltSrcImage, dmem, 0);
set_image_layout(info, bltSrcImage, VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL);
res = vkEndCommandBuffer(info.cmd);
assert(res == VK_SUCCESS);
VkFence cmdFence;
init_fence(info, cmdFence);
VkPipelineStageFlags pipe_stage_flags =
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
VkSubmitInfo submit_info = {};
submit_info.pNext = NULL;
submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submit_info.waitSemaphoreCount = 1;
submit_info.pWaitSemaphores = &presentCompleteSemaphore;
submit_info.pWaitDstStageMask = &pipe_stage_flags;
submit_info.commandBufferCount = 1;
submit_info.pCommandBuffers = &info.cmd;
submit_info.signalSemaphoreCount = 0;
submit_info.pSignalSemaphores = NULL;
/* Queue the command buffer for execution */
res = vkQueueSubmit(info.queue, 1, &submit_info, cmdFence);
assert(res == VK_SUCCESS);
/* Make sure command buffer is finished before mapping */
do {
res =
vkWaitForFences(info.device, 1, &cmdFence, VK_TRUE, FENCE_TIMEOUT);
} while (res == VK_TIMEOUT);
assert(res == VK_SUCCESS);
vkDestroyFence(info.device, cmdFence, NULL);
res = vkMapMemory(info.device, dmem, 0, memReq.size, 0, (void **)&pImgMem);
// Checkerboard of 8x8 pixel squares
for (int row = 0; row < info.height; row++) {
for (int col = 0; col < info.width; col++) {
unsigned char rgb = (((row & 0x8) == 0) ^ ((col & 0x8) == 0)) * 255;
pImgMem[0] = rgb;
pImgMem[1] = rgb;
pImgMem[2] = rgb;
pImgMem[3] = 255;
pImgMem += 4;
}
}
// Flush the mapped memory and then unmap it Assume it isn't coherent since
// we didn't really confirm
VkMappedMemoryRange memRange;
memRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
memRange.pNext = NULL;
memRange.memory = dmem;
memRange.offset = 0;
memRange.size = memReq.size;
res = vkFlushMappedMemoryRanges(info.device, 1, &memRange);
vkUnmapMemory(info.device, dmem);
vkResetCommandBuffer(info.cmd, 0);
execute_begin_command_buffer(info);
set_image_layout(info, bltSrcImage, VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_GENERAL,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
bltDstImage = info.buffers[info.current_buffer].image;
// init_swap_chain will create the images as color attachment optimal
// but we want transfer dst optimal
set_image_layout(info, bltDstImage, VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
// Do a 32x32 blit to all of the dst image - should get big squares
VkImageBlit region;
region.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
region.srcSubresource.mipLevel = 0;
region.srcSubresource.baseArrayLayer = 0;
region.srcSubresource.layerCount = 1;
region.srcOffsets[0].x = 0;
region.srcOffsets[0].y = 0;
region.srcOffsets[0].z = 0;
region.srcOffsets[1].x = 32;
region.srcOffsets[1].y = 32;
region.srcOffsets[1].z = 1;
region.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
region.dstSubresource.mipLevel = 0;
region.dstSubresource.baseArrayLayer = 0;
region.dstSubresource.layerCount = 1;
region.dstOffsets[0].x = 0;
region.dstOffsets[0].y = 0;
region.dstOffsets[0].z = 0;
region.dstOffsets[1].x = info.width;
region.dstOffsets[1].y = info.height;
region.dstOffsets[1].z = 1;
vkCmdBlitImage(info.cmd, bltSrcImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
bltDstImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1,
®ion, VK_FILTER_LINEAR);
// Do a image copy to part of the dst image - checks should stay small
VkImageCopy cregion;
cregion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
cregion.srcSubresource.mipLevel = 0;
cregion.srcSubresource.baseArrayLayer = 0;
cregion.srcSubresource.layerCount = 1;
cregion.srcOffset.x = 0;
cregion.srcOffset.y = 0;
cregion.srcOffset.z = 0;
cregion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
cregion.dstSubresource.mipLevel = 0;
cregion.dstSubresource.baseArrayLayer = 0;
cregion.dstSubresource.layerCount = 1;
cregion.dstOffset.x = 256;
cregion.dstOffset.y = 256;
cregion.dstOffset.z = 0;
cregion.extent.width = 128;
cregion.extent.height = 128;
cregion.extent.depth = 1;
vkCmdCopyImage(info.cmd, bltSrcImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
bltDstImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1,
&cregion);
VkImageMemoryBarrier prePresentBarrier = {};
prePresentBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
prePresentBarrier.pNext = NULL;
prePresentBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
prePresentBarrier.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
prePresentBarrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
prePresentBarrier.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
prePresentBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
prePresentBarrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
prePresentBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
prePresentBarrier.subresourceRange.baseMipLevel = 0;
prePresentBarrier.subresourceRange.levelCount = 1;
prePresentBarrier.subresourceRange.baseArrayLayer = 0;
prePresentBarrier.subresourceRange.layerCount = 1;
prePresentBarrier.image = info.buffers[info.current_buffer].image;
vkCmdPipelineBarrier(info.cmd, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, NULL, 0,
NULL, 1, &prePresentBarrier);
res = vkEndCommandBuffer(info.cmd);
VkFenceCreateInfo fenceInfo;
VkFence drawFence;
fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceInfo.pNext = NULL;
fenceInfo.flags = 0;
vkCreateFence(info.device, &fenceInfo, NULL, &drawFence);
submit_info.pNext = NULL;
submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submit_info.waitSemaphoreCount = 0;
submit_info.pWaitSemaphores = NULL;
submit_info.pWaitDstStageMask = NULL;
submit_info.commandBufferCount = 1;
submit_info.pCommandBuffers = &info.cmd;
submit_info.signalSemaphoreCount = 0;
submit_info.pSignalSemaphores = NULL;
/* Queue the command buffer for execution */
res = vkQueueSubmit(info.queue, 1, &submit_info, drawFence);
assert(res == VK_SUCCESS);
res = vkQueueWaitIdle(info.queue);
assert(res == VK_SUCCESS);
/* Now present the image in the window */
VkPresentInfoKHR present;
present.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
present.pNext = NULL;
present.swapchainCount = 1;
present.pSwapchains = &info.swap_chain;
present.pImageIndices = &info.current_buffer;
present.pWaitSemaphores = NULL;
present.waitSemaphoreCount = 0;
present.pResults = NULL;
/* Make sure command buffer is finished before presenting */
do {
res =
vkWaitForFences(info.device, 1, &drawFence, VK_TRUE, FENCE_TIMEOUT);
} while (res == VK_TIMEOUT);
assert(res == VK_SUCCESS);
res = vkQueuePresentKHR(info.queue, &present);
assert(res == VK_SUCCESS);
wait_seconds(1);
/* VULKAN_KEY_END */
if (info.save_images)
write_ppm(info, "copyblitimage");
vkDestroySemaphore(info.device, presentCompleteSemaphore, NULL);
vkDestroyFence(info.device, drawFence, NULL);
vkDestroyImage(info.device, bltSrcImage, NULL);
vkFreeMemory(info.device, dmem, NULL);
destroy_swap_chain(info);
destroy_command_buffer(info);
destroy_command_pool(info);
destroy_device(info);
destroy_window(info);
destroy_instance(info);
return 0;
}
void vkeGameRendererDynamic::generateDrawCommands(){
//Start generating draw commands.
VulkanDC *dc = VulkanDC::Get();
VulkanDC::Device *device = dc->getDefaultDevice();
VkClearValue clearValues[3];
colorClearValues(&clearValues[0], 1.0, 1.0, 1.0);
depthStencilClearValues(&clearValues[1]);//default#
colorClearValues(&clearValues[2], 0.0, 0.0, 0.0);
/*
Dispatch threads to create the secondary
command buffers.
*/
m_calls_generated = 0;
for (uint32_t i = 0; i < m_max_draw_calls; ++i){
m_draw_calls[i]->initDrawCommands(m_node_data->count(), m_current_buffer_index);
}
/*
Begin setting up the primary command buffer.
*/
VkCommandBufferBeginInfo cmdBeginInfo = { VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };
cmdBeginInfo.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;
VKA_CHECK_ERROR(vkResetCommandBuffer(m_primary_commands[m_current_buffer_index], 0),"Could not reset primary command buffer");
VKA_CHECK_ERROR(vkBeginCommandBuffer(m_primary_commands[m_current_buffer_index], &cmdBeginInfo), "Could not begin primary command buffer.\n");
uint32_t cnt = m_node_data->count();
VkDeviceSize sz = (sizeof(VkeNodeUniform) * cnt) + (m_instance_count * 64);
vkCmdUpdateBuffer(m_primary_commands[m_current_buffer_index], m_uniforms_buffer, 0, sz, (const uint32_t *)m_uniforms_local);
m_camera->updateCameraCmd(m_primary_commands[m_current_buffer_index]);
renderPassBegin(&m_primary_commands[m_current_buffer_index], m_render_pass, m_framebuffers[m_current_buffer_index], 0, 0, m_width, m_height, clearValues, 3, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
VkViewport vp;
VkRect2D sc;
vp.x = 0;
vp.y = 0;
vp.height = (float)(m_height);
vp.width = (float)(m_width);
vp.minDepth = 0.0f;
vp.maxDepth = 1.0f;
sc.offset.x = 0;
sc.offset.y = 0;
sc.extent.width = vp.width;
sc.extent.height = vp.height;
vkCmdSetViewport(m_primary_commands[m_current_buffer_index], 0, 1, &vp);
vkCmdSetScissor(m_primary_commands[m_current_buffer_index], 0, 1, &sc);
/*
Wait here until the secondary commands are ready.
*/
VkCommandBuffer secondaryCommands[11];
secondaryCommands[0] = m_terrain_command[m_current_buffer_index];
for (uint32_t i = 0; i < m_max_draw_calls; ++i){
secondaryCommands[i+1] = m_draw_calls[i]->getDrawCommand(m_current_buffer_index);
}
vkCmdExecuteCommands(m_primary_commands[m_current_buffer_index], 1+m_max_draw_calls, secondaryCommands);
vkCmdEndRenderPass(m_primary_commands[m_current_buffer_index]);
VkImageResolve blitInfo;
blitInfo.srcOffset.x = 0;
blitInfo.srcOffset.y = 0;
blitInfo.srcOffset.z = 0;
blitInfo.dstOffset.x = 0;
blitInfo.dstOffset.y = 0;
blitInfo.dstOffset.z = 0;
blitInfo.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
blitInfo.srcSubresource.mipLevel = 0;
blitInfo.srcSubresource.baseArrayLayer = 0;
blitInfo.srcSubresource.layerCount = 1;
blitInfo.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
blitInfo.dstSubresource.mipLevel = 0;
blitInfo.dstSubresource.baseArrayLayer = 0;
blitInfo.dstSubresource.layerCount = 1;
blitInfo.extent.width = m_width;
blitInfo.extent.height = m_height;
blitInfo.extent.depth = 1;
vkCmdResolveImage(
m_primary_commands[m_current_buffer_index],
m_color_attachment.image,
VK_IMAGE_LAYOUT_GENERAL,
m_resolve_attachment[m_current_buffer_index].image,
VK_IMAGE_LAYOUT_GENERAL,
1,
&blitInfo);
VKA_CHECK_ERROR(vkEndCommandBuffer(m_primary_commands[m_current_buffer_index]), "Could not end command buffer for draw command.\n");
}
void vkeGameRendererDynamic::generateDrawCommands(){
//Start generating draw commands.
VulkanDC *dc = VulkanDC::Get();
VulkanDC::Device *device = dc->getDefaultDevice();
VkClearValue clearValues[3];
/*
Dispatch threads to create the secondary
command buffers.
*/
m_calls_generated = 0;
for (uint32_t i = 0; i < m_max_draw_calls; ++i){
m_draw_calls[i]->initDrawCommands(m_node_data->count(), m_current_buffer_index);
}
/*
Begin setting up the primary command buffer.
*/
VkCommandBufferBeginInfo cmdBeginInfo = { VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };
cmdBeginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
vkResetCommandBuffer(m_primary_commands[m_current_buffer_index], 0);
vkResetCommandBuffer(m_update_commands[m_current_buffer_index], 0);
VKA_CHECK_ERROR(vkBeginCommandBuffer(m_update_commands[m_current_buffer_index], &cmdBeginInfo), "Could not begin primary command buffer.\n");
VkBufferMemoryBarrier bufBarrier = { VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER };
bufBarrier.dstAccessMask = VK_ACCESS_UNIFORM_READ_BIT;
bufBarrier.srcAccessMask = VK_ACCESS_HOST_WRITE_BIT;
bufBarrier.dstQueueFamilyIndex = 0;
bufBarrier.offset = 0;
bufBarrier.buffer = m_uniforms_buffer;
bufBarrier.srcQueueFamilyIndex = 0;
colorClearValues(&clearValues[0], 1.0, 1.0, 1.0);
depthStencilClearValues(&clearValues[1]);//default#
colorClearValues(&clearValues[2], 0.0, 0.0, 0.0);
uint32_t sz = (sizeof(VkeNodeUniform) * 100) + (64 * 64);
VkBufferCopy bufCopy;
bufCopy.dstOffset = 0;
bufCopy.srcOffset = 0;
bufCopy.size = sz;
vkCmdCopyBuffer(m_update_commands[m_current_buffer_index], m_uniforms_buffer_staging, m_uniforms_buffer, 1, &bufCopy);
vkCmdPipelineBarrier(
m_update_commands[m_current_buffer_index],
VK_PIPELINE_STAGE_VERTEX_SHADER_BIT,
VK_PIPELINE_STAGE_VERTEX_SHADER_BIT,
0,
0,
NULL,
1,
&bufBarrier,
0,
NULL);
VKA_CHECK_ERROR(vkEndCommandBuffer(m_update_commands[m_current_buffer_index]), "Could not end command buffer for draw command.\n");
VKA_CHECK_ERROR(vkBeginCommandBuffer(m_primary_commands[m_current_buffer_index], &cmdBeginInfo), "Could not begin primary command buffer.\n");
renderPassBegin(&m_primary_commands[m_current_buffer_index], m_render_pass, m_framebuffers[m_current_buffer_index], 0, 0, m_width, m_height, clearValues, 3, VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS);
VkViewport vp;
VkRect2D sc;
vp.x = 0;
vp.y = 0;
vp.height = (float)(m_height);
vp.width = (float)(m_width);
vp.minDepth = 0.0f;
vp.maxDepth = 1.0f;
sc.offset.x = 0;
sc.offset.y = 0;
sc.extent.width = vp.width;
sc.extent.height = vp.height;
vkCmdSetViewport(m_primary_commands[m_current_buffer_index], 0, 1, &vp);
vkCmdSetScissor(m_primary_commands[m_current_buffer_index], 0, 1, &sc);
/*
Wait here until the secondary commands are ready.
*/
VkCommandBuffer secondaryCommands[11];
secondaryCommands[0] = m_terrain_command[m_current_buffer_index];
for (uint32_t i = 0; i < m_max_draw_calls; ++i){
secondaryCommands[i + 1] = m_draw_calls[i]->getDrawCommand(m_current_buffer_index);
}
vkCmdExecuteCommands(m_primary_commands[m_current_buffer_index], 1 + m_max_draw_calls, secondaryCommands);
vkCmdEndRenderPass(m_primary_commands[m_current_buffer_index]);
VkImageResolve blitInfo;
blitInfo.srcOffset.x = 0;
blitInfo.srcOffset.y = 0;
blitInfo.srcOffset.z = 0;
blitInfo.dstOffset.x = 0;
blitInfo.dstOffset.y = 0;
blitInfo.dstOffset.z = 0;
blitInfo.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
blitInfo.srcSubresource.mipLevel = 0;
blitInfo.srcSubresource.baseArrayLayer = 0;
blitInfo.srcSubresource.layerCount = 1;
blitInfo.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
blitInfo.dstSubresource.mipLevel = 0;
blitInfo.dstSubresource.baseArrayLayer = 0;
blitInfo.dstSubresource.layerCount = 1;
blitInfo.extent.width = m_width;
blitInfo.extent.height = m_height;
blitInfo.extent.depth = 1;
vkCmdResolveImage(
m_primary_commands[m_current_buffer_index],
m_color_attachment.image,
VK_IMAGE_LAYOUT_GENERAL,
m_resolve_attachment[m_current_buffer_index].image,
VK_IMAGE_LAYOUT_GENERAL,
1,
&blitInfo);
VKA_CHECK_ERROR(vkEndCommandBuffer(m_primary_commands[m_current_buffer_index]), "Could not end command buffer for draw command.\n");
}
void createSwapChainAndImages(VulkanContext& context, VulkanSurfaceContext& surfaceContext) {
// Pick an image count and format. According to section 30.5 of VK 1.1, maxImageCount of zero
// apparently means "that there is no limit on the number of images, though there may be limits
// related to the total amount of memory used by presentable images."
uint32_t desiredImageCount = 2;
const uint32_t maxImageCount = surfaceContext.surfaceCapabilities.maxImageCount;
if (desiredImageCount < surfaceContext.surfaceCapabilities.minImageCount ||
(maxImageCount != 0 && desiredImageCount > maxImageCount)) {
utils::slog.e << "Swap chain does not support " << desiredImageCount << " images.\n";
desiredImageCount = surfaceContext.surfaceCapabilities.minImageCount;
}
surfaceContext.surfaceFormat = surfaceContext.surfaceFormats[0];
for (const VkSurfaceFormatKHR& format : surfaceContext.surfaceFormats) {
if (format.format == VK_FORMAT_R8G8B8A8_UNORM) {
surfaceContext.surfaceFormat = format;
break;
}
}
const auto compositionCaps = surfaceContext.surfaceCapabilities.supportedCompositeAlpha;
const auto compositeAlpha = (compositionCaps & VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR) ?
VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR : VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
// Create the low-level swap chain.
const auto size = surfaceContext.surfaceCapabilities.currentExtent;
VkSwapchainCreateInfoKHR createInfo {
.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
.surface = surfaceContext.surface,
.minImageCount = desiredImageCount,
.imageFormat = surfaceContext.surfaceFormat.format,
.imageColorSpace = surfaceContext.surfaceFormat.colorSpace,
.imageExtent = size,
.imageArrayLayers = 1,
.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
.preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR,
.compositeAlpha = compositeAlpha,
.presentMode = VK_PRESENT_MODE_FIFO_KHR,
.clipped = VK_TRUE
};
VkSwapchainKHR swapchain;
VkResult result = vkCreateSwapchainKHR(context.device, &createInfo, VKALLOC, &swapchain);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkGetPhysicalDeviceSurfaceFormatsKHR error.");
surfaceContext.swapchain = swapchain;
// Extract the VkImage handles from the swap chain.
uint32_t imageCount;
result = vkGetSwapchainImagesKHR(context.device, swapchain, &imageCount, nullptr);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkGetSwapchainImagesKHR count error.");
surfaceContext.swapContexts.resize(imageCount);
std::vector<VkImage> images(imageCount);
result = vkGetSwapchainImagesKHR(context.device, swapchain, &imageCount,
images.data());
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkGetSwapchainImagesKHR error.");
for (size_t i = 0; i < images.size(); ++i) {
surfaceContext.swapContexts[i].attachment = {
.image = images[i],
.format = surfaceContext.surfaceFormat.format
};
}
utils::slog.i
<< "vkCreateSwapchain"
<< ": " << size.width << "x" << size.height
<< ", " << surfaceContext.surfaceFormat.format
<< ", " << surfaceContext.surfaceFormat.colorSpace
<< ", " << imageCount
<< utils::io::endl;
// Create image views.
VkImageViewCreateInfo ivCreateInfo = {};
ivCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
ivCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
ivCreateInfo.format = surfaceContext.surfaceFormat.format;
ivCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
ivCreateInfo.subresourceRange.levelCount = 1;
ivCreateInfo.subresourceRange.layerCount = 1;
for (size_t i = 0; i < images.size(); ++i) {
ivCreateInfo.image = images[i];
result = vkCreateImageView(context.device, &ivCreateInfo, VKALLOC,
&surfaceContext.swapContexts[i].attachment.view);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkCreateImageView error.");
}
createSemaphore(context.device, &surfaceContext.imageAvailable);
createSemaphore(context.device, &surfaceContext.renderingFinished);
surfaceContext.depth = {};
}
void createDepthBuffer(VulkanContext& context, VulkanSurfaceContext& surfaceContext,
VkFormat depthFormat) {
assert(context.cmdbuffer);
// Create an appropriately-sized device-only VkImage.
const auto size = surfaceContext.surfaceCapabilities.currentExtent;
VkImage depthImage;
VkImageCreateInfo imageInfo {
.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
.imageType = VK_IMAGE_TYPE_2D,
.extent = { size.width, size.height, 1 },
.format = depthFormat,
.mipLevels = 1,
.arrayLayers = 1,
.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
.samples = VK_SAMPLE_COUNT_1_BIT,
};
VkResult error = vkCreateImage(context.device, &imageInfo, VKALLOC, &depthImage);
ASSERT_POSTCONDITION(!error, "Unable to create depth image.");
// Allocate memory for the VkImage and bind it.
VkMemoryRequirements memReqs;
vkGetImageMemoryRequirements(context.device, depthImage, &memReqs);
VkMemoryAllocateInfo allocInfo {
.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
.allocationSize = memReqs.size,
.memoryTypeIndex = selectMemoryType(context, memReqs.memoryTypeBits,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT)
};
error = vkAllocateMemory(context.device, &allocInfo, nullptr,
&surfaceContext.depth.memory);
ASSERT_POSTCONDITION(!error, "Unable to allocate depth memory.");
error = vkBindImageMemory(context.device, depthImage, surfaceContext.depth.memory, 0);
ASSERT_POSTCONDITION(!error, "Unable to bind depth memory.");
// Create a VkImageView so that we can attach depth to the framebuffer.
VkImageView depthView;
VkImageViewCreateInfo viewInfo {
.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
.image = depthImage,
.viewType = VK_IMAGE_VIEW_TYPE_2D,
.format = depthFormat,
.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT,
.subresourceRange.levelCount = 1,
.subresourceRange.layerCount = 1,
};
error = vkCreateImageView(context.device, &viewInfo, VKALLOC, &depthView);
ASSERT_POSTCONDITION(!error, "Unable to create depth view.");
// Transition the depth image into an optimal layout.
VkImageMemoryBarrier barrier {
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.newLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.image = depthImage,
.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT,
.subresourceRange.levelCount = 1,
.subresourceRange.layerCount = 1,
.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT
};
vkCmdPipelineBarrier(context.cmdbuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier);
// Go ahead and set the depth attachment fields, which serves as a signal to VulkanDriver that
// it is now ready.
surfaceContext.depth.view = depthView;
surfaceContext.depth.image = depthImage;
surfaceContext.depth.format = depthFormat;
}
void transitionDepthBuffer(VulkanContext& context, VulkanSurfaceContext& sc, VkFormat depthFormat) {
// Begin a new command buffer solely for the purpose of transitioning the image layout.
SwapContext& swap = getSwapContext(context);
VkResult result = vkWaitForFences(context.device, 1, &swap.fence, VK_FALSE, UINT64_MAX);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkWaitForFences error.");
result = vkResetFences(context.device, 1, &swap.fence);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkResetFences error.");
VkCommandBuffer cmdbuffer = swap.cmdbuffer;
result = vkResetCommandBuffer(cmdbuffer, 0);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkResetCommandBuffer error.");
VkCommandBufferBeginInfo beginInfo = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
};
result = vkBeginCommandBuffer(cmdbuffer, &beginInfo);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkBeginCommandBuffer error.");
context.cmdbuffer = cmdbuffer;
// Create the depth buffer and issue a pipeline barrier command.
createDepthBuffer(context, sc, depthFormat);
// Flush the command buffer.
result = vkEndCommandBuffer(context.cmdbuffer);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkEndCommandBuffer error.");
context.cmdbuffer = nullptr;
VkSubmitInfo submitInfo {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
.commandBufferCount = 1,
.pCommandBuffers = &swap.cmdbuffer,
};
result = vkQueueSubmit(context.graphicsQueue, 1, &submitInfo, swap.fence);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkQueueSubmit error.");
swap.submitted = false;
}
void createCommandBuffersAndFences(VulkanContext& context, VulkanSurfaceContext& surfaceContext) {
// Allocate command buffers.
VkCommandBufferAllocateInfo allocateInfo = {};
allocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
allocateInfo.commandPool = context.commandPool;
allocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
allocateInfo.commandBufferCount = (uint32_t) surfaceContext.swapContexts.size();
std::vector<VkCommandBuffer> cmdbufs(allocateInfo.commandBufferCount);
VkResult result = vkAllocateCommandBuffers(context.device, &allocateInfo, cmdbufs.data());
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkAllocateCommandBuffers error.");
for (uint32_t i = 0; i < allocateInfo.commandBufferCount; ++i) {
surfaceContext.swapContexts[i].cmdbuffer = cmdbufs[i];
}
// Create fences.
VkFenceCreateInfo fenceCreateInfo = {};
fenceCreateInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceCreateInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
for (uint32_t i = 0; i < allocateInfo.commandBufferCount; i++) {
result = vkCreateFence(context.device, &fenceCreateInfo, VKALLOC,
&surfaceContext.swapContexts[i].fence);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkCreateFence error.");
}
}
void destroySurfaceContext(VulkanContext& context, VulkanSurfaceContext& surfaceContext) {
for (SwapContext& swapContext : surfaceContext.swapContexts) {
vkFreeCommandBuffers(context.device, context.commandPool, 1, &swapContext.cmdbuffer);
vkDestroyFence(context.device, swapContext.fence, VKALLOC);
vkDestroyImageView(context.device, swapContext.attachment.view, VKALLOC);
swapContext.fence = VK_NULL_HANDLE;
swapContext.attachment.view = VK_NULL_HANDLE;
}
vkDestroySwapchainKHR(context.device, surfaceContext.swapchain, VKALLOC);
vkDestroySemaphore(context.device, surfaceContext.imageAvailable, VKALLOC);
vkDestroySemaphore(context.device, surfaceContext.renderingFinished, VKALLOC);
vkDestroySurfaceKHR(context.instance, surfaceContext.surface, VKALLOC);
vkDestroyImageView(context.device, surfaceContext.depth.view, VKALLOC);
vkDestroyImage(context.device, surfaceContext.depth.image, VKALLOC);
vkFreeMemory(context.device, surfaceContext.depth.memory, VKALLOC);
if (context.currentSurface == &surfaceContext) {
context.currentSurface = nullptr;
}
}
uint32_t selectMemoryType(VulkanContext& context, uint32_t flags, VkFlags reqs) {
for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++) {
if (flags & 1) {
if ((context.memoryProperties.memoryTypes[i].propertyFlags & reqs) == reqs) {
return i;
}
}
flags >>= 1;
}
ASSERT_POSTCONDITION(false, "Unable to find a memory type that meets requirements.");
return (uint32_t) ~0ul;
}
VkFormat getVkFormat(ElementType type, bool normalized) {
using ElementType = ElementType;
if (normalized) {
switch (type) {
// Single Component Types
case ElementType::BYTE: return VK_FORMAT_R8_SNORM;
case ElementType::UBYTE: return VK_FORMAT_R8_UNORM;
case ElementType::SHORT: return VK_FORMAT_R16_SNORM;
case ElementType::USHORT: return VK_FORMAT_R16_UNORM;
// Two Component Types
case ElementType::BYTE2: return VK_FORMAT_R8G8_SNORM;
case ElementType::UBYTE2: return VK_FORMAT_R8G8_UNORM;
case ElementType::SHORT2: return VK_FORMAT_R16G16_SNORM;
case ElementType::USHORT2: return VK_FORMAT_R16G16_UNORM;
// Three Component Types
case ElementType::BYTE3: return VK_FORMAT_R8G8B8_SNORM;
case ElementType::UBYTE3: return VK_FORMAT_R8G8B8_UNORM;
case ElementType::SHORT3: return VK_FORMAT_R16G16B16_SNORM;
case ElementType::USHORT3: return VK_FORMAT_R16G16B16_UNORM;
// Four Component Types
case ElementType::BYTE4: return VK_FORMAT_R8G8B8A8_SNORM;
case ElementType::UBYTE4: return VK_FORMAT_R8G8B8A8_UNORM;
case ElementType::SHORT4: return VK_FORMAT_R16G16B16A16_SNORM;
case ElementType::USHORT4: return VK_FORMAT_R16G16B16A16_UNORM;
default:
ASSERT_POSTCONDITION(false, "Normalized format does not exist.");
return VK_FORMAT_UNDEFINED;
}
}
switch (type) {
// Single Component Types
case ElementType::BYTE: return VK_FORMAT_R8_SINT;
case ElementType::UBYTE: return VK_FORMAT_R8_UINT;
case ElementType::SHORT: return VK_FORMAT_R16_SINT;
case ElementType::USHORT: return VK_FORMAT_R16_UINT;
case ElementType::HALF: return VK_FORMAT_R16_SFLOAT;
case ElementType::INT: return VK_FORMAT_R32_SINT;
case ElementType::UINT: return VK_FORMAT_R32_UINT;
case ElementType::FLOAT: return VK_FORMAT_R32_SFLOAT;
// Two Component Types
case ElementType::BYTE2: return VK_FORMAT_R8G8_SINT;
case ElementType::UBYTE2: return VK_FORMAT_R8G8_UINT;
case ElementType::SHORT2: return VK_FORMAT_R16G16_SINT;
case ElementType::USHORT2: return VK_FORMAT_R16G16_UINT;
case ElementType::HALF2: return VK_FORMAT_R16G16_SFLOAT;
case ElementType::FLOAT2: return VK_FORMAT_R32G32_SFLOAT;
// Three Component Types
case ElementType::BYTE3: return VK_FORMAT_R8G8B8_SINT;
case ElementType::UBYTE3: return VK_FORMAT_R8G8B8_UINT;
case ElementType::SHORT3: return VK_FORMAT_R16G16B16_SINT;
case ElementType::USHORT3: return VK_FORMAT_R16G16B16_UINT;
case ElementType::HALF3: return VK_FORMAT_R16G16B16_SFLOAT;
case ElementType::FLOAT3: return VK_FORMAT_R32G32B32_SFLOAT;
// Four Component Types
case ElementType::BYTE4: return VK_FORMAT_R8G8B8A8_SINT;
case ElementType::UBYTE4: return VK_FORMAT_R8G8B8A8_UINT;
case ElementType::SHORT4: return VK_FORMAT_R16G16B16A16_SINT;
case ElementType::USHORT4: return VK_FORMAT_R16G16B16A16_UINT;
case ElementType::HALF4: return VK_FORMAT_R16G16B16A16_SFLOAT;
case ElementType::FLOAT4: return VK_FORMAT_R32G32B32A32_SFLOAT;
}
return VK_FORMAT_UNDEFINED;
}
VkFormat getVkFormat(TextureFormat format) {
using TextureFormat = TextureFormat;
switch (format) {
// 8 bits per element.
case TextureFormat::R8: return VK_FORMAT_R8_UNORM;
case TextureFormat::R8_SNORM: return VK_FORMAT_R8_SNORM;
case TextureFormat::R8UI: return VK_FORMAT_R8_UINT;
case TextureFormat::R8I: return VK_FORMAT_R8_SINT;
case TextureFormat::STENCIL8: return VK_FORMAT_S8_UINT;
// 16 bits per element.
case TextureFormat::R16F: return VK_FORMAT_R16_SFLOAT;
case TextureFormat::R16UI: return VK_FORMAT_R16_UINT;
case TextureFormat::R16I: return VK_FORMAT_R16_SINT;
case TextureFormat::RG8: return VK_FORMAT_R8G8_UNORM;
case TextureFormat::RG8_SNORM: return VK_FORMAT_R8G8_SNORM;
case TextureFormat::RG8UI: return VK_FORMAT_R8G8_UINT;
case TextureFormat::RG8I: return VK_FORMAT_R8G8_SINT;
case TextureFormat::RGB565: return VK_FORMAT_R5G6B5_UNORM_PACK16;
case TextureFormat::RGB5_A1: return VK_FORMAT_R5G5B5A1_UNORM_PACK16;
case TextureFormat::RGBA4: return VK_FORMAT_R4G4B4A4_UNORM_PACK16;
case TextureFormat::DEPTH16: return VK_FORMAT_D16_UNORM;
// 24 bits per element. In practice, very few GPU vendors support these. For simplicity
// we just assume they are not supported, not bothering to query the device capabilities.
// Note that VK_FORMAT_ enums for 24-bit formats exist, but are meant for vertex attributes.
case TextureFormat::RGB8:
case TextureFormat::SRGB8:
case TextureFormat::RGB8_SNORM:
case TextureFormat::RGB8UI:
case TextureFormat::RGB8I:
case TextureFormat::DEPTH24:
return VK_FORMAT_UNDEFINED;
// 32 bits per element.
case TextureFormat::R32F: return VK_FORMAT_R32_SFLOAT;
case TextureFormat::R32UI: return VK_FORMAT_R32_UINT;
case TextureFormat::R32I: return VK_FORMAT_R32_SINT;
case TextureFormat::RG16F: return VK_FORMAT_R16G16_SFLOAT;
case TextureFormat::RG16UI: return VK_FORMAT_R16G16_UINT;
case TextureFormat::RG16I: return VK_FORMAT_R16G16_SINT;
case TextureFormat::R11F_G11F_B10F: return VK_FORMAT_B10G11R11_UFLOAT_PACK32;
case TextureFormat::RGB9_E5: return VK_FORMAT_E5B9G9R9_UFLOAT_PACK32;
case TextureFormat::RGBA8: return VK_FORMAT_R8G8B8A8_UNORM;
case TextureFormat::SRGB8_A8: return VK_FORMAT_R8G8B8A8_SRGB;
case TextureFormat::RGBA8_SNORM: return VK_FORMAT_R8G8B8A8_SNORM;
case TextureFormat::RGBM: return VK_FORMAT_R8G8B8A8_UNORM;
case TextureFormat::RGB10_A2: return VK_FORMAT_A2R10G10B10_UNORM_PACK32;
case TextureFormat::RGBA8UI: return VK_FORMAT_R8G8B8A8_UINT;
case TextureFormat::RGBA8I: return VK_FORMAT_R8G8B8A8_SINT;
case TextureFormat::DEPTH32F: return VK_FORMAT_D32_SFLOAT;
case TextureFormat::DEPTH24_STENCIL8: return VK_FORMAT_D24_UNORM_S8_UINT;
case TextureFormat::DEPTH32F_STENCIL8: return VK_FORMAT_D32_SFLOAT_S8_UINT;
// 48 bits per element. Note that many GPU vendors do not support these.
case TextureFormat::RGB16F: return VK_FORMAT_R16G16B16_SFLOAT;
case TextureFormat::RGB16UI: return VK_FORMAT_R16G16B16_UINT;
case TextureFormat::RGB16I: return VK_FORMAT_R16G16B16_SINT;
// 64 bits per element.
case TextureFormat::RG32F: return VK_FORMAT_R32G32_SFLOAT;
case TextureFormat::RG32UI: return VK_FORMAT_R32G32_UINT;
case TextureFormat::RG32I: return VK_FORMAT_R32G32_SINT;
case TextureFormat::RGBA16F: return VK_FORMAT_R16G16B16A16_SFLOAT;
case TextureFormat::RGBA16UI: return VK_FORMAT_R16G16B16A16_UINT;
case TextureFormat::RGBA16I: return VK_FORMAT_R16G16B16A16_SINT;
// 96-bits per element.
case TextureFormat::RGB32F: return VK_FORMAT_R32G32B32_SFLOAT;
case TextureFormat::RGB32UI: return VK_FORMAT_R32G32B32_UINT;
case TextureFormat::RGB32I: return VK_FORMAT_R32G32B32_SINT;
// 128-bits per element
case TextureFormat::RGBA32F: return VK_FORMAT_R32G32B32A32_SFLOAT;
case TextureFormat::RGBA32UI: return VK_FORMAT_R32G32B32A32_UINT;
case TextureFormat::RGBA32I: return VK_FORMAT_R32G32B32A32_SINT;
default:
return VK_FORMAT_UNDEFINED;
}
}
uint32_t getBytesPerPixel(TextureFormat format) {
return details::FTexture::getFormatSize(format);
}
// See also FTexture::computeTextureDataSize, which takes a public-facing Texture format rather
// than a driver-level Texture format, and can account for a specified byte alignment.
uint32_t computeSize(TextureFormat format, uint32_t w, uint32_t h, uint32_t d) {
const size_t bytesPerTexel = details::FTexture::getFormatSize(format);
return bytesPerTexel * w * h * d;
}
SwapContext& getSwapContext(VulkanContext& context) {
VulkanSurfaceContext& surface = *context.currentSurface;
return surface.swapContexts[surface.currentSwapIndex];
}
bool hasPendingWork(VulkanContext& context) {
if (context.pendingWork.size() > 0) {
return true;
}
if (context.currentSurface) {
for (auto& swapContext : context.currentSurface->swapContexts) {
if (swapContext.pendingWork.size() > 0) {
return true;
}
}
}
return false;
}
VkCompareOp getCompareOp(SamplerCompareFunc func) {
using Compare = driver::SamplerCompareFunc;
switch (func) {
case Compare::LE: return VK_COMPARE_OP_LESS_OR_EQUAL;
case Compare::GE: return VK_COMPARE_OP_GREATER_OR_EQUAL;
case Compare::L: return VK_COMPARE_OP_LESS;
case Compare::G: return VK_COMPARE_OP_GREATER;
case Compare::E: return VK_COMPARE_OP_EQUAL;
case Compare::NE: return VK_COMPARE_OP_NOT_EQUAL;
case Compare::A: return VK_COMPARE_OP_ALWAYS;
case Compare::N: return VK_COMPARE_OP_NEVER;
}
}
VkBlendFactor getBlendFactor(BlendFunction mode) {
using BlendFunction = filament::driver::BlendFunction;
switch (mode) {
case BlendFunction::ZERO: return VK_BLEND_FACTOR_ZERO;
case BlendFunction::ONE: return VK_BLEND_FACTOR_ONE;
case BlendFunction::SRC_COLOR: return VK_BLEND_FACTOR_SRC_COLOR;
case BlendFunction::ONE_MINUS_SRC_COLOR: return VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR;
case BlendFunction::DST_COLOR: return VK_BLEND_FACTOR_DST_COLOR;
case BlendFunction::ONE_MINUS_DST_COLOR: return VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR;
case BlendFunction::SRC_ALPHA: return VK_BLEND_FACTOR_SRC_ALPHA;
case BlendFunction::ONE_MINUS_SRC_ALPHA: return VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
case BlendFunction::DST_ALPHA: return VK_BLEND_FACTOR_DST_ALPHA;
case BlendFunction::ONE_MINUS_DST_ALPHA: return VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;
case BlendFunction::SRC_ALPHA_SATURATE: return VK_BLEND_FACTOR_SRC_ALPHA_SATURATE;
}
}
void waitForIdle(VulkanContext& context) {
// If there's no valid GPU then we have nothing to do.
if (!context.device) {
return;
}
// If there's no surface, then there's no command buffer.
if (!context.currentSurface) {
return;
}
// First, wait for submitted command buffer(s) to finish.
VkFence fences[2];
uint32_t nfences = 0;
auto& surfaceContext = *context.currentSurface;
for (auto& swapContext : surfaceContext.swapContexts) {
assert(nfences < 2);
if (swapContext.submitted && swapContext.fence) {
fences[nfences++] = swapContext.fence;
swapContext.submitted = false;
}
}
if (nfences > 0) {
vkWaitForFences(context.device, nfences, fences, VK_FALSE, ~0ull);
}
// If we don't have any pending work, we're done.
if (!hasPendingWork(context)) {
return;
}
// We cannot invoke arbitrary commands inside a render pass.
assert(context.currentRenderPass.renderPass == VK_NULL_HANDLE);
// Create a one-off command buffer to avoid the cost of swap chain acquisition and to avoid
// the possibility of SURFACE_LOST. Note that Vulkan command buffers use the Allocate/Free
// model instead of Create/Destroy and are therefore okay to create at a high frequency.
VkCommandBuffer cmdbuffer;
VkFence fence;
VkCommandBufferBeginInfo beginInfo { .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };
VkCommandBufferAllocateInfo allocateInfo = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
.commandPool = context.commandPool,
.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
.commandBufferCount = 1
};
VkFenceCreateInfo fenceCreateInfo { .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, };
vkAllocateCommandBuffers(context.device, &allocateInfo, &cmdbuffer);
vkCreateFence(context.device, &fenceCreateInfo, VKALLOC, &fence);
// Keep performing work until there's nothing queued up. This should never iterate more than
// a couple times because the only work we queue up is for resource transition / reclamation.
VkPipelineStageFlags waitDestStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
VkSubmitInfo submitInfo {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
.pWaitDstStageMask = &waitDestStageMask,
.commandBufferCount = 1,
.pCommandBuffers = &cmdbuffer,
};
int cycles = 0;
while (hasPendingWork(context)) {
if (cycles++ > 2) {
utils::slog.e << "Unexpected daisychaining of pending work." << utils::io::endl;
break;
}
for (auto& swapContext : context.currentSurface->swapContexts) {
vkBeginCommandBuffer(cmdbuffer, &beginInfo);
performPendingWork(context, swapContext, cmdbuffer);
vkEndCommandBuffer(cmdbuffer);
vkQueueSubmit(context.graphicsQueue, 1, &submitInfo, fence);
vkWaitForFences(context.device, 1, &fence, VK_FALSE, UINT64_MAX);
vkResetFences(context.device, 1, &fence);
vkResetCommandBuffer(cmdbuffer, 0);
}
}
vkFreeCommandBuffers(context.device, context.commandPool, 1, &cmdbuffer);
vkDestroyFence(context.device, fence, VKALLOC);
}
void acquireCommandBuffer(VulkanContext& context) {
// Ask Vulkan for the next image in the swap chain and update the currentSwapIndex.
VulkanSurfaceContext& surface = *context.currentSurface;
VkResult result = vkAcquireNextImageKHR(context.device, surface.swapchain,
UINT64_MAX, surface.imageAvailable, VK_NULL_HANDLE, &surface.currentSwapIndex);
ASSERT_POSTCONDITION(result != VK_ERROR_OUT_OF_DATE_KHR,
"Stale / resized swap chain not yet supported.");
ASSERT_POSTCONDITION(result == VK_SUBOPTIMAL_KHR || result == VK_SUCCESS,
"vkAcquireNextImageKHR error.");
SwapContext& swap = getSwapContext(context);
// Ensure that the previous submission of this command buffer has finished.
result = vkWaitForFences(context.device, 1, &swap.fence, VK_FALSE, UINT64_MAX);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkWaitForFences error.");
// Restart the command buffer.
result = vkResetFences(context.device, 1, &swap.fence);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkResetFences error.");
VkCommandBuffer cmdbuffer = swap.cmdbuffer;
VkResult error = vkResetCommandBuffer(cmdbuffer, 0);
ASSERT_POSTCONDITION(not error, "vkResetCommandBuffer error.");
VkCommandBufferBeginInfo beginInfo {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
};
error = vkBeginCommandBuffer(cmdbuffer, &beginInfo);
ASSERT_POSTCONDITION(not error, "vkBeginCommandBuffer error.");
context.cmdbuffer = cmdbuffer;
swap.submitted = false;
}
void releaseCommandBuffer(VulkanContext& context) {
// Finalize the command buffer and set the cmdbuffer pointer to null.
VkResult result = vkEndCommandBuffer(context.cmdbuffer);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkEndCommandBuffer error.");
context.cmdbuffer = nullptr;
// Submit the command buffer.
VkPipelineStageFlags waitDestStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
VulkanSurfaceContext& surfaceContext = *context.currentSurface;
SwapContext& swapContext = getSwapContext(context);
VkSubmitInfo submitInfo {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
.waitSemaphoreCount = 1u,
.pWaitSemaphores = &surfaceContext.imageAvailable,
.pWaitDstStageMask = &waitDestStageMask,
.commandBufferCount = 1,
.pCommandBuffers = &swapContext.cmdbuffer,
.signalSemaphoreCount = 1u,
.pSignalSemaphores = &surfaceContext.renderingFinished,
};
result = vkQueueSubmit(context.graphicsQueue, 1, &submitInfo, swapContext.fence);
ASSERT_POSTCONDITION(result == VK_SUCCESS, "vkQueueSubmit error.");
swapContext.submitted = true;
}
void performPendingWork(VulkanContext& context, SwapContext& swapContext, VkCommandBuffer cmdbuf) {
// First, execute pending tasks that are specific to this swap context. Copy the tasks into a
// local queue first, which allows newly added tasks to be deferred until the next frame.
decltype(swapContext.pendingWork) tasks;
tasks.swap(swapContext.pendingWork);
for (auto& callback : tasks) {
callback(cmdbuf);
}
// Next, execute the global pending work. Again, we copy the work queue into a local queue
// to allow tasks to re-add themselves.
tasks.clear();
tasks.swap(context.pendingWork);
for (auto& callback : tasks) {
callback(cmdbuf);
}
}
// Flushes the command buffer and waits for it to finish executing. Useful for diagnosing
// sychronization issues.
void flushCommandBuffer(VulkanContext& context) {
VulkanSurfaceContext& surface = *context.currentSurface;
const SwapContext& sc = surface.swapContexts[surface.currentSwapIndex];
// Submit the command buffer.
VkResult error = vkEndCommandBuffer(context.cmdbuffer);
ASSERT_POSTCONDITION(!error, "vkEndCommandBuffer error.");
VkPipelineStageFlags waitDestStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
VkSubmitInfo submitInfo {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
.pWaitDstStageMask = &waitDestStageMask,
.commandBufferCount = 1,
.pCommandBuffers = &context.cmdbuffer,
};
error = vkQueueSubmit(context.graphicsQueue, 1, &submitInfo, sc.fence);
ASSERT_POSTCONDITION(!error, "vkQueueSubmit error.");
// Restart the command buffer.
error = vkWaitForFences(context.device, 1, &sc.fence, VK_FALSE, UINT64_MAX);
ASSERT_POSTCONDITION(!error, "vkWaitForFences error.");
error = vkResetFences(context.device, 1, &sc.fence);
ASSERT_POSTCONDITION(!error, "vkResetFences error.");
error = vkResetCommandBuffer(context.cmdbuffer, 0);
ASSERT_POSTCONDITION(!error, "vkResetCommandBuffer error.");
VkCommandBufferBeginInfo beginInfo {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT,
};
error = vkBeginCommandBuffer(context.cmdbuffer, &beginInfo);
ASSERT_POSTCONDITION(!error, "vkBeginCommandBuffer error.");
}
VkFormat findSupportedFormat(VulkanContext& context, const std::vector<VkFormat>& candidates,
VkImageTiling tiling, VkFormatFeatureFlags features) {
for (VkFormat format : candidates) {
VkFormatProperties props;
vkGetPhysicalDeviceFormatProperties(context.physicalDevice, format, &props);
if (tiling == VK_IMAGE_TILING_LINEAR &&
(props.linearTilingFeatures & features) == features) {
return format;
} else if (tiling == VK_IMAGE_TILING_OPTIMAL &&
(props.optimalTilingFeatures & features) == features) {
return format;
}
}
return VK_FORMAT_UNDEFINED;
}
} // namespace filament
} // namespace driver
int tut7_render_start(struct tut7_render_essentials *essentials, struct tut2_device *dev,
struct tut6_swapchain *swapchain, VkImageLayout to_layout, uint32_t *image_index)
{
tut1_error retval = TUT1_ERROR_NONE;
VkResult res;
/* Use `vkAcquireNextImageKHR` to get an image to render to */
res = vkAcquireNextImageKHR(dev->device, swapchain->swapchain, 1000000000, essentials->sem_post_acquire, NULL, image_index);
tut1_error_set_vkresult(&retval, res);
if (res == VK_TIMEOUT)
{
printf("A whole second and no image. I give up.\n");
return -1;
}
else if (res == VK_SUBOPTIMAL_KHR)
printf("Did you change the window size? I didn't recreate the swapchains,\n"
"so the presentation is now suboptimal.\n");
else if (res < 0)
{
tut1_error_printf(&retval, "Couldn't acquire image\n");
return -1;
}
/*
* Unless the first time we are rendering, wait for the last frame to finish rendering. Let's wait up to a
* second, and if the fence is still not signalled, we'll assume something went horribly wrong and quit.
*
* This wait needs to be done before we start recording over the command buffer again, because, well, if not
* we would be resetting it while it's being executed.
*/
if (!essentials->first_render)
{
res = vkWaitForFences(dev->device, 1, &essentials->exec_fence, true, 1000000000);
tut1_error_set_vkresult(&retval, res);
if (res)
{
tut1_error_printf(&retval, "Wait for fence failed\n");
return -1;
}
}
essentials->first_render = false;
/*
* We have seen many of the command buffer functions in Tutorial 4. Here is a short recap:
*
* - reset: remove all previous recordings from the command buffer
* - begin: start recording
* - bind pipeline: specify the pipeline the commands run on (unused here)
* - bind descriptor set: specify resources to use for rendering (unused here)
* - end: stop recording
*/
vkResetCommandBuffer(essentials->cmd_buffer, 0);
VkCommandBufferBeginInfo begin_info = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
};
res = vkBeginCommandBuffer(essentials->cmd_buffer, &begin_info);
tut1_error_set_vkresult(&retval, res);
if (res)
{
tut1_error_printf(&retval, "Couldn't even begin recording a command buffer\n");
return -1;
}
/*
* To transition an image to a new layout, an image barrier is used. Before we see how that is done, let's see
* what it even means.
*
* In Vulkan, there are barriers on different kinds of resources (images, buffers and memory) and other means
* to specify execution dependency. In each case, you want to make sure some actions A are all executed before
* some actions B. In the specific case of barriers, A could be actions that do something to the resource and
* B could be actions that need the result of those actions.
*
* In our specific case, we want to change the layout of a swapchain image. For the transition from present
* src, we want to make sure that all writes to the image are done after the transition is done. For the
* transition to present src, we want to make sure that all writes to the image are done before the transition
* is done. Note: if we had a graphics pipeline, we would be talking about "color attachment writes" instead
* of just "writes". Keep that in mind.
*
* Using a VkImageMemoryBarrier, we are not only specifying how the image layout should change (if changed at
* all), but also defining the actions A and B where an execution dependency would be created. In the first
* barrier (transition from present src), all reads of the image (for previous presentation) must happen before
* the barrier (A is the set of READ operations), and all writes must be done after the barrier (B is the set
* of WRITE operations). The situation is reversed with the second barrier (transition to present src).
*
* In Vulkan, actions A are referred to as `src` and actions B are referred to as `dst`.
*
* Using an image barrier, it's also possible to transfer one image from a queue family to another, in which
* case A is the set of actions accessing the image in the first queue family and B is the set of actions
* accessing the image in the second queue family. We are not moving between queue families, so we'll specify
* this intention as well.
*
* In our layout transition, we are transitioning from present src to to_layout and back. However, the first
* time the transition happens, the swapchain image layout is actually UNDEFINED. Either way, since we are not
* interested in what was previously in the image when we are just about to render into it, we can set the
* `oldLayout` (the layout transitioning from) to UNDEFINED. This makes the transition more efficient because
* Vulkan knows it can just throw away the contents of the image. Note: in Tutorial 7, we are transition to
* "general", but if we had a graphics pipeline, we would be transition to the "color attachment optimal"
* layout instead.
*
* Finally, we need to specify which part of the image (subresource) is being transitioned. We want to
* transition COLOR parts of the image (which in this case, all of the image is COLOR), and all mip levels and
* arrays (which are both in this case single).
*/
VkImageMemoryBarrier image_barrier = {
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
.srcAccessMask = VK_ACCESS_MEMORY_READ_BIT,
.dstAccessMask = VK_ACCESS_MEMORY_WRITE_BIT,
.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.newLayout = to_layout,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.image = essentials->images[*image_index],
.subresourceRange = {
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
.baseMipLevel = 0,
.levelCount = 1,
.baseArrayLayer = 0,
.layerCount = 1,
},
};
/*
* The image barrier structure above defines the execution dependency of sets of actions A and B. When
* applying the barrier, we also need to specify which pipeline stages these sets of actions are taken from.
*
* In our barrier, first we want to make sure all READs from the image (by the previous presentation) is done
* before the barrier. These reads are not part of our rendering. In fact, they are really done before the
* graphics pipeline even begins. So the pipeline stage we specify for `src` would be the top of the pipeline,
* which means before the pipeline begins. Second, we want to make sure all writes to the image (for
* rendering) is done after the barrier. The writes to the image are likely to happen at later stages of the
* graphics pipeline, so we can specify those stages as `dst` stages of the barrier. We have already specified
* that the barrier works on WRITEs, so we can also be a bit lazy and say that the `dst` stage is all graphics
* pipeline stages.
*
* Let's rephrase the above to make sure it's clear. The vkCmdPipelineBarrier takes a src and dst stage mask.
* The arguments are called srcStageMask and dstStageMask. They can contain more than one pipeline stage.
* Take the combinations (srcAccessMask, srcStageMask) and (dstAccessMask, dstStageMask). Say we make a
* barrier from (A, Sa) to (B, Sb) as src and dst parts of the barrier respectively. The barrier then means
* that all actions A in stages Sa are done before all actions B in stages Sb. So, if Sb is all graphics
* stages, it means that all actions A in stages Sa are done before all actions B anywhere. If Sa is top of
* the pipeline, it means that all actions A before the pipeline are done before all actions B anywhere.
*
* All READs before the pipeline must be done before all WRITEs anywhere.
*/
vkCmdPipelineBarrier(essentials->cmd_buffer,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
0, /* no flags */
0, NULL, /* no memory barriers */
0, NULL, /* no buffer barriers */
1, &image_barrier); /* our image transition */
return 0;
}
void vkImageBase::createMipLevels(VkFormatProperties formatProperties, VulkanRenderer *vk_renderer,
VkCommandBufferBeginInfo setupCmdsBeginInfo, std::vector<VkBufferImageCopy> &bufferCopyRegions,
int mipLevels, std::vector<ImageInfo> &bitmapInfos, VkImageMemoryBarrier imageMemoryBarrier,
VkSubmitInfo submit_info, VkCommandBuffer *buffers, VkQueue queue)
{
assert(formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_BLIT_SRC_BIT);
assert(formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_BLIT_DST_BIT);
VkCommandBuffer blitCmd;
vk_renderer->initCmdBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, blitCmd);
vkResetCommandBuffer(blitCmd, 0);
// Begin recording to the command buffer.
vkBeginCommandBuffer(blitCmd, &setupCmdsBeginInfo);
// Copy down mips from n-1 to n
for(int j=0; j< bufferCopyRegions.size(); j++) {
for (int32_t i = 1; i < mipLevels; i++)
{
VkImageBlit imageBlit{};
// Source
imageBlit.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imageBlit.srcSubresource.layerCount = 1;
imageBlit.srcSubresource.mipLevel = i-1;
imageBlit.srcSubresource.baseArrayLayer = j;
imageBlit.srcOffsets[1].x = int32_t(bitmapInfos[j].width >> (i - 1)) == 0 ? 1 : int32_t(bitmapInfos[j].width >> (i - 1));
imageBlit.srcOffsets[1].y = int32_t(bitmapInfos[j].height >> (i - 1)) == 0 ? 1 : int32_t(bitmapInfos[j].height >> (i - 1));
imageBlit.srcOffsets[1].z = 1;
// Destination
imageBlit.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imageBlit.dstSubresource.layerCount = 1;
imageBlit.dstSubresource.baseArrayLayer = j;
imageBlit.dstSubresource.mipLevel = i;
imageBlit.dstOffsets[1].x = int32_t(bitmapInfos[j].width >> i) == 0 ? 1 : int32_t(bitmapInfos[j].width >> i);
imageBlit.dstOffsets[1].y = int32_t(bitmapInfos[j].height >> i) == 0 ? 1 : int32_t(bitmapInfos[j].height >> i);
imageBlit.dstOffsets[1].z = 1;
VkImageMemoryBarrier imageMemoryBarrier = {};
imageMemoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
imageMemoryBarrier.pNext = NULL;
imageMemoryBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imageMemoryBarrier.subresourceRange.baseMipLevel = i;
imageMemoryBarrier.subresourceRange.levelCount = 1;
imageMemoryBarrier.subresourceRange.baseArrayLayer = j;
imageMemoryBarrier.subresourceRange.layerCount = 1;
// change layout of current mip level to transfer dest
setImageLayout(imageMemoryBarrier,
blitCmd,
imageHandle,
VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, imageMemoryBarrier.subresourceRange,
VK_PIPELINE_STAGE_TRANSFER_BIT,
VK_PIPELINE_STAGE_HOST_BIT);
// Do blit operation from previous mip level
vkCmdBlitImage(
blitCmd,
imageHandle,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
imageHandle,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
1,
&imageBlit,
VK_FILTER_LINEAR);
// change layout of current mip level to source for next iteration
setImageLayout(imageMemoryBarrier,
blitCmd,
imageHandle,
VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, imageMemoryBarrier.subresourceRange,
VK_PIPELINE_STAGE_HOST_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT);
}
}
// Change layout of all mip levels to shader read
imageMemoryBarrier.subresourceRange.levelCount = mipLevels;
setImageLayout(imageMemoryBarrier,
blitCmd,
imageHandle,
VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
imageLayout,
imageMemoryBarrier.subresourceRange);
// We are finished recording operations.
vkEndCommandBuffer(blitCmd);
buffers[0] = blitCmd;
submit_info.pCommandBuffers = &buffers[0];
// Submit to our shared graphics queue.
VkResult err = vkQueueSubmit(queue, 1, &submit_info, VK_NULL_HANDLE);
assert(!err);
// Wait for the queue to become idle.
err = vkQueueWaitIdle(queue);
assert(!err);
}
void vkImageBase::updateMipVkImage(uint64_t texSize, std::vector<void *> &pixels,
std::vector<ImageInfo> &bitmapInfos,
std::vector<VkBufferImageCopy> &bufferCopyRegions,
VkImageViewType target, VkFormat internalFormat,
int mipLevels,
VkImageCreateFlags flags) {
VkResult err;
bool pass;
VulkanRenderer *vk_renderer = static_cast<VulkanRenderer *>(Renderer::getInstance());
VkDevice device = vk_renderer->getDevice();
VkFormatProperties formatProperties;
vkGetPhysicalDeviceFormatProperties(vk_renderer->getPhysicalDevice(), internalFormat,
&formatProperties);
VkBuffer texBuffer;
VkDeviceMemory texMemory;
VkMemoryAllocateInfo memoryAllocateInfo = {};
memoryAllocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
memoryAllocateInfo.pNext = NULL;
memoryAllocateInfo.allocationSize = 0;
memoryAllocateInfo.memoryTypeIndex = 0;
err = vkCreateBuffer(device,
gvr::BufferCreateInfo(texSize,
VK_BUFFER_USAGE_TRANSFER_SRC_BIT),
nullptr, &texBuffer);
GVR_VK_CHECK(!err);
// Obtain the requirements on memory for this buffer
VkMemoryRequirements mem_reqs;
vkGetBufferMemoryRequirements(device, texBuffer, &mem_reqs);
assert(!err);
memoryAllocateInfo.allocationSize = mem_reqs.size;
pass = vk_renderer->GetMemoryTypeFromProperties(mem_reqs.memoryTypeBits,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
&memoryAllocateInfo.memoryTypeIndex);
assert(pass);
size = mem_reqs.size;
err = vkAllocateMemory(device, gvr::MemoryAllocateInfo(mem_reqs.size,
memoryAllocateInfo.memoryTypeIndex),
NULL, &texMemory);
unsigned char *texData;
err = vkMapMemory(device, texMemory, 0,
memoryAllocateInfo.allocationSize, 0, (void **) &texData);
assert(!err);
int i = 0;
for (auto &buffer_copy_region: bufferCopyRegions) {
memcpy(texData + buffer_copy_region.bufferOffset, pixels[i],
bitmapInfos[i].size);
i++;
}
vkUnmapMemory(device, texMemory);
// Bind our buffer to the memory
err = vkBindBufferMemory(device, texBuffer, texMemory, 0);
assert(!err);
err = vkCreateImage(device, gvr::ImageCreateInfo(VK_IMAGE_TYPE_2D,
internalFormat,
bitmapInfos[0].width,
bitmapInfos[0].height, 1, mipLevels, pixels.size(),
VK_IMAGE_TILING_OPTIMAL,
VK_IMAGE_USAGE_TRANSFER_DST_BIT |
VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
VK_IMAGE_USAGE_SAMPLED_BIT,
flags,
getVKSampleBit(mSampleCount),
VK_IMAGE_LAYOUT_UNDEFINED), NULL,
&imageHandle);
assert(!err);
vkGetImageMemoryRequirements(device, imageHandle, &mem_reqs);
memoryAllocateInfo.allocationSize = mem_reqs.size;
pass = vk_renderer->GetMemoryTypeFromProperties(mem_reqs.memoryTypeBits,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
&memoryAllocateInfo.memoryTypeIndex);
assert(pass);
/* allocate memory */
err = vkAllocateMemory(device, &memoryAllocateInfo, NULL, &device_memory);
assert(!err);
/* bind memory */
err = vkBindImageMemory(device, imageHandle, device_memory, 0);
assert(!err);
// Reset the setup command buffer
VkCommandBuffer textureCmdBuffer;
vk_renderer->initCmdBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, textureCmdBuffer);
vkResetCommandBuffer(textureCmdBuffer, 0);
VkCommandBufferInheritanceInfo commandBufferInheritanceInfo = {};
commandBufferInheritanceInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO;
commandBufferInheritanceInfo.pNext = NULL;
commandBufferInheritanceInfo.renderPass = VK_NULL_HANDLE;
commandBufferInheritanceInfo.subpass = 0;
commandBufferInheritanceInfo.framebuffer = VK_NULL_HANDLE;
commandBufferInheritanceInfo.occlusionQueryEnable = VK_FALSE;
commandBufferInheritanceInfo.queryFlags = 0;
commandBufferInheritanceInfo.pipelineStatistics = 0;
VkCommandBufferBeginInfo setupCmdsBeginInfo;
setupCmdsBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
setupCmdsBeginInfo.pNext = NULL;
setupCmdsBeginInfo.flags = 0;
setupCmdsBeginInfo.pInheritanceInfo = &commandBufferInheritanceInfo;
// Begin recording to the command buffer.
vkBeginCommandBuffer(textureCmdBuffer, &setupCmdsBeginInfo);
VkImageMemoryBarrier imageMemoryBarrier = {};
imageMemoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
imageMemoryBarrier.pNext = NULL;
imageMemoryBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imageMemoryBarrier.subresourceRange.baseMipLevel = 0;
imageMemoryBarrier.subresourceRange.levelCount = 1;
imageMemoryBarrier.subresourceRange.baseArrayLayer = 0;
imageMemoryBarrier.subresourceRange.layerCount = pixels.size();
imageMemoryBarrier.srcAccessMask = 0;
imageMemoryBarrier.dstAccessMask =
VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;
// Optimal image will be used as destination for the copy, so we must transfer from our initial undefined image layout to the transfer destination layout
setImageLayout(imageMemoryBarrier, textureCmdBuffer, imageHandle, VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
imageMemoryBarrier.subresourceRange);
vkCmdCopyBufferToImage(
textureCmdBuffer,
texBuffer,
imageHandle,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
static_cast<uint32_t>(bufferCopyRegions.size()),
bufferCopyRegions.data());
imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
setImageLayout(imageMemoryBarrier, textureCmdBuffer, imageHandle, VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
imageMemoryBarrier.subresourceRange);
// We are finished recording operations.
vkEndCommandBuffer(textureCmdBuffer);
VkCommandBuffer buffers[1];
buffers[0] = textureCmdBuffer;
VkSubmitInfo submit_info;
submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submit_info.pNext = NULL;
submit_info.waitSemaphoreCount = 0;
submit_info.pWaitSemaphores = NULL;
submit_info.pWaitDstStageMask = NULL;
submit_info.commandBufferCount = 1;
submit_info.pCommandBuffers = &buffers[0];
submit_info.signalSemaphoreCount = 0;
submit_info.pSignalSemaphores = NULL;
VkQueue queue = vk_renderer->getQueue();
// Submit to our shared graphics queue.
err = vkQueueSubmit(queue, 1, &submit_info, VK_NULL_HANDLE);
assert(!err);
// Wait for the queue to become idle.
err = vkQueueWaitIdle(queue);
assert(!err);
vkFreeMemory(device, texMemory, nullptr);
vkDestroyBuffer(device, texBuffer, nullptr);
if(mipLevels > 1)
createMipLevels(formatProperties, vk_renderer, setupCmdsBeginInfo,
bufferCopyRegions, mipLevels, bitmapInfos, imageMemoryBarrier,
submit_info, buffers, queue);
err = vkCreateImageView(device, gvr::ImageViewCreateInfo(imageHandle,
target,
internalFormat, mipLevels,0,
pixels.size(),
VK_IMAGE_ASPECT_COLOR_BIT), NULL,
&imageView);
assert(!err);
}
void CommandBuffer::Reset(bool p_bReleaseResources)
{
ASSERT(m_CommandPool->AllowsIndividualBufferReset(), "Buffer not created from a command pool that allows buffers to be reset individually");
VK_THROW_IF_NOT_SUCCESS(vkResetCommandBuffer(m_Handle, p_bReleaseResources ? VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT : 0), "Failed to reset command buffer");
}
int sample_main(int argc, char *argv[]) {
VkResult U_ASSERT_ONLY res;
struct sample_info info = {};
char sample_title[] = "Events";
init_global_layer_properties(info);
init_instance_extension_names(info);
init_device_extension_names(info);
init_instance(info, sample_title);
init_enumerate_device(info);
init_device(info);
init_command_pool(info);
init_command_buffer(info);
execute_begin_command_buffer(info);
init_device_queue(info);
/* VULKAN_KEY_START */
// Start with a trivial command buffer and make sure fence wait doesn't time out
info.viewport.height = 10.0;
info.viewport.width = 10.0;
info.viewport.minDepth = (float)0.0f;
info.viewport.maxDepth = (float)1.0f;
info.viewport.x = 0;
info.viewport.y = 0;
vkCmdSetViewport(info.cmd, 0, NUM_VIEWPORTS, &info.viewport);
execute_end_command_buffer(info);
VkFence fence;
VkFenceCreateInfo fenceInfo;
fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceInfo.pNext = NULL;
fenceInfo.flags = 0;
vkCreateFence(info.device, &fenceInfo, NULL, &fence);
VkPipelineStageFlags pipe_stage_flags =
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
const VkCommandBuffer cmd_bufs[] = {info.cmd};
VkSubmitInfo submit_info[1] = {};
submit_info[0].pNext = NULL;
submit_info[0].sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submit_info[0].waitSemaphoreCount = 0;
submit_info[0].pWaitSemaphores = NULL;
submit_info[0].pWaitDstStageMask = &pipe_stage_flags;
submit_info[0].commandBufferCount = 1;
submit_info[0].pCommandBuffers = cmd_bufs;
submit_info[0].signalSemaphoreCount = 0;
submit_info[0].pSignalSemaphores = NULL;
res = vkQueueSubmit(info.graphics_queue, 1, submit_info, fence);
assert(res == VK_SUCCESS);
// Make sure timeout is long enough for a simple command buffer without
// waiting for an event
int timeouts = -1;
do {
res =
vkWaitForFences(info.device, 1, &fence, VK_TRUE, FENCE_TIMEOUT);
timeouts++;
} while (res == VK_TIMEOUT);
assert(res == VK_SUCCESS);
if (timeouts != 0) {
std::cout << "Unsuitable timeout value, exiting\n";
exit(-1);
}
vkResetCommandBuffer(info.cmd, 0);
// Now create an event and wait for it on the GPU
VkEvent event;
VkEventCreateInfo eventInfo = {};
eventInfo.sType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO;
eventInfo.pNext = NULL;
eventInfo.flags = 0;
vkCreateEvent(info.device, &eventInfo, NULL, &event);
execute_begin_command_buffer(info);
vkCmdWaitEvents(info.cmd, 1, &event, VK_PIPELINE_STAGE_HOST_BIT,
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
0, nullptr, 0, nullptr,0, nullptr);
execute_end_command_buffer(info);
vkResetFences(info.device, 1, &fence);
// Note that stepping through this code in the debugger is a bad idea because the
// GPU can TDR waiting for the event. Execute the code from vkQueueSubmit through
// vkSetEvent without breakpoints
pipe_stage_flags = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
res = vkQueueSubmit(info.graphics_queue, 1, submit_info, fence);
assert(res == VK_SUCCESS);
// We should timeout waiting for the fence because the GPU should be waiting
// on the event
res = vkWaitForFences(info.device, 1, &fence, VK_TRUE, FENCE_TIMEOUT);
if (res != VK_TIMEOUT) {
std::cout << "Didn't get expected timeout in vkWaitForFences, exiting\n";
exit(-1);
}
// Set the event from the CPU and wait for the fence. This should succeed
// since we set the event
vkSetEvent(info.device, event);
do {
res = vkWaitForFences(info.device, 1, &fence, VK_TRUE, FENCE_TIMEOUT);
} while ( res == VK_TIMEOUT);
assert(res == VK_SUCCESS);
vkResetCommandBuffer(info.cmd, 0);
vkResetFences(info.device, 1, &fence);
vkResetEvent(info.device,event);
// Now set the event from the GPU and wait on the CPU
execute_begin_command_buffer(info);
vkCmdSetEvent(info.cmd, event, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT);
execute_end_command_buffer(info);
// Look for the event on the CPU. It should be RESET since we haven't sent
// the command buffer yet.
res = vkGetEventStatus(info.device, event);
assert(res == VK_EVENT_RESET);
// Send the command buffer and loop waiting for the event
res = vkQueueSubmit(info.graphics_queue, 1, submit_info, fence);
assert(res == VK_SUCCESS);
int polls = 0;
do {
res = vkGetEventStatus(info.device, event);
polls++;
} while (res != VK_EVENT_SET);
printf ("%d polls to find the event set\n", polls);
do {
res = vkWaitForFences(info.device, 1, &fence, VK_TRUE, FENCE_TIMEOUT);
} while (res == VK_TIMEOUT);
assert(res == VK_SUCCESS);
vkDestroyEvent(info.device, event, NULL);
vkDestroyFence(info.device, fence, NULL);
destroy_command_buffer(info);
destroy_command_pool(info);
destroy_device(info);
destroy_instance(info);
return 0;
}
void CommandBuffer::reset(VkCommandBufferResetFlags flags) {
EXPECT(vkResetCommandBuffer(handle(), flags) == VK_SUCCESS);
}
