Guide Summary

Summary for everything this guide covers

This guide should have helped improve understanding of the structure of a basic Vulkan graphics application, as well as some of the most important Vulkan objects and how they interlink.

Here is a brief overview of the Vulkan concepts covered in this guide.

Vulkan concepts covered

  • Validation layers - these are optional components which provide error checking and allow tracking of API objects, amongst other functionality. They are incredibly useful for application debugging as Vulkan intentionally provides very little error checking itself.
  • Instance - this roughly corresponds to the installation of Vulkan on the system.
  • Extensions - these provide additional functionality beyond the base Vulkan API. Vulkan does not assume the developer is writing a graphical application, so the functionality for creating surfaces and swapchains has to be loaded and enabled.
  • Physical devices - these represent the physical hardware involved in rendering or compute jobs.
  • Logical devices - these are objects which allow the application to interface with the chosen physical device.
  • Queue families - these are groups of queues which share the same set of properties. For example, a queue family could contain queues which only support graphics operations and not compute operations.
  • Swapchains - these can be thought of as a series of images in a queue. These images are rendered by the application then returned to the swapchain. The presentation mode of a swapchain determines how these images are presented to the screen.
  • Render passes - these objects encapsulate all the information about the number, type, and formats of the attachments associated with framebuffers. The render pass also determines what work is done with these attachments to produce the final rendered image.
  • Descriptor sets - these are used to make memory object such as buffers and images accessible to shaders. They provide a connection between shader variables and the actual data.
  • Pipeline - this is a set of stages which perform different operations in the rendering process. They are sequential with each stage taking the output of the previous one. A pipeline takes a set of vertices as its input and then outputs the final image.
  • Semaphores and fences - these are synchronisation objects which ensure certain swapchain operations occur in the correct order. For example, it is important that rendering on a particular framebuffer image is finished before it is presented to the screen.

What to do next

It is a good idea to try and write a simple application in Vulkan using the example source code as a reference. It will provide a deeper understanding than simply reading this guide.

It is important to remember that this is only a starting point with Vulkan. The code shown here is a very simple example of a Vulkan application, and there are many features and rendering techniques which are not covered.

Other Vulkan examples, included with the PowerVR SDK, are a fantastic way to learn more about Vulkan and see various techniques and features in action. These examples are also found on the PowerVR SDK's GitHub site.

All other SDK examples make use of the PowerVR Framework, in particular the PVRVk and PVRUtilsVk modules. These modules make many of the steps completed in this tutorial considerably easier and allow you to move on to more interesting stages of development. The Vulkan example called IntroducingPVRVk performs the exact same operations as this example but uses the greatly simplified syntax of PVRVk. For an overview of the PowerVR Framework and its modules, see the PowerVR Framework Development Guide. The PowerVR Framework is also included as part of the PowerVR SDK