A shader is simply a small program that runs on the GPU to process graphics or compute data. Think of it as an application for GPU.

Use of shaders

They are used to transform or generate data in the graphics pipeline (e.g. position, color), or perform general-purpose computation and replaces fixed-function stages with flexible, user-written code.

In a graphic pipeline the following fixed-function stages can be replaced with shaders :

• Vertex Shader: runs once per vertex; computes transformed positions, normals, and outputs “vertex data”.
• Fragment/Pixel Shader: runs once per pixel (or sample); computes final color, depth, and other per-pixel outputs.
• Geometry/Tessellation/Hull/Domain Shaders: (Optional) generate or modify primitives (points, lines, triangles) on the fly.

A compute shader is a general-purpose GPU application; not tied to drawing, used for physics, special effects, image filtering, AI, etc.

Writing shaders

To write a shader you need the source code written using a shading language that is supported by both DirectX and Vulkan :

• HLSL
• Slang

Since the main goal of Vireo is to allow the creation of portable 3D application, the Slang shader language is the best solution (moreover Slang is highly derived from HLSL). By using Slang you only have one version of your shaders for both backends.

If you want to discover Slang with real examples, take a look at the Vireo Samples repository. All the shaders of the samples are written with Slang : vertex, fragment, guffers, lighting, order independent transparency, depth prepass, SMAA, FXAA, ...

Example of a nice wave effect compute shader written in Slang for Vireo :

Note that there is no Vulkan or DirectX specific declaration or instruction in this shader.

Compiling shaders

A shader need to be compiled to an intermediate binary format before loading them into a pipeline. The format depends on the graphic API :

• For vireo::Backend::DIRECTX : DirectX Intermediate Language (DXIL)
• For vireo::Backend::VULKAN : SPIR-V

Note

Once Shader Model 7 is released, DirectX 12 will accept shaders compiled to SPIR-V, suppressing the need for two versions of the binary files for Vireo.

To compile a Slang shader to both DXIL and SPIR-V intermediate formats the best tool is the Vulkan version of slangc shipped with the Vulkan SDK. Take a look at the cmake/shaders.cmake and CMakeLists.txt files of the Vireo Samples repository for an example of use with CMake. This CMake scripts will search for all files with the .slang extension and :

• Compile them as compute shader if the file name ends with .comp.slang (entry point main)
• Compile them as hull/tesselation control shader if the file name ends with .hull.slang (entry point main)
• Compile them as domain//tesselation evaluation shader if the file name ends with .domain.slang (entry point main)
• Compile them as geometry shader if the file name ends with .geom.slang (entry point main)
• Compile them as vertex shader if the file name ends with .vert.slang (entry point vertexMain)
• Compile them as fragment shader if the file name ends with .frag.slang (entry point fragmentMain)
• Does nothing if the file name ends with .inc.slang
• Compile them as vertex and fragment shader for all other files (entry points vertexMain and fragmentMain)

This binary formats are called "intermediate" because the drivers needs to translate them to the final binary format with hardware specific instruction sets:

• For AMD GPUs : Graphics Core Next (GCN) ISA (also called « AMDGPU ISA »).
• For NVidia GPUs : PTX (Parallel Thread Execution, intermediate) and SASS (Streaming ASSembler Shader, low level).
• For Intel GPUs : Gen ISA (also called « Intel GPU ISA »).

This process can take time and resources, which means that creating a pipeline is a time consuming task : never create pipelines on the fly during rendering, always create all your pipelines during the initialization phase of your application.

Creating shader modules

A shader module is a binary compiled version of a shader (like an executable for GPU) that you can load into a pipeline for future execution.

They are created with vireo::Vireo::createShaderModule :

For maximum portability of the application code the extension of the file is not specified. The ShaderModule class load the binary file corresponding to the graphic API specified for the vireo object :

• For vireo::Backend::DIRECTX it loads the .dxil files
• For vireo::Backend::VULKAN it loads the .spv files

Once loaded, a shader module can be use with one or more pipeline.

Using shader modules

Once loaded into shader modules the shaders are used when configuring pipelines :

Note

A pipeline is tied to the configured shader modules, which means that you need one pipeline for each set of shaders.

Binding resources with shader variables

To use a resource in a shader you need to :

• bind them to the pipeline using descriptor sets
• Reference them in your shader using the same binding and set/space numbers.

When using the Slang shader language you can use the HLSL register syntax to reference resource by binding numbers and set/space number.

For example, if you have a descriptor set configured described by this descriptor layout and structures:

During initialization create the descriptor set using this layout and attach the resources :

And during rendering update the data in VRAM then bind the resources before drawing :

You can reference the corresponding resources in the shader like that using the same SET_* (space*) and BINDING_* values :

The slangc tool will translate the register syntax to a SPIR-V compatible code for you.