Vulkan Cookbook

This is the code repository for Vulkan Cookbook, published by Packt. All the example workflows that are mentioned in the book are present in the package.

About the 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, programmable 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.

Related Books

• Vulkan Programming [Video]

• Learning Vulkan

• Building an Unreal RTS Game: The Basics [Video]

Suggestions and Feedback

Click here if you have any feedback or suggestions.

Credits

Special thanks for authors and developers of the following projects and resources:

• tinyobjloader - A single-header library for loading Wavefront OBJ files.
• stb image - A single-header library for loading image files (other libraries are also available).
• Humus - A large collection of cubemaps (and other resources).

Please note!

Currently only Windows operating system is supported. Linux version is being prepared and should be ready soon.

Samples

Chapter 11 - Lighting

• 01 - Rendering a geometry with vertex diffuse lighting

Sample showing how to implement a diffuse lighting algorithm calculated only at geometry's verices using vertex shaders.
Left mouse button: rotate the scene

• 02 - Rendering a geometry with fragment specular lighting

This sample present the Phong specular lighting algorithm implemented on vertex and fragment shaders.
Left mouse button: rotate the scene

• 03 - Rendering a normal mapped geometry

Here a normal mapping technique is presented and the model is lit using the specular lighting algorithm.
Left mouse button: rotate the scene

• 04 - Rendering a reflective and refractive geometry using cubemaps

Sample presenting how to use cubemaps to render a transparent geometry that both reflects and refracts environment.
Left mouse button: rotate the scene

• 05 - Adding shadows to the scene

In this sample a basic shadow mapping algorithm is shown. In the first render pass a shadow map is generated. In the second render pass a scene is rendered and the data from the shadow map is used to check, whether the geometry is lit or covered in shadow.
Left mouse button: rotate the scene
Right mouse button: move the light

Chapter 12 - Advanced Rendering Techniques

• 01 - Drawing a skybox

Here it is shown how to draw a skybox, which simulates background - objects seen in a distance and/or a sky.
Left mouse button: look around

• 02 - Drawing bilboards using geometry shaders

This sample presents a way of drawing sprites or bilboards - flat, textured quads that are always facing the camera.
Left mouse button: rotate the scene

• 03 - Drawing particles using compute and graphics pipelines

Here an example of rendering particles is shown. Compute shaders are used to calculate positions of all particles in the system. Particles are rendered as flat bilboards (sprites).
Left mouse button: rotate the scene

• 04 - Rendering a tesselated terrain

This code sample shows one of the ways to draw a terrain. A complete graphics pipeline with all five programmable stages is used that tessellates the terrain near the camera to improve its complexity, with level of details faiding away with increasing distance from the camera, and with a flat shading lighting algorithm.
Left mouse button: rotate the scene
Mouse wheel: zoom in / zoom out

• 05 - Rendering a fullscreen quad for postprocessing

Sample presenting a fast and easy way to prepare an image postprocessing phase in a graphics pipeline - by using a fullscreen quad drawn already in a clip space. An edge detection algorithm is shown as on of the examples of postprocessing techniques.

• 06 - Using an input attachment for color correction postprocess effect

In this code another postprocessing technique is shown that uses one of the Vulkan's specific features - input attachments, which allow reading data from render targets (attachments) in the same render pass.
Left mouse button: rotate the scene

Other

• 01 - Creating a logical device

Code sample that shows basic Vulkan setup - instance creation, physical device enumeration and logical device creation.

• 02 - Creating a swapchain

Here a swapchain object is created, which allows us to render a scene directly to an application's window.

• 03 - Using render passes

This example shows how to preapre a basic render pass - a description of attachments (render targets) needed to render a geometry.

• 04 - Using a graphics pipeline

Sample showing how to create a graphics pipeline, setup its multiple parameters and use it to draw a scene.

• 05 - Using combined image samplers

Here descriptor sets are introduced. They are required to setup an interface between application and a pipeline and to provide images (textures) to shaders.

• 06 - Using uniform buffers

Another example of using descriptor sets, but this time it presented how to prepare transformation matrices and provide them to shaders.

• 07 - Using push constants

This code sample presents a very fast and easy way to provide data to shaders - push constants. Though the provided data may not be too big, they are ideal for performing frequent updates.

• 08 - Using tessellation shaders

Here we can see how to create a graphics pipeline with tessellation control and evaluation shaders enabled responsible for increasing the complexity of a rendered geometry.

• 09 - Using geometry shaders

Sample presenting how to use geometry shaders and generate new primitives instead of those drawn in an application.

• 10 - Using compute shaders

This code sample shows how to create a compute pipeline - the second type of pipelines supported in the Vulkan API. It allows us to perform mathematical computations.

• 11 - Drawing vertex normals

Here a commonly used debugging technique is presented that uses geometry shaders to display normal vectors provided by the application.

• 12 - Using depth attachments

In this example we can see how to setup a render pass, framebufer and a graphics pipeline to use depth attachment and enable depth test during drawing.

Recipes Library

Chapter 01 - Instance and Devices

• 03 - Connecting with a Vulkan Loader library

• 05 - Loading function exported from a Vulkan Loader library

• 06 - Loading global-level functions

• 07 - Checking available Instance extensions

• 08 - Creating a Vulkan Instance

• 09 - Loading instance-level functions

• 10 - Enumerating available physical devices

• 11 - Checking available device extensions

• 12 - Getting features and properties of a physical device

• 13 - Checking available queue families and their properties

• 14 - Selecting index of a queue family with desired capabilities

• 15 - Creating a logical device

• 16 - Loading device-level functions

• 17 - Getting a device queue

• 18 - Creating a logical device with geometry shaders and graphics queue

• 19 - Destroying a logical device

• 20 - Destroying a Vulkan Instance

• 21 - Releasing a Vulkan Loader library

Chapter 02 - Image Presentation

• 01 - Creating a Vulkan Instance with WSI extensions enabled

• 02 - Creating a presentation surface

• 03 - Selecting a queue family that supports presentation to a given surface

• 04 - Creating a logical device with WSI extensions enabled

• 05 - Selecting a desired presentation mode

• 06 - Getting capabilities of a presentation surface

• 07 - Selecting a number of swapchain images

• 08 - Choosing a size of swapchain images

• 09 - Selecting desired usage scenarios of swapchain images

• 10 - Selecting a transformation of swapchain images

• 11 - Selecting a format of swapchain images

• 12 - Creating a swapchain

• 13 - Getting handles of swapchain images

• 14 - Creating a swapchain with R8G8B8A8 format and a MAILBOX present mode

• 15 - Acquiring a swapchain image

• 16 - Presenting an image

• 17 - Destroying a swapchain

• 18 - Destroying a presentation surface

Chapter 03 - Command Buffers and Synchronization

• 01 - Creating a command pool

• 02 - Allocating command buffers

• 03 - Beginning a command buffer recording operation

• 04 - Ending a command buffer recording operation

• 05 - Resetting a command buffer

• 06 - Resetting a command pool

• 07 - Creating a semaphore

• 08 - Creating a fence

• 09 - Waiting for fences

• 10 - Resetting fences

• 11 - Submitting command buffers to the queue

• 12 - Synchronizing two command buffers

• 13 - Checking if processing of a submitted command buffer has finished

• 14 - Waiting until all commands submitted to a queue are finished

• 15 - Waiting for all submitted commands to be finished

• 16 - Destroying a fence

• 17 - Destroying a semaphore

• 18 - Freeing command buffers

• 19 - Destroying a command pool

Chapter 04 - Resources and Memory

• 01 - Creating a buffer

• 02 - Allocating and binding memory object to a buffer

• 03 - Setting a buffer memory barrier

• 04 - Creating a buffer view

• 05 - Creating an image

• 06 - Allocating and binding memory object to an image

• 07 - Setting an image memory barrier

• 08 - Creating an image view

• 09 - Creating a 2D image and view

• 10 - Creating a layered 2D image with a CUBEMAP view

• 11 - Mapping, updating and unmapping host-visible memory

• 12 - Copying data between buffers

• 13 - Copying data from a buffer to an image

• 14 - Copying data from an image to a buffer

• 15 - Using staging buffer to update a buffer with a device-local memory bound

• 16 - Using staging buffer to update an image with a device-local memory bound

• 17 - Destroying an image view

• 18 - Destroying an image

• 19 - Destroying a buffer view

• 20 - Freeing a memory object

• 21 - Destroying a buffer

Chapter 05 - Descriptor Sets

• 01 - Creating a sampler

• 02 - Creating a sampled image

• 03 - Creating a combined image sampler

• 04 - Creating a storage image

• 05 - Creating a uniform texel buffer

• 06 - Creating a storage texel buffer

• 07 - Creating a uniform buffer

• 08 - Creating a storage buffer

• 09 - Creating an input attachment

• 10 - Creating a descriptor set layout

• 11 - Creating a descriptor pool

• 12 - Allocating descriptor sets

• 13 - Updating descriptor sets

• 14 - Binding descriptor sets

• 15 - Creating descriptors with a texture and a uniform buffer

• 16 - Freeing descriptor sets

• 17 - Resetting a descriptor pool

• 18 - Destroying a descriptor pool

• 19 - Destroying a descriptor set layout

• 20 - Destroying a sampler

Chapter 06 - Render Passes and Framebuffers

• 01 - Specifying attachments descriptions

• 02 - Specifying subpass descriptions

• 03 - Specifying dependencies between subpasses

• 04 - Creating a render pass

• 05 - Creating a framebuffer

• 06 - Preparing a render pass for geometry rendering and postprocess subpasses

• 07 - Preparing a render pass and a framebuffer with color and depth attachments

• 08 - Beginning a render pass

• 09 - Progressing to the next subpass

• 10 - Ending a render pass

• 11 - Destroying a framebuffer

• 12 - Destroying a render pass

Chapter 08 - Graphics and Compute Pipelines

• 01 - Creating a shader module

• 02 - Specifying pipeline shader stages

• 03 - Specifying pipeline vertex input state

• 04 - Specifying pipeline input assembly state

• 05 - Specifying pipeline tessellation state

• 06 - Specifying pipeline viewport and scissor test state

• 07 - Specifying pipeline rasterization state

• 08 - Specifying pipeline multisample state

• 09 - Specifying pipeline depth and stencil state

• 10 - Specifying pipeline blend state

• 11 - Specifying pipeline dynamic states

• 12 - Creating a pipeline layout

• 13 - Specifying graphics pipeline creation parameters

• 14 - Creating a pipeline cache object

• 15 - Retrieving data from a pipeline cache

• 16 - Merging multiple pipeline cache objects

• 17 - Creating graphics pipelines

• 18 - Creating a compute pipeline

• 19 - Binding a pipeline object

• 20 - Creating a pipeline layout with a combined image sampler, a buffer and push constant ranges

• 21 - Creating a graphics pipeline with vertex and fragment shaders, depth test enabled, and with dynamic viewport and scissor tests

• 22 - Creating multiple graphics pipelines on multiple threads

• 23 - Destroying a pipeline

• 24 - Destroying a pipeline cache

• 25 - Destroying a pipeline layout

• 26 - Destroying a shader module

Chapter 09 - Command Recording and Drawing

• 01 - Clearing a color image

• 02 - Clearing a depth-stencil image

• 03 - Clearing render pass attachments

• 04 - Binding vertex buffers

• 05 - Binding an index buffer

• 06 - Providing data to shaders through push constants

• 07 - Setting viewport state dynamically

• 08 - Setting scissor state dynamically

• 09 - Setting line width state dynamically

• 10 - Setting depth bias state dynamically

• 11 - Setting blend constants state dynamically

• 12 - Drawing a geometry

• 13 - Drawing an indexed geometry

• 14 - Dispatching compute work

• 15 - Executing secondary command buffer inside a primary command buffer

• 16 - Recording a command buffer that draws a geometry with dynamic viewport and scissor states

• 17 - Recording command buffers on multiple threads

• 18 - Preparing a single frame of animation

• 19 - Increasing the performance through increasing the number of separately rendered frames

Chapter 10 - Helper Recipes

• 01 - Preparing a translation matrix

• 02 - Preparing a rotation matrix

• 03 - Preparing a scaling matrix

• 04 - Preparing a perspective projection matrix

• 05 - Preparing an orthographic projection matrix

• 06 - Loading texture data from a file

• 07 - Loading a 3D model from an OBJ file