Hybrid Rasterization and Ray Tracing¶

This advanced example shows hybrid rendering that leverages both rasterization (for primary visibility and alpha blending) and ray tracing (for shadows).

The scene contains opaque objects, alpha-blended spheres, and a ground plane.
Rasterization fills a G-buffer with world positions, normals, and colors.
An OIT (order-independent transparency) fragment linked list handles alpha blending.
Ray tracing then shoots shadow rays from G-buffer positions to determine lighting.

This architecture represents modern game rendering where rasterization handles base rendering and ray tracing adds realistic lighting and shadows.

Overview¶

What this demonstrates:

Combining rasterization and ray tracing, G-buffer generation, OIT for alpha blending, ray traced shadows, acceleration structure rebuilds, compute particle updates, multi-pass compositing.

Use cases:

Modern game engines, hybrid pipelines, ray traced shadows/reflections on rasterized geometry, performance-quality balance.

Requirements¶

Vulkan Version: 1.2+
Extensions: VK_KHR_ray_tracing_pipeline, VK_KHR_acceleration_structure
Features: rayTracingPipeline, accelerationStructure, bufferDeviceAddress

Why Hybrid?¶

Rasterization: Fast primary visibility Ray Tracing: Accurate shadows/reflections Combine: Performance + Quality

The scene is composed of:

An Opaque Ground Plane
Multiple Alpha Blended Spheres
Multiple Opaque Spheres

Algorithm Overview¶

Compute Animation: The sphere's positions and velocities are updated using a compute shader.
GBuffer Z-Fill: A depth-only pre-pass is performed for opaque meshes.
GBuffer OIT Fill: For alpha-blended meshes, we use a fragment linked list to store color and depth information.
GBuffer Opaque Fill: Record WorldPosition, WorldNormals, and Color for the opaque meshes.
Acceleration Structure Rebuild: AccelerationStructures are updated or rebuilt based on the new sphere positions.
Ray Tracing Shadows: For each world position recorded in the GBuffer, we compute a ray to the light source. Any intersection means the point is in shadow.
Compositing:
- Final color for opaque areas is retrieved from the GBuffer.
- Alpha fragments are sorted by depth and blended against the opaque background.
- Shadow information from the Ray Tracing pass is applied to modify the final color.

BLAS Generation¶

Each distinct mesh (opaque spheres, alpha spheres, ground plane) gets its own Bottom-Level Acceleration Structure (BLAS).

Sphere BLAS (opaque and alpha):

The same sphere mesh is shared across all sphere instances.

One BLAS entry per sphere is created:

each referencing the shared vertex buffer but with a per-sphere transform read from blasTransformBuffer (written each frame by the compute shader).

PreferFastBuild is chosen over PreferFastTrace because the spheres move every frame.

        m_as.opaqueSpheresBlas = m_device.createAccelerationStructure(AccelerationStructureOptions{
                .label = "OpaqueSphereBLAS",
                .type = AccelerationStructureType::BottomLevel,
                .flags = AccelerationStructureFlagBits::PreferFastBuild,
                .geometryTypesAndCount = std::vector<AccelerationStructureOptions::GeometryTypeAndCount>(
                        OpaqueSpheresCount,
                        {
                                .geometry = AccelerationStructureGeometryTrianglesData{
                                        .vertexFormat = Format::R32G32B32_SFLOAT,
                                        .vertexStride = sizeof(Vertex),
                                        .maxVertex = static_cast<uint32_t>(m_sphereMesh.vertexCount - 1),
                                },
                                .maxPrimitiveCount = static_cast<uint32_t>(m_sphereMesh.vertexCount / 3),
                        }),
        });
        m_as.alphaSpheresBlas = m_device.createAccelerationStructure(AccelerationStructureOptions{
                .label = "AlphaSphereBLAS",
                .type = AccelerationStructureType::BottomLevel,
                .flags = AccelerationStructureFlagBits::PreferFastBuild,
                .geometryTypesAndCount = std::vector<AccelerationStructureOptions::GeometryTypeAndCount>(
                        AlphaSpheresCount,
                        {
                                .geometry = AccelerationStructureGeometryTrianglesData{
                                        .vertexFormat = Format::R32G32B32_SFLOAT,
                                        .vertexStride = sizeof(Vertex),
                                        .maxVertex = static_cast<uint32_t>(m_sphereMesh.vertexCount - 1),
                                },
                                .maxPrimitiveCount = static_cast<uint32_t>(m_sphereMesh.vertexCount / 3),
                        }),
        });

        auto buildSphereTriangleGeometries = [this](Handle<AccelerationStructure_t> dstStructure,
                                                    size_t count, size_t transformOffset = 0) {
            std::vector<AccelerationStructureGeometry> geometries;
            geometries.reserve(count);

            for (size_t i = 0; i < count; ++i) {
                geometries.emplace_back(
                        AccelerationStructureGeometryTrianglesData{
                                .vertexFormat = Format::R32G32B32_SFLOAT,
                                .vertexData = m_sphereMesh.vertexBuffer,
                                .vertexStride = sizeof(Vertex),
                                .maxVertex = static_cast<uint32_t>(m_sphereMesh.vertexCount - 1),
                                .transformData = m_particles.blasTransformBuffer,
                                .transformDataOffset = transformOffset + i * sizeof(VkTransformMatrixKHR),
                        });
            }
            return BuildAccelerationStructureOptions::BuildOptions{
                .geometries = std::move(geometries),
                .destinationStructure = dstStructure,
                .buildRangeInfos = std::vector<BuildAccelerationStructureOptions::BuildRangeInfo>(
                        count,
                        {
                                .primitiveCount = static_cast<uint32_t>(m_sphereMesh.vertexCount / 3),
                        }),
            };
        };

        m_as.opaqueSpheresASBuildOptions = {
            .buildGeometryInfos = { buildSphereTriangleGeometries(m_as.opaqueSpheresBlas, OpaqueSpheresCount, 0) },
        };

        m_as.alphaSpheresASBuildOptions = {
            .buildGeometryInfos = { buildSphereTriangleGeometries(m_as.alphaSpheresBlas, AlphaSpheresCount, OpaqueSpheresCount * sizeof(VkTransformMatrixKHR)) },
        };