The goal of these samples is to demonstrate how to use a particular Vulkan extension at the API level with as little abstraction as possible.
Extension: VK_EXT_conservative_rasterization
Uses conservative rasterization to change the way fragments are generated. Enables overestimation to generate fragments for every pixel touched instead of only pixels that are fully covered.
Extension: VK_KHR_dynamic_rendering
Demonstrates how to use Dynamic Rendering. Read the blog post here for discussion: (https://www.khronos.org/blog/streamlining-render-passes)
Extension: VK_KHR_push_descriptor
Push descriptors apply the push constants concept to descriptor sets. Instead of creating per-object descriptor sets, this example passes descriptors at command buffer creation time.
Extension: VK_EXT_debug_utils
Uses the debug utilities extension to name and group Vulkan objects (command buffers, images, etc.). This information makes debugging in tools like RenderDoc significantly easier.
Extension: VK_EXT_memory_budget
Uses the memory budget extension to monitor the allocated memory in the GPU and demonstrates how to use it.
Extension: VK_EXT_mesh_shader
Uses the mesh shader extension to demonstrate how to do basic culling utilizing both a mesh and a task shader.
Extensions: VK_KHR_ray_query, VK_KHR_acceleration_structure
Render a sponza scene using the ray query extension. Shows how to set up all data structures required for ray queries, including the bottom and top level acceleration structures for the geometry and a standard vertex/fragment shader pipeline. Shadows are cast dynamically by ray queries being cast by the fragment shader.
Extensions: VK_KHR_ray_tracing_pipeline, VK_KHR_acceleration_structure
Render a basic scene using the official cross-vendor ray tracing extension. Shows how to setup all data structures required for ray tracing, including the bottom and top level acceleration structures for the geometry, the shader binding table and the ray tracing pipelines with shader groups for ray generation, ray hits, and ray misses. After dispatching the rays, the final result is copied to the swapchain image.
Extensions: VK_KHR_ray_tracing_pipeline, VK_KHR_acceleration_structure
Render Sponza with Ambient Occlusion. Place a vase in center. Generate a particle fire that demonstrates the TLAS (Top Level Acceleration Structure) animation for the same underlying geometry. Procedurally generate a transparent quad and deform the geometry of the quad in the BLAS (Bottom Level Acceleration Structure) to demonstrate how to animate with deforming geometry. Shows how to rebuild the acceleration structure and when to set it to fast rebuild vs fast traversal.
Extensions: VK_EXT_mesh_shader
Renders a triangle with the most simple of all possible mesh shader pipeline examples. There is no vertex shader, there is only a mesh and fragment shader. The mesh shader creates the vertices for the triangle. The mesh shading pipeline includes the task and mesh shaders before going into the fragment shader. This replaces the vertex / geometry shader standard pipeline.
A transcoded version of the Extensions sample Mesh shading that illustrates the usage of the C++ bindings of vulkan provided by vulkan.hpp.
Extensions: VK_KHR_external_memory, VK_KHR_external_semaphore
Render a procedural image using OpenGL and incorporate that rendered content into a Vulkan scene. Demonstrates using the same backing memory for a texture in both OpenGL and Vulkan and how to synchronize the APIs using shared semaphores and barriers.
Extensions: VK_KHR_external_memory, VK_KHR_external_semaphore
This sample shows how to do Vulkan and OpenCL interoperability using cross vendor extensions in both apis. The sample uses OpenCL to update an image that is then displayed in Vulkan. This is done by sharing the memory for that image across the two apis. The sample also shares semaphores for doing cross api synchronization.
This sample demonstrates usage of OpenCL extensions available on Arm devices. Fill a procedural texture using OpenCL and display it using Vulkan. In this sample data sharing between APIs is achieved using Android Hardware Buffers.
Extensions: VK_KHR_timeline_semaphore
Demonstrates various use cases which are enabled with timeline semaphores. The sample implements "Game of Life" in an esoteric way, using out-of-order signal and wait, multiple waits on same semaphore in different queues, waiting and signalling semaphore on host.
Extensions: VK_KHR_buffer_device_address
Demonstrates how to use the buffer device address feature, which enables extreme flexibility in how buffer memory is accessed.
Extension VK_KHR_synchronization2
Demonstrates the use of the reworked synchronization api introduced with VK_KHR_synchronization2.
Based on the compute shading N-Body particle system, this sample uses the new extension to streamline the memory barriers used for the compute and graphics work submissions.
Extensions: VK_EXT_descriptor_indexing
Demonstrates how to use descriptor indexing to enable update-after-bind and non-dynamically uniform indexing of descriptors.
Extension: VK_KHR_fragment_shading_rate
Uses a special framebuffer attachment to control fragment shading rates for different framebuffer regions. This allows explicit control over the number of fragment shader invocations for each pixel covered by a fragment, which is e.g. useful for foveated rendering.
Extension: VK_KHR_fragment_shading_rate
Render a simple scene showing the basics of shading rate dynamic. This sample shows low and high frequency textures over several cubes. It creates a sample rate map based upon this frequency every frame. Then it uses that dynamic sample rate map as a base for the next frame.
Extensions: VK_KHR_ray_tracing_pipeline, VK_KHR_acceleration_structure, VK_EXT_descriptor_indexing, VK_EXT_scalar_block_layout
Render a simple scene showing the basics of ray tracing, including reflection and shadow rays. The sample creates some geometries and create a bottom acceleration structure for each, then make instances of those, using different materials and placing them at different locations.
Extensions: VK_KHR_ray_tracing_position_fetch
Shows how to use the ray tracing position fetch extension to directly access vertex positions for a hit triangle from the acceleration structure, instead of having to explicitly pass and unpack that information
Extensions: VK_KHR_portability_subset
Demonstrate how to include non-conformant portable Vulkan implementations by using the portability extension to include those implementations in the device query. An example of a non-conformant portable Vulkan implementation is MoltenVk: MoltenVk. Also demonstrate use of beta extension which allows for querying which features of the full Vulkan spec are not currently supported by the non-conformant Vulkan implementation.
Extension: VK_EXT_graphics_pipeline_library
Uses the graphics pipeline library extensions to improve run-time pipeline creation. Instead of creating the whole pipeline at once, this sample makes use of that extension to pre-build shared pipeline parts such as vertex input state and fragment output state. These building blocks are then used to create pipelines at runtime, improving build times compared to traditional pipeline creation.
Extension: VK_EXT_conditional_rendering
Demonstrate how to do conditional rendering, dynamically discarding rendering commands without having to update command buffers. This is done by sourcing conditional rendering blocks from a dedicated buffer that can be updated without having to touch command buffers.
Extension: VK_EXT_vertex_input_dynamic_state
Demonstrate how to use vertex input bindings and attribute descriptions dynamically, which can reduce the number of pipeline objects that are needed to be created.
Extension: VK_EXT_extended_dynamic_state2
Demonstrate how to use depth bias, primitive restart, rasterizer discard and patch control points dynamically, which can reduce the number of pipeline objects that are needed to be created.
Extension: VK_EXT_extended_dynamic_state2
Demonstrate how to use logical operations dynamically, which can reduce the number of pipeline objects that are needed to be created or allow to change the pipeline state dynamically (change type of the logical operation).
Extension: VK_EXT_extended_dynamic_state2
Demonstrate how to use patch control points dynamically, which can reduce the number of pipeline objects that are needed to be created.
Extension: VK_KHR_fragment_shader_barycentric
Demonstrate how to use fragment shader barycentric feature, which allows accessing barycentric coordinates for each processed fragment.
Extension: VK_EXT_descriptor_buffer
Demonstrate how to use the new extension to replace descriptor sets with resource descriptor buffers
Extension: VK_EXT_color_write_enable
Demonstrate how to create multiple color blend attachments and then toggle them dynamically.
Extension: VK_EXT_mesh_shader
Demonstrates how a mesh shader can be used to achieve the same results as with geometry shader, it loads model from a file and visualizes its normals.
Extension: VK_EXT_extended_dynamic_state3
Demonstrate how to use the blending related functions available in the VK_EXT_extended_dynamic_state3 extension.
Extensions: VK_EXT_line_rasterization, VK_EXT_extended_dynamic_state3
Demonstrate methods for dynamically customizing the appearance of the rendered lines.
Extension: VK_KHR_shader_non_semantic_info
Demonstrates how to use Printf statements in a shader to output per-invocation values. This can help find issues with shaders in combination with graphics debugging tools.
Extension: VK_EXT_extended_dynamic_state3
Rendering using primitive clipping and depth clipping configured by dynamic pipeline state.