GPU Library

Description

Abstract rendering API for low-level, high-performance 3D desktop graphics.

This library provides a API to interact with a single desktop GPU, agnostic of whichever graphics API runs under-the-hood (e.g Vulkan/OpenGL/D3D12). When you use this library, the implementation will use one of these graphics APIs (which one is used depends on your platform and is configurable at compile-time) automatically with minimal overhead.

If you intend to do 3D graphics in Topaz, you should first consult the Rendering Library incase a high-level implementation of what you want to achieve already exists. It is unlikely that the Rendering Library contains all the rendering components you need for a modern game, especially if your game has some more bespoke graphical features or its own unique style. In which case, you should use this library to build your feature from the ground-up.

The GPU Library works as follows:

• Passes are comprised of:
  • Shaders - that is, a single shader program.
    • Zero or more Resources - buffers and images that can be accessed within the shader.
• You can build Graphs which are comprised of any number of existing passes. You can choose the execution order of these passes, aswell as any dependencies (if Pass X depends on Pass Y, then Pass Y will not begin execution until Pass X has completed all of its GPU work).
• Every frame, you can invoke a single graph.

An example graph could be comprised of:

• 1.) A frustum/occlusion culling pass using a compute shader.
• 2.) A heavy-duty 3D animation rendering pass to render all the animated models geometry in the scene into a gbuffer comprised of multiple image resources. Depends on (1)
• 3.) A text-rendering pass to render all the game's text into a single image resource.
• 4.) A post-processing pass to pixelate the colour attachment from (2) to provide retro PS1 aesthetics. Depends on (2)
• 5.) A deferred shading pass to add lighting detail to the scene, combining it with the text rendered earlier. This is outputted into the internal window image. Depends on (3, 4).
• 6.) Present the final window image. Depends on (5).

The timeline of GPU execution of this graph could look as follows:

• 1 and 3 both begin execution at the start of the frame.
• 3 completes.
• 1 completes. 2 now begins execution.
• 2 completes. 4 now begins execution.
• 4 completes. 5 now begins execution.
• 5 completes. 6 executes and the final image is displayed in the window.

Topics
	Graphs
	Documentation for render graphs - describes the execution of Passes.
	Hardware
	Documentation specialised for iterating over rendering hardware and selecting one to be used for rendering.
	Passes
	Documentation for render/compute passes - each a single node within Graphs.
	Resources
	Create/edit/destroy resources (images and buffers).
	Settings
	Global settings that affect all passes and graphs. The kind of stuff you'd expect to see in a game's video options.
	Shaders
	Create shaders to carry out programmable GPU work.

Typedefs
using	tz::gpu::index_t = std::uint32_t
	Represents a single index. Indices are always 32-bit unsigned integers.

Classes
struct	tz::gpu::draw_t
	Represents a single unindexed draw-call. More...
struct	tz::gpu::draw_indexed_t
	Represents a single indexed draw-call. More...

Typedef Documentation

index_t

using tz::gpu::index_t = std::uint32_t

Represents a single index. Indices are always 32-bit unsigned integers.