getting closer- there's now a shadow map

Author: rfdickerson

src/vulkan/Buffer.cpp

@@ -43,5 +43,15 @@ namespace reactor {
         }
     }
 
+void* Buffer::map() {
+    void* data;
+    vmaMapMemory(m_allocator.getAllocator(), m_allocation, &data);
+    return data;
+}
+
+void Buffer::unmap() {
+    vmaUnmapMemory(m_allocator.getAllocator(), m_allocation);
+}
+
 
 } // reactor

src/vulkan/Buffer.hpp

@@ -22,7 +22,8 @@ class Buffer {
     [[nodiscard]] VmaAllocation allocation() const { return m_allocation; }
     [[nodiscard]] vk::DeviceSize size() const { return m_size; }
 
-
+    void* map();
+    void unmap();
 
 private:
     Allocator& m_allocator;

src/vulkan/Pipeline.cpp

@@ -87,6 +87,12 @@ namespace reactor
         return *this;
     }
 
+    Pipeline::Builder& Pipeline::Builder::enableDepthBias(bool enable)
+    {
+        m_depthBiasEnable = enable;
+        return *this;
+    }
+
 
     std::unique_ptr<Pipeline> Pipeline::Builder::build() const
     {
@@ -120,7 +126,7 @@ namespace reactor
 
         // 5. Rasterizer
         vk::PipelineRasterizationStateCreateInfo rasterizer(
-            {}, VK_FALSE, VK_FALSE, vk::PolygonMode::eFill, m_cullMode, m_frontFace, VK_FALSE, 0.0f, 0.0f, 0.0f, 1.0f);
+            {}, VK_FALSE, VK_FALSE, vk::PolygonMode::eFill, m_cullMode, m_frontFace, m_depthBiasEnable? VK_TRUE : VK_FALSE, 0.0f, 0.0f, 0.0f, 1.0f);
 
         // 6. Multisampling
         vk::PipelineMultisampleStateCreateInfo multisampling({}, utils::mapSampleCountFlag(m_samples), VK_FALSE);
@@ -149,6 +155,12 @@ namespace reactor
         // 9. Dynamic State
         std::vector<vk::DynamicState> dynamicStates = {vk::DynamicState::eViewport,
                                                        vk::DynamicState::eScissor};
+        // conditionally add eDepthBias to the list of dynamic states
+        if (m_depthBiasEnable)
+        {
+            dynamicStates.push_back(vk::DynamicState::eDepthBias);
+        }
+
         vk::PipelineDynamicStateCreateInfo dynamicState({}, dynamicStates);
 
         // 10. Pipeline Layout

src/vulkan/Pipeline.hpp

@@ -27,6 +27,7 @@ namespace reactor
             Builder& setCullMode(vk::CullModeFlags cullMode);
             Builder& setFrontFace(vk::FrontFace frontFace);
             Builder& addPushContantRange(vk::ShaderStageFlags stages, uint32_t offset, uint32_t size);
+            Builder& enableDepthBias(bool enable=true);
 
             [[nodiscard]] std::unique_ptr<Pipeline> build() const;
 
@@ -41,6 +42,7 @@ namespace reactor
             uint32_t m_samples = 1;
             vk::CullModeFlags m_cullMode = vk::CullModeFlagBits::eBack;
             vk::FrontFace m_frontFace = vk::FrontFace::eCounterClockwise;
+            bool m_depthBiasEnable = false;
 
             std::vector<vk::VertexInputBindingDescription> m_bindings;
             std::vector<vk::VertexInputAttributeDescription> m_attributes;

src/vulkan/ShadowMapping.cpp

@@ -5,6 +5,12 @@
 namespace reactor
 {
 
+struct SceneUBO
+{
+    glm::mat4 view;
+    glm::mat4 projection;
+};
+
 ShadowMapping::ShadowMapping(VulkanRenderer& renderer, uint32_t resolution)
     : m_renderer(renderer), m_resolution(resolution), m_shadowMapView(VK_NULL_HANDLE),
       m_shadowMapSampler(VK_NULL_HANDLE)
@@ -76,7 +82,11 @@ void ShadowMapping::createResources()
     m_mvpBuffer.reserve(frameCount);
     for (size_t i = 0; i < frameCount; ++i)
     {
-        m_mvpBuffer.push_back(std::make_unique<Buffer>(m_renderer.allocator(), sizeof(glm::mat4), vk::BufferUsageFlagBits::eUniformBuffer, VMA_MEMORY_USAGE_AUTO, "MVP Buffer"));
+        m_mvpBuffer.push_back(std::make_unique<Buffer>(m_renderer.allocator(),
+                                                       sizeof(SceneUBO),
+                                                       vk::BufferUsageFlagBits::eUniformBuffer,
+                                                       VMA_MEMORY_USAGE_CPU_TO_GPU,
+                                                       "MVP Buffer"));
     }
 }
 
@@ -99,8 +109,10 @@ void ShadowMapping::createPipeline()
         // No fragment shader, we only want depth output
         .setVertexInputFromVertex()
         .setDepthAttachment(vk::Format::eD32Sfloat, true) // depth test and write enabled
+        .enableDepthBias()
         .setDescriptorSetLayouts(setLayouts)
-        .setMultisample(4)
+        .setMultisample(1)
+        .setCullMode(vk::CullModeFlagBits::eFront)
         .setFrontFace(vk::FrontFace::eClockwise) // Match main geometry pipeline
         .addPushContantRange(vk::ShaderStageFlagBits::eVertex, 0, sizeof(glm::mat4));
 
@@ -115,7 +127,7 @@ void ShadowMapping::createDescriptors()
 
     // Descriptor set bindings: UBO for light's MVP
     std::vector<vk::DescriptorSetLayoutBinding> bindings = {
-        { 0, vk::DescriptorType::eUniformBuffer, 1, vk::ShaderStageFlagBits::eVertex }
+        {0, vk::DescriptorType::eUniformBuffer, 1, vk::ShaderStageFlagBits::eVertex}
         // Add more if you want—for example for a sampler or shadow map
     };
 
@@ -128,7 +140,7 @@ void ShadowMapping::createDescriptors()
         vk::DescriptorBufferInfo uboInfo{};
         uboInfo.buffer = m_mvpBuffer[i]->getHandle();
         uboInfo.offset = 0;
-        uboInfo.range = sizeof(glm::mat4);
+        uboInfo.range = sizeof(SceneUBO);
 
         vk::WriteDescriptorSet writes{};
         writes.dstSet = m_descriptors->get(i);
@@ -140,7 +152,76 @@ void ShadowMapping::createDescriptors()
 
         m_descriptors->updateSet({writes});
     }
+}
+
+void ShadowMapping::recordShadowPass(vk::CommandBuffer cmd,
+                                     size_t frameIndex,
+                                     const std::function<void(vk::CommandBuffer)>& drawCallback)
+{
+    vk::ClearValue clearDepth;
+    clearDepth.depthStencil = vk::ClearDepthStencilValue{1.0f, 0};
+
+    vk::RenderingAttachmentInfo depthAttachment{};
+    depthAttachment.imageView = m_shadowMapView;
+    depthAttachment.imageLayout = vk::ImageLayout::eDepthStencilAttachmentOptimal;
+    depthAttachment.loadOp = vk::AttachmentLoadOp::eClear;
+    depthAttachment.storeOp = vk::AttachmentStoreOp::eStore;
+    depthAttachment.clearValue = clearDepth;
+
+    vk::RenderingInfo renderingInfo{};
+    renderingInfo.renderArea = vk::Rect2D({0, 0}, {m_resolution, m_resolution});
+    renderingInfo.layerCount = 1;
+    renderingInfo.pDepthAttachment = &depthAttachment;
+
+    cmd.setDepthBias(depthBiasConstant, 0.0f, depthBiasSlope);
+
+    cmd.beginRendering(&renderingInfo);
+
+    // set viewport/scissor
+    vk::Viewport viewport = {0.0f, 0.0f, (float)m_resolution, (float)m_resolution, 0.0f, 1.0f};
+    vk::Rect2D scissor = {vk::Offset2D{0, 0}, vk::Extent2D{m_resolution, m_resolution}};
+    cmd.setViewport(0, viewport);
+    cmd.setScissor(0, scissor);
+
+    cmd.bindPipeline(vk::PipelineBindPoint::eGraphics, m_depthPassPipeline->get());
+
+    auto descriptor = m_descriptors->get(frameIndex);
+
+    // bind descriptor set (with light MVP)
+    cmd.bindDescriptorSets(
+        vk::PipelineBindPoint::eGraphics, m_depthPassPipeline->getLayout(), 0, 1, &descriptor, 0, nullptr);
 
+    // draw the shadow casters
+    drawCallback(cmd);
+
+    cmd.endRendering();
+}
+
+vk::ImageView ShadowMapping::shadowMapView() const
+{
+    return m_shadowMapView;
+}
+
+vk::Sampler ShadowMapping::shadowMapSampler() const
+{
+    return m_shadowMapSampler;
+}
+
+vk::DescriptorSet ShadowMapping::shadowMapDescriptorSet(size_t frameIndex) const
+{
+    return m_descriptors->get(frameIndex);
+}
+
+void ShadowMapping::setLightMatrix(const glm::mat4& lightSpaceMatrix, size_t frameIndex)
+{
+    SceneUBO ubo;
+    ubo.view = glm::mat4(1.0f);
+    ubo.projection = lightSpaceMatrix;
+
+    // map buffer, copy matrix
+    void* data = m_mvpBuffer[frameIndex]->map();
+    memcpy(data, &ubo, sizeof(SceneUBO));
+    m_mvpBuffer[frameIndex]->unmap();
 }
 
 } // namespace reactor

src/vulkan/ShadowMapping.hpp

@@ -18,7 +18,7 @@ class ShadowMapping
     explicit ShadowMapping(VulkanRenderer& renderer, uint32_t resolution = 2048);
     ~ShadowMapping();
 
-    void recordShadowPass(vk::CommandBuffer cmd, size_t frameIndex);
+    void recordShadowPass(vk::CommandBuffer cmd, size_t frameIndex, const std::function<void(vk::CommandBuffer)>& drawCallback);
 
     vk::ImageView shadowMapView() const;
     vk::Sampler shadowMapSampler() const;
@@ -36,6 +36,9 @@ class ShadowMapping
     void createPipeline();
     void createDescriptors();
 
+    const float depthBiasConstant = 1.25f;
+    const float depthBiasSlope = 1.75f;
+
     VulkanRenderer& m_renderer;
     uint32_t m_resolution;
 

src/vulkan/VulkanRenderer.cpp

@@ -359,6 +359,47 @@ void VulkanRenderer::drawFrame()
     drawGeometry(cmd);
     endDynamicRendering(cmd);
 
+    // Shadow pass
+    // --- Prepare for Shadow Pass ---
+    // 1. Create the orthographic projection matrix for the directional light.
+    // This defines a "box" in space that will cast shadows.
+    // You can adjust these values to fit your scene's size.
+    const float orthoSize = 10.0f;
+    const float nearPlane = 0.1f;
+    const float farPlane = 100.0f;
+    glm::mat4 lightProjection = glm::ortho(-orthoSize, orthoSize, -orthoSize, orthoSize, nearPlane, farPlane);
+
+    // 2. Create the view matrix from the light's perspective.
+    // This uses the light's direction, which is already updated in your m_light UBO.
+    // We place the light "camera" at a position based on its direction and make it look at the scene origin.
+    glm::vec3 lightPosition = glm::vec3(15.0f, 15.0f, 5.0f);
+    glm::mat4 lightView = glm::lookAt(
+        lightPosition,             // Position of the light in world space
+        glm::vec3(0.0f, 0.0f, 0.0f), // The point the light is looking at (scene origin)
+        glm::vec3(0.0f, 1.0f, 0.0f)  // Up vector
+    );
+
+    // 3. Combine the matrices to create the final light-space matrix.
+    // Note: Vulkan's clip space has an inverted Y-axis. We need to add a correction.
+    glm::mat4 clipCorrection = {
+        1.0f, 0.0f, 0.0f, 0.0f,
+        0.0f,-1.0f, 0.0f, 0.0f,
+        0.0f, 0.0f, 0.5f, 0.5f,
+        0.0f, 0.0f, 0.0f, 1.0f
+    };
+
+    glm::mat4 lightSpaceMatrix = clipCorrection * lightProjection * lightView;
+
+    // 4. Set the matrix for the shadow mapping pass.
+    m_shadowMapping->setLightMatrix(lightSpaceMatrix, frameIdx);
+
+    //m_shadowMapping->setLightMatrix(lightMVP, frameIdx);
+    auto drawFunc = [this](vk::CommandBuffer cmd) {
+        this->drawGeometry(cmd);
+    };
+
+    m_shadowMapping->recordShadowPass(cmd, frameIdx, drawFunc);
+
     // --- 1. Geometry Pass ---
     // Transition the MSAA image so we can render the main scene into it.
     // Its layout was likely UNDEFINED (on first use) or TRANSFER_SRC (from previous frame's resolve).