The descriptor layout is implemented in the createDescriptorLayout() function of the VulkanDrawable class. This function is a pure virtual function that is declared in the VulkanDescriptor class. The VulkanDrawable class inherits the VulkanDescriptor class. The following is the implementation of this:

void VulkanDrawable::createDescriptorLayout(bool useTexture) 
{ 
    // Define the layout binding information for the
 
   // descriptor set(before creating it), specify binding point,
 
   // shader type(like vertex shader below), count etc. 
    VkDescriptorSetLayoutBinding layoutBindings[2]; 
    layoutBindings[0].binding     = 0; // DESCRIPTOR_SET_BINDING_INDEX 
    layoutBindings[0].descriptorType =  
                           VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; 
    layoutBindings[0].descriptorCount = 1; 
    layoutBindings[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT; 
    layoutBindings[0].pImmutableSamplers = NULL; 
 
    // If texture is being used then there exists a
 
   // second binding in the fragment shader 
    if (useTexture) 
    { 
         layoutBindings[1].binding      = 1; 
         layoutBindings[1].descriptorType = 
         VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; 
         layoutBindings[1].descriptorCount = 1; 
         layoutBindings[1].stageFlags =  
           VK_SHADER_STAGE_FRAGMENT_BIT; 
         layoutBindings[1].pImmutableSamplers      = NULL; 
    } 
 
    // Specify the layout bind into the VkDescriptorSetLayout-

    // CreateInfo and use it to create a descriptor set layout 
    VkDescriptorSetLayoutCreateInfo descriptorLayout = {}; 
    descriptorLayout.sType =  
         VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; 
    descriptorLayout.pNext = NULL; 
    descriptorLayout.bindingCount = useTexture ? 2 : 1; 
    descriptorLayout.pBindings = layoutBindings; 
 
    VkResult  result; 
    // Allocate required number of descriptor layout objects and
  
  // create them using vkCreateDescriptorSetLayout() 
    descLayout.resize(numberOfDescriptorSet); 
    result = vkCreateDescriptorSetLayout(deviceObj->device, 
    &descriptorLayout, NULL, descLayout.data()); 
    assert(result == VK_SUCCESS); 
} 

Before you create the descriptor set object, the layout bindings need to be defined. There are two VkDescriptorSetLayoutBinding objects (an array) created in the preceding implementation.

The first layout binding, layoutBindings[0], is used to bind the uniform block with the resource index specified in the shader. In the present case, the index of our uniform block in the vertex shader is 0, which is the same value that is specified in the layoutBindings[0].binding field. The other fields of the object indicate that the binding point is attached to the vertex shader stage (stageFlags), and the number of descriptors (descriptorCount) are attached as an array in the shader that is contained within the binding.

The second array object, layoutBindings[1], indicates the layout binding for texture support in our geometry; however, this sample example only implements the uniform block to demonstrate a 3D transformation. In order to use the current implementation for texture support, the useTexture flag parameter of the createDescriptorLayout() function must be set to the boolean true. In the present example, although we are using two descriptor sets, only one is used, that is, useTexture is false. In the upcoming chapter, we will implement texture support.

The descriptor layout can be destroyed using the vkDestroyDescriptorSetLayout() API. Here's the syntax for this:

void vkDestroyDescriptorSetLayout( 
    VkDevice                      device, 
    VkDescriptorSetLayout         descriptorSetLayout, 
    const VkAllocationCallbacks*  pAllocator); 

The vkDestroyDescriptorSetLayout() API takes the following parameters:

A pipeline layout object can be created with the help of the vkCreatePipelineLayout () API. This API accepts VkPipelineLayoutCreateInfo, which contains the descriptor set's state information. This creates one pipeline layout. Let's take a look at the syntax of this API:

VkResult vkCreatePipelineLayout( 
    VkDevice                           device, 
    const VkPipelineLayoutCreateInfo*  pCreateInfo, 
    const VkAllocationCallbacks*       pAllocator, 
    VkPipelineLayout*                  pPipelineLayout); 

The various fields of the vkCreatePipelineLayout structure are defined as follows:

The VulkanDrawable class implements the createPipelineLayout() interface from VulkanDrawble, which allows a drawable class to implement its own implementation based on the drawing object resource requirements.

First, VkPipelineLayoutCreateInfo is created (pPipelineLayoutCreateInfo) and specified with the descriptor layout objects (descLayout), which was created using the vkCreateDescriptorSetLayout() API. The descriptor set binding information is accessed with the pipeline layout within the pipeline (VkPipeline).

The created pPipelineLayoutCreateInfo is set into the vkCreatePipelineLayout() API to create the pipelineLayout object. During pipeline creation, this object will be passed to VkGraphicsPipelineCreateInfo::layout in order to create the graphics pipeline object (VkPipeline):

// createPipelineLayout is a virtual function from

// VulkanDescriptor and defined in the VulkanDrawable class.

// virtual void VulkanDescriptor::createPipelineLayout() = 0;

// Creates the pipeline layout to inject into the pipeline 
void VulkanDrawable::createPipelineLayout() 
{ 
   // Create the pipeline layout using descriptor layout. 
   VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = {}; 
   pPipelineLayoutCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE- 
                                           _LAYOUT_CREATE_INFO; 
   pPipelineLayoutCreateInfo.pNext                 = NULL; 
   pPipelineLayoutCreateInfo.pushConstantRangeCount= 0; 
   pPipelineLayoutCreateInfo.pPushConstantRanges   = NULL; 
   pPipelineLayoutCreateInfo.setLayoutCount        = 
                                 numberOfDescriptorSet; 
   pPipelineLayoutCreateInfo.pSetLayouts  = descLayout.data(); 
 
   VkResult  result; 
   result = vkCreatePipelineLayout(deviceObj->device, 
   &pPipelineLayoutCreateInfo, NULL, &pipelineLayout); 
   assert(result == VK_SUCCESS); 
} 

The created pipeline layout can be destroyed using the vkDestroyPipelineLayout() API in Vulkan. The following is its description:

void vkDestroyPipelineLayout( 
    VkDevice                            device, 
    VkPipelineLayout                    pipelineLayout, 
    const VkAllocationCallbacks*        pAllocator); 

The various fields of the vkDestroyPipelineLayout structure are defined here:

Let's use this API and implement it in the next section.

The VulkanDescriptor class provides a high-level function to destroy the created pipeline layout: the destroyPipelineLayouts() function. The following is the code implementation:

// Destroy the create pipeline layout object 
void VulkanDescriptor::destroyPipelineLayouts() 
{ 
    vkDestroyPipelineLayout(deviceObj->device, pipelineLayout, NULL); 
} 

Creating a descriptor pool is simple; use the vkCreateDescriptorPool API. The following is the API specification, followed by the implementation of this API in our sample recipe:

VkResult vkCreateDescriptorPool( 
    VkDevice                            device, 
    const VkDescriptorPoolCreateInfo*   pCreateInfo, 
    const VkAllocationCallbacks*        pAllocator, 
    VkDescriptorPool*                   pDescriptorPool); 

The various fields of the vkCreateDescriptorPool structure are defined here:

The createDescriptorPool () is a pure virtual function exposed by the VulkanDescriptor class. This function is implemented in the VulkanDrawble class, which is responsible for creating the descriptor pool in our Vulkan application sample. Let's understand the working of this function:

The implementation of the descriptor pool is given here:

// Creates the descriptor pool, this function depends on - 

// createDescriptorSetLayout() 
void VulkanDrawable::createDescriptorPool(bool useTexture) 
{ 
   VkResult  result; 
   // Define the size of descriptor pool based on the

   // type of descriptor set being used. 
   VkDescriptorPoolSize descriptorTypePool[2]; 
 
   // The first descriptor pool object is of type Uniform buffer 
descriptorTypePool[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; 
   descriptorTypePool[0].descriptorCount     = 1; 
 
   // If texture is supported then define the second object with 

   // descriptor type to be Image sampler 
   if (useTexture){ 
             descriptorTypePool[1].type= VK_DESCRIPTOR_TYPE_- 
                                            COMBINED_IMAGE_SAMPLER; 
         descriptorTypePool[1].descriptorCount     = 1; 
   } 
 
   // Populate the descriptor pool state information

   // in the create info structure. 
   VkDescriptorPoolCreateInfo descriptorPoolCreateInfo = {}; 
   descriptorPoolCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_- 
                                 POOL_CREATE_INFO; 
   descriptorPoolCreateInfo.pNext            = NULL; 
   descriptorPoolCreateInfo.maxSets          = 1; 
   descriptorPoolCreateInfo.poolSizeCount= useTexture ? 2 : 1; 
   descriptorPoolCreateInfo.pPoolSizes = descriptorTypePool; 
 
   // Create the descriptor pool using the descriptor
 
  // pool create info structure 
   result = vkCreateDescriptorPool(deviceObj->device, 
         &descriptorPoolCreateInfo, NULL, &descriptorPool); 
   assert(result == VK_SUCCESS); 
} 

The descriptor pool can be destroyed using the vkDestroyDescriptorPool() API. This API accepts three parameters. The first parameter, device, specifies the logical device (VkDevice) that owns the descriptor pool and will be used to destroy descriptorPool. The second parameter, descriptorPool, is the descriptor pool object that needs to be destroyed using this API. The last parameter, pAllocator, controls host memory allocation. You can refer to the Host memory section in Chapter 5, Command Buffer and Memory Management in Vulkan, for more information:

void vkDestroyDescriptorPool( 
    VkDevice                      device, 
    VkDescriptorPool              descriptorPool, 
    const VkAllocationCallbacks*  pAllocator); 

In the present sample application, the desctroyDescriptorPool() function from VulkanDescriptor can be used to destroy the created descriptor pool object:

// Deletes the descriptor pool 
void VulkanDescriptor::destroyDescriptorPool() 
{ 
    vkDestroyDescriptorPool(deviceObj->device, descriptorPool, NULL); 
} 

The descriptor set is allocated from the descriptor pool using the vkAllocateDescriptorSets() API. This API intakes three parameters. The first parameter (device) specifies the logical device (of the type VkDevice) that owns the descriptor pool. The second parameter (pAllocateInfo) is a pointer to an object of the VkDescriptorSetAllocateInfo structure describing the various parameters that will be helpful in the allocation process of the descriptor pool. The last parameter (pDescriptorSets) is a pointer to an array of VkDescriptorSet; this will be filled by the API with the handles of each allocated descriptor set:

VkResult vkAllocateDescriptorSets( 
    VkDevice                           device, 
    const VkDescriptorSetAllocateInfo* pAllocateInfo, 
    VkDescriptorSet*                   pDescriptorSets); 

VkResult vkFreeDescriptorSets( 
    VkDevice                 device, 
    VkDescriptorPool         descriptorPool, 
    uint32_t                 descriptorSetCount, 
    const VkDescriptorSet*   pDescriptorSets); 

void VulkanDescriptor::destroyDescriptorSet() 
{ 
   vkFreeDescriptorSets(deviceObj->device, descriptorPool,  
         numberOfDescriptorSet, &descriptorSet[0]); 
} 

The descriptor sets can be associated with the resources information by updating them using the vkUpdateDescriptorSets() API. This API uses four parameters. The first parameter, device, is the logical device that will be used to update the descriptor sets. This logical device should be the one that owns the descriptor sets. The second parameter, descriptorWriteCount, specifies the element count in the pDescriptorWrites array (of the VkCopyDescriptorSettype). The third parameter, pDescriptorWrites, is a pointer to an array of VkWriteDescriptorSet in the pDescriptorCopies array. The last parameter, pDescriptorCopies, is a pointer to the array objects (the VkCopyDescriptorSet structures) describing the descriptor sets to copy between:

void vkUpdateDescriptorSets( 
    VkDevice                         device, 
    uint32_t                         descriptorWriteCount, 
    const VkWriteDescriptorSet*      pDescriptorWrites, 
    uint32_t                         descriptorCopyCount, 
    const VkCopyDescriptorSet*       pDescriptorCopies); 

The update is an amalgamation of two operations, namely write and copy:

The following is the specification of VkWriteDescriptorSet:

typedef struct VkWriteDescriptorSet { 
      VkStructureType                  sType; 
      const void*                      pNext; 
      VkDescriptorSet                  dstSet; 
      uint32_t                         dstBinding; 
      uint32_t                         dstArrayElement; 
      uint32_t                         descriptorCount; 
      VkDescriptorType                 descriptorType; 
      const VkDescriptorImageInfo*     pImageInfo; 
      const VkDescriptorBufferInfo*    pBufferInfo; 
      const VkBufferView*              pTexelBufferView; 
} VkWriteDescriptorSet; 

The various fields of the VkWriteDescriptorSet structure are defined as follows:

Let's take a look at the VkCopyDescriptorSet specification:

typedef struct VkCopyDescriptorSet { 
   VkStructureType         sType; 
   const void*             pNext; 
   VkDescriptorSet         srcSet; 
   uint32_t                srcBinding;  
   uint32_t                srcArrayElement; 
   VkDescriptorSet         dstSet; 
   uint32_t                dstBinding; 
   uint32_t                dstArrayElement; 
   uint32_t                descriptorCount; 
} VkCopyDescriptorSet; 

The various fields of the VkCopyDescriptorSet structure are defined here:

Descriptor sets are created in the VulkanDrawable class, which inherits the createDescriptorSet() interface from the VulkanDescriptor class and implements it.

First, the VkDescriptorSetAllocateInfo control structure (dsAllocInfo) is created and specified within the descriptor pool to allocate descriptorSet from the intended descriptor pool. The second important thing that needs to be specified is the descriptor layout information that we created and stored in the descLayout object. The descriptor layout provides an interface to read the resource in the shader.

The allocated descriptor sets are empty and do not hold any valid information. They are updated using the write or copy descriptor structures (Vk<Write/Copy>DescriptorSet). In this implementation, the write descriptor write[0] is specified with the uniform data buffer (UniformData::bufferInfo) along with other state information. This information includes the destination descriptor set object, descriptorSet[0], into which this uniform buffer needs to be bound and the destination binding index to which it should be attached. The dstBinding must be equal to the index specified in the shader stage. The update operation is performed using vkUpdateDescriptorSets(), specifying the write descriptor into it:

// Creates the descriptor sets using descriptor pool.

// This function depends on the createDescriptorPool()

// and createUniformBuffer(). 
void VulkanDrawable::createDescriptorSet(bool useTexture) 
{ 
    VulkanPipeline* pipelineObj = rendererObj->getPipelineObject(); 
    VkResult result; 
    // Create the descriptor allocation structure and specify

    // the descriptor pool and descriptor layout 
    VkDescriptorSetAllocateInfo dsAllocInfo[1]; 
    dsAllocInfo[0].sType         = 
               VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; 
    dsAllocInfo[0].pNext               = NULL; 
    dsAllocInfo[0].descriptorPool      = descriptorPool; 
    dsAllocInfo[0].descriptorSetCount  = 1; 
    dsAllocInfo[0].pSetLayouts         = descLayout.data(); 
 
    // Allocate the number of descriptor set needs to be produced 
    descriptorSet.resize(1); 
 
    // Allocate descriptor sets  
    result = vkAllocateDescriptorSets(deviceObj->device,  
                     dsAllocInfo, descriptorSet.data()); 
    assert(result == VK_SUCCESS); 
 
    // Allocate two write descriptors for - 1. MVP and 2. Texture 
    VkWriteDescriptorSet writes[2]; 
    memset(&writes, 0, sizeof(writes)); 
 
    // Specify the uniform buffer related
 
   // information into first write descriptor 
    writes[0]        = {}; 
    writes[0].sType  = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; 
    writes[0].pNext  = NULL; 
    writes[0].dstSet = descriptorSet[0]; 
    writes[0].descriptorCount    = 1; 
    writes[0].descriptorType     = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; 
    writes[0].pBufferInfo        = &UniformData.bufferInfo; 
    writes[0].dstArrayElement    = 0; 
    writes[0].dstBinding         = 0;  
 
    // If texture is used then update the second
 
    // write descriptor structure. We will use this descriptor

    // set in the next chapter where textures are used. 
    if (useTexture) 
    { 
      // In this sample textures are not used 
       writes[1]                  = {}; 
       writes[1].sType            = VK_STRUCTURE_TYPE_WRITE- 
                                    _DESCRIPTOR_SET;
       writes[1].dstSet           = descriptorSet[0]; 
       writes[1].dstBinding       = 1; 
       writes[1].descriptorCount  = 1; 
       writes[1].descriptorType   = VK_DESCRIPTOR_TYPE_- 
                                    COMBINED_IMAGE_SAMPLER; 
       writes[1].pImageInfo       = NULL; 
       writes[1].dstArrayElement  = 0; 
    } 
 
    // Update the uniform buffer into the allocated descriptor set 
    vkUpdateDescriptorSets(deviceObj->device,  
               useTexture ? 2 : 1, writes, 0, NULL); 
}