Implement Reinhard and ACES tone mapping.

Author: Adnn

src/apps/ch11_voxel/ch11_voxel/FrameGraph.cpp

@@ -223,6 +223,10 @@ void FrameGraph::renderFinalScene(const scenic::SceneTree & aSceneTree,
     graphics::setUniform(program, "u_VoxelSize", aVoxelizer.mVoxelSize);
     graphics::setUniform(program, "u_AabbMin", aVoxelizer.mSceneAabb.leftBottomZMin());
 
+    graphics::setUniform(program, "u_TanHalfAperture", mFrameControl.mConeAperture.data());
+
+    graphics::setUniform(program, "u_ToneMapping", (GLuint)mFrameControl.mToneMapping);
+
     glProgramUniform4fv(program,
                         glGetUniformLocation(program, "u_LightingFactors"),
                         1, &mFrameControl.mDirectDiffuseFactor);
@@ -293,6 +297,9 @@ void FrameGraph::appendUi()
                       FrameControl::gPolygonModes.end(),
                       [](auto aModeIt) {return graphics::to_string(*aModeIt); });
 
+    imguiui::addComboContinuousEnum<FrameControl::ToneMapping::_End>(
+        "Tone Mapping", mFrameControl.mToneMapping);
+
     ImGui::SliderAngle("Diffuse Cone Aperture", &mFrameControl.mConeAperture.data(), 1.f, 180.f);
 
     ImGui::Checkbox("Grid Aligned Trace Origin", &mFrameControl.mGridAlign);
@@ -309,5 +316,19 @@ void FrameGraph::appendUi()
 }
 
 
+std::string to_string(FrameGraph::FrameControl::ToneMapping aValue)
+{
+#define STR(enumerator) case FrameGraph::FrameControl::ToneMapping::enumerator: return #enumerator
+    switch (aValue)
+    {
+        STR(None);
+        STR(Reinhard);
+        STR(Aces);
+        STR(AcesApprox);
+    default:
+        throw std::logic_error{ "Unhandled tone mapping." };
+    }
+#undef STR
+}
 
 } // namespace ad

src/apps/ch11_voxel/ch11_voxel/FrameGraph.h

@@ -34,7 +34,19 @@ struct FrameGraph
              GL_FILL,
          }; 
 
+        enum class ToneMapping : GLuint 
+        {
+            None,
+            Reinhard,
+            Aces,
+            AcesApprox,
+            _End/* keep last */
+        };
+
         decltype(gPolygonModes)::const_iterator mPolygonMode = gPolygonModes.begin() + 2;
+
+        ToneMapping mToneMapping = ToneMapping::AcesApprox;
+
         math::Radian<GLfloat> mConeAperture = math::Degree<GLfloat>{30.f};
         bool mGridAlign = false;
 

src/apps/ch11_voxel/ch11_voxel/Scene.cpp

@@ -643,6 +643,7 @@ std::string to_string(Scene::SceneControl::Mode aValue)
     default:
         throw std::logic_error{ "Unhandled mode." };
     }
+#undef STR
 }
 
 

src/apps/ch11_voxel/ch11_voxel/Scene.h

@@ -148,15 +148,16 @@ struct Scene
         // We decode a sRGB 50% white (which is also perceptually ~50%)
         // to linear space for computation.
         .mAmbientColor = math::decode_sRGB(math::hdr::gWhite<float> * 0.25f),
+        //.mAmbientColor = math::hdr::Rgb_f{0.f, 0.f, 0.f},
         .mDirectionalLights = {
             renderer::DirectionalLight_glsl{
                 // Sponza: strong lighting of the first level
-                .mDirection = math::UnitVec<3, float>{ {0.1f, -0.85f, 0.51f} },
+                //.mDirection = math::UnitVec<3, float>{ {0.1f, -0.85f, 0.51f} },
                 // Sponza: lighting down to the lower drapes
-                //.mDirection = math::UnitVec<3, float>{ {0.1f, -0.94f, 0.325f} },
+                .mDirection = math::UnitVec<3, float>{ {0.1f, -0.94f, 0.325f} },
                 // TODO: decode the srgb value to have it show correctly in Imgui
                 // (and have it perceptually proportional to the factor)
-                .mColors = renderer::LightColors_glsl{} * 0.5,
+                .mColors = renderer::LightColors_glsl{} * 2.5,
             },
          },
         .mPointLights = {

src/apps/ch11_voxel/ch11_voxel/ShaderConstants.cpp

@@ -38,6 +38,15 @@ namespace ad {
             result.emplace_back(
                 "CLIENT_VOXEL_MODE_IRRADIANCE " 
                 + std::to_string((GLuint)Scene::SceneControl::Mode::VoxelsIrradiance));
+            result.emplace_back(
+                "CLIENT_TONEMAPPING_REINHARD " 
+                + std::to_string((GLuint)FrameGraph::FrameControl::ToneMapping::Reinhard));
+            result.emplace_back(
+                "CLIENT_TONEMAPPING_ACES " 
+                + std::to_string((GLuint)FrameGraph::FrameControl::ToneMapping::Aces));
+            result.emplace_back(
+                "CLIENT_TONEMAPPING_ACESAPPROX " 
+                + std::to_string((GLuint)FrameGraph::FrameControl::ToneMapping::AcesApprox));
             return result;
         }
 

src/apps/ch11_voxel/ch11_voxel/resources/shaders/ch11_Pbr.frag

@@ -9,6 +9,7 @@
 #include "shaders/LightUtilities.glsl"
 #include "shaders/MaterialGenericBlock.glsl"
 #include "shaders/PbrUtilities.glsl"
+#include "shaders/ToneMapping.glsl"
 #include "shaders/ViewProjectionBlock.glsl"
 
 
@@ -48,12 +49,14 @@ uniform uint u_DiffuseUvChannel;
 uniform uint u_NormalUvChannel;
 uniform uint u_MraoUvChannel;
 
-uniform ivec2 u_FramebufferSize;
+uniform uint u_MaterialIdx;
+
 uniform bool u_ApplyAo = false;
 uniform bool u_ApplyEnvironment;
 uniform bool u_ApplyNormalMap = true;
-uniform uint u_MaterialIdx;
+uniform uint u_ToneMapping;
 
+uniform ivec2 u_FramebufferSize;
 uniform float u_VoxelSize;
 uniform vec3 u_AabbMin;
 
@@ -467,5 +470,17 @@ void main(void)
     //
     // Output
     //
+    switch(u_ToneMapping)
+    {
+    case CLIENT_TONEMAPPING_REINHARD:
+		fragmentColor = tonemapReinhard(fragmentColor);
+        break;
+    case CLIENT_TONEMAPPING_ACES:
+		fragmentColor = tonemapAces(fragmentColor);
+    case CLIENT_TONEMAPPING_ACESAPPROX:
+		fragmentColor = tonemapAces_approx(fragmentColor);
+        break;
+    // Default is none
+    }
     out_Color = correctGamma(vec4(fragmentColor, albedo.a));
 }

src/libs/engine/engine/resources/shaders/ToneMapping.glsl

@@ -0,0 +1,59 @@
+#if !defined(TONEMAPPING_GLSL_INCLUDE_GUARD)
+#define TONEMAPPING_GLSL_INCLUDE_GUARD
+
+
+vec3 tonemapReinhard(vec3 aColor)
+{
+	return aColor / (aColor + 1);
+}
+
+//
+// ACES
+// see: https://github.com/TheRealMJP/BakingLab/blob/v1.0/BakingLab/ACES.hlsl
+// note: GLSL matrices are column major, so the literal value is transposed
+//
+
+// sRGB => XYZ => D65_2_D60 => AP1 => RRT_SAT
+const mat3 ACESInputMat = mat3(
+    0.59719, 0.07600, 0.02840,
+    0.35458, 0.90834, 0.13383,
+    0.04823, 0.01566, 0.83777
+);
+
+// ODT_SAT => XYZ => D60_2_D65 => sRGB
+const mat3 ACESOutputMat = mat3(
+    1.60475, -0.10208, -0.00327,
+    -0.53108,  1.10813, -0.07276,
+    -0.07367, -0.00605,  1.07602
+);
+
+vec3 RRTAndODTFit(vec3 v)
+{
+    vec3 a = v * (v + 0.0245786f) - 0.000090537f;
+    vec3 b = v * (0.983729f * v + 0.4329510f) + 0.238081f;
+    return a / b;
+}
+
+vec3 tonemapAces(vec3 aColor)
+{
+    aColor = ACESInputMat * aColor;
+    aColor = RRTAndODTFit(aColor);
+    aColor = ACESOutputMat * aColor;
+    return clamp(aColor, 0, 1);
+}
+
+vec3 tonemapAces_approx(vec3 v)
+{
+    v *= 0.6f;
+    float a = 2.51f;
+    float b = 0.03f;
+    float c = 2.43f;
+    float d = 0.59f;
+    float e = 0.14f;
+    return clamp(
+        (v*(a*v+b)) / (v*(c*v+d)+e),
+        0, 1);
+}
+
+
+#endif //include guard