diff --git a/.gitmodules b/.gitmodules
index d3b0a1404e8b1bb1a7b29154759d006adc8615e4..e1d38a91697947d5b87f0767f231f1dee48ec4ed 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -46,3 +46,6 @@
 [submodule "lib/VulkanMemoryAllocator"]
 	path = lib/VulkanMemoryAllocator
 	url = https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator.git
+[submodule "modules/tone_mapping/lib/glsl-tone-map"]
+	path = modules/tone_mapping/lib/glsl-tone-map
+	url = https://github.com/dmnsgn/glsl-tone-map.git
diff --git a/modules/CMakeLists.txt b/modules/CMakeLists.txt
index fd3c4cfdfedff17e6952d8b2222aca37d0510d24..2d96cfe2e17c0d7276bf43ad9038054b924be88c 100644
--- a/modules/CMakeLists.txt
+++ b/modules/CMakeLists.txt
@@ -13,6 +13,7 @@ add_subdirectory(material)
 add_subdirectory(meshlet)
 add_subdirectory(scene)
 add_subdirectory(shader_compiler)
+add_subdirectory(tone_mapping)
 add_subdirectory(upscaling)
 
 message(STATUS "Modules:")
diff --git a/modules/effects/CMakeLists.txt b/modules/effects/CMakeLists.txt
index 94bb819d2a00443827ed40f5e015cc0745f61667..ba5a4ff4369adb4290c0ba253688ad4ddf461e16 100644
--- a/modules/effects/CMakeLists.txt
+++ b/modules/effects/CMakeLists.txt
@@ -14,6 +14,9 @@ set(vkcv_effects_sources
 		
 		${vkcv_effects_include}/vkcv/effects/BloomAndFlaresEffect.hpp
 		${vkcv_effects_source}/vkcv/effects/BloomAndFlaresEffect.cpp
+		
+		${vkcv_effects_include}/vkcv/effects/GammaCorrectionEffect.hpp
+		${vkcv_effects_source}/vkcv/effects/GammaCorrectionEffect.cpp
 )
 
 filter_headers(vkcv_effects_sources ${vkcv_effects_include} vkcv_effects_headers)
@@ -23,16 +26,19 @@ set(vkcv_effects_shaders ${PROJECT_SOURCE_DIR}/shaders)
 include_shader(${vkcv_effects_shaders}/bloomDownsample.comp ${vkcv_effects_include} ${vkcv_effects_source})
 include_shader(${vkcv_effects_shaders}/bloomFlaresComposite.comp ${vkcv_effects_include} ${vkcv_effects_source})
 include_shader(${vkcv_effects_shaders}/bloomUpsample.comp ${vkcv_effects_include} ${vkcv_effects_source})
+include_shader(${vkcv_effects_shaders}/gammaCorrection.comp ${vkcv_effects_include} ${vkcv_effects_source})
 include_shader(${vkcv_effects_shaders}/lensFlares.comp ${vkcv_effects_include} ${vkcv_effects_source})
 
 list(APPEND vkcv_effects_sources ${vkcv_effects_source}/bloomDownsample.comp.cxx)
 list(APPEND vkcv_effects_sources ${vkcv_effects_source}/bloomFlaresComposite.comp.cxx)
 list(APPEND vkcv_effects_sources ${vkcv_effects_source}/bloomUpsample.comp.cxx)
+list(APPEND vkcv_effects_sources ${vkcv_effects_source}/gammaCorrection.comp.cxx)
 list(APPEND vkcv_effects_sources ${vkcv_effects_source}/lensFlares.comp.cxx)
 
 list(APPEND vkcv_effects_sources ${vkcv_effects_include}/bloomDownsample.comp.hxx)
 list(APPEND vkcv_effects_sources ${vkcv_effects_include}/bloomFlaresComposite.comp.hxx)
 list(APPEND vkcv_effects_sources ${vkcv_effects_include}/bloomUpsample.comp.hxx)
+list(APPEND vkcv_effects_sources ${vkcv_effects_include}/gammaCorrection.comp.hxx)
 list(APPEND vkcv_effects_sources ${vkcv_effects_include}/lensFlares.comp.hxx)
 
 # adding source files to the project
@@ -40,10 +46,21 @@ add_library(vkcv_effects ${vkcv_build_attribute} ${vkcv_effects_sources})
 set_target_properties(vkcv_effects PROPERTIES PUBLIC_HEADER "${vkcv_effects_headers}")
 
 # link the required libraries to the module
-target_link_libraries(vkcv_effects ${vkcv_effects_libraries} vkcv vkcv_shader_compiler vkcv_camera vkcv_asset_loader)
+target_link_libraries(vkcv_effects
+		${vkcv_effects_libraries}
+		vkcv
+		vkcv_shader_compiler
+		vkcv_camera
+		vkcv_asset_loader)
 
 # including headers of dependencies and the VkCV framework
-target_include_directories(vkcv_effects SYSTEM BEFORE PRIVATE ${vkcv_effects_includes} ${vkcv_include} ${vkcv_includes} ${vkcv_shader_compiler_include} ${vkcv_camera_include} {vkcv_asset_loader_include})
+target_include_directories(vkcv_effects SYSTEM BEFORE PRIVATE
+		${vkcv_effects_includes}
+		${vkcv_include}
+		${vkcv_includes}
+		${vkcv_shader_compiler_include}
+		${vkcv_camera_include}
+		${vkcv_asset_loader_include})
 
 # add the own include directory for public headers
 target_include_directories(vkcv_effects BEFORE PUBLIC ${vkcv_effects_include})
diff --git a/modules/effects/include/vkcv/effects/GammaCorrectionEffect.hpp b/modules/effects/include/vkcv/effects/GammaCorrectionEffect.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..93a90b8284e4af69ed0148552c972c3ef66201cf
--- /dev/null
+++ b/modules/effects/include/vkcv/effects/GammaCorrectionEffect.hpp
@@ -0,0 +1,30 @@
+#pragma once
+
+#include "Effect.hpp"
+
+namespace vkcv::effects {
+	
+	class GammaCorrectionEffect : public Effect {
+	private:
+		float m_gamma;
+		
+		ComputePipelineHandle m_pipeline;
+		
+		DescriptorSetLayoutHandle m_descriptorSetLayout;
+		
+		DescriptorSetHandle m_descriptorSet;
+	
+	public:
+		GammaCorrectionEffect(Core& core);
+		
+		void recordEffect(const CommandStreamHandle& cmdStream,
+						  const ImageHandle& input,
+						  const ImageHandle& output) override;
+		
+		void setGamma(float gamma);
+		
+		float getGamma() const;
+		
+	};
+	
+}
diff --git a/modules/effects/shaders/gammaCorrection.comp b/modules/effects/shaders/gammaCorrection.comp
new file mode 100644
index 0000000000000000000000000000000000000000..392ac8e0c80cff5ac821cadb6a23d981f21420e5
--- /dev/null
+++ b/modules/effects/shaders/gammaCorrection.comp
@@ -0,0 +1,27 @@
+#version 450
+
+layout(set=0, binding=0, rgba8) restrict readonly uniform image2D inImage;
+layout(set=0, binding=1, rgba8) restrict writeonly uniform image2D outImage;
+
+layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
+
+layout( push_constant ) uniform constants {
+    float gamma;
+};
+
+void main() {
+    if (any(greaterThanEqual(gl_GlobalInvocationID.xy, imageSize(inImage)))) {
+        return;
+    }
+
+    if (any(greaterThanEqual(gl_GlobalInvocationID.xy, imageSize(outImage)))) {
+        return;
+    }
+
+    ivec2 uv = ivec2(gl_GlobalInvocationID.xy);
+    vec3 color = imageLoad(inImage, uv).xyz;
+
+    color = pow(color, vec3(1.0f / gamma));
+
+    imageStore(outImage, uv, vec4(color, 0.f));
+}
\ No newline at end of file
diff --git a/modules/effects/src/vkcv/effects/GammaCorrectionEffect.cpp b/modules/effects/src/vkcv/effects/GammaCorrectionEffect.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..088a3dbd97ae9654cdbfe6355b4837310c51bddc
--- /dev/null
+++ b/modules/effects/src/vkcv/effects/GammaCorrectionEffect.cpp
@@ -0,0 +1,100 @@
+
+#include "vkcv/effects/GammaCorrectionEffect.hpp"
+
+#include <vkcv/shader/GLSLCompiler.hpp>
+
+#include "gammaCorrection.comp.hxx"
+
+namespace vkcv::effects {
+	
+	static DescriptorBindings getDescriptorBindings() {
+		DescriptorBindings descriptorBindings = {};
+		
+		auto binding_0 = DescriptorBinding {
+				0,
+				DescriptorType::IMAGE_STORAGE,
+				1,
+				ShaderStage::COMPUTE,
+				false,
+				false
+		};
+		
+		auto binding_1 = DescriptorBinding {
+				1,
+				DescriptorType::IMAGE_STORAGE,
+				1,
+				ShaderStage::COMPUTE,
+				false,
+				false
+		};
+		
+		descriptorBindings.insert(std::make_pair(0, binding_0));
+		descriptorBindings.insert(std::make_pair(1, binding_1));
+		
+		return descriptorBindings;
+	}
+	
+	GammaCorrectionEffect::GammaCorrectionEffect(Core &core)
+	: Effect(core), m_gamma(2.2f), m_descriptorSetLayout(), m_descriptorSet(), m_pipeline() {
+		vkcv::shader::GLSLCompiler compiler;
+		ShaderProgram program;
+		
+		compiler.compileSource(
+			ShaderStage::COMPUTE,
+			GAMMACORRECTION_COMP_SHADER.c_str(),
+			[&program](ShaderStage stage, const std::filesystem::path &path) {
+				program.addShader(stage, path);
+			}
+		);
+		
+		m_descriptorSetLayout = m_core.createDescriptorSetLayout(getDescriptorBindings());
+		m_descriptorSet = m_core.createDescriptorSet(m_descriptorSetLayout);
+		m_pipeline = m_core.createComputePipeline({
+			program,
+			{ m_descriptorSetLayout }
+		});
+	}
+	
+	void GammaCorrectionEffect::recordEffect(const CommandStreamHandle &cmdStream,
+											 const ImageHandle &input,
+											 const ImageHandle &output) {
+		m_core.recordBeginDebugLabel(cmdStream, "Gamma Correction", std::array<float, 4>{
+				0.95f, 0.95f, 0.95f, 1.0f
+		});
+		
+		m_core.prepareImageForStorage(cmdStream, input);
+		m_core.prepareImageForStorage(cmdStream, output);
+		
+		vkcv::DescriptorWrites writes;
+		
+		writes.writeStorageImage(0, input);
+		writes.writeStorageImage(1, output);
+		
+		m_core.writeDescriptorSet(m_descriptorSet, writes);
+		
+		const uint32_t width = m_core.getImageWidth(output);
+		const uint32_t height = m_core.getImageHeight(output);
+		
+		m_core.recordComputeDispatchToCmdStream(
+				cmdStream,
+				m_pipeline,
+				dispatchInvocations(
+						DispatchSize(width, height),
+						DispatchSize(8, 8)
+				),
+				{ useDescriptorSet(0, m_descriptorSet) },
+				pushConstants<float>(m_gamma)
+		);
+		
+		m_core.recordEndDebugLabel(cmdStream);
+	}
+	
+	void GammaCorrectionEffect::setGamma(float gamma) {
+		m_gamma = std::max(gamma, std::numeric_limits<float>::epsilon());
+	}
+	
+	float GammaCorrectionEffect::getGamma() const {
+		return m_gamma;
+	}
+	
+}
diff --git a/modules/shader_compiler/include/vkcv/shader/GLSLCompiler.hpp b/modules/shader_compiler/include/vkcv/shader/GLSLCompiler.hpp
index face4cba350122f22feee6bae878397dccf4a070..0cb3a39436675e722f818643808b769189165793 100644
--- a/modules/shader_compiler/include/vkcv/shader/GLSLCompiler.hpp
+++ b/modules/shader_compiler/include/vkcv/shader/GLSLCompiler.hpp
@@ -76,7 +76,7 @@ namespace vkcv::shader {
          */
 		bool compileSource(ShaderStage shaderStage, const char* shaderSource,
 						   const ShaderCompiledFunction& compiled,
-						   const std::filesystem::path& includePath) override;
+						   const std::filesystem::path& includePath = "") override;
 
         /**
          * Compile a GLSL shader from a specific file path for a target stage with
diff --git a/modules/tone_mapping/CMakeLists.txt b/modules/tone_mapping/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a63d74650b22716c49eda3842b7fcea6dba4b9cd
--- /dev/null
+++ b/modules/tone_mapping/CMakeLists.txt
@@ -0,0 +1,83 @@
+cmake_minimum_required(VERSION 3.16)
+project(vkcv_tone_mapping)
+
+# setting c++ standard for the project
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+set(vkcv_tone_mapping_source ${PROJECT_SOURCE_DIR}/src)
+set(vkcv_tone_mapping_include ${PROJECT_SOURCE_DIR}/include)
+
+set(vkcv_tone_mapping_sources
+		${vkcv_tone_mapping_include}/vkcv/tone/ToneMapping.hpp
+		${vkcv_tone_mapping_source}/vkcv/tone/ToneMapping.cpp
+		
+		${vkcv_tone_mapping_include}/vkcv/tone/ACESToneMapping.hpp
+		${vkcv_tone_mapping_source}/vkcv/tone/ACESToneMapping.cpp
+		
+		${vkcv_tone_mapping_include}/vkcv/tone/FilmicToneMapping.hpp
+		${vkcv_tone_mapping_source}/vkcv/tone/FilmicToneMapping.cpp
+		
+		${vkcv_tone_mapping_include}/vkcv/tone/LottesToneMapping.hpp
+		${vkcv_tone_mapping_source}/vkcv/tone/LottesToneMapping.cpp
+		
+		${vkcv_tone_mapping_include}/vkcv/tone/ReinhardToneMapping.hpp
+		${vkcv_tone_mapping_source}/vkcv/tone/ReinhardToneMapping.cpp
+		
+		${vkcv_tone_mapping_include}/vkcv/tone/Reinhard2ToneMapping.hpp
+		${vkcv_tone_mapping_source}/vkcv/tone/Reinhard2ToneMapping.cpp
+		
+		${vkcv_tone_mapping_include}/vkcv/tone/UchimuraToneMapping.hpp
+		${vkcv_tone_mapping_source}/vkcv/tone/UchimuraToneMapping.cpp
+		
+		${vkcv_tone_mapping_include}/vkcv/tone/Uncharted2ToneMapping.hpp
+		${vkcv_tone_mapping_source}/vkcv/tone/Uncharted2ToneMapping.cpp
+		
+		${vkcv_tone_mapping_include}/vkcv/tone/UnrealToneMapping.hpp
+		${vkcv_tone_mapping_source}/vkcv/tone/UnrealToneMapping.cpp
+)
+
+filter_headers(vkcv_tone_mapping_sources ${vkcv_tone_mapping_include} vkcv_tone_mapping_headers)
+
+# Setup some path variables to load libraries
+set(vkcv_tone_mapping_lib lib)
+set(vkcv_tone_mapping_lib_path ${PROJECT_SOURCE_DIR}/${vkcv_tone_mapping_lib})
+
+# Check and load glsl-tone-map
+include(config/GLSL_TONE_MAP.cmake)
+
+# Add compile definitions depending on the build context of the module
+add_compile_definitions(${vkcv_tone_mapping_definitions})
+
+# adding source files to the project
+add_library(vkcv_tone_mapping ${vkcv_build_attribute} ${vkcv_tone_mapping_sources})
+set_target_properties(vkcv_tone_mapping PROPERTIES PUBLIC_HEADER "${vkcv_tone_mapping_headers}")
+
+# link the required libraries to the module
+target_link_libraries(vkcv_tone_mapping
+		${vkcv_tone_mapping_libraries}
+		vkcv
+		vkcv_shader_compiler
+)
+
+# including headers of dependencies and the VkCV framework
+target_include_directories(vkcv_tone_mapping SYSTEM BEFORE PRIVATE
+		${vkcv_tone_mapping_includes}
+		${vkcv_include}
+		${vkcv_includes}
+		${vkcv_shader_compiler_include}
+)
+
+# add the own include directory for public headers
+target_include_directories(vkcv_tone_mapping BEFORE PUBLIC ${vkcv_tone_mapping_include})
+
+if (vkcv_parent_scope)
+	list(APPEND vkcv_modules_includes ${vkcv_tone_mapping_include})
+	list(APPEND vkcv_modules_libraries vkcv_tone_mapping)
+	
+	set(vkcv_modules_includes ${vkcv_modules_includes} PARENT_SCOPE)
+	set(vkcv_modules_libraries ${vkcv_modules_libraries} PARENT_SCOPE)
+endif()
+
+install(TARGETS vkcv_tone_mapping PUBLIC_HEADER DESTINATION
+		${CMAKE_INSTALL_INCLUDEDIR}/vkcv/tone)
diff --git a/modules/tone_mapping/config/GLSL_TONE_MAP.cmake b/modules/tone_mapping/config/GLSL_TONE_MAP.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..814344132d7e9f14e3e6df58544b9d7e88ee3677
--- /dev/null
+++ b/modules/tone_mapping/config/GLSL_TONE_MAP.cmake
@@ -0,0 +1,54 @@
+
+use_git_submodule("${vkcv_tone_mapping_lib_path}/glsl-tone-map" glsl_tone_map_status)
+
+if (${glsl_tone_map_status})
+	include_shader(${vkcv_tone_mapping_lib_path}/glsl-tone-map/aces.glsl
+			${vkcv_tone_mapping_include}
+			${vkcv_tone_mapping_source})
+	
+	include_shader(${vkcv_tone_mapping_lib_path}/glsl-tone-map/filmic.glsl
+			${vkcv_tone_mapping_include}
+			${vkcv_tone_mapping_source})
+	
+	include_shader(${vkcv_tone_mapping_lib_path}/glsl-tone-map/lottes.glsl
+			${vkcv_tone_mapping_include}
+			${vkcv_tone_mapping_source})
+	
+	include_shader(${vkcv_tone_mapping_lib_path}/glsl-tone-map/reinhard.glsl
+			${vkcv_tone_mapping_include}
+			${vkcv_tone_mapping_source})
+	
+	include_shader(${vkcv_tone_mapping_lib_path}/glsl-tone-map/reinhard2.glsl
+			${vkcv_tone_mapping_include}
+			${vkcv_tone_mapping_source})
+	
+	include_shader(${vkcv_tone_mapping_lib_path}/glsl-tone-map/uchimura.glsl
+			${vkcv_tone_mapping_include}
+			${vkcv_tone_mapping_source})
+	
+	include_shader(${vkcv_tone_mapping_lib_path}/glsl-tone-map/uncharted2.glsl
+			${vkcv_tone_mapping_include}
+			${vkcv_tone_mapping_source})
+	
+	include_shader(${vkcv_tone_mapping_lib_path}/glsl-tone-map/unreal.glsl
+			${vkcv_tone_mapping_include}
+			${vkcv_tone_mapping_source})
+	
+	list(APPEND vkcv_tone_mapping_sources ${vkcv_tone_mapping_source}/aces.glsl.cxx)
+	list(APPEND vkcv_tone_mapping_sources ${vkcv_tone_mapping_source}/filmic.glsl.cxx)
+	list(APPEND vkcv_tone_mapping_sources ${vkcv_tone_mapping_source}/lottes.glsl.cxx)
+	list(APPEND vkcv_tone_mapping_sources ${vkcv_tone_mapping_source}/reinhard.glsl.cxx)
+	list(APPEND vkcv_tone_mapping_sources ${vkcv_tone_mapping_source}/reinhard2.glsl.cxx)
+	list(APPEND vkcv_tone_mapping_sources ${vkcv_tone_mapping_source}/uchimura.glsl.cxx)
+	list(APPEND vkcv_tone_mapping_sources ${vkcv_tone_mapping_source}/uncharted2.glsl.cxx)
+	list(APPEND vkcv_tone_mapping_sources ${vkcv_tone_mapping_source}/unreal.glsl.cxx)
+	
+	list(APPEND vkcv_tone_mapping_sources ${vkcv_tone_mapping_include}/aces.glsl.hxx)
+	list(APPEND vkcv_tone_mapping_sources ${vkcv_tone_mapping_include}/filmic.glsl.hxx)
+	list(APPEND vkcv_tone_mapping_sources ${vkcv_tone_mapping_include}/lottes.glsl.hxx)
+	list(APPEND vkcv_tone_mapping_sources ${vkcv_tone_mapping_include}/reinhard.glsl.hxx)
+	list(APPEND vkcv_tone_mapping_sources ${vkcv_tone_mapping_include}/reinhard2.glsl.hxx)
+	list(APPEND vkcv_tone_mapping_sources ${vkcv_tone_mapping_include}/uchimura.glsl.hxx)
+	list(APPEND vkcv_tone_mapping_sources ${vkcv_tone_mapping_include}/uncharted2.glsl.hxx)
+	list(APPEND vkcv_tone_mapping_sources ${vkcv_tone_mapping_include}/unreal.glsl.hxx)
+endif()
diff --git a/modules/tone_mapping/include/vkcv/tone/ACESToneMapping.hpp b/modules/tone_mapping/include/vkcv/tone/ACESToneMapping.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..77a9896e9b472017497012fdc6b14a35adfd5f5a
--- /dev/null
+++ b/modules/tone_mapping/include/vkcv/tone/ACESToneMapping.hpp
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "ToneMapping.hpp"
+
+namespace vkcv::tone {
+	
+	class ACESToneMapping : public ToneMapping {
+	private:
+		void initToneMapping() override;
+		
+	public:
+		explicit ACESToneMapping(Core& core);
+		
+	};
+	
+}
diff --git a/modules/tone_mapping/include/vkcv/tone/FilmicToneMapping.hpp b/modules/tone_mapping/include/vkcv/tone/FilmicToneMapping.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..fd6bb975e3e7cbac0c741ef8d47e6940c374e630
--- /dev/null
+++ b/modules/tone_mapping/include/vkcv/tone/FilmicToneMapping.hpp
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "ToneMapping.hpp"
+
+namespace vkcv::tone {
+	
+	class FilmicToneMapping : public ToneMapping {
+	private:
+		void initToneMapping() override;
+	
+	public:
+		explicit FilmicToneMapping(Core& core);
+		
+	};
+	
+}
diff --git a/modules/tone_mapping/include/vkcv/tone/LottesToneMapping.hpp b/modules/tone_mapping/include/vkcv/tone/LottesToneMapping.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..e899e2667353b4a6a8737d33465f6df9046b6a93
--- /dev/null
+++ b/modules/tone_mapping/include/vkcv/tone/LottesToneMapping.hpp
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "ToneMapping.hpp"
+
+namespace vkcv::tone {
+	
+	class LottesToneMapping : public ToneMapping {
+	private:
+		void initToneMapping() override;
+	
+	public:
+		explicit LottesToneMapping(Core& core);
+		
+	};
+	
+}
diff --git a/modules/tone_mapping/include/vkcv/tone/Reinhard2ToneMapping.hpp b/modules/tone_mapping/include/vkcv/tone/Reinhard2ToneMapping.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..68f8fb57d62881bb9dafa25a500ff47105e83b06
--- /dev/null
+++ b/modules/tone_mapping/include/vkcv/tone/Reinhard2ToneMapping.hpp
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "ToneMapping.hpp"
+
+namespace vkcv::tone {
+	
+	class Reinhard2ToneMapping : public ToneMapping {
+	private:
+		void initToneMapping() override;
+	
+	public:
+		explicit Reinhard2ToneMapping(Core& core);
+		
+	};
+	
+}
diff --git a/modules/tone_mapping/include/vkcv/tone/ReinhardToneMapping.hpp b/modules/tone_mapping/include/vkcv/tone/ReinhardToneMapping.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..e1c61fd3144a4532382b06f93db5e5015e6b6b31
--- /dev/null
+++ b/modules/tone_mapping/include/vkcv/tone/ReinhardToneMapping.hpp
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "ToneMapping.hpp"
+
+namespace vkcv::tone {
+	
+	class ReinhardToneMapping : public ToneMapping {
+	private:
+		void initToneMapping() override;
+	
+	public:
+		explicit ReinhardToneMapping(Core& core);
+		
+	};
+	
+}
diff --git a/modules/tone_mapping/include/vkcv/tone/ToneMapping.hpp b/modules/tone_mapping/include/vkcv/tone/ToneMapping.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..7dce06172227f524ba89c5a1c1a6cf5b19d85a54
--- /dev/null
+++ b/modules/tone_mapping/include/vkcv/tone/ToneMapping.hpp
@@ -0,0 +1,66 @@
+#pragma once
+
+#include <vkcv/Core.hpp>
+
+namespace vkcv::tone {
+	
+	class ToneMapping {
+	private:
+		/**
+         * Reference to the current Core instance.
+         */
+		Core& m_core;
+		
+		std::string m_name;
+		
+		ComputePipelineHandle m_pipeline;
+		
+		/**
+         * The descriptor set layout of the tone mapping pipeline.
+         */
+		DescriptorSetLayoutHandle m_descriptorSetLayout;
+		
+		/**
+		 * The descriptor set for the tone mapping pipeline.
+		 */
+		DescriptorSetHandle m_descriptorSet;
+		
+	protected:
+		ShaderProgram compileShaderProgram(const std::string& functionName,
+										   const std::string& functionSource);
+		
+		void buildComputePipeline(const std::string& functionName,
+								  const std::string& functionSource);
+		
+		virtual void initToneMapping() = 0;
+		
+	public:
+		/**
+         * Constructor to create an tone mapping instance.
+         *
+         * @param[in,out] core Reference to a Core instance
+         * @param[in] name Name of the tone mapping function
+         */
+		explicit ToneMapping(Core& core, const std::string& name);
+	
+		~ToneMapping() = default;
+		
+		[[nodiscard]]
+		const std::string& getName() const;
+		
+		/**
+		 * Record the commands of the given tone mapping instance to
+		 * process the image of the input handle mapping its colors into
+		 * the regarding output image handle.
+		 *
+		 * @param[in] cmdStream Command stream handle to record commands
+		 * @param[in] input Input image handle
+		 * @param[in] output Output image handle
+		 */
+		void recordToneMapping(const CommandStreamHandle& cmdStream,
+							   const ImageHandle& input,
+							   const ImageHandle& output);
+		
+	};
+	
+}
diff --git a/modules/tone_mapping/include/vkcv/tone/UchimuraToneMapping.hpp b/modules/tone_mapping/include/vkcv/tone/UchimuraToneMapping.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..b4047d1c2097f580068bdccfe0561bab8397cc5f
--- /dev/null
+++ b/modules/tone_mapping/include/vkcv/tone/UchimuraToneMapping.hpp
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "ToneMapping.hpp"
+
+namespace vkcv::tone {
+	
+	class UchimuraToneMapping : public ToneMapping {
+	private:
+		void initToneMapping() override;
+	
+	public:
+		explicit UchimuraToneMapping(Core& core);
+		
+	};
+	
+}
diff --git a/modules/tone_mapping/include/vkcv/tone/Uncharted2ToneMapping.hpp b/modules/tone_mapping/include/vkcv/tone/Uncharted2ToneMapping.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..c1cf0f749f3a4dd1dc20569f6204258fbf05e1c1
--- /dev/null
+++ b/modules/tone_mapping/include/vkcv/tone/Uncharted2ToneMapping.hpp
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "ToneMapping.hpp"
+
+namespace vkcv::tone {
+	
+	class Uncharted2ToneMapping : public ToneMapping {
+	private:
+		void initToneMapping() override;
+	
+	public:
+		explicit Uncharted2ToneMapping(Core& core);
+		
+	};
+	
+}
diff --git a/modules/tone_mapping/include/vkcv/tone/UnrealToneMapping.hpp b/modules/tone_mapping/include/vkcv/tone/UnrealToneMapping.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..2d3c80906139cfca7d3a205117e6e2b7fab2154b
--- /dev/null
+++ b/modules/tone_mapping/include/vkcv/tone/UnrealToneMapping.hpp
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "ToneMapping.hpp"
+
+namespace vkcv::tone {
+	
+	class UnrealToneMapping : public ToneMapping {
+	private:
+		void initToneMapping() override;
+	
+	public:
+		explicit UnrealToneMapping(Core& core);
+		
+	};
+	
+}
diff --git a/modules/tone_mapping/lib/glsl-tone-map b/modules/tone_mapping/lib/glsl-tone-map
new file mode 160000
index 0000000000000000000000000000000000000000..e3d822adee738de936da5d9541dff266f899ed46
--- /dev/null
+++ b/modules/tone_mapping/lib/glsl-tone-map
@@ -0,0 +1 @@
+Subproject commit e3d822adee738de936da5d9541dff266f899ed46
diff --git a/modules/tone_mapping/src/vkcv/tone/ACESToneMapping.cpp b/modules/tone_mapping/src/vkcv/tone/ACESToneMapping.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..26e5624c944f6d9ed8c751cff534a73e8daa7888
--- /dev/null
+++ b/modules/tone_mapping/src/vkcv/tone/ACESToneMapping.cpp
@@ -0,0 +1,16 @@
+
+#include "vkcv/tone/ACESToneMapping.hpp"
+
+#include "aces.glsl.hxx"
+
+namespace vkcv::tone {
+	
+	void ACESToneMapping::initToneMapping() {
+		buildComputePipeline("aces", ACES_GLSL_SHADER);
+	}
+	
+	ACESToneMapping::ACESToneMapping(Core &core) : ToneMapping(core, "ACES Tone Mapping") {
+		initToneMapping();
+	}
+	
+}
diff --git a/modules/tone_mapping/src/vkcv/tone/FilmicToneMapping.cpp b/modules/tone_mapping/src/vkcv/tone/FilmicToneMapping.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..26b02f5bd4249c8c4c31e52c87434054d5aa84c8
--- /dev/null
+++ b/modules/tone_mapping/src/vkcv/tone/FilmicToneMapping.cpp
@@ -0,0 +1,16 @@
+
+#include "vkcv/tone/FilmicToneMapping.hpp"
+
+#include "filmic.glsl.hxx"
+
+namespace vkcv::tone {
+	
+	void FilmicToneMapping::initToneMapping() {
+		buildComputePipeline("filmic", FILMIC_GLSL_SHADER);
+	}
+	
+	FilmicToneMapping::FilmicToneMapping(Core &core) : ToneMapping(core, "Filmic Tone Mapping") {
+		initToneMapping();
+	}
+
+}
diff --git a/modules/tone_mapping/src/vkcv/tone/LottesToneMapping.cpp b/modules/tone_mapping/src/vkcv/tone/LottesToneMapping.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ab5b7af11c439cebb5d220cfb39e3e740f322480
--- /dev/null
+++ b/modules/tone_mapping/src/vkcv/tone/LottesToneMapping.cpp
@@ -0,0 +1,16 @@
+
+#include "vkcv/tone/LottesToneMapping.hpp"
+
+#include "lottes.glsl.hxx"
+
+namespace vkcv::tone {
+	
+	void LottesToneMapping::initToneMapping() {
+		buildComputePipeline("lottes", LOTTES_GLSL_SHADER);
+	}
+	
+	LottesToneMapping::LottesToneMapping(Core &core) : ToneMapping(core, "Lottes Tone Mapping") {
+		initToneMapping();
+	}
+
+}
diff --git a/modules/tone_mapping/src/vkcv/tone/Reinhard2ToneMapping.cpp b/modules/tone_mapping/src/vkcv/tone/Reinhard2ToneMapping.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..914a64913441026926017cf2e2723d0681b17529
--- /dev/null
+++ b/modules/tone_mapping/src/vkcv/tone/Reinhard2ToneMapping.cpp
@@ -0,0 +1,16 @@
+
+#include "vkcv/tone/Reinhard2ToneMapping.hpp"
+
+#include "reinhard2.glsl.hxx"
+
+namespace vkcv::tone {
+	
+	void Reinhard2ToneMapping::initToneMapping() {
+		buildComputePipeline("reinhard2", REINHARD2_GLSL_SHADER);
+	}
+	
+	Reinhard2ToneMapping::Reinhard2ToneMapping(Core &core) : ToneMapping(core, "Reinhard2 Tone Mapping") {
+		initToneMapping();
+	}
+
+}
diff --git a/modules/tone_mapping/src/vkcv/tone/ReinhardToneMapping.cpp b/modules/tone_mapping/src/vkcv/tone/ReinhardToneMapping.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..743a4f1366c09d764aef338afeb29cbf70187703
--- /dev/null
+++ b/modules/tone_mapping/src/vkcv/tone/ReinhardToneMapping.cpp
@@ -0,0 +1,16 @@
+
+#include "vkcv/tone/ReinhardToneMapping.hpp"
+
+#include "reinhard.glsl.hxx"
+
+namespace vkcv::tone {
+	
+	void ReinhardToneMapping::initToneMapping() {
+		buildComputePipeline("reinhard", REINHARD_GLSL_SHADER);
+	}
+	
+	ReinhardToneMapping::ReinhardToneMapping(Core &core) : ToneMapping(core, "Reinhard Tone Mapping") {
+		initToneMapping();
+	}
+
+}
diff --git a/modules/tone_mapping/src/vkcv/tone/ToneMapping.cpp b/modules/tone_mapping/src/vkcv/tone/ToneMapping.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2c3fcb4a8599449f694bac4881c96605a33d3db3
--- /dev/null
+++ b/modules/tone_mapping/src/vkcv/tone/ToneMapping.cpp
@@ -0,0 +1,132 @@
+
+#include "vkcv/tone/ToneMapping.hpp"
+
+#include <vkcv/shader/GLSLCompiler.hpp>
+
+#include <sstream>
+
+namespace vkcv::tone {
+	
+	static DescriptorBindings getDescriptorBindings() {
+		DescriptorBindings descriptorBindings = {};
+		
+		auto binding_0 = DescriptorBinding {
+				0,
+				DescriptorType::IMAGE_STORAGE,
+				1,
+				ShaderStage::COMPUTE,
+				false,
+				false
+		};
+		
+		auto binding_1 = DescriptorBinding {
+				1,
+				DescriptorType::IMAGE_STORAGE,
+				1,
+				ShaderStage::COMPUTE,
+				false,
+				false
+		};
+		
+		descriptorBindings.insert(std::make_pair(0, binding_0));
+		descriptorBindings.insert(std::make_pair(1, binding_1));
+		
+		return descriptorBindings;
+	}
+	
+	ShaderProgram ToneMapping::compileShaderProgram(const std::string &functionName,
+													const std::string &functionSource) {
+		vkcv::shader::GLSLCompiler compiler;
+		ShaderProgram program;
+		
+		std::ostringstream stream;
+		stream << "#version 450" << std::endl;
+		stream << "layout(set=0, binding=0, rgba16f) restrict readonly uniform image2D inImage;" << std::endl;
+		stream << "layout(set=0, binding=1, rgba8) restrict writeonly uniform image2D outImage;" << std::endl;
+		stream << "layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in;" << std::endl;
+		stream << functionSource << std::endl;
+		stream << "void main() {" << std::endl;
+		stream << "  if (any(greaterThanEqual(gl_GlobalInvocationID.xy, imageSize(inImage)))) {" << std::endl;
+		stream << "    return;" << std::endl;
+		stream << "  }" << std::endl;
+		stream << "  if (any(greaterThanEqual(gl_GlobalInvocationID.xy, imageSize(outImage)))) {" << std::endl;
+		stream << "    return;" << std::endl;
+		stream << "  }" << std::endl;
+		stream << "  ivec2 uv = ivec2(gl_GlobalInvocationID.xy);" << std::endl;
+		stream << "  vec3 color = imageLoad(inImage, uv).xyz;" << std::endl;
+		stream << "  color = " << functionName << "(color);" << std::endl;
+		stream << "  imageStore(outImage, uv, vec4(color, 0.f));" << std::endl;
+		stream << "}" << std::endl;
+		
+		compiler.compileSource(
+				ShaderStage::COMPUTE,
+				stream.str().c_str(),
+				[&](ShaderStage stage, const std::filesystem::path &path) {
+					program.addShader(stage, path);
+				}
+		);
+		
+		return program;
+	}
+	
+	void ToneMapping::buildComputePipeline(const std::string &functionName,
+										   const std::string &functionSource) {
+		const ShaderProgram program = compileShaderProgram(
+				functionName,
+				functionSource
+		);
+		
+		m_descriptorSetLayout = m_core.createDescriptorSetLayout(
+				getDescriptorBindings()
+		);
+		
+		m_descriptorSet = m_core.createDescriptorSet(m_descriptorSetLayout);
+		
+		m_pipeline = m_core.createComputePipeline({
+			program,
+			{ m_descriptorSetLayout }
+		});
+	}
+	
+	ToneMapping::ToneMapping(Core &core, const std::string &name)
+	: m_core(core), m_name(name), m_pipeline(), m_descriptorSetLayout(), m_descriptorSet() {}
+	
+	const std::string &ToneMapping::getName() const {
+		return m_name;
+	}
+	
+	void ToneMapping::recordToneMapping(const CommandStreamHandle& cmdStream,
+										const ImageHandle& input,
+										const ImageHandle& output) {
+		m_core.recordBeginDebugLabel(cmdStream, m_name, std::array<float, 4>{
+			0.75f, 0.75f, 0.75f, 1.0f
+		});
+		
+		m_core.prepareImageForStorage(cmdStream, input);
+		m_core.prepareImageForStorage(cmdStream, output);
+		
+		vkcv::DescriptorWrites writes;
+		
+		writes.writeStorageImage(0, input);
+		writes.writeStorageImage(1, output);
+		
+		m_core.writeDescriptorSet(m_descriptorSet, writes);
+		
+		const uint32_t width = m_core.getImageWidth(output);
+		const uint32_t height = m_core.getImageHeight(output);
+		
+		m_core.recordComputeDispatchToCmdStream(
+				cmdStream,
+				m_pipeline,
+				dispatchInvocations(
+						DispatchSize(width, height),
+						DispatchSize(8, 8)
+				),
+				{ useDescriptorSet(0, m_descriptorSet) },
+				PushConstants(0)
+		);
+		
+		m_core.recordEndDebugLabel(cmdStream);
+	}
+	
+}
diff --git a/modules/tone_mapping/src/vkcv/tone/UchimuraToneMapping.cpp b/modules/tone_mapping/src/vkcv/tone/UchimuraToneMapping.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ee0263cc7faf8a873d2f605dcb633714127056b0
--- /dev/null
+++ b/modules/tone_mapping/src/vkcv/tone/UchimuraToneMapping.cpp
@@ -0,0 +1,16 @@
+
+#include "vkcv/tone/UchimuraToneMapping.hpp"
+
+#include "uchimura.glsl.hxx"
+
+namespace vkcv::tone {
+	
+	void UchimuraToneMapping::initToneMapping() {
+		buildComputePipeline("uchimura", UCHIMURA_GLSL_SHADER);
+	}
+	
+	UchimuraToneMapping::UchimuraToneMapping(Core &core) : ToneMapping(core, "Uchimura Tone Mapping") {
+		initToneMapping();
+	}
+
+}
diff --git a/modules/tone_mapping/src/vkcv/tone/Uncharted2ToneMapping.cpp b/modules/tone_mapping/src/vkcv/tone/Uncharted2ToneMapping.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ff6a68ce00c512493c1947c3bcf04f871b3a8f83
--- /dev/null
+++ b/modules/tone_mapping/src/vkcv/tone/Uncharted2ToneMapping.cpp
@@ -0,0 +1,16 @@
+
+#include "vkcv/tone/Uncharted2ToneMapping.hpp"
+
+#include "uncharted2.glsl.hxx"
+
+namespace vkcv::tone {
+	
+	void Uncharted2ToneMapping::initToneMapping() {
+		buildComputePipeline("uncharted2", UNCHARTED2_GLSL_SHADER);
+	}
+	
+	Uncharted2ToneMapping::Uncharted2ToneMapping(Core &core) : ToneMapping(core, "Uncharted2 Tone Mapping") {
+		initToneMapping();
+	}
+
+}
diff --git a/modules/tone_mapping/src/vkcv/tone/UnrealToneMapping.cpp b/modules/tone_mapping/src/vkcv/tone/UnrealToneMapping.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ebbe8fb5fbf02761da416e3e2fb058623711d054
--- /dev/null
+++ b/modules/tone_mapping/src/vkcv/tone/UnrealToneMapping.cpp
@@ -0,0 +1,16 @@
+
+#include "vkcv/tone/UnrealToneMapping.hpp"
+
+#include "unreal.glsl.hxx"
+
+namespace vkcv::tone {
+	
+	void UnrealToneMapping::initToneMapping() {
+		buildComputePipeline("unreal", UNREAL_GLSL_SHADER);
+	}
+	
+	UnrealToneMapping::UnrealToneMapping(Core &core) : ToneMapping(core, "Unreal Tone Mapping") {
+		initToneMapping();
+	}
+
+}
diff --git a/projects/fire_works/CMakeLists.txt b/projects/fire_works/CMakeLists.txt
index 7f9fd1fdd30bff0b331138821f10035f4b7dc64d..4907967793dd843a4016e9577ffb67dee1d780d4 100644
--- a/projects/fire_works/CMakeLists.txt
+++ b/projects/fire_works/CMakeLists.txt
@@ -16,6 +16,7 @@ target_include_directories(fire_works SYSTEM BEFORE PRIVATE
 		${vkcv_camera_include}
 		${vkcv_gui_include}
 		${vkcv_shader_compiler_include}
+		${vkcv_tone_mapping_include}
 		${vkcv_effects_include})
 
 # linking with libraries from all dependencies and the VkCV framework
@@ -24,4 +25,5 @@ target_link_libraries(fire_works
 		vkcv_camera
 		vkcv_gui
 		vkcv_shader_compiler
+		vkcv_tone_mapping
 		vkcv_effects)
diff --git a/projects/fire_works/shaders/tonemapping.comp b/projects/fire_works/shaders/tonemapping.comp
deleted file mode 100644
index 5e6cc8412a77939888fc8e961ea5e9ef29534a81..0000000000000000000000000000000000000000
--- a/projects/fire_works/shaders/tonemapping.comp
+++ /dev/null
@@ -1,21 +0,0 @@
-#version 440
-
-layout(set=0, binding=0, rgba16f) readonly uniform image2D inImage;
-layout(set=0, binding=1, rgba8) writeonly uniform image2D outImage;
-
-
-layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
-
-void main() {
-    if(any(greaterThanEqual(gl_GlobalInvocationID.xy, imageSize(inImage)))){
-        return;
-    }
-
-    ivec2 uv            = ivec2(gl_GlobalInvocationID.xy);
-    vec3 linearColor    = imageLoad(inImage, uv).rgb;
-
-    vec3 tonemapped     = linearColor / (dot(linearColor, vec3(0.21, 0.71, 0.08)) + 1); // reinhard tonemapping
-    vec3 gammaCorrected = pow(tonemapped, vec3(1.f / 2.2f));
-
-    imageStore(outImage, uv, vec4(gammaCorrected, 0.f));
-}
\ No newline at end of file
diff --git a/projects/fire_works/src/main.cpp b/projects/fire_works/src/main.cpp
index 2bec78711c12a221fd7e82da06af6d87ee5be0fe..aa23f74a75f4c4deab44632bdf7f7c53f543098e 100644
--- a/projects/fire_works/src/main.cpp
+++ b/projects/fire_works/src/main.cpp
@@ -8,9 +8,11 @@
 #include <vkcv/Sampler.hpp>
 
 #include <vkcv/camera/CameraManager.hpp>
-#include <vkcv/shader/GLSLCompiler.hpp>
-#include <vkcv/gui/GUI.hpp>
 #include <vkcv/effects/BloomAndFlaresEffect.hpp>
+#include <vkcv/effects/GammaCorrectionEffect.hpp>
+#include <vkcv/gui/GUI.hpp>
+#include <vkcv/shader/GLSLCompiler.hpp>
+#include <vkcv/tone/ReinhardToneMapping.hpp>
 
 struct particle_t {
 	glm::vec3 position;
@@ -910,17 +912,8 @@ int main(int argc, const char **argv) {
 		{ addDescriptorLayout, generationDescriptorLayout }
 	});
 	
-	vkcv::ShaderProgram tonemappingShader;
-	compiler.compile(vkcv::ShaderStage::COMPUTE, "shaders/tonemapping.comp", [&](vkcv::ShaderStage shaderStage, const std::filesystem::path& path) {
-		tonemappingShader.addShader(shaderStage, path);
-	});
-	
-	vkcv::DescriptorSetLayoutHandle tonemappingDescriptorLayout = core.createDescriptorSetLayout(tonemappingShader.getReflectedDescriptors().at(0));
-	vkcv::DescriptorSetHandle tonemappingDescriptor = core.createDescriptorSet(tonemappingDescriptorLayout);
-	vkcv::ComputePipelineHandle tonemappingPipe = core.createComputePipeline({
-		tonemappingShader,
-		{ tonemappingDescriptorLayout }
-	});
+	vkcv::tone::ReinhardToneMapping toneMapping (core);
+	vkcv::effects::GammaCorrectionEffect gammaCorrection (core);
 	
 	vkcv::ImageHandle swapchainImage = vkcv::ImageHandle::createSwapchainImageHandle();
 	
@@ -1273,29 +1266,8 @@ int main(int argc, const char **argv) {
 		core.recordEndDebugLabel(cmdStream);
 		
 		bloomAndFlares.recordEffect(cmdStream, colorBuffers.back(), colorBuffers.back());
-		
-		core.recordBeginDebugLabel(cmdStream, "Tonemapping", { 0.0f, 1.0f, 0.0f, 1.0f });
-		core.prepareImageForStorage(cmdStream, colorBuffers.back());
-		core.prepareImageForStorage(cmdStream, swapchainImage);
-		
-		vkcv::DescriptorWrites tonemappingDescriptorWrites;
-		tonemappingDescriptorWrites.writeStorageImage(
-			0, colorBuffers.back()
-		).writeStorageImage(
-			1, swapchainImage
-		);
-		
-		core.writeDescriptorSet(tonemappingDescriptor, tonemappingDescriptorWrites);
-		
-		core.recordComputeDispatchToCmdStream(
-			cmdStream,
-			tonemappingPipe,
-			colorDispatchCount,
-			{ vkcv::useDescriptorSet(0, tonemappingDescriptor) },
-			vkcv::PushConstants(0)
-		);
-		
-		core.recordEndDebugLabel(cmdStream);
+		toneMapping.recordToneMapping(cmdStream, colorBuffers.back(), colorBuffers.back());
+		gammaCorrection.recordEffect(cmdStream, colorBuffers.back(), swapchainImage);
 		
 		core.prepareSwapchainImageForPresent(cmdStream);
 		core.submitCommandStream(cmdStream);
@@ -1321,6 +1293,11 @@ int main(int argc, const char **argv) {
 		
 		bool colorChanged = ImGui::ColorPicker3("Color", (float*) & color);
 		
+		float gamma = gammaCorrection.getGamma();
+		if (ImGui::SliderFloat("Gamma", &gamma, 0.0f, 10.0f)) {
+			gammaCorrection.setGamma(gamma);
+		}
+		
 		ImGui::End();
 		gui.endGUI();