3D Graphics Rendering Cookbook

By : Sergey Kosarevsky, Viktor Latypov

4 (2)

Buy this Book

3D Graphics Rendering Cookbook

4 (2)

By: Sergey Kosarevsky, Viktor Latypov

Buy this Book

Overview of this book

OpenGL is a popular cross-language, cross-platform application programming interface (API) used for rendering 2D and 3D graphics, while Vulkan is a low-overhead, cross-platform 3D graphics API that targets high-performance applications. 3D Graphics Rendering Cookbook helps you learn about modern graphics rendering algorithms and techniques using C++ programming along with OpenGL and Vulkan APIs. The book begins by setting up a development environment and takes you through the steps involved in building a 3D rendering engine with the help of basic, yet self-contained, recipes. Each recipe will enable you to incrementally add features to your codebase and show you how to integrate different 3D rendering techniques and algorithms into one large project. You'll also get to grips with core techniques such as physically based rendering, image-based rendering, and CPU/GPU geometry culling, to name a few. As you advance, you'll explore common techniques and solutions that will help you to work with large datasets for 2D and 3D rendering. Finally, you'll discover how to apply optimization techniques to build performant and feature-rich graphics applications. By the end of this 3D rendering book, you'll have gained an improved understanding of best practices used in modern graphics APIs and be able to create fast and versatile 3D rendering frameworks.

Preface

Who this book is for

What this book covers

To get the most out of this book

Download the color images

Chapter 1: Establishing a Build Environment

Technical requirements

OpenGL 4.6 with AZDO and Vulkan

Setting up our development environment on Windows

Setting up our development environment on Linux

Installing the Vulkan SDK for Windows and Linux

Managing dependencies

Getting the demo data

Creating utilities for CMake projects

Free Chapter

Chapter 2: Using Essential Libraries

Technical requirements

Using the GLFW library

Doing math with GLM

Loading images with STB

Rendering a basic UI with Dear ImGui

Integrating EasyProfiler

Integrating Optick

Using the Assimp library

Getting started with Etc2Comp

Multithreading with Taskflow

Introducing MeshOptimizer

Chapter 3: Getting Started with OpenGL and Vulkan

Technical requirements

Intercepting OpenGL API calls

Working with Direct State Access (DSA)

Loading and compiling shaders in OpenGL

Implementing programmable vertex pulling (PVP) in OpenGL

Working with cube map textures

Compiling Vulkan shaders at runtime

Initializing Vulkan instances and graphical devices

Initializing the Vulkan swap chain

Setting up Vulkan's debugging capabilities

Tracking and cleaning up Vulkan objects

Using Vulkan command buffers

Dealing with buffers in Vulkan

Using texture data in Vulkan

Using mesh geometry data in Vulkan

Using Vulkan descriptor sets

Initializing Vulkan shader modules

Initializing the Vulkan pipeline

Putting it all together into a Vulkan application

Chapter 4: Adding User Interaction and Productivity Tools

Technical requirements

Organizing Vulkan frame rendering code

Organizing mesh rendering in Vulkan

Implementing an immediate mode drawing canvas

Rendering a Dear ImGui user interface with Vulkan

Working with a 3D camera and basic user interaction

Adding a frames-per-second counter

Adding camera animations and motion

Integrating EasyProfiler and Optick into C++ applications

Using cube map textures in Vulkan

Rendering onscreen charts

Putting it all together into a Vulkan application

Chapter 5: Working with Geometry Data

Technical requirements

Organizing the storage of mesh data

Implementing a geometry conversion tool

Indirect rendering in Vulkan

Implementing an infinite grid GLSL shader

Rendering multiple meshes with OpenGL

Generating LODs using MeshOptimizer

Integrating tessellation into the OpenGL graphics pipeline

Chapter 6: Physically Based Rendering Using the glTF2 Shading Model

Technical requirements

Simplifying Vulkan initialization and frame composition

Initializing compute shaders in Vulkan

Using descriptor indexing and texture arrays in Vulkan

Using descriptor indexing in Vulkan to render an ImGui

Generating textures in Vulkan using compute shaders

Implementing computed meshes in Vulkan

Precomputing BRDF LUTs

Precomputing irradiance maps and diffuse convolution

Implementing the glTF2 shading model

Chapter 7: Graphics Rendering Pipeline

Technical requirements

How not to do a scene graph

Using data-oriented design for a scene graph

Loading and saving a scene graph

Implementing transformation trees

Implementing a material system

Importing materials from Assimp

Implementing a scene conversion tool

Managing Vulkan resources

Refactoring Vulkan initialization and the main loop

Working with rendering passes

Unifying descriptor set creation routines

Putting it all together into a Vulkan application

Chapter 8: Image-Based Techniques

Technical requirements

Implementing offscreen rendering in OpenGL

Implementing fullscreen quad rendering

Implementing shadow maps in OpenGL

Implementing SSAO in OpenGL

Implementing HDR rendering and tone mapping

Implementing HDR light adaptation

Writing postprocessing effects in Vulkan

Implementing SSAO in Vulkan

Implementing HDR rendering in Vulkan

Chapter 9: Working with Scene Graphs

Technical requirements

Deleting nodes and merging scene graphs

Finalizing the scene-converter tool

Implementing lightweight rendering queues in OpenGL

Working with shape lists in Vulkan

Adding Bullet physics to a graphics application

Chapter 10: Advanced Rendering Techniques and Optimizations

Technical requirements

Doing frustum culling on the CPU

Doing frustum culling on the GPU with compute shaders

Implementing order-independent transparency

Loading texture assets asynchronously

Implementing projective shadows for directional lights

Using GPU atomic counters in Vulkan

Putting it all together into an OpenGL demo

Why subscribe?

Other Books You May Enjoy

Packt is searching for authors like you

Share Your Thoughts

Customer Reviews

4 (2)

5 star

50%

4 star

3 star

50%

2 star

1 star

Rendering onscreen charts

In the Implementing an immediate mode drawing canvas recipe, we learned how to create immediate mode drawing facilities in Vulkan with basic drawing functionality. In this recipe, we will continue adding useful utilities built on top of a 2D line drawing.

Getting ready

We recommend revisiting the Implementing an immediate mode drawing canvas recipe to get a better grasp of how a simple Vulkan drawing canvas can be implemented.

How to do it...

What we need at this point essentially boils down to decomposing a 2D chart or graph into a set of lines. Let's go through the code to see how to do it:

We introduce the LinearGraph class to render a graph of floating-point values. It stores a collection of values and the maximum number of points that should be visible on the screen. A deque is used here for the sake of simplicity:
```
class LinearGraph {
  std::deque<float> graph_;
  const size_t maxPoints_;
public:
 ...
```

3D Graphics Rendering Cookbook

By : Sergey Kosarevsky, Viktor Latypov

3D Graphics Rendering Cookbook

By: Sergey Kosarevsky, Viktor Latypov

Overview of this book

Related Content you might be interested in

Current Title:

3D Graphics Rendering Cookbook

C++ Game Development By Example

OpenGL 4 Shading Language Cookbook

Vulkan Cookbook

Rendering onscreen charts

Getting ready

How to do it...