book

Learning Vulkan

Name: Learning Vulkan
Author: Parminder Singh
ISBN: 9781786469809

by Parminder Singh

December 2016

Beginner to intermediate

466 pages

10h 37m

English

Packt Publishing

Read now

Unlock full access

Learning Vulkan
Learning Vulkan
Credits
About the Author
Acknowledgments
About the Reviewer
www.PacktPub.com
Why subscribe?
Preface
What this book covers
What you need for this book
Who this book is for

Conventions
Reader feedback
Customer support
Downloading the example code Downloading the color images of this book ErrataPiracyQuestions
1. 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
Vulkan's execution modelVulkan's queuesThe object modelObject lifetime and command syntaxError checking and validation
Understanding the Vulkan application
DriverApplicationWSISPIR-VLunarG SDK
Getting started with the Vulkan programming model
Hardware initializationWindow presentation surfacesResource setupPipeline setupDescriptor sets and descriptor poolsShaders with SPIR-VPipeline managementRecording commandsQueue submission
Summary
2. Your First Vulkan Pseudo Program
Installing Vulkan
The Hello World!!! pseudocode
Initialization - a handshake with the deviceSwapchain initialization - querying the WSI extensionCommand buffer initialization - allocating command buffersResource objects - managing images and buffersCreating a presentation surface - creating a swapchainCreating a depth imageResource allocation - allocating and binding device memorySupplying shaders - shader compilation into SPIR-VBuilding layouts - descriptor and pipeline layoutsCreating a Render Pass - defining a pass attributeFramebuffer - connect drawing images to the Render PassPopulating geometry - storing a vertex into GPU memoryPipeline state management - creating pipelinesDefining statesCreating a graphics pipelineExecuting the Render Pass - drawing Hello World!!!Acquiring the drawing surfacePreparing the Render Pass control structureRender Pass executionQueue submission and synchronization - sending jobsDisplaying with presentation layer - rendering a triangle
Fitting it all together
Summary
3. Shaking Hands with the Device
Getting started with the LunarG SDK
Setting up our first project with CMake
How to build the CMake file
Introduction to extensions
Querying layers and extensions
Creating a Vulkan instance
Enabling layers and extensionsTesting the enabled layers and extensions
Understanding physical and logical devices
Physical devicesEnumerating physical devicesQuerying physical device extensionsGetting the properties of a physical deviceInterrogating memory properties from the physical deviceLogical deviceCreating a logical deviceWaiting on the hostLosing the device
Understanding queues and queue families
Querying queue familiesStoring the graphics queue handleCreating a queue
Implementing devices and queues all together
Summary
4. 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
Getting started with command buffersExplicit synchronizationTypes of command in command buffersCommand buffers and queuesThe order of execution
Understanding command pool and buffer APIs
Creating a command poolResetting a command poolDestroying a command poolCommand buffer allocationResetting command buffersFreeing command buffers
Recording command buffers
Queue submissionQueue waiting
Implementing the wrapper class for a command buffer
Implementing the command buffer allocation processRecording the command buffer allocation processHow to use command buffer recording functionsSubmitting the command to the queue
Managing memory in Vulkan
Host memoryDevice memoryAllocating device memoryFreeing up device memoryAccessing device memory from the hostLazily allocated memory
Summary
6. Allocating Image Resources and Building a Swapchain with WSI
Getting started with image resourcesImage creation overview
Understanding image resources
Creating imagesDestroying the created imagesUnderstanding image layoutsCreating an image viewDestroying the image view
Memory allocation and binding image resources
Gathering memory allocation requirementsAllocating physical memory on the deviceBinding the allocated memory to an image object
Introducing swapchains
Understanding the swapchain implementation flowThe swapchain implementation's class block diagramRenderer - a window management custom classCreating the presentation windowInitializing the rendererCreating the command poolBuilding swapchain and depth imagesRendering the presentation windowVulkanSwapChain - the swapchain managerQuerying swapchain extensionsCreating the surface with WSI and associating it with the created windowThe graphics queue with present supportQuerying swapchain image formatsCreating the swapchainSwapchain surface capabilities and the presentation modeManaging presentation mode informationRetrieving the swapchain's color imagesCreating color image views
Creating a depth image
Introduction to tilingCreating a depth buffer image objectGetting the depth image's memory requirementsDetermining the type of memoryAllocating and binding physical memory to a depth imageImage layout transitionImage layout transition with memory barriersCreating the image view
Summarizing the application flow
InitializationRendering - displaying the output window
Summary
7. Buffer Resource, Render Pass, Framebuffer, and Shaders with SPIR-V
Understanding the Vulkan buffer resource typeCreating the buffer resource objectDestroying the bufferCreating a buffer viewDestroying the buffer view
Creating geometry with a buffer resource
Preparing geometry dataCreating a vertex bufferBuffer creation overviewImplementing a buffer resource - creating the vertex buffer for the geometryUnderstanding the code flow
Understanding a Render Pass
AttachmentsSubpassesVulkan APIs for the Render PassImplementing the Render Pass
Using the Render Pass and creating the framebuffer
Implementing the framebuffer
Clearing the background color
Setting the background color in the Render Pass instanceRendering the colored background
Working with a shader in Vulkan
Introduction to SPIR-VCompiling a GLSL shader into SPIR-VOffline compilation with the glslangValidator executableOnline compilation with SPIR-V tool librariesImplementing a shader
Summary
8. Pipelines and Pipeline State Management
Getting started with pipelinesVulkanPipeline - the pipeline implementation class
Caching pipeline objects with a PCO
Creating a pipeline cache objectMerging pipeline cachesRetrieving data from pipeline cachesImplementing the PCO
Creating a graphics pipeline
Implementing a graphics pipelineDestroying pipelines
Understanding compute pipelines
Pipeline State Objects (PSO) in Vulkan
Dynamic statesImplementing dynamic statesVertex input statesImplementing vertex input statesInput assembly statesImplementing input assembly statesPrimitive restartPrimitive topologiesPrimitives topologies with no adjacencyPrimitives topologies with adjacencyRasterizationRasterization statesImplementing rasterization statesBlendingColor blend statesImplementing color blend statesViewport managementThe viewport stateImplementing the viewport stateDepth and stencil testsDepth and stencil statesImplementing depth stencil statesMultisample statesImplementing multisample states
Implementing the pipeline
Summary
9. Drawing Objects
Overview of the drawing process in VulkanWalking through the header declaration
Preparing the drawing object
Recording Render Pass commandsBeginning Render Pass instance recordingTransitioning to the next subpassFinishing Render Pass instance recordingImplementationBinding pipeline objectImplementationSpecifying drawing object geometry informationImplementationDefining a dynamic viewportImplementationScissoringImplementationDraw commandvkCmdDraw commandImplementing drawing object preparation
Rendering the drawing object
Acquiring the swapchain imageExecuting the drawing command buffer objectDisplaying the output with the presentation engineImplementing drawing object rendering
Rendering an indexed geometry
Understanding synchronization primitives in Vulkan
FencesSemaphoresEvents
Resizing the display window
Summary
10. Descriptors and Push Constant
Understanding the concept of descriptorsVulkanDescriptor - a user-defined descriptor classDescriptor set layoutImplementing the descriptor set layoutDestroying the descriptor set layoutUnderstanding pipeline layoutsCreating a pipeline layoutImplementing the pipeline layout creationDestroying the pipeline layoutImplementing the pipeline layout destruction processDescriptor poolCreating a descriptor poolImplementing the creation of the descriptor poolDestroying the descriptor poolImplementing the destruction of the descriptor poolCreating the descriptor set resourcesCreating the descriptor setsAllocating the descriptor set object from the descriptor poolDestroying the allocated descriptor set objectsAssociating the resources with the descriptor setsImplementing descriptor set creation
How to implement Uniforms in Vulkan?
PrerequisitesExecution model overviewInitializationShader implementationCreating descriptorsRenderingBinding the descriptor setUpdateUpdating the transformation
Push constant updates
Defining the push constant resource in the shaderUpdating the pipeline layout with the push constantUpdating the resource data
Summary
11. Drawing Textures
Image resource - a quick recap
Prerequisites for texture drawing
Specifying the texture coordinatesUpdating the shader programLoading the image filesUsing the GLI libraryLocal image data structure
Implementing the image resource with linear tiling
Loading the image fileCreating the image objectMemory allocation and bindingPopulating the allocated device memoryCreating the command buffer objectSetting the image layoutSubmitting the command bufferCreating an image samplerFilteringWrapping modesCreating the image view
Implementing the image resource with optimal tiling
Loading the image fileBuffer object memory allocation and bindingPopulating the allocated device memoryCreating the image objectImage object memory allocation and bindingCreating a command buffer objectSetting the image layoutBuffer to image copySetting the optimal image layoutSubmitting the command bufferCreating an image samplerCreating the image view
Copying data content between images and buffers
Updating the descriptor set
Summary

Content preview from Learning Vulkan

Getting started with the Vulkan programming model

Let's discuss the Vulkan programming model in detail. Here, the end user, considering he or she is a total beginner, will be able to understand the following concepts:

The Vulkan programming model
The rendering execution model, which will be described using a pseudo step-by-step approach
How Vulkan works

The following diagram shows a top-down approach of the Vulkan application programming model; we will understand this process in detail and also delve into the sublevel components and their functionalities:

Getting started with the Vulkan programming model

Hardware initialization

When a Vulkan application starts, its very first job is the initialization ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Mastering Graphics Programming with Vulkan

Publisher Resources

ISBN: 9781786469809

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Learning Vulkan

by Parminder Singh

Getting started with the Vulkan programming model

Hardware initialization

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.