Screen space reflection with hierarchical ray tracer

README.md

@@ -7,7 +7,7 @@
 <!-- soon! [![Documentation](https://codedocs.xyz/MomoDeve/MxEngine.svg)](https://codedocs.xyz/MomoDeve/MxEngine/) -->
 
 MxEngine is an educational modern-C++ general-purpose 3D game engine. 
-Right now MxEngine is developed only by me, [#Momo](https://github.com/MomoDeve), but any contributions are welcome and will be reviewed.
+Right now MxEngine is developed only by me, [#Momo](https://github.com/MomoDeve) and [#Lucas](https://github.com/fall2019) contributing some features from time to time. Any contributions are welcome and will be reviewed.
 Fow now MxEngine supports OpenGL as graphic API and targets x64 only. I develop the project in my free time, so updates may be not so frequent!
 
 ***Note:** MxEngine is currently being ported to new Vulkan rendering backend. Development progress of the rendering library can be found here: [VulkanAbstractionLayer](https://github.com/asc-community/VulkanAbstractionLayer)*
@@ -292,9 +292,8 @@ If you are interesed in libraries MxEngine depend on, consider reading [dependen
 <i>shadow casting from dynamic lights, screen-space reflections</i>
 </p>
 
-## Special thanks
-#### God Ray Effect by [#Fall2019](https://github.com/fall2019)
 <img src="preview_images/readme_god_ray.PNG">
+<i>god ray effect</i>
 </p>
 
 ## Projects based on MxEngine

src/Core/Components/Camera/CameraController.cpp

@@ -27,6 +27,7 @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "CameraController.h"
+#include "Utilities/Format/Format.h"
 #include "Core/Events/WindowResizeEvent.h"
 #include "Core/Config/GlobalConfig.h"
 #include "Core/Application/Event.h"
@@ -35,6 +36,7 @@
 #include "PerspectiveCamera.h"
 #include "FrustrumCamera.h"
 #include "Core/Runtime/Reflection.h"
+#include "fmt/format.h"
 
 namespace MxEngine
 {
@@ -425,11 +427,21 @@ namespace MxEngine
         return this->renderBuffers->Material;
     }
 
+    TextureHandle CameraController::GetSSRMask()const
+    {
+        return this->renderBuffers->SSRMask;
+    }
+
     TextureHandle CameraController::GetDepthTexture() const
     {
         return this->renderBuffers->Depth;
     }
 
+    const MxVector<TextureHandle>&  CameraController::GetHiZ() const
+    {
+        return this->renderBuffers->HiZ;
+    }
+
     TextureHandle CameraController::GetAverageWhiteTexture() const
     {
         return this->renderBuffers->AverageWhite;
@@ -456,23 +468,27 @@ namespace MxEngine
         this->Albedo = Factory<Texture>::Create();
         this->Normal = Factory<Texture>::Create();
         this->Material = Factory<Texture>::Create();
+        this->SSRMask = Factory<Texture>::Create();
         this->Depth = Factory<Texture>::Create();
         this->AverageWhite = Factory<Texture>::Create();
         this->HDR = Factory<Texture>::Create();
         this->SwapHDR1 = Factory<Texture>::Create();
         this->SwapHDR2 = Factory<Texture>::Create();
+        for (int i = 0; i < 4; i++)  HiZ.emplace_back(Factory<Texture>::Create());
 
         this->Resize(width, height);
 
         this->GBuffer->AttachTexture(this->Albedo, Attachment::COLOR_ATTACHMENT0);
         this->GBuffer->AttachTextureExtra(this->Normal, Attachment::COLOR_ATTACHMENT1);
         this->GBuffer->AttachTextureExtra(this->Material, Attachment::COLOR_ATTACHMENT2);
+        this->GBuffer->AttachTextureExtra(this->SSRMask, Attachment::COLOR_ATTACHMENT3);
         this->GBuffer->AttachTextureExtra(this->Depth, Attachment::DEPTH_ATTACHMENT);
 
         std::array attachments = {
             Attachment::COLOR_ATTACHMENT0,
             Attachment::COLOR_ATTACHMENT1,
             Attachment::COLOR_ATTACHMENT2,
+            Attachment::COLOR_ATTACHMENT3
         };
         this->GBuffer->UseDrawBuffers(attachments);
         this->GBuffer->Validate();
@@ -493,10 +509,23 @@ namespace MxEngine
         this->Material->SetInternalEngineTag(MXENGINE_MAKE_INTERNAL_TAG("camera material"));
         this->Material->SetWrapType(TextureWrap::CLAMP_TO_EDGE);
 
+        this->SSRMask->Load(nullptr, width, height, 1, false, TextureFormat::R32F);
+        this->SSRMask->SetInternalEngineTag(MXENGINE_MAKE_INTERNAL_TAG("ssr mask"));
+        this->SSRMask->SetWrapType(TextureWrap::CLAMP_TO_EDGE);
+
         this->Depth->LoadDepth(width, height, TextureFormat::DEPTH32F);
         this->Depth->SetInternalEngineTag(MXENGINE_MAKE_INTERNAL_TAG("camera depth"));
         this->Depth->SetWrapType(TextureWrap::CLAMP_TO_EDGE);
 
+        for (int i = 0; i < this->HiZ.size(); i++) 
+        {
+            int scale = pow(2, i+1);
+            MxString tag = MxFormat("!camera depth lv{}", i + 1);
+            this->HiZ[i]->Load(nullptr, width / scale, height / scale, 1, false, TextureFormat::R32F);
+            this->HiZ[i]->SetInternalEngineTag(tag);
+            this->HiZ[i]->SetWrapType(TextureWrap::CLAMP_TO_EDGE);
+        }
+
         this->AverageWhite->Load(nullptr, 1, 1, 3, false, TextureFormat::RGBA16F);
         this->AverageWhite->SetInternalEngineTag(MXENGINE_MAKE_INTERNAL_TAG("camera white"));
         this->AverageWhite->SetWrapType(TextureWrap::CLAMP_TO_EDGE);
@@ -520,10 +549,12 @@ namespace MxEngine
         Factory<Texture>::Destroy(this->Albedo);
         Factory<Texture>::Destroy(this->Normal);
         Factory<Texture>::Destroy(this->Material);
+        Factory<Texture>::Destroy(this->SSRMask);
         Factory<Texture>::Destroy(this->Depth);
         Factory<Texture>::Destroy(this->HDR);
         Factory<Texture>::Destroy(this->SwapHDR1);
         Factory<Texture>::Destroy(this->SwapHDR2);
+        for(auto& it:this->HiZ)Factory<Texture>::Destroy(it);
     }
 
     MXENGINE_REFLECT_TYPE

src/Core/Components/Camera/CameraController.h

@@ -49,6 +49,8 @@ namespace MxEngine
         TextureHandle Normal;
         TextureHandle Material;
         TextureHandle Depth;
+        TextureHandle SSRMask;
+        MxVector<TextureHandle> HiZ;
         TextureHandle AverageWhite;
         TextureHandle HDR;
         TextureHandle SwapHDR1;
@@ -130,7 +132,9 @@ namespace MxEngine
         TextureHandle GetAlbedoTexture() const;
         TextureHandle GetNormalTexture() const;
         TextureHandle GetMaterialTexture() const;
+        TextureHandle GetSSRMask()const;
         TextureHandle GetDepthTexture() const;
+        const MxVector<TextureHandle>& GetHiZ() const;
         TextureHandle GetAverageWhiteTexture() const;
         TextureHandle GetHDRTexture() const;
         TextureHandle GetSwapHDRTexture1() const;

src/Core/Components/Camera/CameraSSR.cpp

@@ -37,31 +37,21 @@ namespace MxEngine
         return this->thickness;
     }
 
-    size_t CameraSSR::GetSteps() const
-    {
-        return this->steps;
-    }
-
-    float CameraSSR::GetStartDistance() const
-    {
-        return this->startDistance;
-    }
-
     void CameraSSR::SetThickness(float thickness)
     {
         this->thickness = Max(thickness, 0.0f);
     }
 
-    void CameraSSR::SetSteps(size_t steps)
+    int CameraSSR::GetMaxLevel() const
     {
-        this->steps = steps;
+        return this->maxLevel;
     }
 
-    void CameraSSR::SetStartDistance(float distance)
+    void CameraSSR::SetMaxLevel(int level) 
     {
-        this->startDistance = Max(distance, 0.0f);
+        this->maxLevel = level;
     }
-
+    
     MXENGINE_REFLECT_TYPE
     {
         rttr::registration::class_<CameraSSR>("CameraSSR")
@@ -72,20 +62,14 @@ namespace MxEngine
             .property("thickness", &CameraSSR::GetThickness, &CameraSSR::SetThickness)
             (
                 rttr::metadata(MetaInfo::FLAGS, MetaInfo::SERIALIZABLE | MetaInfo::EDITABLE),
-                rttr::metadata(EditorInfo::EDIT_RANGE, Range { 0.0f, 10000.0f }),
+                rttr::metadata(EditorInfo::EDIT_RANGE, Range { 1.0f, 100.0f }),
                 rttr::metadata(EditorInfo::EDIT_PRECISION, 0.01f)
             )
-            .property("steps", &CameraSSR::GetSteps, &CameraSSR::SetSteps)
+            .property("max level", &CameraSSR::GetMaxLevel, &CameraSSR::SetMaxLevel)
             (
                 rttr::metadata(MetaInfo::FLAGS, MetaInfo::SERIALIZABLE | MetaInfo::EDITABLE),
-                rttr::metadata(EditorInfo::EDIT_RANGE, Range { 0.0f, 128.0f }),
-                rttr::metadata(EditorInfo::EDIT_PRECISION, 0.1f)
-            )
-            .property("start distance", &CameraSSR::GetStartDistance, &CameraSSR::SetStartDistance)
-            (
-                rttr::metadata(MetaInfo::FLAGS, MetaInfo::SERIALIZABLE | MetaInfo::EDITABLE),
-                rttr::metadata(EditorInfo::EDIT_RANGE, Range { 0.0f, 10000000.0f }),
-                rttr::metadata(EditorInfo::EDIT_PRECISION, 0.01f)
+                rttr::metadata(EditorInfo::EDIT_RANGE, Range { 1, 4 }),
+                rttr::metadata(EditorInfo::EDIT_PRECISION, 1)
             );
     }
 }

src/Core/Components/Camera/CameraSSR.h

@@ -37,17 +37,16 @@ namespace MxEngine
         MAKE_COMPONENT(CameraSSR);
 
         float thickness = 0.5f;
-        size_t steps = 10;
-        float startDistance = 2.0f;
+        float maxLevel = 2.0f;
+
     public:
         CameraSSR() = default;
 
         float GetThickness() const;
-        size_t GetSteps() const;
-        float GetStartDistance() const;
+        int GetMaxLevel()const;
 
         void SetThickness(float thickness);
-        void SetSteps(size_t steps);
-        void SetStartDistance(float distance);
+        void SetMaxLevel(int level);
+
     };
 }

src/Core/Rendering/RenderAdaptor.cpp

@@ -143,6 +143,11 @@ namespace MxEngine
             shaderFolder / "gbuffer_fragment.glsl"
         );
 
+        environment.Shaders["HIZ"_id] = AssetManager::LoadShader(
+            shaderFolder / "rect_vertex.glsl",
+            shaderFolder / "hierarchical_depth_buffer_generator.glsl"
+        );
+
         environment.Shaders["GBufferMask"_id] = AssetManager::LoadShader(
             shaderFolder / "gbuffer_vertex.glsl",
             shaderFolder / "gbuffer_mask_fragment.glsl"