Merge pull request #9 from rfdickerson/8-add-tonemapping

Add Tone Mapping

Author: rfdickerson

CMakeLists.txt

@@ -38,7 +38,14 @@ add_executable(Reactor src/main.cpp
         src/Imgui.hpp
         src/VulkanUtils.hpp
         src/Image.cpp
-        src/Image.hpp)
+        src/Image.hpp
+        src/Sampler.cpp
+        src/Sampler.hpp
+        src/ImageStateTracker.cpp
+        src/ImageStateTracker.h
+        src/Uniforms.hpp
+        src/UniformManager.cpp
+        src/UniformManager.hpp)
 
 target_link_libraries(Reactor PRIVATE Vulkan::Vulkan Vulkan::Headers glfw fmt::fmt spdlog::spdlog GPUOpen::VulkanMemoryAllocator glm::glm)
 target_link_libraries(Reactor PRIVATE imgui::imgui)

build-shaders.bat

@@ -0,0 +1,5 @@
+glslc --target-env=vulkan1.3 -o shaders/triangle.vert.spv shaders/triangle.vert
+glslc --target-env=vulkan1.3 -o shaders/triangle.frag.spv shaders/triangle.frag
+
+glslc --target-env=vulkan1.3 -o shaders/composite.vert.spv shaders/composite.vert
+glslc --target-env=vulkan1.3 -o shaders/composite.frag.spv shaders/composite.frag

shaders/composite.frag

@@ -0,0 +1,47 @@
+#version 450
+
+layout(location = 0) in vec2 fragUV;
+layout(location = 0) out vec4 outColor;
+
+layout(binding = 0) uniform sampler2D uInputImage;
+
+layout(set = 0, binding = 1) uniform CompositeParams {
+    float uExposure;    // Default: 1.0
+    float uContrast;    // Default: 1.0
+    float uSaturation;  // Default: 1.0
+    float uVignetteIntensity;   // Default: 0.5
+    float uVignetteFalloff;     // Default 0.5
+};
+
+// ACES Filmic Tone Mapping Curve
+vec3 tonemapACES(vec3 x) {
+    const float a = 2.51;
+    const float b = 0.03;
+    const float c = 2.43;
+    const float d = 0.59;
+    const float e = 0.14;
+    return clamp((x * (a * x + b)) / (x * (c * x + d) + e), 0.0, 1.0);
+}
+
+void main() {
+    // Sample the HDR input image
+    vec3 hdrColor = texture(uInputImage, fragUV).rgb;
+
+    // Apply exposure
+    vec3 exposedColor = hdrColor * uExposure;
+
+    // Tonemap (Reinhard)
+    vec3 ldrColor = tonemapACES(exposedColor);
+
+    // Apply Color Grading
+    vec3 finalColor = ldrColor;
+
+    // Contrast
+    finalColor = pow(finalColor, vec3(uContrast));
+
+    // Saturation
+    vec3 grayscale = vec3(dot(finalColor, vec3(0.299, 0.587, 0.114)));
+    finalColor = mix(grayscale, finalColor, uSaturation);
+
+    outColor = vec4(finalColor, 1.0);
+}

shaders/composite.frag.spv

@@ -0,0 +1,20 @@
+#version 450
+
+layout(location = 0) out vec2 fragUV;
+
+void main() {
+    // Fullscreen triangle using gl_VertexIndex (0, 1, 2)
+    const vec2 pos[3] = vec2[](
+        vec2(-1.0, -1.0), // bottom-left
+        vec2( 3.0, -1.0), // bottom-right far (for covering entire screen)
+        vec2(-1.0,  3.0)  // top-left far (for covering entire screen)
+    );
+    const vec2 uv[3] = vec2[](
+        vec2(0.0, 0.0),
+        vec2(2.0, 0.0),
+        vec2(0.0, 2.0)
+    );
+
+    fragUV = uv[gl_VertexIndex];
+    gl_Position = vec4(pos[gl_VertexIndex], 0.0, 1.0);
+}

shaders/composite.vert

@@ -57,4 +57,8 @@ namespace reactor {
 
         m_device.updateDescriptorSets(1, &write, 0, nullptr);
     }
+
+void DescriptorSet::updateSet(const std::vector<vk::WriteDescriptorSet> &writes) {
+        m_device.updateDescriptorSets(static_cast<uint32_t>(writes.size()), writes.data(), 0, nullptr);
+    }
 } // reactor

shaders/composite.vert.spv

@@ -24,7 +24,7 @@ namespace reactor {
     [[nodiscard]] vk::DescriptorSet getCurrentSet(size_t currentFrame) const { return m_sets[currentFrame]; }
 
     // helper for updating sets
-    void updateSet(size_t frame, const std::vector<vk::WriteDescriptorSet>& writes);
+    void updateSet(const std::vector<vk::WriteDescriptorSet>& writes);
 
     void updateUniformBuffer(size_t frame, const Buffer& buffer);
 

src/DescriptorSet.cpp

@@ -0,0 +1,68 @@
+//
+// Created by rfdic on 6/29/2025.
+//
+
+#include "ImageStateTracker.h"
+#include <stdexcept>
+
+namespace reactor {
+
+void ImageStateTracker::recordState(vk::Image image, vk::ImageLayout initialState) {
+    m_imageStates[image] = initialState;
+}
+
+vk::ImageLayout ImageStateTracker::getCurrentLayout(vk::Image image) const {
+    auto it = m_imageStates.find(image);
+    if (it == m_imageStates.end()) {
+        // Or you could default to eUndefined and record it, depending on desired strictness
+        throw std::runtime_error("Attempted to get layout of an untracked image.");
+    }
+    return it->second;
+}
+
+void ImageStateTracker::transition(
+    vk::CommandBuffer cmd,
+    vk::Image image,
+    vk::ImageLayout newLayout,
+    vk::PipelineStageFlags srcStage,
+    vk::PipelineStageFlags dstStage,
+    vk::AccessFlags srcAccess,
+    vk::AccessFlags dstAccess,
+    vk::ImageAspectFlags aspectFlags
+) {
+    const vk::ImageLayout oldLayout = getCurrentLayout(image);
+
+    // If the layout is already correct, we don't need a barrier.
+    if (oldLayout == newLayout) {
+        return;
+    }
+
+    vk::ImageMemoryBarrier barrier{};
+    barrier.oldLayout = oldLayout;
+    barrier.newLayout = newLayout;
+    barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+    barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+    barrier.image = image;
+    barrier.subresourceRange.aspectMask = aspectFlags;
+    barrier.subresourceRange.baseMipLevel = 0;
+    barrier.subresourceRange.levelCount = 1;
+    barrier.subresourceRange.baseArrayLayer = 0;
+    barrier.subresourceRange.layerCount = 1;
+    barrier.srcAccessMask = srcAccess;
+    barrier.dstAccessMask = dstAccess;
+
+    cmd.pipelineBarrier(
+        srcStage,       // Stage where operations occurred before the barrier
+        dstStage,       // Stage where operations will wait for the barrier
+        {},             // Dependency flags
+        nullptr,        // Memory barriers
+        nullptr,        // Buffer memory barriers
+        barrier         // Image memory barriers
+    );
+
+    // IMPORTANT: Update the internal state to the new layout.
+    m_imageStates[image] = newLayout;
+}
+
+
+} // reactor

src/DescriptorSet.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <vulkan/vulkan.hpp>
+#include <map>
+
+namespace reactor {
+
+class ImageStateTracker {
+public:
+    ImageStateTracker() = default;
+
+    void recordState(vk::Image image, vk::ImageLayout initialState = vk::ImageLayout::eUndefined);
+
+    void transition(
+        vk::CommandBuffer cmd,
+        vk::Image image,
+        vk::ImageLayout newLayout,
+        vk::PipelineStageFlags srcStage,
+        vk::PipelineStageFlags dstStage,
+        vk::AccessFlags srcAccess,
+        vk::AccessFlags dstAccess,
+        vk::ImageAspectFlags aspectFlags = vk::ImageAspectFlagBits::eColor);
+
+    vk::ImageLayout getCurrentLayout(vk::Image image) const;
+
+private:
+    std::map<vk::Image, vk::ImageLayout> m_imageStates;
+};
+
+} // namespace reactor
+