Mastering graphics programming with Vulkan : develop a modern rendering engine from first principles to state-of-the-art techniques / Marco Castorina and Gabriel Sassone.

Format:

Book

Author/Creator:

Castorina, Marco, author.

Sassone, Gabriel, author.

Language:

English

Subjects (All):

Video games--Development.

Video games.

Video games--Programming.

Physical Description:

1 online resource (382 pages)

Edition:

1st ed.

Distribution:

London : Bloomsbury Publishing (UK), 2024.

Place of Publication:

Birmingham : Packt Publishing, 2023.

System Details:

text file HTML

Biography/History:

Castorina Marco: Marco Castorina first got familiar with Vulkan while working as a driver developer at Samsung. Later he developed a 2D and 3D renderer in Vulkan from scratch for a leading media-server company. He recently joined the games graphics performance team at AMD. In his spare time, he keeps up to date with the latest techniques in real-time graphics. Sassone Gabriel: Gabriel Sassone is a rendering enthusiast currently working as a Principal Rendering Engineer at Multiplayer Group. Previously working for Avalanche Studios, where his first contact with Vulkan happened, where they developed the Vulkan layer for the proprietary Apex Engine and its Google Stadia Port. He previously worked at ReadyAtDawn, Codemasters, FrameStudios, and some non-gaming tech companies. His spare time is filled with music and rendering, gaming, and outdoor activities.

Summary:

Vulkan is now an established and flexible multi-platform graphics API. It has been adopted in many industries, including game development, medical imaging, movie productions, and media playback. Learning Vulkan is a foundational step to understanding how a modern graphics API works, both on desktop and mobile.

Contents:

Cover

Title Page

Copyright and Credits

Acknowledgments

Contributors

Table of Contents

Preface

Part 1: Foundations of a Modern Rendering Engine

Chapter 1: Introducing the Raptor Engine and Hydra

Technical requirements

Windows

Linux

macOS

How to read this book

Understanding the code structure

Layers of code

Understanding the glTF scene format

PBR in a nutshell

A word on GPU debugging

Summary

Further reading

Chapter 2: Improving Resources Management

Unlocking and implementing bindless rendering

Checking for support

Creating the descriptor pool

Updating the descriptor set

Update to shader code

Automating pipeline layout generation

Compiling GLSL to SPIR-V

Understanding the SPIR-V output

From SPIR-V to pipeline layout

Improving load times with a pipeline cache

Chapter 3: Unlocking Multi-Threading

Task-based multi-threading using enkiTS

Why task-based parallelism?

Using the enkiTS (Task-Scheduler) library

Asynchronous loading

Creating the I/O thread and tasks

Vulkan queues and the first parallel command generation

The AsynchronousLoader class

Recording commands on multiple threads

The allocation strategy

Command buffer recycling

Primary versus secondary command buffers

Drawing using primary command buffers

Drawing using secondary command buffers

Spawning multiple tasks to record command buffers

Chapter 4: Implementing a Frame Graph

Understanding frame graphs

Building a graph

A data-driven approach

Implementing the frame graph

Implementing topological sort

Driving rendering with the frame graph

Further reading.

Chapter 5: Unlocking Async Compute

Replacing multiple fences with a single timeline semaphore

Enabling the timeline semaphore extension

Creating a timeline semaphore

Waiting for a timeline semaphore on the CPU

Using a timeline semaphore on the GPU

Adding a separate queue for async compute

Submitting work on separate queues

Implementing cloth simulation using async compute

Benefits of using compute shaders

Compute shaders overview

Writing compute shaders

Part 2: GPU-Driven Rendering

Chapter 6: GPU-Driven Rendering

Breaking down large meshes into meshlets

Generating meshlets

Understanding task and mesh shaders

Implementing task shaders

Implementing mesh shaders

GPU culling using compute

Depth pyramid generation

Occlusion culling

Chapter 7: Rendering Many Lights with Clustered Deferred Rendering

A brief history of clustered lighting

Differences between forward and deferred techniques

Implementing a G-buffer

Implementing light clusters

CPU lights assignment

GPU light processing

Chapter 8: Adding Shadows Using Mesh Shaders

A brief history of shadow techniques

Shadow volumes

Shadow mapping

Raytraced shadows

Implementing shadow mapping using mesh shaders

Overview

Cubemap shadows

A note about multiview rendering

Per-light mesh instance culling

Indirect draw commands generation

Shadow cubemap face culling

Meshlet shadow rendering - task shader

Meshlet shadow rendering - mesh shader

Shadow map sampling

Improving shadow memory with Vulkan's sparse resources

Creating and allocating sparse textures.

Choosing per-light shadow memory usage

Rendering into a sparse shadow map

Chapter 9: Implementing Variable Rate Shading

Introducing variable rate shading

Determining the shading rate

Integrating variable rate shading using Vulkan

Taking advantage of specialization constants

Chapter 10: Adding Volumetric Fog

Introducing Volumetric Fog Rendering

Volumetric Rendering

Volumetric Fog

Implementing Volumetric Fog Rendering

Data injection

Calculating the lighting contribution

Integrating scattering and extinction

Applying Volumetric Fog to the scene

Adding filters

Volumetric noise generation

Blue noise

Part 3: Advanced Rendering Techniques

Chapter 11: Temporal Anti-Aliasing

The simplest TAA implementation

Jittering the camera

Choosing jittering sequences

Adding motion vectors

First implementation code

Improving TAA

Reprojection

History sampling

Scene sampling

The history constraint

Resolve

Sharpening the image

Sharpness post-processing

Negative mip bias

Unjitter texture UVs

Improving banding

Chapter 12: Getting Started with Ray Tracing

Introduction to ray tracing in Vulkan

Building the BLAS and TLAS

Defining and creating a ray tracing pipeline

Chapter 13: Revisiting Shadows with Ray Tracing

Implementing simple ray-traced shadows

Improving ray-traced shadows

Motion vectors

Computing visibility variance

Computing visibility

Computing filtered visibility

Using the filtered visibility

Chapter 14: Adding Dynamic Diffuse Global Illumination with Ray Tracing

Introduction to indirect lighting

Introduction to Dynamic Diffuse Global Illumination (DDGI)

Ray tracing for each probe

Probes offsetting

Probes irradiance and visibility updates

Probes sampling

Implementing DDGI

Ray-generation shader

Ray-hit shader

Ray-miss shader

Updating probes irradiance and visibility shaders

Indirect lighting sampling

Modifications to the calculate_lighting method

Probe offsets shader

Chapter 15: Adding Reflections with Ray Tracing

How screen-space reflections work

Implementing ray-traced reflections

Implementing a denoiser

Index

Other Books You May Enjoy.

ISBN:

9781803230207

1803230207

OCLC:

1363101048