Book Image

Learning Vulkan

By : Parminder Singh
Book Image

Learning Vulkan

By: Parminder Singh

Overview of this book

Vulkan, the next generation graphics and compute API, is the latest offering by Khronos. This API is the successor of OpenGL and unlike OpenGL, it offers great flexibility and high performance capabilities to control modern GPU devices. With this book, you'll get great insights into the workings of Vulkan and how you can make stunning graphics run with minimum hardware requirements. We begin with a brief introduction to the Vulkan system and show you its distinct features with the successor to the OpenGL API. First, you will see how to establish a connection with hardware devices to query the available queues, memory types, and capabilities offered. Vulkan is verbose, so before diving deep into programing, you’ll get to grips with debugging techniques so even first-timers can overcome error traps using Vulkan’s layer and extension features. You’ll get a grip on command buffers and acquire the knowledge to record various operation commands into command buffer and submit it to a proper queue for GPU processing. We’ll take a detailed look at memory management and demonstrate the use of buffer and image resources to create drawing textures and image views for the presentation engine and vertex buffers to store geometry information. You'll get a brief overview of SPIR-V, the new way to manage shaders, and you'll define the drawing operations as a single unit of work in the Render pass with the help of attachments and subpasses. You'll also create frame buffers and build a solid graphics pipeline, as well as making use of the synchronizing mechanism to manage GPU and CPU hand-shaking. By the end, you’ll know everything you need to know to get your hands dirty with the coolest Graphics API on the block.

Related Content you might be interested in

Current Title:

Small book image
Learning Vulkan
Parminder Singh
Dec, 2016 | 466 pages
No titles found
Table of Contents (18 chapters)
Learning Vulkan
Learning Vulkan
Credits
Credits
About the Author
About the Author
Acknowledgments
Acknowledgments
About the Reviewer
About the Reviewer
www.PacktPub.com
www.PacktPub.com
Preface
Preface
Free Chapter
1
Getting Started with the NextGen 3D Graphics API
Getting Started with the NextGen 3D Graphics API
Vulkan and its evolution
Vulkan versus OpenGL
Important jargons before we get started
Learning the fundamentals of Vulkan
Understanding the Vulkan application
Getting started with the Vulkan programming model
Summary
2
Your First Vulkan Pseudo Program
Your First Vulkan Pseudo Program
Installing Vulkan
The Hello World!!! pseudocode
Fitting it all together
Summary
3
Shaking Hands with the Device
Shaking Hands with the Device
Getting started with the LunarG SDK
Setting up our first project with CMake
Introduction to extensions
Creating a Vulkan instance
Understanding physical and logical devices
Understanding queues and queue families
Implementing devices and queues all together
Summary
4
Debugging in Vulkan
Debugging in Vulkan
Peeking into Vulkan debugging
Understanding LunarG validation layers and their features
Implementing debugging in Vulkan
Summary
5
Command Buffer and Memory Management in Vulkan
Command Buffer and Memory Management in Vulkan
Getting started with command buffers
Understanding command pool and buffer APIs
Recording command buffers
Implementing the wrapper class for a command buffer
Managing memory in Vulkan
Summary
6
Allocating Image Resources and Building a Swapchain with WSI
Allocating Image Resources and Building a Swapchain with WSI
Getting started with image resources
Understanding image resources
Memory allocation and binding image resources
Introducing swapchains
Creating a depth image
Summarizing the application flow
Summary
7
Buffer Resource, Render Pass, Framebuffer, and Shaders with SPIR-V
Buffer Resource, Render Pass, Framebuffer, and Shaders with SPIR-V
Understanding the Vulkan buffer resource type
Creating geometry with a buffer resource
Understanding a Render Pass
Using the Render Pass and creating the framebuffer
Clearing the background color
Working with a shader in Vulkan
Summary
8
Pipelines and Pipeline State Management
Pipelines and Pipeline State Management
Getting started with pipelines
Caching pipeline objects with a PCO
Creating a graphics pipeline
Understanding compute pipelines
Pipeline State Objects (PSO) in Vulkan
Implementing the pipeline
Summary
9
Drawing Objects
Drawing Objects
Overview of the drawing process in Vulkan
Preparing the drawing object
Rendering the drawing object
Rendering an indexed geometry
Understanding synchronization primitives in Vulkan
Resizing the display window
Summary
10
Descriptors and Push Constant
Descriptors and Push Constant
Understanding the concept of descriptors
How to implement Uniforms in Vulkan?
Push constant updates
Summary
11
Drawing Textures
Drawing Textures
Image resource - a quick recap
Prerequisites for texture drawing
Implementing the image resource with linear tiling
Implementing the image resource with optimal tiling
Copying data content between images and buffers
Updating the descriptor set
Summary

Understanding the Vulkan application

This section will provide you with an overview of the various components that contribute to, and are helpful in building a Vulkan application.

The following block diagram shows the different component blocks and respective interconnections within the system:

Driver

A Vulkan-capable system comprises a minimum of one CPU and GPU. IHV's vendor supplies the driver of a given Vulkan specification implementation for their dedicated GPU architecture. The driver acts as an interface between the application and the device itself. It provides high-level facilities to the application so it can communicate with the device. For example, it advertises the number of devices available on the system, their queues and queue capabilities, available heaps and their related properties, and so on.

Application

An application refers to a user-written program that is intended to make use of Vulkan APIs to perform graphics or compute jobs. The application starts with the initialization of the hardware and software; it detects the driver and loads all the Vulkan APIs. The presentation layer is initialized with Vulkan's Window System Integration (WSI) APIs; WSI will be helpful in rendering the drawing image on the display surface. The application creates resources and binds them to the shader stage using descriptors. The descriptor set layout helps bind the created resources to the underlying pipeline object that is created (of the graphics or compute type). Finally, command buffers are recorded and submitted to the queue for processing.

WSI

Windows System Integration is a set of extensions from Khronos for the unification of the presentation layer across different platforms, such as Linux, Windows, and Android.

SPIR-V

SPIR-V provides a precompiled binary format for specifying shaders to Vulkan. Compilers are available for various shader source languages, including variants of GLSL and HLSL, which produce SPIR-V.

LunarG SDK

The Vulkan SDK from LunarG comprises a variety of tools and resources to aid Vulkan application development. These tools and resources include the Vulkan loader, validation layers, trace and replay tools, SPIR-V tools, Vulkan runtime installer, documentation, samples, and demos, see Chapter 3, Shaking Hands with the Device to see detailed description to get started with LunarG SDK. You can read more about it at http://lunarg.com/vulkan-sdk.

Previous Section
End of Section 6
Next Section