Added support for conservative rasterization for upscaler motion vectors.

Author: chrismile

src/Main.cpp

@@ -170,6 +170,7 @@ int main(int argc, char *argv[]) {
     optionalDeviceExtensions.push_back(VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME);
     optionalDeviceExtensions.push_back(VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME);
     optionalDeviceExtensions.push_back(VK_KHR_8BIT_STORAGE_EXTENSION_NAME);
+    optionalDeviceExtensions.push_back(VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME);
     //optionalDeviceExtensions.push_back(VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME);
     optionalDeviceExtensions.push_back(VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME);
     optionalDeviceExtensions.push_back(VK_NV_MESH_SHADER_EXTENSION_NAME);

src/Renderers/Deferred/DeferredRenderer.cpp

@@ -115,6 +115,7 @@ class DeferredRenderer : public LineRenderer {
 
     /// Called when the used supersampling mode has changed.
     void onSupersamplingModeChanged();
+    void onConservativeRasterOptionChanged();
 
     // Renders the object to the scene framebuffer.
     void render() override;
@@ -204,7 +205,10 @@ class DeferredRenderer : public LineRenderer {
         // DeferredRenderingMode::TASK_MESH_SHADER
         VISIBILITY_BUFFER_TASK_MESH_SHADER_PASS,
         // Resolve/further passes.
-        DEFERRED_RESOLVE_PASS, MOTION_VECTOR_RESOLVE_PASS, HULL_RASTER_PASS, NODE_AABB_PASS
+        DEFERRED_RESOLVE_PASS, MOTION_VECTOR_RESOLVE_PASS, HULL_RASTER_PASS, NODE_AABB_PASS,
+
+        // Conservative rasterization + DeferredRenderingMode::DRAW_INDEXED
+        VISIBILITY_BUFFER_DRAW_INDEXED_PASS_CONSERVATIVE,
     };
     int framebufferModeIndex = 0;
     FramebufferMode framebufferMode = FramebufferMode::VISIBILITY_BUFFER_DRAW_INDEXED_PASS;
@@ -331,10 +335,30 @@ class DeferredRenderer : public LineRenderer {
     uint32_t finalWidth = 0, finalHeight = 0;
 
     // Multiple frames can be accumulated with the temporal upscalers to achieve a multisampling effect.
+    int numSamplesBase = 8;
     uint32_t jitteredSamplesOffset = 0;
     uint32_t accumulatedFramesCounter = 0;
     std::vector<glm::vec2> jitteredSamples;
 
+    // For conservative rasterization of the motion vectors (currently only supported for DeferredRenderingMode::DRAW_INDEXED).
+    bool useConservativeRasterizationMV = false;
+    bool useConservativeRasterizationDepth = false;
+    bool useConservativeRasterizationPass = false;
+    sgl::vk::ImageViewPtr primitiveIndexConservativeImage;
+    sgl::vk::TexturePtr primitiveIndexConservativeTexture;
+    sgl::vk::ImageViewPtr depthConservativeRenderTargetImage;
+    sgl::vk::TexturePtr depthBufferConservativeTexture;
+    // DeferredRenderingMode::DRAW_INDEXED
+    std::shared_ptr<VisibilityBufferDrawIndexedPass> visibilityBufferDrawIndexedPassConservative;
+    // DeferredRenderingMode::DRAW_INDIRECT
+    std::shared_ptr<VisibilityBufferDrawIndexedIndirectPass> visibilityBufferDrawIndexedIndirectPassesConservative[2];
+    // DeferredRenderingMode::TASK_MESH_SHADER
+    std::shared_ptr<MeshletTaskMeshPass> meshletTaskMeshPassesConservative[2];
+    // DeferredRenderingMode::BVH_DRAW_INDIRECT
+    std::shared_ptr<VisibilityBufferBVHDrawIndexedIndirectPass> visibilityBufferBVHDrawIndexedIndirectPassesConservative[2];
+    // DeferredRenderingMode::BVH_MESH_SHADER
+    std::shared_ptr<MeshletMeshBVHPass> meshletMeshBVHPassesConservative[2];
+
     // Data for performance measurements.
     int frameCounter = 0;
     std::string currentStateName;

src/Renderers/Deferred/DeferredRenderer.hpp

@@ -41,6 +41,10 @@ void VisibilityBufferDrawIndexedPass::setDrawIndexedGeometryMode(DrawIndexedGeom
     }
 }
 
+void VisibilityBufferDrawIndexedPass::setUseConservativeRasterization() {
+    useConservativeRasterization = true;
+}
+
 void VisibilityBufferDrawIndexedPass::loadShader() {
     sgl::vk::ShaderManager->invalidateShaderCache();
     std::map<std::string, std::string> preprocessorDefines;
@@ -81,6 +85,10 @@ void VisibilityBufferDrawIndexedPass::setGraphicsPipelineInfo(sgl::vk::GraphicsP
     pipelineInfo.setDepthTestEnabled(true);
     pipelineInfo.setDepthWriteEnabled(true);
     pipelineInfo.setBlendMode(sgl::vk::BlendMode::OVERWRITE);
+
+    if (useConservativeRasterization) {
+        pipelineInfo.setUseConservativeRasterization();
+    }
 }
 
 void VisibilityBufferDrawIndexedPass::createRasterData(

src/Renderers/Deferred/VisibilityBufferDrawIndexedPass.cpp

@@ -41,6 +41,7 @@ class VisibilityBufferDrawIndexedPass : public LineRasterPass {
 public:
     explicit VisibilityBufferDrawIndexedPass(LineRenderer* lineRenderer);
     void setDrawIndexedGeometryMode(DrawIndexedGeometryMode geometryModeNew);
+    void setUseConservativeRasterization();
 
 protected:
     void loadShader() override;
@@ -49,6 +50,7 @@ class VisibilityBufferDrawIndexedPass : public LineRasterPass {
 
 private:
     DrawIndexedGeometryMode geometryMode = DrawIndexedGeometryMode::TRIANGLES;
+    bool useConservativeRasterization = false;
 };
 
 #endif //LINEVIS_VISIBILITYBUFFERDRAWINDEXEDPASS_HPP

src/Renderers/Deferred/VisibilityBufferDrawIndexedPass.hpp

@@ -73,11 +73,11 @@ void evaluateHaltonSequence(float* sequencePointer, int numSamples, int base) {
 }
 
 void computeJitteredSamples(
-        std::vector<glm::vec2>& jitteredSamples,
+        std::vector<glm::vec2>& jitteredSamples, int numSamplesBase,
         uint32_t renderWidth, uint32_t renderHeight,
         uint32_t displayWidth, uint32_t displayHeight) {
     const float scaleFraction = float(displayWidth * displayHeight) / float(renderWidth * renderHeight);
-    const int numSamples = std::max(8 * int(std::ceil(scaleFraction * scaleFraction)), 1);
+    const int numSamples = std::max(numSamplesBase * int(std::ceil(scaleFraction * scaleFraction)), 1);
     jitteredSamples.resize(numSamples);
     auto* samplesPtr = &jitteredSamples.front().x;
     constexpr int baseX = 2, baseY = 3;

src/Renderers/Upscaler/Upscaler.cpp

@@ -94,7 +94,7 @@ class Upscaler {
 
 Upscaler* createNewUpscaler(UpscalerType upscalerType);
 void computeJitteredSamples(
-        std::vector<glm::vec2>& jitteredSamples,
+        std::vector<glm::vec2>& jitteredSamples, int numSamplesBase,
         uint32_t renderWidth, uint32_t renderHeight,
         uint32_t displayWidth, uint32_t displayHeight);
 void adaptProjectionMatrixJitterSample(