What do you get with eBook?

Instant access to your Digital eBook purchase

Download this book in EPUB and PDF formats

Access this title in our online reader with advanced features

DRM FREE - Read whenever, wherever and however you want

Buy Now

Instance and Devices

In this chapter, we will cover the following recipes:

Downloading Vulkan SDK
Enabling validation layers
Connecting with a Vulkan Loader library
Preparing for loading Vulkan API functions
Loading function 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 and graphics and compute queues
Destroying a logical device
Destroying a Vulkan Instance
Releasing a Vulkan Loader library

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:

Go to https://vulkan.lunarg.com.
Scroll to the bottom of the page and choose WINDOWS operating system.
Download and save the SDK installer file.

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.
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.
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:

Update system packages by running the following commands:

       sudo apt-get update
       sudo apt-get dist-upgrade

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

Go to https://vulkan.lunarg.com.
Scroll to the bottom of the page and choose LINUX operating system.
Download the Linux package for the SDK and save it in the desired folder.
Open Terminal and change the current directory to the folder to which the SDK package was downloaded.
Change the access permissions to the downloaded file by executing the following command:

       chmod ugo+x vulkansdk-linux-x86_64-<version>.run

Run the downloaded SDK package installer file with the following command:

       ./vulkansdk-linux-x86_64-<version>.run

Change the current directory to the VulkanSDK/<version> folder that was created by the SDK package installer.

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

Change the current directory to the x86_64/include/vulkan folder.
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.
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.

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.

What you will learn

[*] Work with Swapchain to present images on screen [*] Create, submit, and synchronize operations processed by the hardware [*] Create buffers and images, manage their memory, and upload data to them from CPU [*] Explore descriptor sets and set up an interface between application and shaders [*] Organize drawing operations into a set of render passes and subpasses [*] Prepare graphics pipelines to draw 3D scenes and compute pipelines to perform mathematical calculations [*] Implement geometry projection and tessellation, texturing, lighting, and post-processing techniques [*] Write shaders in GLSL and convert them into SPIR-V assemblies [*] Find out about and implement a collection of popular, advanced rendering techniques found in games and benchmarks

What do you get with eBook?