VkBool32 Example::buildPipelineCache()
{
VkResult result;
//
VkPipelineCacheCreateInfo pipelineCacheCreateInfo;
memset(&pipelineCacheCreateInfo, 0, sizeof(VkPipelineCacheCreateInfo));
pipelineCacheCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
pipelineCacheCreateInfo.flags = 0;
pipelineCacheCreateInfo.initialDataSize = 0;
pipelineCacheCreateInfo.pInitialData = nullptr;
result = vkCreatePipelineCache(device->getDevice(), &pipelineCacheCreateInfo, nullptr, &pipelineCache);
if (result != VK_SUCCESS)
{
vkts::logPrint(VKTS_LOG_ERROR, "Example: Could not create pipeline cache.");
return VK_FALSE;
}
return VK_TRUE;
}
void VulkanExampleBase::createPipelineCache()
{
VkPipelineCacheCreateInfo pipelineCacheCreateInfo = {};
pipelineCacheCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
VkResult err = vkCreatePipelineCache(device, &pipelineCacheCreateInfo, nullptr, &pipelineCache);
assert(!err);
}
VkPipelineCache VulkanContext::CreatePipelineCache() {
VkPipelineCache cache;
VkPipelineCacheCreateInfo pc{ VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO };
pc.pInitialData = nullptr;
pc.initialDataSize = 0;
pc.flags = 0;
VkResult res = vkCreatePipelineCache(device_, &pc, nullptr, &cache);
assert(VK_SUCCESS == res);
return cache;
}
void Pipeline::init(const Device &dev,
const VkComputePipelineCreateInfo &info) {
VkPipelineCache cache;
VkPipelineCacheCreateInfo ci;
memset((void *)&ci, 0, sizeof(VkPipelineCacheCreateInfo));
ci.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
VkResult err = vkCreatePipelineCache(dev.handle(), &ci, NULL, &cache);
if (err == VK_SUCCESS) {
NON_DISPATCHABLE_HANDLE_INIT(vkCreateComputePipelines, dev, cache, 1,
&info);
vkDestroyPipelineCache(dev.handle(), cache, NULL);
}
}
VkResult Pipeline::init_try(const Device &dev,
const VkGraphicsPipelineCreateInfo &info) {
VkPipeline pipe;
VkPipelineCache cache;
VkPipelineCacheCreateInfo ci;
memset((void *)&ci, 0, sizeof(VkPipelineCacheCreateInfo));
ci.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
VkResult err = vkCreatePipelineCache(dev.handle(), &ci, NULL, &cache);
EXPECT(err == VK_SUCCESS);
if (err == VK_SUCCESS) {
err = vkCreateGraphicsPipelines(dev.handle(), cache, 1, &info, NULL,
&pipe);
if (err == VK_SUCCESS) {
NonDispHandle::init(dev.handle(), pipe);
}
vkDestroyPipelineCache(dev.handle(), cache, NULL);
}
return err;
}
void vkeGameRendererDynamic::initPipeline(){
VulkanDC *dc = VulkanDC::Get();
VulkanDC::Device *device = dc->getDefaultDevice();
VkPipelineCacheCreateInfo pipelineCache = { VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO };
VkPipelineVertexInputStateCreateInfo vertexState;
VkPipelineInputAssemblyStateCreateInfo inputState;
VkPipelineRasterizationStateCreateInfo rasterState;
VkPipelineColorBlendStateCreateInfo blendState;
VkPipelineDepthStencilStateCreateInfo depthState;
VkPipelineViewportStateCreateInfo viewportState;
VkPipelineMultisampleStateCreateInfo multisampleState;
VkVertexInputBindingDescription binding;
VkVertexInputAttributeDescription attrs[3];
/*----------------------------------------------------------
Create the pipeline cache.
----------------------------------------------------------*/
VKA_CHECK_ERROR(vkCreatePipelineCache(device->getVKDevice(), &pipelineCache, NULL, &m_pipeline_cache), "Couldn not create pipeline cache.\n");
/*----------------------------------------------------------
Create the scene pipeline.
----------------------------------------------------------*/
/*
Create the vertex input state.
Binding at location 0.
3 attributes:
1 : Vertex Position : vec4
2 : Vertex Normal : vec4
3 : UV : vec2
*/
vertexBinding(&binding, 0, sizeof(VertexObject), VK_VERTEX_INPUT_RATE_VERTEX);
vertexAttributef(&attrs[0], 0, binding.binding, VK_FORMAT_R32G32B32A32_SFLOAT, 0);
vertexAttributef(&attrs[1], 1, binding.binding, VK_FORMAT_R32G32B32A32_SFLOAT, 4);
vertexStateInfo(&vertexState, 1, 2, &binding, attrs);
/*
Create the input assembly state
Topology: Triangle List
Primitive restart enable : false
*/
inputAssemblyStateInfo(&inputState, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, VK_FALSE);
/*
Create the raster state
*/
rasterStateInfo(&rasterState, VK_POLYGON_MODE_FILL);
/*
Create the color blend state.
*/
VkPipelineColorBlendAttachmentState attState[3];
uint32_t sampleMask = 0xFF;
blendAttachmentStateN(3, attState);
blendStateInfo(&blendState, 3, attState);
/*
Create the viewport state
*/
viewportStateInfo(&viewportState, 1);
/*
Create the depth stencil state
*/
depthStateInfo(&depthState);
/*
Create the multisample state
*/
multisampleStateInfo(&multisampleState, getSamples(), &sampleMask);
/*
Create the pipeline shaders.
*/
VkPipelineShaderStageCreateInfo shaderStages[4];
createShaderStage(&shaderStages[0], VK_SHADER_STAGE_VERTEX_BIT, m_shaders.scene_vertex);
createShaderStage(&shaderStages[1], VK_SHADER_STAGE_FRAGMENT_BIT, m_shaders.scene_fragment);
/*
Create the graphics pipeline.
*/
graphicsPipelineCreate(&m_pipeline, &m_pipeline_cache, m_pipeline_layout, 2, shaderStages, &vertexState, &inputState, &rasterState, &blendState, &multisampleState, &viewportState, &depthState, &m_render_pass, 0, VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT);
/*----------------------------------------------------------
Create the skybox pipeline.
----------------------------------------------------------*/
/*
Reusing the create info struct from
the scene pipeline, just update what
we need.
*/
vertexBinding(&binding, 0, sizeof(VertexObjectUV), VK_VERTEX_INPUT_RATE_VERTEX);
vertexAttributef(&attrs[0], 0, binding.binding, VK_FORMAT_R32G32B32A32_SFLOAT, 0);
vertexAttributef(&attrs[1], 1, binding.binding, VK_FORMAT_R32G32_SFLOAT, 4);
vertexStateInfo(&vertexState, 1, 2, &binding, attrs);
depthStateInfo(&depthState, VK_FALSE);
/*
Create the pipeline shaders.
*/
createShaderStage(&shaderStages[0], VK_SHADER_STAGE_VERTEX_BIT, m_shaders.quad_vertex);
createShaderStage(&shaderStages[1], VK_SHADER_STAGE_FRAGMENT_BIT, m_shaders.quad_fragment);
/*
create the graphics pipeline.
*/
graphicsPipelineCreate(&m_quad_pipeline, &m_pipeline_cache, m_quad_pipeline_layout, 2, shaderStages, &vertexState, &inputState, &rasterState, &blendState, &multisampleState, &viewportState, &depthState, &m_render_pass, 0, VK_PIPELINE_CREATE_DERIVATIVE_BIT);
/*----------------------------------------------------------
Create the terrain pipeline.
----------------------------------------------------------*/
/*
Reusing the create info struct from
the scene pipeline, just update what
we need.
*/
inputAssemblyStateInfo(&inputState, VK_PRIMITIVE_TOPOLOGY_PATCH_LIST);
depthStateInfo(&depthState);
rasterStateInfo(&rasterState, VK_POLYGON_MODE_FILL);
/*
create the graphics pipeline.
*/
createShaderStage(&shaderStages[0], VK_SHADER_STAGE_VERTEX_BIT, m_shaders.terrain_vertex);
createShaderStage(&shaderStages[1], VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT, m_shaders.terrain_tcs);
createShaderStage(&shaderStages[2], VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT, m_shaders.terrain_tes);
createShaderStage(&shaderStages[3], VK_SHADER_STAGE_FRAGMENT_BIT, m_shaders.terrain_fragment);
/*
create the graphics pipeline.
*/
graphicsPipelineCreate(&m_terrain_pipeline, &m_pipeline_cache, m_terrain_pipeline_layout, 4, shaderStages, &vertexState, &inputState, &rasterState, &blendState, &multisampleState, &viewportState, &depthState, &m_render_pass, 0, VK_PIPELINE_CREATE_DERIVATIVE_BIT);
}
void TriangleVK::OnCreate(DeviceVK* pDevice, DynamicBufferRingVK *pConstantBufferRing, StaticBufferPoolVK *pStaticGeom, VkRenderPass renderPass)
{
m_pDevice = pDevice;
m_pConstantBufferRing = pConstantBufferRing;
VkResult res;
struct Vertex {
float posX, posY, posZ, posW; // Position data
float r, g, b, a; // Color
};
#define XYZ1(_x_, _y_, _z_) (_x_), (_y_), (_z_), 1.f
const Vertex g_vb_solid_face_colors_Data[] = {
// red face
{ XYZ1(-1, -1, 1), XYZ1(1.f, 0.f, 0.f) },
{ XYZ1(-1, 1, 1), XYZ1(1.f, 0.f, 0.f) },
{ XYZ1(1, -1, 1), XYZ1(1.f, 0.f, 0.f) },
{ XYZ1(1, -1, 1), XYZ1(1.f, 0.f, 0.f) },
{ XYZ1(-1, 1, 1), XYZ1(1.f, 0.f, 0.f) },
{ XYZ1(1, 1, 1), XYZ1(1.f, 0.f, 0.f) },
// green face
{ XYZ1(-1, -1, -1), XYZ1(0.f, 1.f, 0.f) },
{ XYZ1(1, -1, -1), XYZ1(0.f, 1.f, 0.f) },
{ XYZ1(-1, 1, -1), XYZ1(0.f, 1.f, 0.f) },
{ XYZ1(-1, 1, -1), XYZ1(0.f, 1.f, 0.f) },
{ XYZ1(1, -1, -1), XYZ1(0.f, 1.f, 0.f) },
{ XYZ1(1, 1, -1), XYZ1(0.f, 1.f, 0.f) },
// blue face
{ XYZ1(-1, 1, 1), XYZ1(0.f, 0.f, 1.f) },
{ XYZ1(-1, -1, 1), XYZ1(0.f, 0.f, 1.f) },
{ XYZ1(-1, 1, -1), XYZ1(0.f, 0.f, 1.f) },
{ XYZ1(-1, 1, -1), XYZ1(0.f, 0.f, 1.f) },
{ XYZ1(-1, -1, 1), XYZ1(0.f, 0.f, 1.f) },
{ XYZ1(-1, -1, -1), XYZ1(0.f, 0.f, 1.f) },
// yellow face
{ XYZ1(1, 1, 1), XYZ1(1.f, 1.f, 0.f) },
{ XYZ1(1, 1, -1), XYZ1(1.f, 1.f, 0.f) },
{ XYZ1(1, -1, 1), XYZ1(1.f, 1.f, 0.f) },
{ XYZ1(1, -1, 1), XYZ1(1.f, 1.f, 0.f) },
{ XYZ1(1, 1, -1), XYZ1(1.f, 1.f, 0.f) },
{ XYZ1(1, -1, -1), XYZ1(1.f, 1.f, 0.f) },
// magenta face
{ XYZ1(1, 1, 1), XYZ1(1.f, 0.f, 1.f) },
{ XYZ1(-1, 1, 1), XYZ1(1.f, 0.f, 1.f) },
{ XYZ1(1, 1, -1), XYZ1(1.f, 0.f, 1.f) },
{ XYZ1(1, 1, -1), XYZ1(1.f, 0.f, 1.f) },
{ XYZ1(-1, 1, 1), XYZ1(1.f, 0.f, 1.f) },
{ XYZ1(-1, 1, -1), XYZ1(1.f, 0.f, 1.f) },
// cyan face
{ XYZ1(1, -1, 1), XYZ1(0.f, 1.f, 1.f) },
{ XYZ1(1, -1, -1), XYZ1(0.f, 1.f, 1.f) },
{ XYZ1(-1, -1, 1), XYZ1(0.f, 1.f, 1.f) },
{ XYZ1(-1, -1, 1), XYZ1(0.f, 1.f, 1.f) },
{ XYZ1(1, -1, -1), XYZ1(0.f, 1.f, 1.f) },
{ XYZ1(-1, -1, -1), XYZ1(0.f, 1.f, 1.f) },
};
int vertices = 6 * 6;
int vertexSize = 8 * sizeof(float);
void *pData;
pStaticGeom->AllocVertexBuffer(vertices, vertexSize, &pData, &m_geometry);
memcpy(pData, g_vb_solid_face_colors_Data, sizeof(g_vb_solid_face_colors_Data));
///////////////////////////////////////////////
// shaders
const char *vertShaderText =
"#version 400\n"
"#extension GL_ARB_separate_shader_objects : enable\n"
"#extension GL_ARB_shading_language_420pack : enable\n"
"layout (std140, binding = 0) uniform bufferVals {\n"
" mat4 mvp;\n"
"} myBufferVals;\n"
"layout (location = 0) in vec4 pos;\n"
"layout (location = 1) in vec4 inColor;\n"
"layout (location = 0) out vec4 outColor;\n"
"void main() {\n"
" outColor = inColor;\n"
" gl_Position = myBufferVals.mvp * pos;\n"
"}\n";
const char *fragShaderText =
"#version 400\n"
"#extension GL_ARB_separate_shader_objects : enable\n"
"#extension GL_ARB_shading_language_420pack : enable\n"
"layout (location = 0) in vec4 color;\n"
"layout (location = 0) out vec4 outColor;\n"
"void main() {\n"
" outColor = color;\n"
"}\n";
/////////////////////////////////////////////
// Compile and create shaders
init_glslang();
std::map<std::string, std::string> attributeDefines;
VkPipelineShaderStageCreateInfo m_vertexShader;
res = VKCompile(pDevice->GetDevice(), SST_GLSL, VK_SHADER_STAGE_VERTEX_BIT, vertShaderText, "main", attributeDefines, &m_vertexShader);
assert(res == VK_SUCCESS);
VkPipelineShaderStageCreateInfo m_fragmentShader;
res = VKCompile(pDevice->GetDevice(), SST_GLSL, VK_SHADER_STAGE_FRAGMENT_BIT, fragShaderText, "main", attributeDefines, &m_fragmentShader);
assert(res == VK_SUCCESS);
finalize_glslang();
std::vector<VkPipelineShaderStageCreateInfo> shaderStages = { m_vertexShader, m_fragmentShader };
/////////////////////////////////////////////
// Create descriptor pool
std::vector<VkDescriptorPoolSize> type_count = { { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 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 = (uint32_t)type_count.size();
descriptor_pool.pPoolSizes = type_count.data();
res = vkCreateDescriptorPool(pDevice->GetDevice(), &descriptor_pool, NULL, &m_descriptorPool);
assert(res == VK_SUCCESS);
/////////////////////////////////////////////
// Create pipeline layout
VkDescriptorSetLayoutBinding layout_bindings[1];
layout_bindings[0].binding = 0;
layout_bindings[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_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.flags = 0;
descriptor_layout.bindingCount = 1;
descriptor_layout.pBindings = layout_bindings;
std::vector<VkDescriptorSetLayout> desc_layout;
desc_layout.resize(1);
res = vkCreateDescriptorSetLayout(pDevice->GetDevice(), &descriptor_layout, NULL, 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 = (uint32_t)desc_layout.size();
pPipelineLayoutCreateInfo.pSetLayouts = desc_layout.data();
res = vkCreatePipelineLayout(pDevice->GetDevice(), &pPipelineLayoutCreateInfo, NULL, &m_pipelineLayout);
assert(res == VK_SUCCESS);
/////////////////////////////////////////////
// Create descriptor sets
VkDescriptorSetAllocateInfo alloc_info[1];
alloc_info[0].sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
alloc_info[0].pNext = NULL;
alloc_info[0].descriptorPool = m_descriptorPool;
alloc_info[0].descriptorSetCount = (uint32_t)desc_layout.size();
alloc_info[0].pSetLayouts = desc_layout.data();
m_descriptorSets.resize(desc_layout.size());
res = vkAllocateDescriptorSets(pDevice->GetDevice(), alloc_info, m_descriptorSets.data());
assert(res == VK_SUCCESS);
/////////////////////////////////////////////
// Create pipeline
// vertex input state
VkVertexInputBindingDescription vi_binding = {};
vi_binding.binding = 0;
vi_binding.stride = sizeof(float) * 8;
vi_binding.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
std::vector<VkVertexInputAttributeDescription> vi_attrs(2);
// Position
vi_attrs[0].location = 0;
vi_attrs[0].binding = 0;
vi_attrs[0].format = VK_FORMAT_R32G32B32A32_SFLOAT;
vi_attrs[0].offset = 0;
// Normal
vi_attrs[1].location = 1;
vi_attrs[1].binding = 0;
vi_attrs[1].format = VK_FORMAT_R32G32B32A32_SFLOAT;
vi_attrs[1].offset = sizeof(float) * 4;
VkPipelineVertexInputStateCreateInfo vi = {};
vi.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
vi.pNext = NULL;
vi.flags = 0;
vi.vertexBindingDescriptionCount = 1;
vi.pVertexBindingDescriptions = &vi_binding;
vi.vertexAttributeDescriptionCount = (uint32_t)vi_attrs.size();
vi.pVertexAttributeDescriptions = vi_attrs.data();
// input assembly state
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;
// rasterizer state
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_COUNTER_CLOCKWISE;
rs.depthClampEnable = VK_FALSE;
rs.rasterizerDiscardEnable = VK_FALSE;
rs.depthBiasEnable = VK_FALSE;
rs.depthBiasConstantFactor = 0;
rs.depthBiasClamp = 0;
rs.depthBiasSlopeFactor = 0;
rs.lineWidth = 1.0f;
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;
// Color blend state
VkPipelineColorBlendStateCreateInfo cb;
cb.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
cb.flags = 0;
cb.pNext = NULL;
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;
std::vector<VkDynamicState> dynamicStateEnables = {
VK_DYNAMIC_STATE_VIEWPORT,
VK_DYNAMIC_STATE_SCISSOR
};
VkPipelineDynamicStateCreateInfo dynamicState = {};
dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
dynamicState.pNext = NULL;
dynamicState.pDynamicStates = dynamicStateEnables.data();
dynamicState.dynamicStateCount = (uint32_t)dynamicStateEnables.size();
// view port state
VkPipelineViewportStateCreateInfo vp = {};
vp.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
vp.pNext = NULL;
vp.flags = 0;
vp.viewportCount = 1;
vp.scissorCount = 1;
vp.pScissors = NULL;
vp.pViewports = NULL;
// depth stencil state
VkPipelineDepthStencilStateCreateInfo ds;
ds.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
ds.pNext = NULL;
ds.flags = 0;
ds.depthTestEnable = true;
ds.depthWriteEnable = true;
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;
// multi sample state
VkPipelineMultisampleStateCreateInfo ms;
ms.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
ms.pNext = NULL;
ms.flags = 0;
ms.pSampleMask = NULL;
ms.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
ms.sampleShadingEnable = VK_FALSE;
ms.alphaToCoverageEnable = VK_FALSE;
ms.alphaToOneEnable = VK_FALSE;
ms.minSampleShading = 0.0;
// create pipeline cache
VkPipelineCacheCreateInfo pipelineCache;
pipelineCache.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
pipelineCache.pNext = NULL;
pipelineCache.initialDataSize = 0;
pipelineCache.pInitialData = NULL;
pipelineCache.flags = 0;
res = vkCreatePipelineCache(pDevice->GetDevice(), &pipelineCache, NULL, &m_pipelineCache);
assert(res == VK_SUCCESS);
// create pipeline
VkGraphicsPipelineCreateInfo pipeline = {};
pipeline.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
pipeline.pNext = NULL;
pipeline.layout = m_pipelineLayout;
pipeline.basePipelineHandle = VK_NULL_HANDLE;
pipeline.basePipelineIndex = 0;
pipeline.flags = 0;
pipeline.pVertexInputState = &vi;
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 = shaderStages.data();
pipeline.stageCount = (uint32_t)shaderStages.size();
pipeline.renderPass = renderPass;
pipeline.subpass = 0;
res = vkCreateGraphicsPipelines(pDevice->GetDevice(), m_pipelineCache, 1, &pipeline, NULL, &m_pipeline);
assert(res == VK_SUCCESS);
}
int sample_main(int argc, char *argv[]) {
VkResult U_ASSERT_ONLY res;
struct sample_info info = {};
char sample_title[] = "Pipeline Cache";
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, "blue.ppm");
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);
/* VULKAN_KEY_START */
// Check disk for existing cache data
size_t startCacheSize = 0;
void *startCacheData = nullptr;
std::string directoryName = get_file_directory();
std::string readFileName = directoryName + "pipeline_cache_data.bin";
FILE *pReadFile = fopen(readFileName.c_str(), "rb");
if (pReadFile) {
// Determine cache size
fseek(pReadFile, 0, SEEK_END);
startCacheSize = ftell(pReadFile);
rewind(pReadFile);
// Allocate memory to hold the initial cache data
startCacheData = (char *)malloc(sizeof(char) * startCacheSize);
if (startCacheData == nullptr) {
fputs("Memory error", stderr);
exit(EXIT_FAILURE);
}
// Read the data into our buffer
size_t result = fread(startCacheData, 1, startCacheSize, pReadFile);
if (result != startCacheSize) {
fputs("Reading error", stderr);
free(startCacheData);
exit(EXIT_FAILURE);
}
// Clean up and print results
fclose(pReadFile);
printf(" Pipeline cache HIT!\n");
printf(" cacheData loaded from %s\n", readFileName.c_str());
} else {
// No cache found on disk
printf(" Pipeline cache miss!\n");
}
if (startCacheData != nullptr) {
// clang-format off
//
// Check for cache validity
//
// TODO: Update this as the spec evolves. The fields are not defined by the header.
//
// The code below supports SDK 0.10 Vulkan spec, which contains the following table:
//
// Offset Size Meaning
// ------ ------------ ------------------------------------------------------------------
// 0 4 a device ID equal to VkPhysicalDeviceProperties::DeviceId written
// as a stream of bytes, with the least significant byte first
//
// 4 VK_UUID_SIZE a pipeline cache ID equal to VkPhysicalDeviceProperties::pipelineCacheUUID
//
//
// The code must be updated for latest Vulkan spec, which contains the following table:
//
// Offset Size Meaning
// ------ ------------ ------------------------------------------------------------------
// 0 4 length in bytes of the entire pipeline cache header written as a
// stream of bytes, with the least significant byte first
// 4 4 a VkPipelineCacheHeaderVersion value written as a stream of bytes,
// with the least significant byte first
// 8 4 a vendor ID equal to VkPhysicalDeviceProperties::vendorID written
// as a stream of bytes, with the least significant byte first
// 12 4 a device ID equal to VkPhysicalDeviceProperties::deviceID written
// as a stream of bytes, with the least significant byte first
// 16 VK_UUID_SIZE a pipeline cache ID equal to VkPhysicalDeviceProperties::pipelineCacheUUID
//
// clang-format on
uint32_t headerLength = 0;
uint32_t cacheHeaderVersion = 0;
uint32_t vendorID = 0;
uint32_t deviceID = 0;
uint8_t pipelineCacheUUID[VK_UUID_SIZE] = {};
memcpy(&headerLength, (uint8_t *)startCacheData + 0, 4);
memcpy(&cacheHeaderVersion, (uint8_t *)startCacheData + 4, 4);
memcpy(&vendorID, (uint8_t *)startCacheData + 8, 4);
memcpy(&deviceID, (uint8_t *)startCacheData + 12, 4);
memcpy(pipelineCacheUUID, (uint8_t *)startCacheData + 16, VK_UUID_SIZE);
// Check each field and report bad values before freeing existing cache
bool badCache = false;
if (headerLength <= 0) {
badCache = true;
printf(" Bad header length in %s.\n", readFileName.c_str());
printf(" Cache contains: 0x%.8x\n", headerLength);
}
if (cacheHeaderVersion != VK_PIPELINE_CACHE_HEADER_VERSION_ONE) {
badCache = true;
printf(" Unsupported cache header version in %s.\n", readFileName.c_str());
printf(" Cache contains: 0x%.8x\n", cacheHeaderVersion);
}
if (vendorID != info.gpu_props.vendorID) {
badCache = true;
printf(" Vendor ID mismatch in %s.\n", readFileName.c_str());
printf(" Cache contains: 0x%.8x\n", vendorID);
printf(" Driver expects: 0x%.8x\n", info.gpu_props.vendorID);
}
if (deviceID != info.gpu_props.deviceID) {
badCache = true;
printf(" Device ID mismatch in %s.\n", readFileName.c_str());
printf(" Cache contains: 0x%.8x\n", deviceID);
printf(" Driver expects: 0x%.8x\n", info.gpu_props.deviceID);
}
if (memcmp(pipelineCacheUUID, info.gpu_props.pipelineCacheUUID,
sizeof(pipelineCacheUUID)) != 0) {
badCache = true;
printf(" UUID mismatch in %s.\n", readFileName.c_str());
printf(" Cache contains: ");
print_UUID(pipelineCacheUUID);
printf("\n");
printf(" Driver expects: ");
print_UUID(info.gpu_props.pipelineCacheUUID);
printf("\n");
}
if (badCache) {
// Don't submit initial cache data if any version info is incorrect
free(startCacheData);
startCacheSize = 0;
startCacheData = nullptr;
// And clear out the old cache file for use in next run
printf(" Deleting cache entry %s to repopulate.\n", readFileName.c_str());
if (remove(readFileName.c_str()) != 0) {
fputs("Reading error", stderr);
exit(EXIT_FAILURE);
}
}
}
// Feed the initial cache data into pipeline creation
VkPipelineCacheCreateInfo pipelineCache;
pipelineCache.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
pipelineCache.pNext = NULL;
pipelineCache.initialDataSize = startCacheSize;
pipelineCache.pInitialData = startCacheData;
pipelineCache.flags = 0;
res = vkCreatePipelineCache(info.device, &pipelineCache, nullptr,
&info.pipelineCache);
assert(res == VK_SUCCESS);
// Free our initialData now that pipeline has been created
free(startCacheData);
// Time (roughly) taken to create the graphics pipeline
timestamp_t start = get_milliseconds();
init_pipeline(info, depthPresent);
timestamp_t elapsed = get_milliseconds() - start;
printf(" vkCreateGraphicsPipeline time: %0.f ms\n", (double)elapsed);
// Begin standard draw stuff
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_cache");
// End standard draw stuff
if (startCacheData) {
// TODO: Create another pipeline, preferably different from the first
// one and merge it here. Then store the merged one.
}
// Store away the cache that we've populated. This could conceivably happen
// earlier, depends on when the pipeline cache stops being populated
// internally.
size_t endCacheSize = 0;
void *endCacheData = nullptr;
// Call with nullptr to get cache size
res = vkGetPipelineCacheData(info.device, info.pipelineCache, &endCacheSize,
nullptr);
assert(res == VK_SUCCESS);
// Allocate memory to hold the populated cache data
endCacheData = (char *)malloc(sizeof(char) * endCacheSize);
if (!endCacheData) {
fputs("Memory error", stderr);
exit(EXIT_FAILURE);
}
// Call again with pointer to buffer
res = vkGetPipelineCacheData(info.device, info.pipelineCache, &endCacheSize,
endCacheData);
assert(res == VK_SUCCESS);
// Write the file to disk, overwriting whatever was there
FILE *pWriteFile;
std::string writeFileName = directoryName + "pipeline_cache_data.bin";
pWriteFile = fopen(writeFileName.c_str(), "wb");
if (pWriteFile) {
fwrite(endCacheData, sizeof(char), endCacheSize, pWriteFile);
fclose(pWriteFile);
printf(" cacheData written to %s\n", writeFileName.c_str());
} else {
// Something bad happened
printf(" Unable to write cache data to disk!\n");
}
/* VULKAN_KEY_END */
vkDestroyFence(info.device, drawFence, NULL);
vkDestroySemaphore(info.device, info.presentCompleteSemaphore, 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;
}
/**
* Prepare all vulkan resources required to render the font
* The text overlay uses separate resources for descriptors (pool, sets, layouts), pipelines and command buffers
*/
void prepareResources()
{
static unsigned char font24pixels[STB_FONT_HEIGHT][STB_FONT_WIDTH];
STB_FONT_NAME(stbFontData, font24pixels, STB_FONT_HEIGHT);
// Command buffer
// Pool
VkCommandPoolCreateInfo cmdPoolInfo = {};
cmdPoolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
cmdPoolInfo.queueFamilyIndex = vulkanDevice->queueFamilyIndices.graphics;
cmdPoolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
VK_CHECK_RESULT(vkCreateCommandPool(vulkanDevice->logicalDevice, &cmdPoolInfo, nullptr, &commandPool));
VkCommandBufferAllocateInfo cmdBufAllocateInfo =
vks::initializers::commandBufferAllocateInfo(
commandPool,
VK_COMMAND_BUFFER_LEVEL_PRIMARY,
(uint32_t)cmdBuffers.size());
VK_CHECK_RESULT(vkAllocateCommandBuffers(vulkanDevice->logicalDevice, &cmdBufAllocateInfo, cmdBuffers.data()));
// Vertex buffer
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
&vertexBuffer,
MAX_CHAR_COUNT * sizeof(glm::vec4)));
// Map persistent
vertexBuffer.map();
// Font texture
VkImageCreateInfo imageInfo = vks::initializers::imageCreateInfo();
imageInfo.imageType = VK_IMAGE_TYPE_2D;
imageInfo.format = VK_FORMAT_R8_UNORM;
imageInfo.extent.width = STB_FONT_WIDTH;
imageInfo.extent.height = STB_FONT_HEIGHT;
imageInfo.extent.depth = 1;
imageInfo.mipLevels = 1;
imageInfo.arrayLayers = 1;
imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
imageInfo.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
imageInfo.initialLayout = VK_IMAGE_LAYOUT_PREINITIALIZED;
VK_CHECK_RESULT(vkCreateImage(vulkanDevice->logicalDevice, &imageInfo, nullptr, &image));
VkMemoryRequirements memReqs;
VkMemoryAllocateInfo allocInfo = vks::initializers::memoryAllocateInfo();
vkGetImageMemoryRequirements(vulkanDevice->logicalDevice, image, &memReqs);
allocInfo.allocationSize = memReqs.size;
allocInfo.memoryTypeIndex = vulkanDevice->getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
VK_CHECK_RESULT(vkAllocateMemory(vulkanDevice->logicalDevice, &allocInfo, nullptr, &imageMemory));
VK_CHECK_RESULT(vkBindImageMemory(vulkanDevice->logicalDevice, image, imageMemory, 0));
// Staging
vks::Buffer stagingBuffer;
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
&stagingBuffer,
allocInfo.allocationSize));
stagingBuffer.map();
memcpy(stagingBuffer.mapped, &font24pixels[0][0], STB_FONT_WIDTH * STB_FONT_HEIGHT); // Only one channel, so data size = W * H (*R8)
stagingBuffer.unmap();
// Copy to image
VkCommandBuffer copyCmd;
cmdBufAllocateInfo.commandBufferCount = 1;
VK_CHECK_RESULT(vkAllocateCommandBuffers(vulkanDevice->logicalDevice, &cmdBufAllocateInfo, ©Cmd));
VkCommandBufferBeginInfo cmdBufInfo = vks::initializers::commandBufferBeginInfo();
VK_CHECK_RESULT(vkBeginCommandBuffer(copyCmd, &cmdBufInfo));
// Prepare for transfer
vks::tools::setImageLayout(
copyCmd,
image,
VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_PREINITIALIZED,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
VkBufferImageCopy bufferCopyRegion = {};
bufferCopyRegion.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
bufferCopyRegion.imageSubresource.mipLevel = 0;
bufferCopyRegion.imageSubresource.layerCount = 1;
bufferCopyRegion.imageExtent.width = STB_FONT_WIDTH;
bufferCopyRegion.imageExtent.height = STB_FONT_HEIGHT;
bufferCopyRegion.imageExtent.depth = 1;
vkCmdCopyBufferToImage(
copyCmd,
stagingBuffer.buffer,
image,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
1,
&bufferCopyRegion
);
// Prepare for shader read
vks::tools::setImageLayout(
copyCmd,
image,
VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
VK_CHECK_RESULT(vkEndCommandBuffer(copyCmd));
VkSubmitInfo submitInfo = vks::initializers::submitInfo();
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = ©Cmd;
VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE));
VK_CHECK_RESULT(vkQueueWaitIdle(queue));
stagingBuffer.destroy();
vkFreeCommandBuffers(vulkanDevice->logicalDevice, commandPool, 1, ©Cmd);
VkImageViewCreateInfo imageViewInfo = vks::initializers::imageViewCreateInfo();
imageViewInfo.image = image;
imageViewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
imageViewInfo.format = imageInfo.format;
imageViewInfo.components = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A };
imageViewInfo.subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
VK_CHECK_RESULT(vkCreateImageView(vulkanDevice->logicalDevice, &imageViewInfo, nullptr, &view));
// Sampler
VkSamplerCreateInfo samplerInfo = vks::initializers::samplerCreateInfo();
samplerInfo.magFilter = VK_FILTER_LINEAR;
samplerInfo.minFilter = VK_FILTER_LINEAR;
samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
samplerInfo.mipLodBias = 0.0f;
samplerInfo.compareOp = VK_COMPARE_OP_NEVER;
samplerInfo.minLod = 0.0f;
samplerInfo.maxLod = 1.0f;
samplerInfo.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
samplerInfo.maxAnisotropy = 1.0f;
VK_CHECK_RESULT(vkCreateSampler(vulkanDevice->logicalDevice, &samplerInfo, nullptr, &sampler));
// Descriptor
// Font uses a separate descriptor pool
std::array<VkDescriptorPoolSize, 1> poolSizes;
poolSizes[0] = vks::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1);
VkDescriptorPoolCreateInfo descriptorPoolInfo =
vks::initializers::descriptorPoolCreateInfo(
static_cast<uint32_t>(poolSizes.size()),
poolSizes.data(),
1);
VK_CHECK_RESULT(vkCreateDescriptorPool(vulkanDevice->logicalDevice, &descriptorPoolInfo, nullptr, &descriptorPool));
// Descriptor set layout
std::array<VkDescriptorSetLayoutBinding, 1> setLayoutBindings;
setLayoutBindings[0] = vks::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, VK_SHADER_STAGE_FRAGMENT_BIT, 0);
VkDescriptorSetLayoutCreateInfo descriptorSetLayoutInfo =
vks::initializers::descriptorSetLayoutCreateInfo(
setLayoutBindings.data(),
static_cast<uint32_t>(setLayoutBindings.size()));
VK_CHECK_RESULT(vkCreateDescriptorSetLayout(vulkanDevice->logicalDevice, &descriptorSetLayoutInfo, nullptr, &descriptorSetLayout));
// Pipeline layout
VkPipelineLayoutCreateInfo pipelineLayoutInfo =
vks::initializers::pipelineLayoutCreateInfo(
&descriptorSetLayout,
1);
VK_CHECK_RESULT(vkCreatePipelineLayout(vulkanDevice->logicalDevice, &pipelineLayoutInfo, nullptr, &pipelineLayout));
// Descriptor set
VkDescriptorSetAllocateInfo descriptorSetAllocInfo =
vks::initializers::descriptorSetAllocateInfo(
descriptorPool,
&descriptorSetLayout,
1);
VK_CHECK_RESULT(vkAllocateDescriptorSets(vulkanDevice->logicalDevice, &descriptorSetAllocInfo, &descriptorSet));
VkDescriptorImageInfo texDescriptor =
vks::initializers::descriptorImageInfo(
sampler,
view,
VK_IMAGE_LAYOUT_GENERAL);
std::array<VkWriteDescriptorSet, 1> writeDescriptorSets;
writeDescriptorSets[0] = vks::initializers::writeDescriptorSet(descriptorSet, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 0, &texDescriptor);
vkUpdateDescriptorSets(vulkanDevice->logicalDevice, static_cast<uint32_t>(writeDescriptorSets.size()), writeDescriptorSets.data(), 0, NULL);
// Pipeline cache
VkPipelineCacheCreateInfo pipelineCacheCreateInfo = {};
pipelineCacheCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
VK_CHECK_RESULT(vkCreatePipelineCache(vulkanDevice->logicalDevice, &pipelineCacheCreateInfo, nullptr, &pipelineCache));
// Command buffer execution fence
VkFenceCreateInfo fenceCreateInfo = vks::initializers::fenceCreateInfo();
VK_CHECK_RESULT(vkCreateFence(vulkanDevice->logicalDevice, &fenceCreateInfo, nullptr, &fence));
}
void PipelineCache::create() {
VULKAN_CHECK_RESULT(vkCreatePipelineCache(device->getHandle(), &createInfo, nullptr, &handle), "Failed to create pipeline cache");
}
Error GrManagerImpl::initInternal(const GrManagerInitInfo& init)
{
ANKI_LOGI("Initializing Vulkan backend");
ANKI_CHECK(initInstance(init));
ANKI_CHECK(initSurface(init));
ANKI_CHECK(initDevice(init));
vkGetDeviceQueue(m_device, m_queueIdx, 0, &m_queue);
ANKI_CHECK(initSwapchain(init));
{
VkPipelineCacheCreateInfo ci = {};
ci.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
vkCreatePipelineCache(m_device, &ci, nullptr, &m_pplineCache);
}
ANKI_CHECK(initMemory(*init.m_config));
ANKI_CHECK(m_dsetAlloc.init(getAllocator(), m_device));
m_pplineLayFactory.init(getAllocator(), m_device, &m_dsetAlloc.getDescriptorSetLayoutFactory());
for(PerFrame& f : m_perFrame)
{
resetFrame(f);
}
glslang::InitializeProcess();
m_fences.init(getAllocator(), m_device);
m_semaphores.init(getAllocator(), m_device);
m_queryAlloc.init(getAllocator(), m_device);
m_samplerCache = getAllocator().newInstance<GrObjectCache>(m_manager);
// Set m_r8g8b8ImagesSupported
{
VkImageFormatProperties props = {};
VkResult res = vkGetPhysicalDeviceImageFormatProperties(m_physicalDevice,
VK_FORMAT_R8G8B8_UNORM,
VK_IMAGE_TYPE_2D,
VK_IMAGE_TILING_OPTIMAL,
VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
0,
&props);
if(res == VK_ERROR_FORMAT_NOT_SUPPORTED)
{
ANKI_LOGI("R8G8B8 Images are not supported. Will workaround this");
m_r8g8b8ImagesSupported = false;
}
else
{
ANKI_ASSERT(res == VK_SUCCESS);
ANKI_LOGI("R8G8B8 Images are supported");
m_r8g8b8ImagesSupported = true;
}
}
// Set m_s8ImagesSupported
{
VkImageFormatProperties props = {};
VkResult res = vkGetPhysicalDeviceImageFormatProperties(m_physicalDevice,
VK_FORMAT_S8_UINT,
VK_IMAGE_TYPE_2D,
VK_IMAGE_TILING_OPTIMAL,
VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
0,
&props);
if(res == VK_ERROR_FORMAT_NOT_SUPPORTED)
{
ANKI_LOGI("S8 Images are not supported. Will workaround this");
m_s8ImagesSupported = false;
}
else
{
ANKI_ASSERT(res == VK_SUCCESS);
ANKI_LOGI("S8 Images are supported");
m_s8ImagesSupported = true;
}
}
// Set m_d24S8ImagesSupported
{
VkImageFormatProperties props = {};
VkResult res = vkGetPhysicalDeviceImageFormatProperties(m_physicalDevice,
VK_FORMAT_D24_UNORM_S8_UINT,
VK_IMAGE_TYPE_2D,
VK_IMAGE_TILING_OPTIMAL,
VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
0,
&props);
if(res == VK_ERROR_FORMAT_NOT_SUPPORTED)
{
ANKI_LOGI("D24S8 Images are not supported. Will workaround this");
m_d24S8ImagesSupported = false;
}
else
{
ANKI_ASSERT(res == VK_SUCCESS);
ANKI_LOGI("D24S8 Images are supported");
m_d24S8ImagesSupported = true;
}
}
return ErrorCode::NONE;
}
void VulkanBase::createPipelineCache() {
VkPipelineCacheCreateInfo pipelineCacheCreateInfo = {};
pipelineCacheCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
vkTools::checkResult(vkCreatePipelineCache(device, &pipelineCacheCreateInfo, nullptr, &pipelineCache));
}
