http://www.loc.gov/mods/v3 http://www.loc.gov/standards/mods/v3/mods-3-2.xsd
Mastering graphics programming with Vulkan
develop a modern rendering engine from first principles to state-of-the-art techniques
Develop a rendering framework by implementing next-generation 3D graphics, leveraging advanced Vulkan features, and getting familiar with efficient real-time ray tracing techniques uncovered by leading industry experts Key Features Develop high-performance rendering techniques in Vulkan Automate some of the more tedious aspects like pipeline layouts and resource barriers Understand how to take advantage of mesh shaders and ray tracing Book Description 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. In Mastering Graphics Programming with Vulkan, you'll begin by developing the foundations of a rendering framework. You'll learn how to leverage advanced Vulkan features to write a modern rendering engine. The chapters will cover how to automate resource binding and dependencies. You'll then take advantage of GPU-driven rendering to scale the size of your scenes and finally, you'll get familiar with ray tracing techniques that will improve the visual quality of your rendered image. By the end of this book, you'll have a thorough understanding of the inner workings of a modern rendering engine and the graphics techniques employed to achieve state-of-the-art results. The framework developed in this book will be the starting point for all your future experiments. What you will learn Understand resources management and modern bindless techniques Get comfortable with how a frame graph works and know its advantages Explore how to render efficiently with many light sources Discover how to integrate variable rate shading Understand the benefits and limitations of temporal anti-aliasing Get to grips with how GPU-driven rendering works Explore and leverage ray tracing to improve render quality Who this book is for This book is for professional graphics and game developers who want to gain in-depth knowledge about how to write a modern and performant rendering engine in Vulkan. Familiarity with basic concepts of graphics programming (i.e. matrices, vectors, etc.) and fundamental knowledge of Vulkan are required.
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 -- Technical requirements -- 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 -- Summary -- Further reading -- Chapter 3: Unlocking Multi-Threading -- Technical requirements -- 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 -- Summary -- Further reading -- Chapter 4: Implementing a Frame Graph -- Technical requirements -- Understanding frame graphs -- Building a graph -- A data-driven approach -- Implementing the frame graph -- Implementing topological sort
Driving rendering with the frame graph -- Summary -- Further reading -- Chapter 5: Unlocking Async Compute -- Technical requirements -- 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 -- Summary
Further reading -- Part 2: GPU-Driven Rendering -- Chapter 6: GPU-Driven Rendering -- Technical requirements -- 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 -- Summary -- Further reading -- Chapter 7: Rendering Many Lights with Clustered Deferred Rendering -- Technical requirements -- A brief history of clustered lighting -- Differences between forward and deferred techniques -- Implementing a G-buffer
Includes bibliographical references and index.