Temporary notes

The current version of the project needs to use CMake 4.1.0. This will be fixed in the future when CMake support for import of std module is no longer an experimental feature. See the CMakeLists.txt file for more details.

Vulkan GPGPU Compute Framework

Vulkan Compute Vizualization (vkCompViz) is a Vulkan library for GPU-accelerated data processing. The main purpose are computer-graphics-related GPU-accelerated operations on images.

The library can load input images, run a sequence of compute shaders, display the result in window, and store the result. Uniform parameters can be interactively changed in console with the result updated in the display window. The application can run in headless mode or with window. The library can also generate memory and time performance reports.

How to run

Simple compilation of examples: git clone --recursive https://github.com/ichlubna/vkCompViz.git cd vkCompViz mkdir build cmake .. -G "Ninja" ninja cd ./examples/exampleName/ ./exampleName More detailed instructions can be found here.

A path to Artistic Style (astyle) program can be defined with ccmake and the project can be formatted using: ninja format

Usage

See the existing examples for reference. Especially, Simple Blending, Parallel Reduction, and 3D Viewer are simple and contain explanatory comments. It is recommended to use them as templates for new examples. The API of the library is described in the documentation.

A simple basic code using this library, with no window output, that loads an image, processes it with a compute shader and one workgroup, and stores the result is:

import vkCompViz;
void main()
{
    vkCompViz::App::Parameters params;
    params.shaders.compute.push_back("shader.slang");
    params.shaders.workGroupCounts.push_back({1, 1, 1});
    params.textures.input.push_back("input.jpg");
    params.textures.output.push_back({.sameResolutionAsInputID = 0, .sameFormatAsInputID = 0});
    vkCompViz::App app;
    app.run(params);
    app.saveResultImage("output.jpg");
}

The bindings in shaders are:

| Binding | Resource | |---|---| | 0 | Uniform buffer (One common buffer for all shaders) | | 1 | Sampler for output textures | | 2 | Writeable output textures | | 3 | Sampler for input textures | | 4 | Readable input textures | | 5 | Shader storage buffer |

The first output texture is considered the final one and is displayed in the window. Its content is also stored to file.

Keys for window application:

| Key | Action | |---|---| | Esc | Exit program | | Space | Edit uniforms in runtime | | F1 | Store the the result | | F2 | Store benchmark report | | F3 | Print uniforms |

Possible future features

• RTX pipeline that can render to texture.
• Add a class reflecting the input buffers and textures which can be asynchronously updated in runtime. GPU would update its data when changes happen. This can allow for data changes during runtime (e.g. video player).