int sample_main() {
VkResult U_ASSERT_ONLY res;
char sample_title[] = "MT Cmd Buffer Sample";
const bool depthPresent = false;
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, 500, 500);
init_connection(info);
init_window(info);
init_swapchain_extension(info);
init_device(info);
init_command_pool(info);
init_command_buffer(info);
execute_begin_command_buffer(info);
init_device_queue(info);
init_swap_chain(info);
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo;
presentCompleteSemaphoreCreateInfo.sType =
VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
presentCompleteSemaphoreCreateInfo.pNext = NULL;
presentCompleteSemaphoreCreateInfo.flags = 0;
res = vkCreateSemaphore(info.device, &presentCompleteSemaphoreCreateInfo,
NULL, &info.presentCompleteSemaphore);
assert(res == VK_SUCCESS);
// Get the index of the next available swapchain image:
res = vkAcquireNextImageKHR(info.device, info.swap_chain, UINT64_MAX,
info.presentCompleteSemaphore, NULL,
&info.current_buffer);
// TODO: Deal with the VK_SUBOPTIMAL_KHR and VK_ERROR_OUT_OF_DATE_KHR
// return codes
assert(res == VK_SUCCESS);
VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = {};
pPipelineLayoutCreateInfo.sType =
VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
pPipelineLayoutCreateInfo.pNext = NULL;
pPipelineLayoutCreateInfo.pushConstantRangeCount = 0;
pPipelineLayoutCreateInfo.pPushConstantRanges = NULL;
pPipelineLayoutCreateInfo.setLayoutCount = 0;
pPipelineLayoutCreateInfo.pSetLayouts = NULL;
res = vkCreatePipelineLayout(info.device, &pPipelineLayoutCreateInfo, NULL,
&info.pipeline_layout);
assert(res == VK_SUCCESS);
init_renderpass(
info, depthPresent,
false); // Can't clear in renderpass load because we re-use pipeline
init_shaders(info, vertShaderText, fragShaderText);
init_framebuffers(info, depthPresent);
/* The binding and attributes should be the same for all 3 vertex buffers,
* so init here */
info.vi_binding.binding = 0;
info.vi_binding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
info.vi_binding.stride = sizeof(triData[0]);
info.vi_attribs[0].binding = 0;
info.vi_attribs[0].location = 0;
info.vi_attribs[0].format = VK_FORMAT_R32G32B32A32_SFLOAT;
info.vi_attribs[0].offset = 0;
info.vi_attribs[1].binding = 0;
info.vi_attribs[1].location = 1;
info.vi_attribs[1].format = VK_FORMAT_R32G32B32A32_SFLOAT;
info.vi_attribs[1].offset = 16;
init_pipeline_cache(info);
init_pipeline(info, depthPresent);
VkImageSubresourceRange srRange = {};
srRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
srRange.baseMipLevel = 0;
srRange.levelCount = VK_REMAINING_MIP_LEVELS;
srRange.baseArrayLayer = 0;
srRange.layerCount = VK_REMAINING_ARRAY_LAYERS;
VkClearColorValue clear_color[1];
clear_color[0].float32[0] = 0.2f;
clear_color[0].float32[1] = 0.2f;
clear_color[0].float32[2] = 0.2f;
clear_color[0].float32[3] = 0.2f;
/* We need to do the clear here instead of as a load op since all 3 threads
* share the same pipeline / renderpass */
set_image_layout(info, info.buffers[info.current_buffer].image,
VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
vkCmdClearColorImage(info.cmd, info.buffers[info.current_buffer].image,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, clear_color, 1,
&srRange);
set_image_layout(info, info.buffers[info.current_buffer].image,
VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
res = vkEndCommandBuffer(info.cmd);
const VkCommandBuffer cmd_bufs[] = {info.cmd};
VkFence clearFence;
init_fence(info, clearFence);
VkPipelineStageFlags pipe_stage_flags =
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
VkSubmitInfo submit_info[1] = {};
submit_info[0].pNext = NULL;
submit_info[0].sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submit_info[0].waitSemaphoreCount = 1;
submit_info[0].pWaitSemaphores = &info.presentCompleteSemaphore;
submit_info[0].pWaitDstStageMask = NULL;
submit_info[0].commandBufferCount = 1;
submit_info[0].pCommandBuffers = cmd_bufs;
submit_info[0].signalSemaphoreCount = 0;
submit_info[0].pSignalSemaphores = NULL;
/* Queue the command buffer for execution */
res = vkQueueSubmit(info.queue, 1, submit_info, clearFence);
assert(!res);
do {
res = vkWaitForFences(info.device, 1, &clearFence, VK_TRUE,
FENCE_TIMEOUT);
} while (res == VK_TIMEOUT);
assert(res == VK_SUCCESS);
vkDestroyFence(info.device, clearFence, NULL);
/* VULKAN_KEY_START */
/* Use the fourth slot in the command buffer array for the presentation */
/* barrier using the command buffer in info */
threadCmdBufs[3] = info.cmd;
sample_platform_thread vk_threads[3];
for (size_t i = 0; i < 3; i++) {
sample_platform_thread_create(&vk_threads[i], &per_thread_code,
(void *)i);
}
VkCommandBufferBeginInfo cmd_buf_info = {};
cmd_buf_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
cmd_buf_info.pNext = NULL;
cmd_buf_info.flags = 0;
cmd_buf_info.pInheritanceInfo = NULL;
res = vkBeginCommandBuffer(threadCmdBufs[3], &cmd_buf_info);
assert(res == VK_SUCCESS);
VkImageMemoryBarrier prePresentBarrier = {};
prePresentBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
prePresentBarrier.pNext = NULL;
prePresentBarrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
prePresentBarrier.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT;
prePresentBarrier.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_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(threadCmdBufs[3], VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, NULL, 0,
NULL, 1, &prePresentBarrier);
res = vkEndCommandBuffer(threadCmdBufs[3]);
assert(res == VK_SUCCESS);
pipe_stage_flags = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
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 =
4; /* 3 from threads + prePresentBarrier */
submit_info[0].pCommandBuffers = threadCmdBufs;
submit_info[0].signalSemaphoreCount = 0;
submit_info[0].pSignalSemaphores = NULL;
/* Wait for all of the threads to finish */
for (int i = 0; i < 3; i++) {
sample_platform_thread_join(vk_threads[i], NULL);
}
VkFenceCreateInfo fenceInfo;
VkFence drawFence;
fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceInfo.pNext = NULL;
fenceInfo.flags = 0;
vkCreateFence(info.device, &fenceInfo, NULL, &drawFence);
/* Queue the command buffer for execution */
res = vkQueueSubmit(info.queue, 1, submit_info, drawFence);
assert(!res);
/* 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);
execute_present_image(info);
wait_seconds(1);
/* VULKAN_KEY_END */
vkDestroyBuffer(info.device, vertex_buffer[0].buf, NULL);
vkDestroyBuffer(info.device, vertex_buffer[1].buf, NULL);
vkDestroyBuffer(info.device, vertex_buffer[2].buf, NULL);
vkFreeMemory(info.device, vertex_buffer[0].mem, NULL);
vkFreeMemory(info.device, vertex_buffer[1].mem, NULL);
vkFreeMemory(info.device, vertex_buffer[2].mem, NULL);
for (int i = 0; i < 3; i++) {
vkFreeCommandBuffers(info.device, threadCmdPools[i], 1,
&threadCmdBufs[i]);
vkDestroyCommandPool(info.device, threadCmdPools[i], NULL);
}
vkDestroySemaphore(info.device, info.presentCompleteSemaphore, NULL);
vkDestroyFence(info.device, drawFence, NULL);
destroy_pipeline(info);
destroy_pipeline_cache(info);
destroy_framebuffers(info);
destroy_shaders(info);
destroy_renderpass(info);
vkDestroyPipelineLayout(info.device, info.pipeline_layout, NULL);
destroy_swap_chain(info);
destroy_command_buffer(info);
destroy_command_pool(info);
destroy_window(info);
destroy_device(info);
destroy_instance(info);
return 0;
}
int sample_main(int argc, char *argv[]) {
VkResult U_ASSERT_ONLY res;
bool U_ASSERT_ONLY pass;
struct sample_info info = {};
char sample_title[] = "Input Attachment Sample";
const bool depthPresent = false;
const bool vertexPresent = false;
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);
VkFormatProperties props;
vkGetPhysicalDeviceFormatProperties(info.gpus[0], VK_FORMAT_R8G8B8A8_UNORM, &props);
if (!(props.optimalTilingFeatures & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)) {
std::cout << "VK_FORMAT_R8G8B8A8_UNORM format unsupported for input "
"attachment\n";
exit(-1);
}
init_window_size(info, 500, 500);
init_connection(info);
init_window(info);
init_swapchain_extension(info);
init_device(info);
init_command_pool(info);
init_command_buffer(info);
execute_begin_command_buffer(info);
init_device_queue(info);
init_swap_chain(info);
/* VULKAN_KEY_START */
// Create a framebuffer with 2 attachments, one the color attachment
// the shaders render into, and the other an input attachment which
// will be cleared to yellow, and then used by the shaders to color
// the drawn triangle. Final result should be a yellow triangle
// Create the image that will be used as the input attachment
// The image for the color attachment is the presentable image already
// created in init_swapchain()
VkImageCreateInfo image_create_info = {};
image_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
image_create_info.pNext = NULL;
image_create_info.imageType = VK_IMAGE_TYPE_2D;
image_create_info.format = info.format;
image_create_info.extent.width = info.width;
image_create_info.extent.height = info.height;
image_create_info.extent.depth = 1;
image_create_info.mipLevels = 1;
image_create_info.arrayLayers = 1;
image_create_info.samples = NUM_SAMPLES;
image_create_info.tiling = VK_IMAGE_TILING_OPTIMAL;
image_create_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
image_create_info.usage = VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
image_create_info.queueFamilyIndexCount = 0;
image_create_info.pQueueFamilyIndices = NULL;
image_create_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
image_create_info.flags = 0;
VkMemoryAllocateInfo mem_alloc = {};
mem_alloc.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
mem_alloc.pNext = NULL;
mem_alloc.allocationSize = 0;
mem_alloc.memoryTypeIndex = 0;
VkImage input_image;
VkDeviceMemory input_memory;
res = vkCreateImage(info.device, &image_create_info, NULL, &input_image);
assert(res == VK_SUCCESS);
VkMemoryRequirements mem_reqs;
vkGetImageMemoryRequirements(info.device, input_image, &mem_reqs);
mem_alloc.allocationSize = mem_reqs.size;
pass = memory_type_from_properties(info, mem_reqs.memoryTypeBits, 0, &mem_alloc.memoryTypeIndex);
assert(pass);
res = vkAllocateMemory(info.device, &mem_alloc, NULL, &input_memory);
assert(res == VK_SUCCESS);
res = vkBindImageMemory(info.device, input_image, input_memory, 0);
assert(res == VK_SUCCESS);
// Set the image layout to TRANSFER_DST_OPTIMAL to be ready for clear
set_image_layout(info, input_image, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
VkImageSubresourceRange srRange = {};
srRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
srRange.baseMipLevel = 0;
srRange.levelCount = VK_REMAINING_MIP_LEVELS;
srRange.baseArrayLayer = 0;
srRange.layerCount = VK_REMAINING_ARRAY_LAYERS;
VkClearColorValue clear_color;
clear_color.float32[0] = 1.0f;
clear_color.float32[1] = 1.0f;
clear_color.float32[2] = 0.0f;
clear_color.float32[3] = 0.0f;
// Clear the input attachment image to yellow
vkCmdClearColorImage(info.cmd, input_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, &clear_color, 1, &srRange);
// Set the image layout to SHADER_READONLY_OPTIMAL for use by the shaders
set_image_layout(info, input_image, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, VK_PIPELINE_STAGE_TRANSFER_BIT,
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
VkImageViewCreateInfo view_info = {};
view_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
view_info.pNext = NULL;
view_info.image = VK_NULL_HANDLE;
view_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
view_info.format = info.format;
view_info.components.r = VK_COMPONENT_SWIZZLE_R;
view_info.components.g = VK_COMPONENT_SWIZZLE_G;
view_info.components.b = VK_COMPONENT_SWIZZLE_B;
view_info.components.a = VK_COMPONENT_SWIZZLE_A;
view_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
view_info.subresourceRange.baseMipLevel = 0;
view_info.subresourceRange.levelCount = 1;
view_info.subresourceRange.baseArrayLayer = 0;
view_info.subresourceRange.layerCount = 1;
VkImageView input_attachment_view;
view_info.image = input_image;
res = vkCreateImageView(info.device, &view_info, NULL, &input_attachment_view);
assert(res == VK_SUCCESS);
VkDescriptorImageInfo input_image_info = {};
input_image_info.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
input_image_info.imageView = input_attachment_view;
input_image_info.sampler = VK_NULL_HANDLE;
VkDescriptorSetLayoutBinding layout_bindings[1];
layout_bindings[0].binding = 0;
layout_bindings[0].descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;
layout_bindings[0].descriptorCount = 1;
layout_bindings[0].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
layout_bindings[0].pImmutableSamplers = NULL;
VkDescriptorSetLayoutCreateInfo descriptor_layout = {};
descriptor_layout.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
descriptor_layout.pNext = NULL;
descriptor_layout.bindingCount = 1;
descriptor_layout.pBindings = layout_bindings;
info.desc_layout.resize(NUM_DESCRIPTOR_SETS);
res = vkCreateDescriptorSetLayout(info.device, &descriptor_layout, NULL, info.desc_layout.data());
assert(res == VK_SUCCESS);
VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = {};
pPipelineLayoutCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
pPipelineLayoutCreateInfo.pNext = NULL;
pPipelineLayoutCreateInfo.pushConstantRangeCount = 0;
pPipelineLayoutCreateInfo.pPushConstantRanges = NULL;
pPipelineLayoutCreateInfo.setLayoutCount = NUM_DESCRIPTOR_SETS;
pPipelineLayoutCreateInfo.pSetLayouts = info.desc_layout.data();
res = vkCreatePipelineLayout(info.device, &pPipelineLayoutCreateInfo, NULL, &info.pipeline_layout);
assert(res == VK_SUCCESS);
// First attachment is the color attachment - clear at the beginning of the
// renderpass and transition layout to PRESENT_SRC_KHR at the end of
// renderpass
VkAttachmentDescription attachments[2];
attachments[0].format = info.format;
attachments[0].samples = VK_SAMPLE_COUNT_1_BIT;
attachments[0].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
attachments[0].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
attachments[0].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
attachments[0].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
attachments[0].initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
attachments[0].finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
attachments[0].flags = 0;
// Second attachment is input attachment. Once cleared it should have
// width*height yellow pixels. Doing a subpassLoad in the fragment shader
// should give the shader the color at the fragments x,y location
// from the input attachment
attachments[1].format = info.format;
attachments[1].samples = VK_SAMPLE_COUNT_1_BIT;
attachments[1].loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
attachments[1].storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
attachments[1].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
attachments[1].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
attachments[1].initialLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
attachments[1].finalLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
attachments[1].flags = 0;
VkAttachmentReference color_reference = {};
color_reference.attachment = 0;
color_reference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
VkAttachmentReference input_reference = {};
input_reference.attachment = 1;
input_reference.layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
VkSubpassDescription subpass = {};
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
subpass.flags = 0;
subpass.inputAttachmentCount = 1;
subpass.pInputAttachments = &input_reference;
subpass.colorAttachmentCount = 1;
subpass.pColorAttachments = &color_reference;
subpass.pResolveAttachments = NULL;
subpass.pDepthStencilAttachment = NULL;
subpass.preserveAttachmentCount = 0;
subpass.pPreserveAttachments = NULL;
VkRenderPassCreateInfo rp_info = {};
rp_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
rp_info.pNext = NULL;
rp_info.attachmentCount = 2;
rp_info.pAttachments = attachments;
rp_info.subpassCount = 1;
rp_info.pSubpasses = &subpass;
rp_info.dependencyCount = 0;
rp_info.pDependencies = NULL;
res = vkCreateRenderPass(info.device, &rp_info, NULL, &info.render_pass);
assert(!res);
init_shaders(info, vertShaderText, fragShaderText);
VkImageView fb_attachments[2];
fb_attachments[1] = input_attachment_view;
VkFramebufferCreateInfo fbc_info = {};
fbc_info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
fbc_info.pNext = NULL;
fbc_info.renderPass = info.render_pass;
fbc_info.attachmentCount = 2;
fbc_info.pAttachments = fb_attachments;
fbc_info.width = info.width;
fbc_info.height = info.height;
fbc_info.layers = 1;
uint32_t i;
info.framebuffers = (VkFramebuffer *)malloc(info.swapchainImageCount * sizeof(VkFramebuffer));
for (i = 0; i < info.swapchainImageCount; i++) {
fb_attachments[0] = info.buffers[i].view;
res = vkCreateFramebuffer(info.device, &fbc_info, NULL, &info.framebuffers[i]);
assert(res == VK_SUCCESS);
}
VkDescriptorPoolSize type_count[1];
type_count[0].type = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;
type_count[0].descriptorCount = 1;
VkDescriptorPoolCreateInfo descriptor_pool = {};
descriptor_pool.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
descriptor_pool.pNext = NULL;
descriptor_pool.maxSets = 1;
descriptor_pool.poolSizeCount = 1;
descriptor_pool.pPoolSizes = type_count;
res = vkCreateDescriptorPool(info.device, &descriptor_pool, NULL, &info.desc_pool);
assert(res == VK_SUCCESS);
VkDescriptorSetAllocateInfo desc_alloc_info[1];
desc_alloc_info[0].sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
desc_alloc_info[0].pNext = NULL;
desc_alloc_info[0].descriptorPool = info.desc_pool;
desc_alloc_info[0].descriptorSetCount = 1;
desc_alloc_info[0].pSetLayouts = info.desc_layout.data();
info.desc_set.resize(1);
res = vkAllocateDescriptorSets(info.device, desc_alloc_info, info.desc_set.data());
assert(res == VK_SUCCESS);
VkWriteDescriptorSet writes[1];
// Write descriptor set with one write describing input attachment
writes[0] = {};
writes[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
writes[0].dstSet = info.desc_set[0];
writes[0].dstBinding = 0;
writes[0].descriptorCount = 1;
writes[0].descriptorType = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;
writes[0].pImageInfo = &input_image_info;
writes[0].pBufferInfo = nullptr;
writes[0].pTexelBufferView = nullptr;
writes[0].dstArrayElement = 0;
vkUpdateDescriptorSets(info.device, 1, writes, 0, NULL);
init_pipeline_cache(info);
init_pipeline(info, depthPresent, vertexPresent);
// Color attachment clear to gray
VkClearValue clear_values;
clear_values.color.float32[0] = 0.2f;
clear_values.color.float32[1] = 0.2f;
clear_values.color.float32[2] = 0.2f;
clear_values.color.float32[3] = 0.2f;
VkSemaphoreCreateInfo imageAcquiredSemaphoreCreateInfo;
imageAcquiredSemaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
imageAcquiredSemaphoreCreateInfo.pNext = NULL;
imageAcquiredSemaphoreCreateInfo.flags = 0;
res = vkCreateSemaphore(info.device, &imageAcquiredSemaphoreCreateInfo, NULL, &info.imageAcquiredSemaphore);
assert(res == VK_SUCCESS);
// Get the index of the next available swapchain image:
res = vkAcquireNextImageKHR(info.device, info.swap_chain, UINT64_MAX, info.imageAcquiredSemaphore, 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);
VkRenderPassBeginInfo rp_begin;
rp_begin.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
rp_begin.pNext = NULL;
rp_begin.renderPass = info.render_pass;
rp_begin.framebuffer = info.framebuffers[info.current_buffer];
rp_begin.renderArea.offset.x = 0;
rp_begin.renderArea.offset.y = 0;
rp_begin.renderArea.extent.width = info.width;
rp_begin.renderArea.extent.height = info.height;
rp_begin.clearValueCount = 1;
rp_begin.pClearValues = &clear_values;
vkCmdBeginRenderPass(info.cmd, &rp_begin, VK_SUBPASS_CONTENTS_INLINE);
vkCmdBindPipeline(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline);
vkCmdBindDescriptorSets(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline_layout, 0, NUM_DESCRIPTOR_SETS,
info.desc_set.data(), 0, NULL);
init_viewports(info);
init_scissors(info);
vkCmdDraw(info.cmd, 3, 1, 0, 0);
vkCmdEndRenderPass(info.cmd);
res = vkEndCommandBuffer(info.cmd);
assert(res == VK_SUCCESS);
/* VULKAN_KEY_END */
const VkCommandBuffer cmd_bufs[] = {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);
execute_queue_cmdbuf(info, cmd_bufs, drawFence);
do {
res = vkWaitForFences(info.device, 1, &drawFence, VK_TRUE, FENCE_TIMEOUT);
} while (res == VK_TIMEOUT);
assert(res == VK_SUCCESS);
vkDestroyFence(info.device, drawFence, NULL);
execute_present_image(info);
wait_seconds(1);
if (info.save_images) write_ppm(info, "input_attachment");
vkDestroySemaphore(info.device, info.imageAcquiredSemaphore, NULL);
vkDestroyImageView(info.device, input_attachment_view, NULL);
vkDestroyImage(info.device, input_image, NULL);
vkFreeMemory(info.device, input_memory, NULL);
destroy_pipeline(info);
destroy_pipeline_cache(info);
destroy_descriptor_pool(info);
destroy_framebuffers(info);
destroy_shaders(info);
destroy_renderpass(info);
destroy_descriptor_and_pipeline_layouts(info);
destroy_swap_chain(info);
destroy_command_buffer(info);
destroy_command_pool(info);
destroy_device(info);
destroy_window(info);
destroy_instance(info);
return 0;
}
int sample_main(int argc, char *argv[]) {
VkResult U_ASSERT_ONLY res;
bool U_ASSERT_ONLY pass;
struct sample_info info = {};
char sample_title[] = "Texel Buffer Sample";
float texels[] = {1.0, 0.0, 1.0};
const bool depthPresent = false;
const bool vertexPresent = false;
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);
if (info.gpu_props.limits.maxTexelBufferElements < 4) {
std::cout << "maxTexelBufferElements too small\n";
exit(-1);
}
VkFormatProperties props;
vkGetPhysicalDeviceFormatProperties(info.gpus[0], VK_FORMAT_R32_SFLOAT, &props);
if (!(props.bufferFeatures & VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT)) {
std::cout << "R32_SFLOAT format unsupported for texel buffer\n";
exit(-1);
}
init_window_size(info, 500, 500);
init_connection(info);
init_window(info);
init_swapchain_extension(info);
init_device(info);
init_command_pool(info);
init_command_buffer(info);
execute_begin_command_buffer(info);
init_device_queue(info);
init_swap_chain(info);
VkBufferCreateInfo buf_info = {};
buf_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
buf_info.pNext = NULL;
buf_info.usage = VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT;
buf_info.size = sizeof(texels);
buf_info.queueFamilyIndexCount = 0;
buf_info.pQueueFamilyIndices = NULL;
buf_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
buf_info.flags = 0;
VkBuffer texelBuf;
res = vkCreateBuffer(info.device, &buf_info, NULL, &texelBuf);
assert(res == VK_SUCCESS);
VkMemoryRequirements mem_reqs;
vkGetBufferMemoryRequirements(info.device, texelBuf, &mem_reqs);
VkMemoryAllocateInfo alloc_info = {};
alloc_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
alloc_info.pNext = NULL;
alloc_info.memoryTypeIndex = 0;
alloc_info.allocationSize = mem_reqs.size;
pass = memory_type_from_properties(info, mem_reqs.memoryTypeBits,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
&alloc_info.memoryTypeIndex);
assert(pass && "No mappable, coherent memory");
VkDeviceMemory texelMem;
res = vkAllocateMemory(info.device, &alloc_info, NULL, &texelMem);
assert(res == VK_SUCCESS);
uint8_t *pData;
res = vkMapMemory(info.device, texelMem, 0, mem_reqs.size, 0, (void **)&pData);
assert(res == VK_SUCCESS);
memcpy(pData, &texels, sizeof(texels));
vkUnmapMemory(info.device, texelMem);
res = vkBindBufferMemory(info.device, texelBuf, texelMem, 0);
assert(res == VK_SUCCESS);
VkBufferView texel_view;
VkBufferViewCreateInfo view_info = {};
view_info.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
view_info.pNext = NULL;
view_info.buffer = texelBuf;
view_info.format = VK_FORMAT_R32_SFLOAT;
view_info.offset = 0;
view_info.range = sizeof(texels);
vkCreateBufferView(info.device, &view_info, NULL, &texel_view);
VkDescriptorBufferInfo texel_buffer_info = {};
texel_buffer_info.buffer = texelBuf;
texel_buffer_info.offset = 0;
texel_buffer_info.range = sizeof(texels);
// init_descriptor_and_pipeline_layouts(info, false);
VkDescriptorSetLayoutBinding layout_bindings[1];
layout_bindings[0].binding = 0;
layout_bindings[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
layout_bindings[0].descriptorCount = 1;
layout_bindings[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
layout_bindings[0].pImmutableSamplers = NULL;
/* Next take layout bindings and use them to create a descriptor set layout
*/
VkDescriptorSetLayoutCreateInfo descriptor_layout = {};
descriptor_layout.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
descriptor_layout.pNext = NULL;
descriptor_layout.bindingCount = 1;
descriptor_layout.pBindings = layout_bindings;
info.desc_layout.resize(NUM_DESCRIPTOR_SETS);
res = vkCreateDescriptorSetLayout(info.device, &descriptor_layout, NULL, info.desc_layout.data());
assert(res == VK_SUCCESS);
/* Now use the descriptor layout to create a pipeline layout */
VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = {};
pPipelineLayoutCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
pPipelineLayoutCreateInfo.pNext = NULL;
pPipelineLayoutCreateInfo.pushConstantRangeCount = 0;
pPipelineLayoutCreateInfo.pPushConstantRanges = NULL;
pPipelineLayoutCreateInfo.setLayoutCount = NUM_DESCRIPTOR_SETS;
pPipelineLayoutCreateInfo.pSetLayouts = info.desc_layout.data();
res = vkCreatePipelineLayout(info.device, &pPipelineLayoutCreateInfo, NULL, &info.pipeline_layout);
assert(res == VK_SUCCESS);
init_renderpass(info, depthPresent);
init_shaders(info, vertShaderText, fragShaderText);
init_framebuffers(info, depthPresent);
VkDescriptorPoolSize type_count[1];
type_count[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
type_count[0].descriptorCount = 1;
VkDescriptorPoolCreateInfo descriptor_pool = {};
descriptor_pool.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
descriptor_pool.pNext = NULL;
descriptor_pool.maxSets = 1;
descriptor_pool.poolSizeCount = 1;
descriptor_pool.pPoolSizes = type_count;
res = vkCreateDescriptorPool(info.device, &descriptor_pool, NULL, &info.desc_pool);
assert(res == VK_SUCCESS);
VkDescriptorSetAllocateInfo desc_alloc_info[1];
desc_alloc_info[0].sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
desc_alloc_info[0].pNext = NULL;
desc_alloc_info[0].descriptorPool = info.desc_pool;
desc_alloc_info[0].descriptorSetCount = NUM_DESCRIPTOR_SETS;
desc_alloc_info[0].pSetLayouts = info.desc_layout.data();
/* Allocate descriptor set with UNIFORM_BUFFER_DYNAMIC */
info.desc_set.resize(NUM_DESCRIPTOR_SETS);
res = vkAllocateDescriptorSets(info.device, desc_alloc_info, info.desc_set.data());
assert(res == VK_SUCCESS);
VkWriteDescriptorSet writes[1];
writes[0] = {};
writes[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
writes[0].dstSet = info.desc_set[0];
writes[0].dstBinding = 0;
writes[0].descriptorCount = 1;
writes[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER;
writes[0].pBufferInfo = &texel_buffer_info;
writes[0].pTexelBufferView = &texel_view;
writes[0].dstArrayElement = 0;
vkUpdateDescriptorSets(info.device, 1, writes, 0, NULL);
init_pipeline_cache(info);
init_pipeline(info, depthPresent, vertexPresent);
/* VULKAN_KEY_START */
VkClearValue clear_values[1];
clear_values[0].color.float32[0] = 0.2f;
clear_values[0].color.float32[1] = 0.2f;
clear_values[0].color.float32[2] = 0.2f;
clear_values[0].color.float32[3] = 0.2f;
VkSemaphoreCreateInfo imageAcquiredSemaphoreCreateInfo;
imageAcquiredSemaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
imageAcquiredSemaphoreCreateInfo.pNext = NULL;
imageAcquiredSemaphoreCreateInfo.flags = 0;
res = vkCreateSemaphore(info.device, &imageAcquiredSemaphoreCreateInfo, NULL, &info.imageAcquiredSemaphore);
assert(res == VK_SUCCESS);
// Get the index of the next available swapchain image:
res = vkAcquireNextImageKHR(info.device, info.swap_chain, UINT64_MAX, info.imageAcquiredSemaphore, 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);
VkRenderPassBeginInfo rp_begin;
rp_begin.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
rp_begin.pNext = NULL;
rp_begin.renderPass = info.render_pass;
rp_begin.framebuffer = info.framebuffers[info.current_buffer];
rp_begin.renderArea.offset.x = 0;
rp_begin.renderArea.offset.y = 0;
rp_begin.renderArea.extent.width = info.width;
rp_begin.renderArea.extent.height = info.height;
rp_begin.clearValueCount = 1;
rp_begin.pClearValues = clear_values;
vkCmdBeginRenderPass(info.cmd, &rp_begin, VK_SUBPASS_CONTENTS_INLINE);
vkCmdBindPipeline(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline);
vkCmdBindDescriptorSets(info.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, info.pipeline_layout, 0, NUM_DESCRIPTOR_SETS,
info.desc_set.data(), 0, NULL);
init_viewports(info);
init_scissors(info);
vkCmdDraw(info.cmd, 3, 1, 0, 0);
vkCmdEndRenderPass(info.cmd);
res = vkEndCommandBuffer(info.cmd);
const VkCommandBuffer cmd_bufs[] = {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);
execute_queue_cmdbuf(info, cmd_bufs, drawFence);
do {
res = vkWaitForFences(info.device, 1, &drawFence, VK_TRUE, FENCE_TIMEOUT);
} while (res == VK_TIMEOUT);
assert(res == VK_SUCCESS);
vkDestroyFence(info.device, drawFence, NULL);
execute_present_image(info);
wait_seconds(1);
/* VULKAN_KEY_END */
if (info.save_images) write_ppm(info, "texel_buffer");
vkDestroySemaphore(info.device, info.imageAcquiredSemaphore, NULL);
vkDestroyBufferView(info.device, texel_view, NULL);
vkDestroyBuffer(info.device, texelBuf, NULL);
vkFreeMemory(info.device, texelMem, NULL);
destroy_pipeline(info);
destroy_pipeline_cache(info);
destroy_descriptor_pool(info);
destroy_framebuffers(info);
destroy_shaders(info);
destroy_renderpass(info);
destroy_descriptor_and_pipeline_layouts(info);
destroy_swap_chain(info);
destroy_command_buffer(info);
destroy_command_pool(info);
destroy_device(info);
destroy_window(info);
destroy_instance(info);
return 0;
}