The vkCmdBeginRenderPass() API begins Render Pass instance command recording for a given subpass. The following is the specification:

void vkCmdBeginRenderPass( 
  VkCommandBuffer                commandBuffer, 
  const VkRenderPassBeginInfo*   pRenderPassBegin, 
  VkSubpassContents              contents); 

The vkCmdBeginRenderPass API accepts three parameters. The first parameter—commandBuffer of the VkCommandBuffer type—indicates the command buffer into which the commands are recorded. The second parameter—pRenderPassBegin—is a VkRenderPassBeginInfo type control structure into which Render Pass metadata is passed (more information is provided in the following section). The last parameter is of the VkSubpassContents type and indicates where and how the contents will be recorded in the subpass execution.

The following are the two types of VkSubpassContents:

Let's take a look at the VkRenderPassBeginInfo structure syntax and its parameters:

typedef struct VkRenderPassBeginInfo { 
    VkStructureType        sType; 
    const void*            pNext; 
    VkRenderPass           renderPass; 
    VkFramebuffer          framebuffer; 
    VkRect2D               renderArea; 
    uint32_t               clearValueCount; 
    const VkClearValue*    pClearValues; 
} VkRenderPassBeginInfo; 

The following are the various parameters of the VkRenderPassBeginInfo structure:

void vkGetRenderAreaGranularity( 
  VkDevice              device, 
  VkRenderPass          renderPass, 
  VkExtent2D*           pGranularity); 

This API accepts three parameters: the first parameter—device—is the VkDevice that is associated with renderPass; the second parameter is the renderPass object; the last parameter retrieves the granularity size in pGranularity.

In a given Render Pass instance, when a subpass recording is finished, the application can switch or transit to the next subpass using the vkCmdNextSubpass() API.

void vkCmdNextSubpass( 
  VkCommandBuffer      commandBuffer, 
  VkSubpassContents    contents); 

This API accepts two parameters as shown in the following table:

The vkCmdEndRenderPass() API ends the Render Pass instance command buffer recording for the subpass that is currently being executed. This API takes one parameter specifying the handle of the command buffer on which the recording must be stopped.

void vkCmdEndRenderPass( 
  VkCommandBuffer commandBuffer); 

The current subpass is specified with a clear black color, which will paint the swapchain image with this value, making the background appear black. In addition, other parameters, such as the Render Pass object, framebuffer, and dimension, are also specified. There are many other commands that get executed in the Render Pass instance; this will be discussed in the next section, the following implementation shows the Render Pass instance recording using the vkCmdBeginRenderPass()and vkCmdEndRenderPass() APIs:

void VulkanDrawable::recordCommandBuffer(int currentImage, VkCommandBuffer* cmdDraw) 
{ 
VulkanDevice* deviceObj= rendererObj->getDevice(); 
// Specify the clear color value 
VkClearValue clearValues[2]; 
clearValues[0].color.float32[0]= 0.0f; 
clearValues[0].color.float32[1]= 0.0f; 
clearValues[0].color.float32[2]= 0.0f; 
clearValues[0].color.float32[3]= 0.0f; 
 
// Specify the depth/stencil clear value 
clearValues[1].depthStencil.depth   = 1.0f; 
clearValues[1].depthStencil.stencil = 0; 
 
// Define the VkRenderPassBeginInfo control structure 
VkRenderPassBeginInfo renderPassBegin; 
renderPassBegin.sType                   = 
   VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; 
renderPassBegin.pNext                   = NULL; 
renderPassBegin.renderPass              = rendererObj->renderPass; 
renderPassBegin.framebuffer             = rendererObj->
                                          framebuffers[currentImage]; 
renderPassBegin.renderArea.offset.x     = 0; 
renderPassBegin.renderArea.offset.y     = 0; 
renderPassBegin.renderArea.extent.width = rendererObj->width; 
renderPassBegin.renderArea.extent.height= rendererObj->height; 
renderPassBegin.clearValueCount         = 2; 
renderPassBegin.pClearValues            = clearValues; 
 
// Start recording the render pass instance 
vkCmdBeginRenderPass(*cmdDraw, &renderPassBegin, 
  VK_SUBPASS_CONTENTS_INLINE);
 
// Execute the commands as per requirement 
.  .  .  . 
// pipeline bind, geometry, viewport, scissoring


// End of render pass instance recording 
vkCmdEndRenderPass(*cmdDraw); 
.  .  .  . 
} 

The following code shows the binding of the graphics pipeline with the existing command buffer object cmdDraw, The pipeline object is connected with the graphics bind point (VK_PIPELINE_BIND_POINT_GRAPHICS):

void VulkanDrawable::recordCommandBuffer(int currentImage, VkCommandBuffer* cmdDraw){ 
   .  .  .  . 
   // Bound the command buffer with the graphics pipeline 
   vkCmdBindPipeline(*cmdDraw, VK_PIPELINE_BIND_POINT_GRAPHICS, 
   *pipeline); 
   .  .  .  . 
} 

Bind the command buffer object with the necessary information to pick the geometry data using the vkCmdBindVertexBuffer() API; this API takes the vertex buffer information of the drawing object that we are interested in to draw on the display:

void VulkanDrawable::recordCommandBuffer(int currentImage, VkCommandBuffer* cmdDraw){ 
   .  .  .  . 
   // Bound the vertex buffer with the command buffer 
   vkCmdBindVertexBuffers(*cmdDraw, 0, 1, &VertexBuffer.buf, 
   offsets); 
   .  .  .  . 
} 

The viewport is initialized using the initViewport() function by passing the current command buffer object into which the vkCmdSetViewport() command will be recorded. The vkCmdSetViewport() API sets the viewport parameters, which are dynamically set in the viewport region, specifying the upper-left dimension and depth information of the viewable region:

void VulkanDrawable::recordCommandBuffer(int currentImage, VkCommandBuffer* cmdDraw){ 
   .  .  .  . 
   // Define the dynamic viewport here. 
   initViewports(cmdDraw); 
   .  .  .  . 
} 
 
void VulkanDrawable::initViewports(VkCommandBuffer* cmd) 
{ 
   viewport.height   = (float)rendererObj->height; 
   viewport.width    = (float)rendererObj->width; 
   viewport.minDepth = (float) 0.0f; 
   viewport.maxDepth = (float) 1.0f; 
   viewport.x        = 0; 
   viewport.y        = 0; 
   vkCmdSetViewport(*cmd, 0, NUMBER_OF_VIEWPORTS, &viewport); 
} 

Scissoring is initialized using the initScissors() function specifying the non-clipping region. Anything outside this rectangular region will be discarded. The vkCmdSetScissor() API sets the scissoring parameters, which can be dynamically set, indicating the rectangular dimensions used for single or multiple scissoring:

void VulkanDrawable::recordCommandBuffer(int currentImage, VkCommandBuffer* cmdDraw){ 
   .  .  .  . 
   // Define the scissor here.
initScissors(cmdDraw); 
   .  .  .  . 
} 
void VulkanDrawable::initScissors(VkCommandBuffer* cmd) 
{ 
   scissor.extent.width    = rendererObj->width; 
   scissor.extent.height   = rendererObj->height; 
   scissor.offset.x        = 0; 
   scissor.offset.y        = 0; 
   vkCmdSetScissor(*cmd, 0, NUMBER_OF_SCISSORS, &scissor); 
} 

The vkCmdDraw() API reads the drawing parameters from the command buffer; the vertex information is accessed in the form of an array in sequential order, starting from the first vertex (firstVertex) to the total number of vertices specified by the vertexCount. The vkCmdDraw API renders primitives specified by the input assembly state under the pipeline state object using vertex array data information.

This API supports instancing, which allows efficient rendering of an object multiple times without calling multiple draw commands. Such drawing features are very helpful in situations such as crowd simulation, tree rendering, clone patterns, and so on. The total number of drawing instances is specified using instanceCount, starting from the first instance index indicated by firstInstance.

void vkCmdDraw( 
    VkCommandBuffer commandBuffer, 
    uint32_t        vertexCount, 
    uint32_t        instanceCount, 
    uint32_t        firstVertex, 
    uint32_t        firstInstance); 

The fields and a description of each parameter follow:

The present example in this chapter makes use of the following command:

vkCmdDraw(*cmdDraw, 3, 1, 0, 0); 

This command consumes the following triangle data, which represents three vertices in the interleaved form, hence the second parameter is specified as 3; since there is only one instance, the third parameter is 1. The drawing should start from the first vertex, which is indicated by index 0 as the fourth parameter. The last parameter is 0, pointing to the first instance ID:

struct VertexWithColor 
    { 
      float x, y, z, w;   // Vertex Position 
      float r, g, b, a;   // Color format Red, Green, Blue, Alpha 
    }; 
 
    static const VertexWithColor triangleData[] = 
    { 
      { 0.0f,  1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0 },/*Vertex0*/ 
      { 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0 },/*Vertex1*/ 
      {-1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0 },/*Vertex2*/ 
    };