/**
* Destroy the graphics pipeline.
*/
VkcPipeline::~VkcPipeline()
{
if (logicalDevice != VK_NULL_HANDLE)
{
if (descriptorSet != VK_NULL_HANDLE)
vkFreeDescriptorSets(logicalDevice, descriptorPool, 1, &descriptorSet);
if (setLayout != VK_NULL_HANDLE)
vkDestroyDescriptorSetLayout(logicalDevice, setLayout, nullptr);
if (descriptorPool != VK_NULL_HANDLE)
vkDestroyDescriptorPool(logicalDevice, descriptorPool, nullptr);
if (vertShader != VK_NULL_HANDLE)
vkDestroyShaderModule(logicalDevice, vertShader, nullptr);
if (fragShader != VK_NULL_HANDLE)
vkDestroyShaderModule(logicalDevice, fragShader, nullptr);
if (layout != VK_NULL_HANDLE)
vkDestroyPipelineLayout(logicalDevice, layout, nullptr);
if (handle != VK_NULL_HANDLE)
vkDestroyPipeline(logicalDevice, handle, nullptr);
}
}
void VulkanTexturedQuad::ShutdownImpl()
{
vkDestroyPipeline(device_, pipeline_, nullptr);
vkDestroyPipelineLayout(device_, pipelineLayout_, nullptr);
vkDestroyBuffer(device_, vertexBuffer_, nullptr);
vkDestroyBuffer(device_, indexBuffer_, nullptr);
vkFreeMemory(device_, deviceBufferMemory_, nullptr);
vkDestroyImageView (device_, rubyImageView_, nullptr);
vkDestroyImage (device_, rubyImage_, nullptr);
vkFreeMemory (device_, deviceImageMemory_, nullptr);
vkDestroyBuffer (device_, uploadImageBuffer_, nullptr);
vkFreeMemory (device_, uploadImageMemory_, nullptr);
vkDestroyBuffer (device_, uploadBufferBuffer_, nullptr);
vkFreeMemory (device_, uploadBufferMemory_, nullptr);
vkDestroyDescriptorSetLayout (device_, descriptorSetLayout_, nullptr);
vkDestroyDescriptorPool (device_, descriptorPool_, nullptr);
vkDestroySampler (device_, sampler_, nullptr);
vkDestroyShaderModule(device_, vertexShader_, nullptr);
vkDestroyShaderModule(device_, fragmentShader_, nullptr);
VulkanSample::ShutdownImpl();
}
void Renderer::_DeInitGraphicsPipeline() {
vkDestroyPipelineLayout(_device, _pipeline_layout, nullptr);
_pipeline_layout = nullptr;
vkDestroyShaderModule(_device, _frag_module, nullptr);
_frag_module = nullptr;
vkDestroyShaderModule(_device, _vert_module, nullptr);
_vert_module = nullptr;
vkDestroyPipeline(_device, _graphics_pipeline, nullptr);
_graphics_pipeline = nullptr;
}
void VulkanQuad::ShutdownImpl ()
{
vkDestroyPipeline (device_, pipeline_, nullptr);
vkDestroyPipelineLayout (device_, pipelineLayout_, nullptr);
vkDestroyBuffer (device_, vertexBuffer_, nullptr);
vkDestroyBuffer (device_, indexBuffer_, nullptr);
vkFreeMemory (device_, deviceMemory_, nullptr);
vkDestroyShaderModule (device_, vertexShader_, nullptr);
vkDestroyShaderModule (device_, fragmentShader_, nullptr);
VulkanSample::ShutdownImpl ();
}
ShaderVulkan::~ShaderVulkan()
{
if (shaderModule != nullptr) {
POMDOG_ASSERT(device != nullptr);
vkDestroyShaderModule(device, shaderModule, nullptr);
}
}
VulkanExampleBase::~VulkanExampleBase()
{
// Clean up Vulkan resources
swapChain.cleanup();
if (descriptorPool != VK_NULL_HANDLE)
{
vkDestroyDescriptorPool(device, descriptorPool, nullptr);
}
if (setupCmdBuffer != VK_NULL_HANDLE)
{
vkFreeCommandBuffers(device, cmdPool, 1, &setupCmdBuffer);
}
destroyCommandBuffers();
vkDestroyRenderPass(device, renderPass, nullptr);
for (uint32_t i = 0; i < frameBuffers.size(); i++)
{
vkDestroyFramebuffer(device, frameBuffers[i], nullptr);
}
for (auto& shaderModule : shaderModules)
{
vkDestroyShaderModule(device, shaderModule, nullptr);
}
vkDestroyImageView(device, depthStencil.view, nullptr);
vkDestroyImage(device, depthStencil.image, nullptr);
vkFreeMemory(device, depthStencil.mem, nullptr);
vkDestroyPipelineCache(device, pipelineCache, nullptr);
if (textureLoader)
{
delete textureLoader;
}
vkDestroyCommandPool(device, cmdPool, nullptr);
vkDestroySemaphore(device, semaphores.presentComplete, nullptr);
vkDestroySemaphore(device, semaphores.renderComplete, nullptr);
vkDestroyDevice(device, nullptr);
if (enableValidation)
{
vkDebug::freeDebugCallback(instance);
}
vkDestroyInstance(instance, nullptr);
#if defined(__linux)
#if defined(__ANDROID__)
// todo : android cleanup (if required)
#else
xcb_destroy_window(connection, window);
xcb_disconnect(connection);
#endif
#endif
}
void ShaderStage::clear(VkDevice device)
{
if (m_shaderModule != VK_NULL_HANDLE)
{
vkDestroyShaderModule(device, m_shaderModule, nullptr);
}
m_shaderModule = VK_NULL_HANDLE;
m_entryFunction = "";
}
coVulkanShader::~coVulkanShader()
{
if (shaderModule_vk != VK_NULL_HANDLE)
{
const VkDevice& device_vk = GetVkDevice();
coASSERT(device_vk != VK_NULL_HANDLE);
vkDestroyShaderModule(device_vk, shaderModule_vk, nullptr);
}
}
void VKFragmentProgram::Delete()
{
shader.clear();
if (handle)
{
VkDevice dev = (VkDevice)*vk::get_current_renderer();
vkDestroyShaderModule(dev, handle, NULL);
handle = nullptr;
}
}
void ShaderProgram::destroy() {
for (size_t i = 0; i < StageCount; i++) {
if (stages[i].module) {
vkDestroyShaderModule(vk, stages[i].module, NULL);
stages[i].module = NULL;
}
stages[i].spirv.clear();
stages[i].glsl.clear();
stages[i].entry.clear();
}
}
TextureConverter::~TextureConverter()
{
for (const auto& it : m_palette_conversion_shaders)
{
if (it != VK_NULL_HANDLE)
vkDestroyShaderModule(g_vulkan_context->GetDevice(), it, nullptr);
}
if (m_texel_buffer_view_r8_uint != VK_NULL_HANDLE)
vkDestroyBufferView(g_vulkan_context->GetDevice(), m_texel_buffer_view_r8_uint, nullptr);
if (m_texel_buffer_view_r16_uint != VK_NULL_HANDLE)
vkDestroyBufferView(g_vulkan_context->GetDevice(), m_texel_buffer_view_r16_uint, nullptr);
if (m_texel_buffer_view_r32g32_uint != VK_NULL_HANDLE)
vkDestroyBufferView(g_vulkan_context->GetDevice(), m_texel_buffer_view_r32g32_uint, nullptr);
if (m_texel_buffer_view_rgba8_unorm != VK_NULL_HANDLE)
vkDestroyBufferView(g_vulkan_context->GetDevice(), m_texel_buffer_view_rgba8_unorm, nullptr);
if (m_encoding_render_pass != VK_NULL_HANDLE)
vkDestroyRenderPass(g_vulkan_context->GetDevice(), m_encoding_render_pass, nullptr);
if (m_encoding_render_framebuffer != VK_NULL_HANDLE)
vkDestroyFramebuffer(g_vulkan_context->GetDevice(), m_encoding_render_framebuffer, nullptr);
for (auto& it : m_encoding_shaders)
vkDestroyShaderModule(g_vulkan_context->GetDevice(), it.second, nullptr);
for (const auto& it : m_decoding_pipelines)
{
if (it.second.compute_shader != VK_NULL_HANDLE)
vkDestroyShaderModule(g_vulkan_context->GetDevice(), it.second.compute_shader, nullptr);
}
if (m_rgb_to_yuyv_shader != VK_NULL_HANDLE)
vkDestroyShaderModule(g_vulkan_context->GetDevice(), m_rgb_to_yuyv_shader, nullptr);
if (m_yuyv_to_rgb_shader != VK_NULL_HANDLE)
vkDestroyShaderModule(g_vulkan_context->GetDevice(), m_yuyv_to_rgb_shader, nullptr);
}
void Copy_To_Swapchain::create() {
set_layout = Descriptor_Set_Layout()
.sampler (0, VK_SHADER_STAGE_COMPUTE_BIT)
.sampled_image (1, VK_SHADER_STAGE_COMPUTE_BIT)
.storage_image (2, VK_SHADER_STAGE_COMPUTE_BIT)
.create ("copy_to_swapchain_set_layout");
// pipeline layout
{
VkPushConstantRange range;
range.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
range.offset = 0;
range.size = 8; // uint32 width + uint32 height
VkPipelineLayoutCreateInfo create_info { VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO };
create_info.setLayoutCount = 1;
create_info.pSetLayouts = &set_layout;
create_info.pushConstantRangeCount = 1;
create_info.pPushConstantRanges = ⦥
VK_CHECK(vkCreatePipelineLayout(vk.device, &create_info, nullptr, &pipeline_layout));
}
// pipeline
{
VkShaderModule copy_shader = vk_load_spirv("spirv/copy_to_swapchain.comp.spv");
VkPipelineShaderStageCreateInfo compute_stage { VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO };
compute_stage.stage = VK_SHADER_STAGE_COMPUTE_BIT;
compute_stage.module = copy_shader;
compute_stage.pName = "main";
VkComputePipelineCreateInfo create_info{ VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO };
create_info.stage = compute_stage;
create_info.layout = pipeline_layout;
VK_CHECK(vkCreateComputePipelines(vk.device, VK_NULL_HANDLE, 1, &create_info, nullptr, &pipeline));
vkDestroyShaderModule(vk.device, copy_shader, nullptr);
}
// point sampler
{
VkSamplerCreateInfo create_info { VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO };
VK_CHECK(vkCreateSampler(vk.device, &create_info, nullptr, &point_sampler));
vk_set_debug_name(point_sampler, "point_sampler");
}
}
void VKFragmentProgram::Delete()
{
shader.clear();
if (handle)
{
if (Emu.IsStopped())
{
LOG_WARNING(RSX, "VKFragmentProgram::Delete(): vkDestroyShaderModule(0x%X) avoided", handle);
}
else
{
VkDevice dev = (VkDevice)*vk::get_current_renderer();
vkDestroyShaderModule(dev, handle, NULL);
handle = nullptr;
}
}
}
IShaderModuleSP VKTS_APIENTRY shaderModuleCreate(const VkDevice device, const VkShaderModuleCreateFlags flags, const size_t codeSize, const uint32_t* code)
{
if (!device)
{
return IShaderModuleSP();
}
VkResult result;
VkShaderModuleCreateInfo shaderModuleCreateInfo;
memset(&shaderModuleCreateInfo, 0, sizeof(VkShaderModuleCreateInfo));
shaderModuleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
shaderModuleCreateInfo.flags = flags;
shaderModuleCreateInfo.codeSize = codeSize;
shaderModuleCreateInfo.pCode = code;
VkShaderModule shaderModule;
result = vkCreateShaderModule(device, &shaderModuleCreateInfo, nullptr, &shaderModule);
if (result != VK_SUCCESS)
{
logPrint(VKTS_LOG_ERROR, "Shader: Could not create shader module.");
return IShaderModuleSP();
}
auto newInstance = new ShaderModule(device, flags, codeSize, code, shaderModule);
if (!newInstance)
{
vkDestroyShaderModule(device, shaderModule, nullptr);
return IShaderModuleSP();
}
return IShaderModuleSP(newInstance);
}
VulkanBase::~VulkanBase() {
swapChain.cleanup();
vkDestroyDescriptorPool(device, descriptorPool, nullptr);
if (setupCmdBuffer != VK_NULL_HANDLE)
vkFreeCommandBuffers(device, cmdPool, 1, &setupCmdBuffer);
destroyCommandBuffers();
vkDestroyRenderPass(device, renderPass, nullptr);
for (uint32_t i = 0; i < frameBuffers.size(); i++)
vkDestroyFramebuffer(device, frameBuffers[i], nullptr);
for (auto& shaderModule : shaderModules)
vkDestroyShaderModule(device, shaderModule, nullptr);
vkDestroyImageView(device, depthStencil.view, nullptr);
vkDestroyImage(device, depthStencil.image, nullptr);
vkFreeMemory(device, depthStencil.mem, nullptr);
vkDestroyPipelineCache(device, pipelineCache, nullptr);
if (textureLoader)
delete textureLoader;
vkDestroyCommandPool(device, cmdPool, nullptr);
vkDestroySemaphore(device, semaphores.presentComplete, nullptr);
vkDestroySemaphore(device, semaphores.renderComplete, nullptr);
vkDestroyDevice(device, nullptr);
if (enableValidation)
vkDebug::freeDebugCallback(instance);
vkDestroyInstance(instance, nullptr);
}
void createGraphicsPipeline() {
auto vertShaderCode = readFile("shaders/vert.spv");
auto fragShaderCode = readFile("shaders/frag.spv");
VkShaderModule vertShaderModule = createShaderModule(vertShaderCode);
VkShaderModule fragShaderModule = createShaderModule(fragShaderCode);
VkPipelineShaderStageCreateInfo vertShaderStageInfo = {};
vertShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
vertShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
vertShaderStageInfo.module = vertShaderModule;
vertShaderStageInfo.pName = "main";
VkPipelineShaderStageCreateInfo fragShaderStageInfo = {};
fragShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
fragShaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
fragShaderStageInfo.module = fragShaderModule;
fragShaderStageInfo.pName = "main";
VkPipelineShaderStageCreateInfo shaderStages[] = {vertShaderStageInfo, fragShaderStageInfo};
VkPipelineVertexInputStateCreateInfo vertexInputInfo = {};
vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
vertexInputInfo.vertexBindingDescriptionCount = 0;
vertexInputInfo.vertexAttributeDescriptionCount = 0;
VkPipelineInputAssemblyStateCreateInfo inputAssembly = {};
inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
inputAssembly.primitiveRestartEnable = VK_FALSE;
VkViewport viewport = {};
viewport.x = 0.0f;
viewport.y = 0.0f;
viewport.width = (float) swapChainExtent.width;
viewport.height = (float) swapChainExtent.height;
viewport.minDepth = 0.0f;
viewport.maxDepth = 1.0f;
VkRect2D scissor = {};
scissor.offset = {0, 0};
scissor.extent = swapChainExtent;
VkPipelineViewportStateCreateInfo viewportState = {};
viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
viewportState.viewportCount = 1;
viewportState.pViewports = &viewport;
viewportState.scissorCount = 1;
viewportState.pScissors = &scissor;
VkPipelineRasterizationStateCreateInfo rasterizer = {};
rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
rasterizer.depthClampEnable = VK_FALSE;
rasterizer.rasterizerDiscardEnable = VK_FALSE;
rasterizer.polygonMode = VK_POLYGON_MODE_FILL;
rasterizer.lineWidth = 1.0f;
rasterizer.cullMode = VK_CULL_MODE_BACK_BIT;
rasterizer.frontFace = VK_FRONT_FACE_CLOCKWISE;
rasterizer.depthBiasEnable = VK_FALSE;
VkPipelineMultisampleStateCreateInfo multisampling = {};
multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
multisampling.sampleShadingEnable = VK_FALSE;
multisampling.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
VkPipelineColorBlendAttachmentState colorBlendAttachment = {};
colorBlendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
colorBlendAttachment.blendEnable = VK_FALSE;
VkPipelineColorBlendStateCreateInfo colorBlending = {};
colorBlending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
colorBlending.logicOpEnable = VK_FALSE;
colorBlending.logicOp = VK_LOGIC_OP_COPY;
colorBlending.attachmentCount = 1;
colorBlending.pAttachments = &colorBlendAttachment;
colorBlending.blendConstants[0] = 0.0f;
colorBlending.blendConstants[1] = 0.0f;
colorBlending.blendConstants[2] = 0.0f;
colorBlending.blendConstants[3] = 0.0f;
VkPipelineLayoutCreateInfo pipelineLayoutInfo = {};
pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
pipelineLayoutInfo.setLayoutCount = 0;
pipelineLayoutInfo.pushConstantRangeCount = 0;
if (vkCreatePipelineLayout(device, &pipelineLayoutInfo, nullptr, &pipelineLayout) != VK_SUCCESS) {
throw std::runtime_error("failed to create pipeline layout!");
}
vkDestroyShaderModule(device, fragShaderModule, nullptr);
vkDestroyShaderModule(device, vertShaderModule, nullptr);
}
bool ShaderProgram::compile(const char *name) {
EShMessages messages = (EShMessages)(EShMsgSpvRules | EShMsgVulkanRules);
glslang::TProgram program;
const char *stageNames[StageCount] = {"Vertex", "TessControl", "TessEvaluation", "Geometry", "Fragment", "Compute"};
const char *extensions[StageCount] = { "vert", "tesc", "tese", "geom", "frag", "comp" };
glslang::TShader tShaders[EShLangCount] = {
glslang::TShader(EShLangVertex),
glslang::TShader(EShLangTessControl),
glslang::TShader(EShLangTessEvaluation),
glslang::TShader(EShLangGeometry),
glslang::TShader(EShLangFragment),
glslang::TShader(EShLangCompute)
};
//#define glslangValidator "C:\\VulkanSDK\\1.0.21.1\\Bin\\glslangValidator.exe"
#ifdef glslangValidator
char szCommand[1024];
sprintf(szCommand, glslangValidator " -V");
#endif
const char *psz = NULL;
for (int i = 0; i < EShLangCount; i++) {
if (stages[i].glsl.empty())
continue;
#ifdef glslangValidator
VK::Path pGLSL = VK::Path::Shader().add("temp.%s", extensions[i]);
strcat(szCommand, " ");
strcat(szCommand, pGLSL.basename().c_str());
std::ofstream os(pGLSL, std::ios::binary);
os << stages[i].glsl;
os.close();
#endif
psz = stages[i].glsl.c_str();
tShaders[i].setStrings(&psz, 1);
if (!stages[i].entry.empty())
tShaders[i].setEntryPoint(stages[i].entry.c_str());
VKLogDebug("%s stage for program: %s\n%s", stageNames[i], name, stages[i].glsl.c_str());
if (!tShaders[i].parse(&DefaultTBuiltInResource, 110, false, messages)) {
psz = tShaders[i].getInfoLog();
if (psz && *psz)
VKLogError("%s", psz);
return false;
}
psz = tShaders[i].getInfoLog();
if (psz && *psz)
VKLogInfo("%s stage parsing info for program: %s\n%s", stageNames[i], name, psz);
psz = tShaders[i].getInfoDebugLog();
if (psz && *psz)
VKLogDebug("%s stage debug info for program: %s\n%s", stageNames[i], name, psz);
program.addShader(&tShaders[i]);
}
if (!program.link(messages)) {
psz = program.getInfoLog();
if (psz && *psz)
VKLogError("Link failed for program: %s\n%s", name, psz);
return false;
}
#ifdef glslangValidator
LaunchAndWait(szCommand, VK::Path::Shader(), 0, 0, SW_HIDE);
#endif
for (int i = 0; i < EShLangCount; i++) {
stages[i].spirv.clear();
if (stages[i].module) {
vkDestroyShaderModule(vk, stages[i].module, NULL);
stages[i].module = NULL;
}
glslang::TIntermediate *intermediate = program.getIntermediate((EShLanguage)i);
if (intermediate) {
glslang::GlslangToSpv(*intermediate, stages[i].spirv);
#ifdef glslangValidator
VK::Path p = VK::Path::Shader().add("%s.spv", extensions[i]);
std::string str = p.read();
std::vector<uint32_t> spirv;
spirv.resize(str.size() / 4);
memcpy(&spirv[0], str.c_str(), str.size());
if (spirv.size() != stages[i].spirv.size() || memcmp(&spirv[0], &stages[i].spirv[0], spirv.size() * 4) != 0)
VKLogWarning("glslangValidator mismatch!");
#endif
std::ostringstream ostr;
spv::Disassemble(ostr, stages[i].spirv);
VKLogDebug("%s stage dissassembly for program: %s\n%s", stageNames[i], name, ostr.str().c_str());
ShaderModuleCreateInfo shader(stages[i].spirv);
OBJ_CHECK(vkCreateShaderModule(vk, &shader, nullptr, &stages[i].module));
}
}
return true;
}
int main(void) {
VkInstance instance;
{
const char debug_ext[] = "VK_EXT_debug_report";
const char* extensions[] = {debug_ext,};
const char validation_layer[] = "VK_LAYER_LUNARG_standard_validation";
const char* layers[] = {validation_layer,};
VkInstanceCreateInfo create_info = {
.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.pApplicationInfo = NULL,
.enabledLayerCount = NELEMS(layers),
.ppEnabledLayerNames = layers,
.enabledExtensionCount = NELEMS(extensions),
.ppEnabledExtensionNames = extensions,
};
assert(vkCreateInstance(&create_info, NULL, &instance) == VK_SUCCESS);
}
VkDebugReportCallbackEXT debug_callback;
{
VkDebugReportCallbackCreateInfoEXT create_info = {
.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT,
.pNext = NULL,
.flags = (VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT |
VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT),
.pfnCallback = &debugReportCallback,
.pUserData = NULL,
};
PFN_vkCreateDebugReportCallbackEXT createDebugReportCallback =
(PFN_vkCreateDebugReportCallbackEXT) vkGetInstanceProcAddr(instance, "vkCreateDebugReportCallbackEXT");
assert(createDebugReportCallback);
assert(createDebugReportCallback(instance, &create_info, NULL, &debug_callback) == VK_SUCCESS);
}
VkPhysicalDevice phy_device;
{
uint32_t num_devices;
assert(vkEnumeratePhysicalDevices(instance, &num_devices, NULL) == VK_SUCCESS);
assert(num_devices >= 1);
VkPhysicalDevice * phy_devices = malloc(sizeof(*phy_devices) * num_devices);
assert(vkEnumeratePhysicalDevices(instance, &num_devices, phy_devices) == VK_SUCCESS);
phy_device = phy_devices[0];
free(phy_devices);
}
VkPhysicalDeviceMemoryProperties memory_properties;
vkGetPhysicalDeviceMemoryProperties(phy_device, &memory_properties);
VkDevice device;
{
float queue_priorities[] = {1.0};
const char validation_layer[] = "VK_LAYER_LUNARG_standard_validation";
const char* layers[] = {validation_layer,};
uint32_t nqueues;
matchingQueues(phy_device, VK_QUEUE_GRAPHICS_BIT, &nqueues, NULL);
assert(nqueues > 0);
uint32_t * queue_family_idxs = malloc(sizeof(*queue_family_idxs) * nqueues);
matchingQueues(phy_device, VK_QUEUE_GRAPHICS_BIT, &nqueues, queue_family_idxs);
VkDeviceQueueCreateInfo queue_info = {
.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.queueFamilyIndex = queue_family_idxs[0],
.queueCount = 1,
.pQueuePriorities = queue_priorities,
};
free(queue_family_idxs);
VkPhysicalDeviceFeatures features = {
.geometryShader = VK_TRUE,
.fillModeNonSolid = VK_TRUE,
};
VkDeviceCreateInfo create_info = {
.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.queueCreateInfoCount = 1,
.pQueueCreateInfos = &queue_info,
.enabledLayerCount = NELEMS(layers),
.ppEnabledLayerNames = layers,
.enabledExtensionCount = 0,
.ppEnabledExtensionNames = NULL,
.pEnabledFeatures = &features,
};
assert(vkCreateDevice(phy_device, &create_info, NULL, &device) == VK_SUCCESS);
}
VkQueue queue;
vkGetDeviceQueue(device, 0, 0, &queue);
VkCommandPool cmd_pool;
{
VkCommandPoolCreateInfo create_info = {
.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
.pNext = NULL,
.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
.queueFamilyIndex = 0,
};
assert(vkCreateCommandPool(device, &create_info, NULL, &cmd_pool) == VK_SUCCESS);
}
VkRenderPass render_pass;
{
VkAttachmentDescription attachments[] = {{
.flags = 0,
.format = VK_FORMAT_R8G8B8A8_UNORM,
.samples = VK_SAMPLE_COUNT_8_BIT,
.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
}, {
.flags = 0,
.format = VK_FORMAT_D16_UNORM,
.samples = VK_SAMPLE_COUNT_8_BIT,
.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
}, {
.flags = 0,
.format = VK_FORMAT_R8G8B8A8_UNORM,
.samples = VK_SAMPLE_COUNT_1_BIT,
.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
.storeOp = VK_ATTACHMENT_STORE_OP_STORE,
.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
.finalLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
}};
VkAttachmentReference attachment_refs[NELEMS(attachments)] = {{
.attachment = 0,
.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
}, {
.attachment = 1,
.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
}, {
.attachment = 2,
.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
}};
VkSubpassDescription subpasses[1] = {{
.flags = 0,
.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
.inputAttachmentCount = 0,
.pInputAttachments = NULL,
.colorAttachmentCount = 1,
.pColorAttachments = &attachment_refs[0],
.pResolveAttachments = &attachment_refs[2],
.pDepthStencilAttachment = &attachment_refs[1],
.preserveAttachmentCount = 0,
.pPreserveAttachments = NULL,
}};
VkSubpassDependency dependencies[] = {{
.srcSubpass = 0,
.dstSubpass = VK_SUBPASS_EXTERNAL,
.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
.dstStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT,
.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT,
.dependencyFlags = 0,
}};
VkRenderPassCreateInfo create_info = {
.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.attachmentCount = NELEMS(attachments),
.pAttachments = attachments,
.subpassCount = NELEMS(subpasses),
.pSubpasses = subpasses,
.dependencyCount = NELEMS(dependencies),
.pDependencies = dependencies,
};
assert(vkCreateRenderPass(device, &create_info, NULL, &render_pass) == VK_SUCCESS);
}
VkImage images[3];
VkDeviceMemory image_memories[NELEMS(images)];
VkImageView views[NELEMS(images)];
createFrameImage(memory_properties, device, render_size,
VK_FORMAT_R8G8B8A8_UNORM, VK_SAMPLE_COUNT_8_BIT,
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, VK_IMAGE_ASPECT_COLOR_BIT,
&images[0], &image_memories[0], &views[0]);
createFrameImage(memory_properties, device, render_size,
VK_FORMAT_D16_UNORM, VK_SAMPLE_COUNT_8_BIT,
VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_IMAGE_ASPECT_DEPTH_BIT,
&images[1], &image_memories[1], &views[1]);
createFrameImage(memory_properties, device, render_size,
VK_FORMAT_R8G8B8A8_UNORM, VK_SAMPLE_COUNT_1_BIT,
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
VK_IMAGE_ASPECT_COLOR_BIT,
&images[2], &image_memories[2], &views[2]);
VkBuffer verts_buffer;
VkDeviceMemory verts_memory;
createBuffer(memory_properties, device, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, sizeof(verts), verts, &verts_buffer, &verts_memory);
VkBuffer index_buffer;
VkDeviceMemory index_memory;
createBuffer(memory_properties, device, VK_BUFFER_USAGE_INDEX_BUFFER_BIT, sizeof(indices), indices, &index_buffer, &index_memory);
VkBuffer image_buffer;
VkDeviceMemory image_buffer_memory;
createBuffer(memory_properties, device, VK_BUFFER_USAGE_TRANSFER_DST_BIT, render_size.height * render_size.width * 4, NULL, &image_buffer, &image_buffer_memory);
VkFramebuffer framebuffer;
createFramebuffer(device, render_size, 3, views, render_pass, &framebuffer);
VkShaderModule shaders[5];
{
char* filenames[NELEMS(shaders)] = {"cube.vert.spv", "cube.geom.spv", "cube.frag.spv", "wireframe.geom.spv", "color.frag.spv"};
for (size_t i = 0; i < NELEMS(shaders); i++){
size_t code_size;
uint32_t * code;
assert((code_size = loadModule(filenames[i], &code)) != 0);
VkShaderModuleCreateInfo create_info = {
.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.codeSize = code_size,
.pCode = code,
};
assert(vkCreateShaderModule(device, &create_info, NULL, &shaders[i]) == VK_SUCCESS);
free(code);
}
}
VkPipelineLayout pipeline_layout;
{
VkPushConstantRange push_range = {
.stageFlags = VK_SHADER_STAGE_VERTEX_BIT,
.offset = 0,
.size = 4,
};
VkPipelineLayoutCreateInfo create_info = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.setLayoutCount = 0,
.pSetLayouts = NULL,
.pushConstantRangeCount = 1,
.pPushConstantRanges = &push_range,
};
assert(vkCreatePipelineLayout(device, &create_info, NULL, &pipeline_layout) == VK_SUCCESS);
}
VkPipeline pipelines[2];
{
VkPipelineShaderStageCreateInfo stages[3] = {{
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.stage = VK_SHADER_STAGE_VERTEX_BIT,
.module = shaders[0],
.pName = "main",
.pSpecializationInfo = NULL,
},{
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.stage = VK_SHADER_STAGE_GEOMETRY_BIT,
.module = shaders[1],
.pName = "main",
.pSpecializationInfo = NULL,
},{
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.stage = VK_SHADER_STAGE_FRAGMENT_BIT,
.module = shaders[2],
.pName = "main",
.pSpecializationInfo = NULL,
}};
VkVertexInputBindingDescription vtx_binding = {
.binding = 0,
.stride = sizeof(struct Vertex),
.inputRate = VK_VERTEX_INPUT_RATE_VERTEX,
};
VkVertexInputAttributeDescription vtx_attr = {
.location = 0,
.binding = 0,
.format = VK_FORMAT_R32G32B32_SFLOAT,
.offset = offsetof(struct Vertex, pos),
};
VkPipelineVertexInputStateCreateInfo vtx_state = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.vertexBindingDescriptionCount = 1,
.pVertexBindingDescriptions = &vtx_binding,
.vertexAttributeDescriptionCount = 1,
.pVertexAttributeDescriptions = &vtx_attr,
};
VkPipelineInputAssemblyStateCreateInfo ia_state = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
.primitiveRestartEnable = VK_TRUE,
};
VkViewport viewport = {
.x = 0,
.y = 0,
.width = render_size.width,
.height = render_size.height,
.minDepth = 0.0,
.maxDepth = 1.0,
};
VkRect2D scissor= {
.offset = {.x = 0, .y = 0,},
.extent = render_size,
};
VkPipelineViewportStateCreateInfo viewport_state = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.viewportCount = 1,
.pViewports = &viewport,
.scissorCount = 1,
.pScissors = &scissor,
};
VkPipelineRasterizationStateCreateInfo rasterization_state = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.depthClampEnable = VK_FALSE,
.rasterizerDiscardEnable = VK_FALSE,
.polygonMode = VK_POLYGON_MODE_FILL,
.cullMode = VK_CULL_MODE_NONE,
.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE,
.depthBiasEnable = VK_FALSE,
.lineWidth = 1.0,
};
VkPipelineMultisampleStateCreateInfo multisample_state = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.rasterizationSamples = VK_SAMPLE_COUNT_8_BIT,
.sampleShadingEnable = VK_FALSE,
.minSampleShading = 0.0,
.pSampleMask = NULL,
.alphaToCoverageEnable = VK_FALSE,
.alphaToOneEnable = VK_FALSE,
};
VkPipelineDepthStencilStateCreateInfo depth_stencil_state = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.depthTestEnable = VK_TRUE,
.depthWriteEnable = VK_TRUE,
.depthCompareOp = VK_COMPARE_OP_LESS_OR_EQUAL,
.depthBoundsTestEnable = VK_FALSE,
.stencilTestEnable = VK_FALSE,
.front = {},
.back = {},
.minDepthBounds = 0.0,
.maxDepthBounds = 1.0,
};
VkPipelineColorBlendAttachmentState color_blend_attachment = {
.blendEnable = VK_FALSE,
.colorWriteMask = ( VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT
| VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT),
};
VkPipelineColorBlendStateCreateInfo color_blend_state = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.logicOpEnable = VK_FALSE, //.logicOp = 0,
.attachmentCount = 1,
.pAttachments = &color_blend_attachment,
.blendConstants = {},
};
VkGraphicsPipelineCreateInfo create_info = {
.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
.pNext = NULL,
.flags = 0,
.stageCount = NELEMS(stages),
.pStages = stages,
.pVertexInputState = &vtx_state,
.pInputAssemblyState = &ia_state,
.pTessellationState = NULL,
.pViewportState = &viewport_state,
.pRasterizationState = &rasterization_state,
.pMultisampleState = &multisample_state,
.pDepthStencilState = &depth_stencil_state,
.pColorBlendState = &color_blend_state,
.pDynamicState = NULL,
.layout = pipeline_layout,
.renderPass = render_pass,
.subpass = 0,
.basePipelineHandle = VK_NULL_HANDLE,
.basePipelineIndex = 0,
};
assert(vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &create_info, NULL, &pipelines[0]) == VK_SUCCESS);
stages[1].module = shaders[3];
stages[2].module = shaders[4];
rasterization_state.polygonMode = VK_POLYGON_MODE_LINE;
assert(vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &create_info, NULL, &pipelines[1]) == VK_SUCCESS);
}
VkCommandBuffer draw_buffers[2];
{
VkCommandBufferAllocateInfo allocate_info = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
.pNext = NULL,
.commandPool = cmd_pool,
.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
.commandBufferCount = NELEMS(draw_buffers),
};
assert(vkAllocateCommandBuffers(device, &allocate_info, draw_buffers) == VK_SUCCESS);
}
{
VkCommandBufferBeginInfo begin_info = {
.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
.pNext = NULL,
.flags = 0,
.pInheritanceInfo = NULL,
};
VkClearValue clear_values[] = {{
.color.float32 = {0.0, 0.0, 0.0, 1.0},
}, {
.depthStencil = {.depth = 1.0},
}};
VkRenderPassBeginInfo renderpass_begin_info = {
.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
.pNext = NULL,
.renderPass = render_pass,
.framebuffer = framebuffer,
.renderArea = {
.offset = {.x = 0, .y = 0},
.extent = render_size,
},
.clearValueCount = NELEMS(clear_values),
.pClearValues = clear_values,
};
for (size_t i = 0; i < NELEMS(draw_buffers); i++){
assert(vkBeginCommandBuffer(draw_buffers[i], &begin_info) == VK_SUCCESS);
uint32_t persp = i == 0;
vkCmdPushConstants(draw_buffers[i], pipeline_layout, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(persp), &persp);
vkCmdBeginRenderPass(draw_buffers[i], &renderpass_begin_info, VK_SUBPASS_CONTENTS_INLINE);
VkDeviceSize offset = 0;
vkCmdBindVertexBuffers(draw_buffers[i], 0, 1, &verts_buffer, &offset);
vkCmdBindIndexBuffer(draw_buffers[i], index_buffer, 0, VK_INDEX_TYPE_UINT32);
for (size_t j = 0; j < NELEMS(pipelines); j++) {
vkCmdBindPipeline(draw_buffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines[j]);
vkCmdDrawIndexed(draw_buffers[i], 20, 27, 0, 0, 0);
}
vkCmdEndRenderPass(draw_buffers[i]);
}
VkBufferImageCopy copy = {
.bufferOffset = 0,
.bufferRowLength = 0, // Tightly packed
.bufferImageHeight = 0, // Tightly packed
.imageSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1},
.imageOffset = {0, 0, 0},
.imageExtent = {.width = render_size.width,
.height = render_size.height,
.depth = 1},
};
VkBufferMemoryBarrier transfer_barrier = {
.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
.pNext = 0,
.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
.dstAccessMask = VK_ACCESS_HOST_READ_BIT,
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.buffer = image_buffer,
.offset = 0,
.size = VK_WHOLE_SIZE,
};
for (size_t i = 0; i < NELEMS(draw_buffers); i++){
vkCmdCopyImageToBuffer(draw_buffers[i], images[2], VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, image_buffer, 1, ©);
vkCmdPipelineBarrier(draw_buffers[i], VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0, 0, NULL, 1, &transfer_barrier, 0, NULL);
assert(vkEndCommandBuffer(draw_buffers[i]) == VK_SUCCESS);
}
}
VkFence fence;
{
VkFenceCreateInfo create_info = {
.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
.pNext = 0,
.flags = 0,
};
assert(vkCreateFence(device, &create_info, NULL, &fence) == VK_SUCCESS);
}
{
char * filenames[] = {"cube_persp.tif", "cube_ortho.tif"};
char * image_data;
assert(vkMapMemory(device, image_buffer_memory, 0, VK_WHOLE_SIZE, 0, (void **) &image_data) == VK_SUCCESS);
VkMappedMemoryRange image_flush = {
.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE, .pNext = NULL,
.memory = image_buffer_memory,
.offset = 0,
.size = VK_WHOLE_SIZE,
};
VkSubmitInfo submit_info = {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
.pNext = NULL,
.waitSemaphoreCount = 0,
.pWaitSemaphores = NULL,
.pWaitDstStageMask = NULL,
.commandBufferCount = 1,
.pCommandBuffers = NULL,
.signalSemaphoreCount = 0,
.pSignalSemaphores = NULL,
};
for (size_t i = 0; i < NELEMS(filenames); i++){
submit_info.pCommandBuffers = &draw_buffers[i];
assert(vkResetFences(device, 1, &fence) == VK_SUCCESS);
assert(vkQueueSubmit(queue, 1, &submit_info, fence) == VK_SUCCESS);
assert(vkWaitForFences(device, 1, &fence, VK_TRUE, UINT64_MAX) == VK_SUCCESS);
assert(vkInvalidateMappedMemoryRanges(device, 1, &image_flush) == VK_SUCCESS);
assert(writeTiff(filenames[i], image_data, render_size, nchannels) == 0);
}
vkUnmapMemory(device, image_buffer_memory);
}
assert(vkQueueWaitIdle(queue) == VK_SUCCESS);
vkDestroyFence(device, fence, NULL);
vkDestroyFramebuffer(device, framebuffer, NULL);
for (size_t i = 0; i < NELEMS(images); i++){
vkDestroyImage(device, images[i], NULL);
vkDestroyImageView(device, views[i], NULL);
vkFreeMemory(device, image_memories[i], NULL);
}
vkDestroyBuffer(device, image_buffer, NULL);
vkFreeMemory(device, image_buffer_memory, NULL);
vkDestroyBuffer(device, verts_buffer, NULL);
vkFreeMemory(device, verts_memory, NULL);
vkDestroyBuffer(device, index_buffer, NULL);
vkFreeMemory(device, index_memory, NULL);
for (size_t i = 0; i < NELEMS(pipelines); i++){
vkDestroyPipeline(device, pipelines[i], NULL);
}
vkDestroyPipelineLayout(device, pipeline_layout, NULL);
for(size_t i = 0; i < NELEMS(shaders); i++)
vkDestroyShaderModule(device, shaders[i], NULL);
vkDestroyRenderPass(device, render_pass, NULL);
vkFreeCommandBuffers(device, cmd_pool, NELEMS(draw_buffers), draw_buffers);
vkDestroyCommandPool(device, cmd_pool, NULL);
vkDestroyDevice(device, NULL);
{
PFN_vkDestroyDebugReportCallbackEXT destroyDebugReportCallback =
(PFN_vkDestroyDebugReportCallbackEXT) vkGetInstanceProcAddr(instance, "vkDestroyDebugReportCallbackEXT");
assert(destroyDebugReportCallback);
destroyDebugReportCallback(instance, debug_callback, NULL);
}
vkDestroyInstance(instance, NULL);
return 0;
}
bool ImGui_ImplGlfwVulkan_CreateDeviceObjects()
{
VkResult err;
VkShaderModule vert_module;
VkShaderModule frag_module;
// Create The Shader Modules:
{
VkShaderModuleCreateInfo vert_info = {};
vert_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
vert_info.codeSize = __glsl_shader_vert_spv_len;
vert_info.pCode = (uint32_t*)__glsl_shader_vert_spv;
err = vkCreateShaderModule(g_Device, &vert_info, g_Allocator, &vert_module);
ImGui_ImplGlfwVulkan_VkResult(err);
VkShaderModuleCreateInfo frag_info = {};
frag_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
frag_info.codeSize = __glsl_shader_frag_spv_len;
frag_info.pCode = (uint32_t*)__glsl_shader_frag_spv;
err = vkCreateShaderModule(g_Device, &frag_info, g_Allocator, &frag_module);
ImGui_ImplGlfwVulkan_VkResult(err);
}
if (!g_FontSampler)
{
VkSamplerCreateInfo info = {};
info.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
info.magFilter = VK_FILTER_LINEAR;
info.minFilter = VK_FILTER_LINEAR;
info.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
info.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
info.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
info.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
info.minLod = -1000;
info.maxLod = 1000;
err = vkCreateSampler(g_Device, &info, g_Allocator, &g_FontSampler);
ImGui_ImplGlfwVulkan_VkResult(err);
}
if (!g_DescriptorSetLayout)
{
VkSampler sampler[1] = {g_FontSampler};
VkDescriptorSetLayoutBinding binding[1] = {};
binding[0].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
binding[0].descriptorCount = 1;
binding[0].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
binding[0].pImmutableSamplers = sampler;
VkDescriptorSetLayoutCreateInfo info = {};
info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
info.bindingCount = 1;
info.pBindings = binding;
err = vkCreateDescriptorSetLayout(g_Device, &info, g_Allocator, &g_DescriptorSetLayout);
ImGui_ImplGlfwVulkan_VkResult(err);
}
// Create Descriptor Set:
{
VkDescriptorSetAllocateInfo alloc_info = {};
alloc_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
alloc_info.descriptorPool = g_DescriptorPool;
alloc_info.descriptorSetCount = 1;
alloc_info.pSetLayouts = &g_DescriptorSetLayout;
err = vkAllocateDescriptorSets(g_Device, &alloc_info, &g_DescriptorSet);
ImGui_ImplGlfwVulkan_VkResult(err);
}
if (!g_PipelineLayout)
{
VkPushConstantRange push_constants[1] = {};
push_constants[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
push_constants[0].offset = sizeof(float) * 0;
push_constants[0].size = sizeof(float) * 4;
VkDescriptorSetLayout set_layout[1] = {g_DescriptorSetLayout};
VkPipelineLayoutCreateInfo layout_info = {};
layout_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
layout_info.setLayoutCount = 1;
layout_info.pSetLayouts = set_layout;
layout_info.pushConstantRangeCount = 1;
layout_info.pPushConstantRanges = push_constants;
err = vkCreatePipelineLayout(g_Device, &layout_info, g_Allocator, &g_PipelineLayout);
ImGui_ImplGlfwVulkan_VkResult(err);
}
VkPipelineShaderStageCreateInfo stage[2] = {};
stage[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
stage[0].stage = VK_SHADER_STAGE_VERTEX_BIT;
stage[0].module = vert_module;
stage[0].pName = "main";
stage[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
stage[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
stage[1].module = frag_module;
stage[1].pName = "main";
VkVertexInputBindingDescription binding_desc[1] = {};
binding_desc[0].stride = sizeof(ImDrawVert);
binding_desc[0].inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
VkVertexInputAttributeDescription attribute_desc[3] = {};
attribute_desc[0].location = 0;
attribute_desc[0].binding = binding_desc[0].binding;
attribute_desc[0].format = VK_FORMAT_R32G32_SFLOAT;
attribute_desc[0].offset = (size_t)(&((ImDrawVert*)0)->pos);
attribute_desc[1].location = 1;
attribute_desc[1].binding = binding_desc[0].binding;
attribute_desc[1].format = VK_FORMAT_R32G32_SFLOAT;
attribute_desc[1].offset = (size_t)(&((ImDrawVert*)0)->uv);
attribute_desc[2].location = 2;
attribute_desc[2].binding = binding_desc[0].binding;
attribute_desc[2].format = VK_FORMAT_R8G8B8A8_UNORM;
attribute_desc[2].offset = (size_t)(&((ImDrawVert*)0)->col);
VkPipelineVertexInputStateCreateInfo vertex_info = {};
vertex_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
vertex_info.vertexBindingDescriptionCount = 1;
vertex_info.pVertexBindingDescriptions = binding_desc;
vertex_info.vertexAttributeDescriptionCount = 3;
vertex_info.pVertexAttributeDescriptions = attribute_desc;
VkPipelineInputAssemblyStateCreateInfo ia_info = {};
ia_info.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
ia_info.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
VkPipelineViewportStateCreateInfo viewport_info = {};
viewport_info.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
viewport_info.viewportCount = 1;
viewport_info.scissorCount = 1;
VkPipelineRasterizationStateCreateInfo raster_info = {};
raster_info.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
raster_info.polygonMode = VK_POLYGON_MODE_FILL;
raster_info.cullMode = VK_CULL_MODE_NONE;
raster_info.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
raster_info.lineWidth = 1.0f;
VkPipelineMultisampleStateCreateInfo ms_info = {};
ms_info.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
ms_info.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
VkPipelineColorBlendAttachmentState color_attachment[1] = {};
color_attachment[0].blendEnable = VK_TRUE;
color_attachment[0].srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
color_attachment[0].dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
color_attachment[0].colorBlendOp = VK_BLEND_OP_ADD;
color_attachment[0].srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
color_attachment[0].dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
color_attachment[0].alphaBlendOp = VK_BLEND_OP_ADD;
color_attachment[0].colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
VkPipelineDepthStencilStateCreateInfo depth_info = {};
depth_info.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
VkPipelineColorBlendStateCreateInfo blend_info = {};
blend_info.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
blend_info.attachmentCount = 1;
blend_info.pAttachments = color_attachment;
VkDynamicState dynamic_states[2] = { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR };
VkPipelineDynamicStateCreateInfo dynamic_state = {};
dynamic_state.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
dynamic_state.dynamicStateCount = 2;
dynamic_state.pDynamicStates = dynamic_states;
VkGraphicsPipelineCreateInfo info = {};
info.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
info.flags = g_PipelineCreateFlags;
info.stageCount = 2;
info.pStages = stage;
info.pVertexInputState = &vertex_info;
info.pInputAssemblyState = &ia_info;
info.pViewportState = &viewport_info;
info.pRasterizationState = &raster_info;
info.pMultisampleState = &ms_info;
info.pDepthStencilState = &depth_info;
info.pColorBlendState = &blend_info;
info.pDynamicState = &dynamic_state;
info.layout = g_PipelineLayout;
info.renderPass = g_RenderPass;
err = vkCreateGraphicsPipelines(g_Device, g_PipelineCache, 1, &info, g_Allocator, &g_Pipeline);
ImGui_ImplGlfwVulkan_VkResult(err);
vkDestroyShaderModule(g_Device, vert_module, g_Allocator);
vkDestroyShaderModule(g_Device, frag_module, g_Allocator);
return true;
}
CVulkanShader::~CVulkanShader()
{
vkDestroyShaderModule(m_pVkDevice->getDevice(), m_vkShaderModule, nullptr);
}
void VulkanDeleteList::PerformDeletes(VkDevice device) {
for (auto &cmdPool : cmdPools_) {
vkDestroyCommandPool(device, cmdPool, nullptr);
}
cmdPools_.clear();
for (auto &descPool : descPools_) {
vkDestroyDescriptorPool(device, descPool, nullptr);
}
descPools_.clear();
for (auto &module : modules_) {
vkDestroyShaderModule(device, module, nullptr);
}
modules_.clear();
for (auto &buf : buffers_) {
vkDestroyBuffer(device, buf, nullptr);
}
buffers_.clear();
for (auto &bufView : bufferViews_) {
vkDestroyBufferView(device, bufView, nullptr);
}
bufferViews_.clear();
for (auto &image : images_) {
vkDestroyImage(device, image, nullptr);
}
images_.clear();
for (auto &imageView : imageViews_) {
vkDestroyImageView(device, imageView, nullptr);
}
imageViews_.clear();
for (auto &mem : deviceMemory_) {
vkFreeMemory(device, mem, nullptr);
}
deviceMemory_.clear();
for (auto &sampler : samplers_) {
vkDestroySampler(device, sampler, nullptr);
}
samplers_.clear();
for (auto &pipeline : pipelines_) {
vkDestroyPipeline(device, pipeline, nullptr);
}
pipelines_.clear();
for (auto &pcache : pipelineCaches_) {
vkDestroyPipelineCache(device, pcache, nullptr);
}
pipelineCaches_.clear();
for (auto &renderPass : renderPasses_) {
vkDestroyRenderPass(device, renderPass, nullptr);
}
renderPasses_.clear();
for (auto &framebuffer : framebuffers_) {
vkDestroyFramebuffer(device, framebuffer, nullptr);
}
framebuffers_.clear();
for (auto &pipeLayout : pipelineLayouts_) {
vkDestroyPipelineLayout(device, pipeLayout, nullptr);
}
pipelineLayouts_.clear();
for (auto &descSetLayout : descSetLayouts_) {
vkDestroyDescriptorSetLayout(device, descSetLayout, nullptr);
}
descSetLayouts_.clear();
for (auto &callback : callbacks_) {
callback.func(callback.userdata);
}
callbacks_.clear();
}
VulkanShaderModule::~VulkanShaderModule()
{
vkDestroyShaderModule(mOwner->getDevice().getLogical(), mModule, gVulkanAllocator);
}
void BaseImage::ValidateContent(RandomNumberGenerator& rand)
{
/*
dstBuf has following layout:
For each of texels to be sampled, [0..valueCount):
struct {
in uint32_t pixelX;
in uint32_t pixelY;
out uint32_t pixelColor;
}
*/
const uint32_t valueCount = 128;
VkBufferCreateInfo dstBufCreateInfo = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO };
dstBufCreateInfo.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
dstBufCreateInfo.size = valueCount * sizeof(uint32_t) * 3;
VmaAllocationCreateInfo dstBufAllocCreateInfo = {};
dstBufAllocCreateInfo.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT;
dstBufAllocCreateInfo.usage = VMA_MEMORY_USAGE_GPU_TO_CPU;
VkBuffer dstBuf = nullptr;
VmaAllocation dstBufAlloc = nullptr;
VmaAllocationInfo dstBufAllocInfo = {};
TEST( vmaCreateBuffer(g_hAllocator, &dstBufCreateInfo, &dstBufAllocCreateInfo, &dstBuf, &dstBufAlloc, &dstBufAllocInfo) == VK_SUCCESS );
// Fill dstBuf input data.
{
uint32_t* dstBufContent = (uint32_t*)dstBufAllocInfo.pMappedData;
for(uint32_t i = 0; i < valueCount; ++i)
{
const uint32_t x = rand.Generate() % m_CreateInfo.extent.width;
const uint32_t y = rand.Generate() % m_CreateInfo.extent.height;
dstBufContent[i * 3 ] = x;
dstBufContent[i * 3 + 1] = y;
dstBufContent[i * 3 + 2] = 0;
}
}
VkSamplerCreateInfo samplerCreateInfo = { VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO };
samplerCreateInfo.magFilter = VK_FILTER_NEAREST;
samplerCreateInfo.minFilter = VK_FILTER_NEAREST;
samplerCreateInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
samplerCreateInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
samplerCreateInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
samplerCreateInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
samplerCreateInfo.unnormalizedCoordinates = VK_TRUE;
VkSampler sampler = nullptr;
TEST( vkCreateSampler( g_hDevice, &samplerCreateInfo, nullptr, &sampler) == VK_SUCCESS );
VkDescriptorSetLayoutBinding bindings[2] = {};
bindings[0].binding = 0;
bindings[0].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
bindings[0].descriptorCount = 1;
bindings[0].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
bindings[0].pImmutableSamplers = &sampler;
bindings[1].binding = 1;
bindings[1].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
bindings[1].descriptorCount = 1;
bindings[1].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT;
VkDescriptorSetLayoutCreateInfo descSetLayoutCreateInfo = { VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO };
descSetLayoutCreateInfo.bindingCount = 2;
descSetLayoutCreateInfo.pBindings = bindings;
VkDescriptorSetLayout descSetLayout = nullptr;
TEST( vkCreateDescriptorSetLayout(g_hDevice, &descSetLayoutCreateInfo, nullptr, &descSetLayout) == VK_SUCCESS );
VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = { VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO };
pipelineLayoutCreateInfo.setLayoutCount = 1;
pipelineLayoutCreateInfo.pSetLayouts = &descSetLayout;
VkPipelineLayout pipelineLayout = nullptr;
TEST( vkCreatePipelineLayout(g_hDevice, &pipelineLayoutCreateInfo, nullptr, &pipelineLayout) == VK_SUCCESS );
std::vector<char> shaderCode;
LoadShader(shaderCode, "SparseBindingTest.comp.spv");
VkShaderModuleCreateInfo shaderModuleCreateInfo = { VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO };
shaderModuleCreateInfo.codeSize = shaderCode.size();
shaderModuleCreateInfo.pCode = (const uint32_t*)shaderCode.data();
VkShaderModule shaderModule = nullptr;
TEST( vkCreateShaderModule(g_hDevice, &shaderModuleCreateInfo, nullptr, &shaderModule) == VK_SUCCESS );
VkComputePipelineCreateInfo pipelineCreateInfo = { VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO };
pipelineCreateInfo.stage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
pipelineCreateInfo.stage.stage = VK_SHADER_STAGE_COMPUTE_BIT;
pipelineCreateInfo.stage.module = shaderModule;
pipelineCreateInfo.stage.pName = "main";
pipelineCreateInfo.layout = pipelineLayout;
VkPipeline pipeline = nullptr;
TEST( vkCreateComputePipelines(g_hDevice, nullptr, 1, &pipelineCreateInfo, nullptr, &pipeline) == VK_SUCCESS );
VkDescriptorPoolSize poolSizes[2] = {};
poolSizes[0].type = bindings[0].descriptorType;
poolSizes[0].descriptorCount = bindings[0].descriptorCount;
poolSizes[1].type = bindings[1].descriptorType;
poolSizes[1].descriptorCount = bindings[1].descriptorCount;
VkDescriptorPoolCreateInfo descPoolCreateInfo = { VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO };
descPoolCreateInfo.maxSets = 1;
descPoolCreateInfo.poolSizeCount = 2;
descPoolCreateInfo.pPoolSizes = poolSizes;
VkDescriptorPool descPool = nullptr;
TEST( vkCreateDescriptorPool(g_hDevice, &descPoolCreateInfo, nullptr, &descPool) == VK_SUCCESS );
VkDescriptorSetAllocateInfo descSetAllocInfo = { VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO };
descSetAllocInfo.descriptorPool = descPool;
descSetAllocInfo.descriptorSetCount = 1;
descSetAllocInfo.pSetLayouts = &descSetLayout;
VkDescriptorSet descSet = nullptr;
TEST( vkAllocateDescriptorSets(g_hDevice, &descSetAllocInfo, &descSet) == VK_SUCCESS );
VkImageViewCreateInfo imageViewCreateInfo = { VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
imageViewCreateInfo.image = m_Image;
imageViewCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
imageViewCreateInfo.format = m_CreateInfo.format;
imageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imageViewCreateInfo.subresourceRange.layerCount = 1;
imageViewCreateInfo.subresourceRange.levelCount = 1;
VkImageView imageView = nullptr;
TEST( vkCreateImageView(g_hDevice, &imageViewCreateInfo, nullptr, &imageView) == VK_SUCCESS );
VkDescriptorImageInfo descImageInfo = {};
descImageInfo.imageView = imageView;
descImageInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
VkDescriptorBufferInfo descBufferInfo = {};
descBufferInfo.buffer = dstBuf;
descBufferInfo.offset = 0;
descBufferInfo.range = VK_WHOLE_SIZE;
VkWriteDescriptorSet descWrites[2] = {};
descWrites[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
descWrites[0].dstSet = descSet;
descWrites[0].dstBinding = bindings[0].binding;
descWrites[0].dstArrayElement = 0;
descWrites[0].descriptorCount = 1;
descWrites[0].descriptorType = bindings[0].descriptorType;
descWrites[0].pImageInfo = &descImageInfo;
descWrites[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
descWrites[1].dstSet = descSet;
descWrites[1].dstBinding = bindings[1].binding;
descWrites[1].dstArrayElement = 0;
descWrites[1].descriptorCount = 1;
descWrites[1].descriptorType = bindings[1].descriptorType;
descWrites[1].pBufferInfo = &descBufferInfo;
vkUpdateDescriptorSets(g_hDevice, 2, descWrites, 0, nullptr);
BeginSingleTimeCommands();
vkCmdBindPipeline(g_hTemporaryCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline);
vkCmdBindDescriptorSets(g_hTemporaryCommandBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, pipelineLayout, 0, 1, &descSet, 0, nullptr);
vkCmdDispatch(g_hTemporaryCommandBuffer, valueCount, 1, 1);
EndSingleTimeCommands();
// Validate dstBuf output data.
{
const uint32_t* dstBufContent = (const uint32_t*)dstBufAllocInfo.pMappedData;
for(uint32_t i = 0; i < valueCount; ++i)
{
const uint32_t x = dstBufContent[i * 3 ];
const uint32_t y = dstBufContent[i * 3 + 1];
const uint32_t color = dstBufContent[i * 3 + 2];
const uint8_t a = (uint8_t)(color >> 24);
const uint8_t b = (uint8_t)(color >> 16);
const uint8_t g = (uint8_t)(color >> 8);
const uint8_t r = (uint8_t)color;
TEST(r == (uint8_t)x && g == (uint8_t)y && b == 13 && a == 25);
}
}
vkDestroyImageView(g_hDevice, imageView, nullptr);
vkDestroyDescriptorPool(g_hDevice, descPool, nullptr);
vmaDestroyBuffer(g_hAllocator, dstBuf, dstBufAlloc);
vkDestroyPipeline(g_hDevice, pipeline, nullptr);
vkDestroyShaderModule(g_hDevice, shaderModule, nullptr);
vkDestroyPipelineLayout(g_hDevice, pipelineLayout, nullptr);
vkDestroyDescriptorSetLayout(g_hDevice, descSetLayout, nullptr);
vkDestroySampler(g_hDevice, sampler, nullptr);
}
void
VKDevice::destroy_shader_id (VkShaderModule shader)
{
if (XCAM_IS_VALID_VK_ID(_dev_id) && XCAM_IS_VALID_VK_ID (shader))
vkDestroyShaderModule (_dev_id, shader, _allocator.ptr());
}
//
// Vulkan termination.
//
void Example::terminate(const vkts::IUpdateThreadContext& updateContext)
{
if (device.get())
{
terminateResources(updateContext);
//
if (swapchain.get())
{
swapchain->destroy();
}
if (pipelineLayout != VK_NULL_HANDLE)
{
vkDestroyPipelineLayout(device->getDevice(), pipelineLayout, nullptr);
pipelineLayout = VK_NULL_HANDLE;
}
if (pipelineCache != VK_NULL_HANDLE)
{
vkDestroyPipelineCache(device->getDevice(), pipelineCache, nullptr);
pipelineCache = VK_NULL_HANDLE;
}
if (vertexShaderModule != VK_NULL_HANDLE)
{
vkDestroyShaderModule(device->getDevice(), vertexShaderModule, nullptr);
vertexShaderModule = VK_NULL_HANDLE;
}
if (fragmentShaderModule != VK_NULL_HANDLE)
{
vkDestroyShaderModule(device->getDevice(), fragmentShaderModule, nullptr);
fragmentShaderModule = VK_NULL_HANDLE;
}
if (vertexBuffer != VK_NULL_HANDLE)
{
vkDestroyBuffer(device->getDevice(), vertexBuffer, nullptr);
vertexBuffer = VK_NULL_HANDLE;
}
if (deviceMemoryVertexBuffer != VK_NULL_HANDLE)
{
vkFreeMemory(device->getDevice(), deviceMemoryVertexBuffer, nullptr);
deviceMemoryVertexBuffer = VK_NULL_HANDLE;
}
if (renderingCompleteSemaphore.get())
{
renderingCompleteSemaphore->destroy();
}
if (imageAcquiredSemaphore.get())
{
imageAcquiredSemaphore->destroy();
}
if (commandPool.get())
{
commandPool->destroy();
}
if (surface.get())
{
surface->destroy();
}
device->destroy();
}
if (instance.get())
{
instance->destroy();
}
}
void Shadow::CleanupSetupOnlyResources()
{
// From this point, the shader modules are consumed by the API and no longer needed
vkDestroyShaderModule(gDevice.VkHandle(), vertexModule, nullptr);
}
int main(int argc, char *argv[]) {
VkResult U_ASSERT_ONLY res;
struct sample_info info = {};
char sample_title[] = "Pipeline Derivative";
const bool depthPresent = true;
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, 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);
init_depth_buffer(info);
init_texture(info);
init_uniform_buffer(info);
init_descriptor_and_pipeline_layouts(info, true);
init_renderpass(info, depthPresent);
init_shaders(info, vertShaderText, fragShaderText);
init_framebuffers(info, depthPresent);
init_vertex_buffer(info, g_vb_texture_Data, sizeof(g_vb_texture_Data),
sizeof(g_vb_texture_Data[0]), true);
init_descriptor_pool(info, true);
init_descriptor_set(info, true);
init_pipeline_cache(info);
/* VULKAN_KEY_START */
//
// Create two pipelines.
//
// First pipeline is the same as that generated by init_pipeline(),
// but with VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT set.
//
// Second pipeline has a modified fragment shader and sets the
// VK_PIPELINE_CREATE_DERIVATIVE_BIT flag.
//
bool include_depth = true;
bool include_vi = true;
VkDynamicState dynamicStateEnables[VK_DYNAMIC_STATE_RANGE_SIZE];
VkPipelineDynamicStateCreateInfo dynamicState = {};
memset(dynamicStateEnables, 0, sizeof dynamicStateEnables);
dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
dynamicState.pNext = NULL;
dynamicState.pDynamicStates = dynamicStateEnables;
dynamicState.dynamicStateCount = 0;
VkPipelineVertexInputStateCreateInfo vi;
vi.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
vi.pNext = NULL;
vi.flags = 0;
vi.vertexBindingDescriptionCount = 1;
vi.pVertexBindingDescriptions = &info.vi_binding;
vi.vertexAttributeDescriptionCount = 2;
vi.pVertexAttributeDescriptions = info.vi_attribs;
VkPipelineInputAssemblyStateCreateInfo ia;
ia.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
ia.pNext = NULL;
ia.flags = 0;
ia.primitiveRestartEnable = VK_FALSE;
ia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
VkPipelineRasterizationStateCreateInfo rs;
rs.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
rs.pNext = NULL;
rs.flags = 0;
rs.polygonMode = VK_POLYGON_MODE_FILL;
rs.cullMode = VK_CULL_MODE_BACK_BIT;
rs.frontFace = VK_FRONT_FACE_CLOCKWISE;
rs.depthClampEnable = include_depth;
rs.rasterizerDiscardEnable = VK_FALSE;
rs.depthBiasEnable = VK_FALSE;
rs.depthBiasConstantFactor = 0;
rs.depthBiasClamp = 0;
rs.depthBiasSlopeFactor = 0;
rs.lineWidth = 0;
VkPipelineColorBlendStateCreateInfo cb;
cb.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
cb.flags = 0;
cb.pNext = NULL;
VkPipelineColorBlendAttachmentState att_state[1];
att_state[0].colorWriteMask = 0xf;
att_state[0].blendEnable = VK_FALSE;
att_state[0].alphaBlendOp = VK_BLEND_OP_ADD;
att_state[0].colorBlendOp = VK_BLEND_OP_ADD;
att_state[0].srcColorBlendFactor = VK_BLEND_FACTOR_ZERO;
att_state[0].dstColorBlendFactor = VK_BLEND_FACTOR_ZERO;
att_state[0].srcAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
att_state[0].dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
cb.attachmentCount = 1;
cb.pAttachments = att_state;
cb.logicOpEnable = VK_FALSE;
cb.logicOp = VK_LOGIC_OP_NO_OP;
cb.blendConstants[0] = 1.0f;
cb.blendConstants[1] = 1.0f;
cb.blendConstants[2] = 1.0f;
cb.blendConstants[3] = 1.0f;
VkPipelineViewportStateCreateInfo vp = {};
vp.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
vp.pNext = NULL;
vp.flags = 0;
vp.viewportCount = NUM_VIEWPORTS;
dynamicStateEnables[dynamicState.dynamicStateCount++] =
VK_DYNAMIC_STATE_VIEWPORT;
vp.scissorCount = NUM_SCISSORS;
dynamicStateEnables[dynamicState.dynamicStateCount++] =
VK_DYNAMIC_STATE_SCISSOR;
vp.pScissors = NULL;
vp.pViewports = NULL;
VkPipelineDepthStencilStateCreateInfo ds;
ds.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
ds.pNext = NULL;
ds.flags = 0;
ds.depthTestEnable = include_depth;
ds.depthWriteEnable = include_depth;
ds.depthCompareOp = VK_COMPARE_OP_LESS_OR_EQUAL;
ds.depthBoundsTestEnable = VK_FALSE;
ds.stencilTestEnable = VK_FALSE;
ds.back.failOp = VK_STENCIL_OP_KEEP;
ds.back.passOp = VK_STENCIL_OP_KEEP;
ds.back.compareOp = VK_COMPARE_OP_ALWAYS;
ds.back.compareMask = 0;
ds.back.reference = 0;
ds.back.depthFailOp = VK_STENCIL_OP_KEEP;
ds.back.writeMask = 0;
ds.minDepthBounds = 0;
ds.maxDepthBounds = 0;
ds.stencilTestEnable = VK_FALSE;
ds.front = ds.back;
VkPipelineMultisampleStateCreateInfo ms;
ms.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
ms.pNext = NULL;
ms.flags = 0;
ms.pSampleMask = NULL;
ms.rasterizationSamples = NUM_SAMPLES;
ms.sampleShadingEnable = VK_FALSE;
ms.alphaToCoverageEnable = VK_FALSE;
ms.alphaToOneEnable = VK_FALSE;
ms.minSampleShading = 0.0;
VkGraphicsPipelineCreateInfo pipeline;
pipeline.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
pipeline.pNext = NULL;
pipeline.layout = info.pipeline_layout;
pipeline.basePipelineHandle = VK_NULL_HANDLE;
pipeline.basePipelineIndex = 0;
// Specify that we will be creating a derivative of this pipeline.
pipeline.flags = VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT;
pipeline.pVertexInputState = include_vi ? &vi : NULL;
pipeline.pInputAssemblyState = &ia;
pipeline.pRasterizationState = &rs;
pipeline.pColorBlendState = &cb;
pipeline.pTessellationState = NULL;
pipeline.pMultisampleState = &ms;
pipeline.pDynamicState = &dynamicState;
pipeline.pViewportState = &vp;
pipeline.pDepthStencilState = &ds;
pipeline.pStages = info.shaderStages;
pipeline.stageCount = 2;
pipeline.renderPass = info.render_pass;
pipeline.subpass = 0;
// Create the base pipeline without storing it in the info struct
// NOTE: If desired, we can add timing info around pipeline creation to
// demonstrate any perf benefits to derivation.
VkPipeline basePipeline;
res = vkCreateGraphicsPipelines(info.device, info.pipelineCache, 1,
&pipeline, NULL, &basePipeline);
assert(res == VK_SUCCESS);
// Now create the derivative pipeline, using a different fragment shader
// This shader will shade the cube faces with interpolated colors
// NOTE: If this step is too heavyweight to show any benefit of derivation,
// then
// create a pipeline that differs in some other, simpler way.
const char *fragShaderText2 = "#version 450\n"
"layout (location = 0) in vec2 texcoord;\n"
"layout (location = 0) out vec4 outColor;\n"
"void main() {\n"
" outColor = vec4(texcoord.x, texcoord.y, "
"1.0 - texcoord.x - texcoord.y, 1.0f);\n"
"}\n";
// Convert GLSL to SPIR-V
init_glslang();
std::vector<unsigned int> fragSpv;
bool U_ASSERT_ONLY retVal =
GLSLtoSPV(VK_SHADER_STAGE_FRAGMENT_BIT, fragShaderText2, fragSpv);
assert(retVal);
finalize_glslang();
// Replace the module entry of info.shaderStages to change the fragment
// shader
vkDestroyShaderModule(info.device, info.shaderStages[1].module, NULL);
VkShaderModuleCreateInfo moduleCreateInfo = {};
moduleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
moduleCreateInfo.pNext = NULL;
moduleCreateInfo.flags = 0;
moduleCreateInfo.codeSize = fragSpv.size() * sizeof(unsigned int);
moduleCreateInfo.pCode = fragSpv.data();
res = vkCreateShaderModule(info.device, &moduleCreateInfo, NULL,
&info.shaderStages[1].module);
assert(res == VK_SUCCESS);
// Modify pipeline info to reflect derivation
pipeline.flags = VK_PIPELINE_CREATE_DERIVATIVE_BIT;
pipeline.basePipelineHandle = basePipeline;
pipeline.basePipelineIndex = -1;
// And create the derived pipeline, assigning to info.pipeline for use by
// later helpers
res = vkCreateGraphicsPipelines(info.device, info.pipelineCache, 1,
&pipeline, NULL, &info.pipeline);
assert(res == VK_SUCCESS);
/* VULKAN_KEY_END */
init_presentable_image(info);
VkClearValue clear_values[2];
init_clear_color_and_depth(info, clear_values);
VkRenderPassBeginInfo rp_begin;
init_render_pass_begin_info(info, rp_begin);
rp_begin.clearValueCount = 2;
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);
const VkDeviceSize offsets[1] = {0};
vkCmdBindVertexBuffers(info.cmd, 0, 1, &info.vertex_buffer.buf, offsets);
init_viewports(info);
init_scissors(info);
vkCmdDraw(info.cmd, 12 * 3, 1, 0, 0);
vkCmdEndRenderPass(info.cmd);
execute_pre_present_barrier(info);
res = vkEndCommandBuffer(info.cmd);
assert(res == VK_SUCCESS);
VkFence drawFence = {};
init_fence(info, drawFence);
VkPipelineStageFlags pipe_stage_flags =
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
VkSubmitInfo submit_info = {};
init_submit_info(info, submit_info, pipe_stage_flags);
/* Queue the command buffer for execution */
res = vkQueueSubmit(info.queue, 1, &submit_info, drawFence);
assert(res == VK_SUCCESS);
/* Now present the image in the window */
VkPresentInfoKHR present = {};
init_present_info(info, present);
/* 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);
if (info.save_images)
write_ppm(info, "pipeline_derivative");
vkDestroyFence(info.device, drawFence, NULL);
vkDestroySemaphore(info.device, info.presentCompleteSemaphore, NULL);
vkDestroyPipeline(info.device, basePipeline, NULL);
destroy_pipeline(info);
destroy_pipeline_cache(info);
destroy_textures(info);
destroy_descriptor_pool(info);
destroy_vertex_buffer(info);
destroy_framebuffers(info);
destroy_shaders(info);
destroy_renderpass(info);
destroy_descriptor_and_pipeline_layouts(info);
destroy_uniform_buffer(info);
destroy_depth_buffer(info);
destroy_swap_chain(info);
destroy_command_buffer(info);
destroy_command_pool(info);
destroy_device(info);
destroy_window(info);
destroy_instance(info);
return 0;
}