Book Image

Vulkan Cookbook

By : Pawel Lapinski
Book Image

Vulkan Cookbook

By: Pawel Lapinski

Overview of this book

Vulkan is the next generation graphics API released by the Khronos group. It is expected to be the successor to OpenGL and OpenGL ES, which it shares some similarities with such as its cross-platform capabilities, programmed pipeline stages, or nomenclature. Vulkan is a low-level API that gives developers much more control over the hardware, but also adds new responsibilities such as explicit memory and resources management. With it, though, Vulkan is expected to be much faster. This book is your guide to understanding Vulkan through a series of recipes. We start off by teaching you how to create instances in Vulkan and choose the device on which operations will be performed. You will then explore more complex topics such as command buffers, resources and memory management, pipelines, GLSL shaders, render passes, and more. Gradually, the book moves on to teach you advanced rendering techniques, how to draw 3D scenes, and how to improve the performance of your applications. By the end of the book, you will be familiar with the latest advanced techniques implemented with the Vulkan API, which can be used on a wide range of platforms.

Related Content you might be interested in

Current Title:

Small book image
Vulkan Cookbook
Pawel Lapinski
Apr, 2017 | 700 pages
Small book image
C++ Game Development By Example
Siddharth Shekar
May, 2019 | 420 pages
Small book image
3D Graphics Rendering Cookbook
Viktor Latypov | Sergey Kosarevsky
Aug, 2021 | 670 pages
Small book image
Mastering Graphics Programming with Vulkan
Marco Castorina | Gabriel Sassone
Feb, 2023 | 382 pages
Table of Contents (13 chapters)
Preface
Preface
What this book covers
What you need for this book
Who this book is for
Sections
Conventions
Reader feedback
Customer support
Free Chapter
1
Instance and Devices
Instance and Devices
Introduction
Downloading Vulkan's SDK
Enabling validation layers
Connecting with a Vulkan Loader library
Preparing for loading Vulkan API functions
Loading functions exported from a Vulkan Loader library
Loading global-level functions
Checking available Instance extensions
Creating a Vulkan Instance
Loading instance-level functions
Enumerating available physical devices
Checking available device extensions
Getting features and properties of a physical device
Checking available queue families and their properties
Selecting the index of a queue family with the desired capabilities
Creating a logical device
Loading device-level functions
Getting a device queue
Creating a logical device with geometry shaders, graphics, and compute queues
Destroying a logical device
Destroying a Vulkan Instance
Releasing a Vulkan Loader library
2
Image Presentation
Image Presentation
Introduction
Creating a Vulkan Instance with WSI extensions enabled
Creating a presentation surface
Selecting a queue family that supports presentation to a given surface
Creating a logical device with WSI extensions enabled
Selecting a desired presentation mode
Getting the capabilities of a presentation surface
Selecting a number of swapchain images
Choosing a size of swapchain images
Selecting desired usage scenarios of swapchain images
Selecting a transformation of swapchain images
Selecting a format of swapchain images
Creating a swapchain
Getting handles of swapchain images
Creating a swapchain with R8G8B8A8 format and a mailbox present mode
Acquiring a swapchain image
Presenting an image
Destroying a swapchain
Destroying a presentation surface
3
Command Buffers and Synchronization
Command Buffers and Synchronization
Introduction
Creating a command pool
Allocating command buffers
Beginning a command buffer recording operation
Ending a command buffer recording operation
Resetting a command buffer
Resetting a command pool
Creating a semaphore
Creating a fence
Waiting for fences
Resetting fences
Submitting command buffers to a queue
Synchronizing two command buffers
Checking if processing of a submitted command buffer has finished
Waiting until all commands submitted to a queue are finished
Waiting for all submitted commands to be finished
Destroying a fence
Destroying a semaphore
Freeing command buffers
Destroying a command pool
4
Resources and Memory
Resources and Memory
Introduction
Creating a buffer
Allocating and binding a memory object for a buffer
Setting a buffer memory barrier
Creating a buffer view
Creating an image
Allocating and binding a memory object to an image
Setting an image memory barrier
Creating an image view
Creating a 2D image and view
Creating a layered 2D image with a CUBEMAP view
Mapping, updating and unmapping host-visible memory
Copying data between buffers
Copying data from a buffer to an image
Copying data from an image to a buffer
Using a staging buffer to update a buffer with a device-local memory bound
Using a staging buffer to update an image with a device-local memory bound
Destroying an image view
Destroying an image
Destroying a buffer view
Freeing a memory object
Destroying a buffer
5
Descriptor Sets
Descriptor Sets
Introduction
Creating a sampler
Creating a sampled image
Creating a combined image sampler
Creating a storage image
Creating a uniform texel buffer
Creating a storage texel buffer
Creating a uniform buffer
Creating a storage buffer
Creating an input attachment
Creating a descriptor set layout
Creating a descriptor pool
Allocating descriptor sets
Updating descriptor sets
Binding descriptor sets
Creating descriptors with a texture and a uniform buffer
Freeing descriptor sets
Resetting a descriptor pool
Destroying a descriptor pool
Destroying a descriptor set layout
Destroying a sampler
6
Render Passes and Framebuffers
Render Passes and Framebuffers
Introduction
Specifying attachments descriptions
Specifying subpass descriptions
Specifying dependencies between subpasses
Creating a render pass
Creating a framebuffer
Preparing a render pass for geometry rendering and postprocess subpasses
Preparing a render pass and a framebuffer with color and depth attachments
Beginning a render pass
Progressing to the next subpass
Ending a render pass
Destroying a framebuffer
Destroying a render pass
7
Shaders
Shaders
Introduction
Converting GLSL shaders to SPIR-V assemblies
Writing vertex shaders
Writing tessellation control shaders
Writing tessellation evaluation shaders
Writing geometry shaders
Writing fragment shaders
Writing compute shaders
Writing a vertex shader that multiplies vertex position by a projection matrix
Using push constants in shaders
Writing texturing vertex and fragment shaders
Displaying polygon normals with a geometry shader
8
Graphics and Compute Pipelines
Graphics and Compute Pipelines
Introduction
Creating a shader module
Specifying pipeline shader stages
Specifying a pipeline vertex binding description, attribute description, and input state
Specifying a pipeline input assembly state
Specifying a pipeline tessellation state
Specifying a pipeline viewport and scissor test state
Specifying a pipeline rasterization state
Specifying a pipeline multisample state
Specifying a pipeline depth and stencil state
Specifying a pipeline blend state
Specifying pipeline dynamic states
Creating a pipeline layout
Specifying graphics pipeline creation parameters
Creating a pipeline cache object
Retrieving data from a pipeline cache
Merging multiple pipeline cache objects
Creating a graphics pipeline
Creating a compute pipeline
Binding a pipeline object
Creating a pipeline layout with a combined image sampler, a buffer, and push constant ranges
Creating a graphics pipeline with vertex and fragment shaders, depth test enabled, and with dynamic viewport and scissor tests
Creating multiple graphics pipelines on multiple threads
Destroying a pipeline
Destroying a pipeline cache
Destroying a pipeline layout
Destroying a shader module
9
Command Recording and Drawing
Command Recording and Drawing
Introduction
Clearing a color image
Clearing a depth-stencil image
Clearing render pass attachments
Binding vertex buffers
Binding an index buffer
Providing data to shaders through push constants
Setting viewport states dynamically
Setting scissor states dynamically
Setting line width states dynamically
Setting depth bias states dynamically
Setting blend constants states dynamically
Drawing a geometry
Drawing an indexed geometry
Dispatching compute work
Executing a secondary command buffer inside a primary command buffer
Recording a command buffer that draws a geometry with dynamic viewport and scissor states
Recording command buffers on multiple threads
Preparing a single frame of animation
Increasing the performance through increasing the number of separately rendered frames
10
Helper Recipes
Helper Recipes
Introduction
Preparing a translation matrix
Preparing a rotation matrix
Preparing a scaling matrix
Preparing a perspective projection matrix
Preparing an orthographic projection matrix
Loading texture data from a file
Loading a 3D model from an OBJ file
11
Lighting
Lighting
Introduction
Rendering a geometry with a vertex diffuse lighting
Rendering a geometry with a fragment specular lighting
Rendering a normal mapped geometry
Drawing a reflective and refractive geometry using cubemaps
Adding shadows to the scene
12
Advanced Rendering Techniques
Advanced Rendering Techniques
Introduction
Drawing a skybox
Drawing billboards using geometry shaders
Drawing particles using compute and graphics pipelines
Rendering a tessellated terrain
Rendering a full-screen quad for post-processing
Using input attachments for a color correction post-process effect

Downloading Vulkan's SDK

To start developing applications using the Vulkan API, we need to download a SDK and use some of its resources in our application.

Vulkan's SDK can be found at https://vulkan.lunarg.com.

Getting ready

Before we can execute any application that uses the Vulkan API, we also need to install a graphics drivers that supports the Vulkan API. These can be found on a graphics hardware vendor's site.

How to do it...

On the Windows operating system family:

  1. Go to https://vulkan.lunarg.com.
  2. Scroll to the bottom of the page and choose WINDOWS operating system.
  3. Download and save the SDK installer file.
  1. Run the installer and select the destination at which you want to install the SDK. By default, it is installed to a C:\VulkanSDK\<version>\ folder.
  2. When the installation is finished, open the folder in which the Vulkan SDK was installed and then open the RunTimeInstaller sub-folder. Execute VulkanRT-<version>-Installer file. This will install the latest version of the Vulkan Loader.
  3. Once again, go to the folder in which the SDK was installed and open the Include\vulkan sub-folder. Copy the vk_platform.h and vulkan.h header files to the project folder of the application you want to develop. We will call these two files Vulkan header files.

On the Linux operating system family:

  1. Update system packages by running the following commands:
       sudo apt-get update
       sudo apt-get dist-upgrade
  1. To be able to build and execute Vulkan samples from the SDK, install additional development packages by running the following command:
       sudo apt-get install libglm-dev graphviz libxcb-dri3-0 
       libxcb-present0 libpciaccess0 cmake libpng-dev libxcb-dri3-
       dev libx11-dev
  1. Go to https://vulkan.lunarg.com.
  2. Scroll to the bottom of the page and choose LINUX operating system.
  3. Download the Linux package for the SDK and save it in the desired folder.
  4. Open Terminal and change the current directory to the folder to which the SDK package was downloaded.
  5. Change the access permissions to the downloaded file by executing the following command:
       chmod ugo+x vulkansdk-linux-x86_64-<version>.run
  1. Run the downloaded SDK package installer file with the following command:
       ./vulkansdk-linux-x86_64-<version>.run
  1. Change the current directory to the VulkanSDK/<version> folder that was created by the SDK package installer.
  1. Set up environment variables by executing the following command:
      sudo su
      VULKAN_SDK=$PWD/x86_64
      echo export PATH=$PATH:$VULKAN_SDK/bin >> /etc/environment
      echo export VK_LAYER_PATH=$VULKAN_SDK/etc/explicit_layer.d >> 
      /etc/environment
      echo $VULKAN_SDK/lib >> /etc/ld.so.conf.d/vulkan.conf
      ldconfig
  1. Change the current directory to the x86_64/include/vulkan folder.
  2. Copy vk_platform.h and vulkan.h header files to the project folder of the application you want to develop. We will call these two files Vulkan header files.
  3. Restart the computer for the changes to take effect.

How it works...

The SDK contains resources needed to create applications using the Vulkan API. Vulkan header files (the vk_platform.h and vulkan.h files) need to be included in the source code of our application so we can use the Vulkan API functions, structures, enumerations, and so on, inside the code.

The Vulkan Loader (vulkan-1.dll file on Windows, libvulkan.so.1 file on Linux systems) is a dynamic library responsible for exposing Vulkan API functions and forwarding them to the graphics driver. We connect with it in our application and load Vulkan API functions from it.

See also

The following recipes in this chapter:

  • Enabling validation layers
  • Connecting with a Vulkan Loader library
  • Releasing a Vulkan Loader library
Previous Section
End of Section 3
Next Section