Abstracting Render Graph

Resources/Shaders/base.vert

@@ -0,0 +1,6 @@
+#version 460
+
+void main()
+{
+    gl_Position = vec4(vec3(0), 0.0f);
+}

Resources/Shaders/composite.frag

@@ -0,0 +1,14 @@
+#version 460
+
+layout(location = 0) in vec2 outUV;
+
+layout(set = 0, binding = 0) uniform texture2D sharedRTAsTex;
+layout(set = 1, binding = 1) uniform sampler LinearWrapSampler;
+
+layout(location = 0) out vec4 outColor;
+
+void main()
+{
+    vec4 color = texture(sampler2D(sharedRTAsTex, LinearWrapSampler), outUV);
+    outColor   = color;
+}

Resources/Shaders/composite.vert

@@ -0,0 +1,9 @@
+#version 460
+
+layout(location = 0) out vec2 outUV;
+
+void main()
+{
+    outUV       = vec2((gl_VertexIndex << 1) & 2, gl_VertexIndex & 2);
+    gl_Position = vec4(outUV * 2.0f - 1.0f, 0.0f, 1.0f);
+}

Resources/Shaders/infinite_grid.frag

@@ -8,21 +8,24 @@ layout(location = 1) in float scaleFactor;
 layout(location = 0) out vec4 outColor;
 
 float       gridCellSize              = 0.025;
-
 vec4        gridColorThin             = vec4(1.0, 1.0, 1.0, 1.0);
 vec4        gridColorThick            = vec4(0.5, 0.5, 0.5, 1.0);
 const float gridMinPixelsBetweenCells = 2.0;
 
 void        main()
 {
-    vec2  dudv            = vec2(length(vec2(dFdx(uv.x), dFdy(uv.x))), length(vec2(dFdx(uv.y), dFdy(uv.y))));
+    vec2 dudv             = vec2(length(vec2(dFdx(uv.x), dFdy(uv.x))), length(vec2(dFdx(uv.y), dFdy(uv.y))));
+    dudv                  = max(dudv, vec2(0.0001));
 
     float lodLevel        = max(0.0, log_10((length(dudv) * gridMinPixelsBetweenCells) / gridCellSize) + 1.0);
-    float lodFade         = fract(lodLevel);
+    lodLevel              = min(lodLevel, 2.0);
+
+    // Smooth fade between LOD levels to kill flickering
+    float lodFade         = smoothstep(0.0, 1.0, fract(lodLevel));
 
-    float lod0            = gridCellSize * pow(10.0, floor(lodLevel + 0));
-    float lod1            = gridCellSize * pow(10.0, floor(lodLevel + 1));
-    float lod2            = gridCellSize * pow(10.0, floor(lodLevel + 2));
+    float lod0            = gridCellSize * pow(10.0, floor(lodLevel));
+    float lod1            = gridCellSize * pow(10.0, floor(lodLevel + 1.0));
+    float lod2            = gridCellSize * pow(10.0, floor(lodLevel + 2.0));
 
     dudv                 *= 4.0;
 
@@ -31,8 +34,17 @@ void        main()
     float lod2a           = max2(vec2(1.0) - abs(satv(mod(uv, lod2) / dudv) * 2.0 - vec2(1.0)));
 
     vec4  c               = lod2a > 0.0 ? gridColorThick : lod1a > 0.0 ? mix(gridColorThick, gridColorThin, lodFade) : gridColorThin;
-    float opacityFalloff  = (1.0 - satf(length(uv) / scaleFactor));
-    c.a                  *= lod2a > 0.0 ? lod2a : lod1a > 0.0 ? lod1a : (lod0a * (1.0 - lodFade));
+
+    // Fade based on distance from camera, using actual world-space diagonal
+    float maxDist         = scaleFactor * 1.5; // covers the quad diagonal
+    float opacityFalloff  = pow(1.0 - satf(length(uv) / maxDist), 0.5);
+
+    c.a                   = lod2a > 0.0 ? lod2a : lod1a > 0.0 ? lod1a : (lod0a * (1.0 - lodFade));
     c.a                  *= opacityFalloff;
-    outColor              = c;
-}
+
+    // Discard fully transparent fragments to avoid depth artifacts
+    if (c.a < 0.001)
+        discard;
+
+    outColor = c;
+}

Resources/Shaders/infinite_grid.vert

@@ -13,9 +13,9 @@ Camera;
 
 void main()
 {
-    scaleFactor   = 50.0;
+    scaleFactor   = 1000.0f;
+    vec3 worldPos = pos + vec3(Camera.Position.x, 0.0, Camera.Position.z);
 
-    vec3 posScale = pos * scaleFactor;
-    uv            = posScale.xz;
-    gl_Position   = Camera.Projection * Camera.View * vec4(posScale, 1.0);
-}
+    uv            = worldPos.xz;
+    gl_Position   = Camera.Projection * Camera.View * vec4(worldPos, 1.0);
+}

Resources/Shaders/skybox.frag

@@ -3,9 +3,9 @@ layout(location = 0) in vec3 dir;
 layout(location = 0) out vec4 outColor;
 
 layout(set = 0, binding = 1) uniform textureCube EnvMap;
-layout(set = 1, binding = 1) uniform sampler LinearWrapSampler;
+layout(set = 0, binding = 2) uniform sampler LinearClampToEdgeSampler;
 
 void main()
 {
-    outColor = texture(samplerCube(EnvMap, LinearWrapSampler), dir);
-}
+    outColor = texture(samplerCube(EnvMap, LinearClampToEdgeSampler), normalize(dir));
+}

Resources/Shaders/skybox.vert

@@ -12,8 +12,10 @@ Camera;
 
 void main()
 {
-    dir               = normalize(vec3(pos.x, -pos.y, pos.z));
+    dir               = pos; // normalize(vec3(pos.x, -pos.y, pos.z));
     mat4 rotScaleView = mat4(mat3(Camera.View));
-    vec4 position     = Camera.Projection * rotScaleView * vec4(pos, 1.0f);
+
+    vec4 position     = Camera.Projection * rotScaleView * vec4(pos * 10.0f, 1.0f);
+
     gl_Position       = position.xyww;
 }

Tetragrama/Components/HierarchyViewUIComponent.cpp

@@ -223,8 +223,8 @@ namespace Tetragrama::Components
         if (app->CameraController)
         {
             auto       camera             = app->CameraController->GetCamera();
-            const auto camera_projection  = camera->GetPerspectiveMatrix();
-            const auto camera_view_matrix = camera->GetViewMatrix();
+            const auto camera_projection  = camera->GetProjection();
+            const auto camera_view_matrix = camera->GetView();
 
             auto&      global_transform   = current_scene->GlobalTransforms[selected_node];
             auto       initial_transform  = global_transform;
@@ -233,7 +233,7 @@ namespace Tetragrama::Components
             if (camera && IDevice::As<Keyboard>()->IsKeyPressed(ZENGINE_KEY_F, app->CurrentWindow))
             {
                 auto active_editor_camera = reinterpret_cast<Controllers::EditorCameraControllerPtr>(app->CameraController);
-                active_editor_camera->SetTarget(Vec3f(global_transform[0][3], global_transform[1][3], global_transform[2][3]));
+                // active_editor_camera->SetFocus(Vec3f(global_transform[0][3], global_transform[1][3], global_transform[2][3]));
             }
 
             // snapping

Tetragrama/Components/SceneViewportUIComponent.cpp

@@ -104,7 +104,7 @@ namespace Tetragrama::Components
 
         if (m_scene_texture.Valid())
         {
-            ImGui::Image((ImTextureID) m_scene_texture.Index, m_viewport_size, ImVec2(0, 1), ImVec2(1, 0));
+            ImGui::Image((ImTextureID) m_scene_texture.Index, m_viewport_size, ImVec2(0, 0), ImVec2(1, 1));
         }
         // ViewPort bound computation
         ImVec2 viewport_windows_size  = ImGui::GetWindowSize();

Tetragrama/Controllers/EditorCameraController.cpp

@@ -7,17 +7,12 @@ using namespace ZEngine::Core::Maths;
 
 namespace Tetragrama::Controllers
 {
-    void EditorCameraController::Initialize(ZEngine::Core::Memory::ArenaAllocator* arena, ZEngine::Windows::CoreWindow* window, double distance, float yaw_degree, float pitch_degree)
+    void EditorCameraController::Initialize(ZEngine::Core::Memory::ArenaAllocator* arena, ZEngine::Windows::CoreWindow* window)
     {
-        m_position           = {0.0f, 0.0f, 1.5f};
-        m_process_event      = true;
-        m_controller_type    = ZEngine::Controllers::CameraControllerType::PERSPECTIVE_CONTROLLER;
-        m_window             = window;
+        m_window              = window;
+        m_controller_type     = ZEngine::Controllers::CameraControllerType::PERSPECTIVE_CONTROLLER;
 
-        m_perspective_camera = ZPushStructCtor(arena, PerspectiveCamera);
-        m_perspective_camera->Initialize(m_camera_fov, m_aspect_ratio, m_camera_near, m_camera_far, radians(yaw_degree), radians(pitch_degree));
-        m_perspective_camera->SetDistance(distance);
-
-        m_window = window;
+        const auto& win_props = m_window->GetWindowProperty();
+        m_camera              = ZPushStructCtorArgs(arena, FlyCamera, win_props.AspectRatio);
     }
 } // namespace Tetragrama::Controllers

Tetragrama/Controllers/EditorCameraController.h

@@ -1,14 +1,14 @@
 #pragma once
-#include <ZEngine/Controllers/PerspectiveCameraController.h>
+#include <ZEngine/Controllers/FlyCameraController.h>
 
 namespace Tetragrama::Controllers
 {
-    struct EditorCameraController : public ZEngine::Controllers::PerspectiveCameraController
+    struct EditorCameraController : public ZEngine::Controllers::FlyCameraController
     {
         EditorCameraController()          = default;
         virtual ~EditorCameraController() = default;
 
-        void Initialize(ZEngine::Core::Memory::ArenaAllocator* arena, ZEngine::Windows::CoreWindow* window, double distance, float yaw_degree, float pitch_degree);
+        void Initialize(ZEngine::Core::Memory::ArenaAllocator* arena, ZEngine::Windows::CoreWindow* window);
     };
     ZDEFINE_PTR(EditorCameraController);
 } // namespace Tetragrama::Controllers

Tetragrama/Editor.cpp

@@ -47,7 +47,7 @@ namespace Tetragrama
         UILayer                    = ZPushStructCtor(Arena, ImguiLayer);
 
         UILayer->Initialize(Arena, this);
-        editor_cam_controller->Initialize(Arena, CurrentWindow, 150.0, 0.f, 45.f);
+        editor_cam_controller->Initialize(Arena, CurrentWindow);
         editor_scene->Initialize(Arena, Configuration->ActiveSceneName.c_str());
 
         CameraController = editor_cam_controller;

ZEngine/ZEngine/Controllers/FlyCameraController.cpp

@@ -0,0 +1,101 @@
+#include <Controllers/FlyCameraController.h>
+#include <Inputs/KeyCodeDefinition.h>
+#include <Inputs/Keyboard.h>
+#include <Inputs/Mouse.h>
+
+using namespace ZEngine::Helpers;
+using namespace ZEngine::Windows::Inputs;
+using namespace ZEngine::Windows::Events;
+
+namespace ZEngine::Controllers
+{
+    void FlyCameraController::Update(Core::TimeStep dt)
+    {
+        m_camera->OnUpdate(dt);
+    }
+
+    bool FlyCameraController::OnEvent(Core::CoreEvent& e)
+    {
+        if (!m_process_event.value.load(std::memory_order_acquire))
+        {
+            return false;
+        }
+
+        Core::EventDispatcher dispatcher(e);
+        dispatcher.Dispatch<MouseButtonWheelEvent>(std::bind(&FlyCameraController::OnMouseButtonWheelMoved, this, std::placeholders::_1));
+        dispatcher.Dispatch<MouseButtonReleasedEvent>(std::bind(&FlyCameraController::OnMouseButtonReleased, this, std::placeholders::_1));
+        dispatcher.Dispatch<MouseButtonPressedEvent>(std::bind(&FlyCameraController::OnMouseButtonPressed, this, std::placeholders::_1));
+        dispatcher.Dispatch<MouseButtonMovedEvent>(std::bind(&FlyCameraController::OnMouseButtonMoved, this, std::placeholders::_1));
+
+        dispatcher.Dispatch<KeyPressedEvent>(std::bind(&FlyCameraController::OnKeyPressed, this, std::placeholders::_1));
+        dispatcher.Dispatch<KeyReleasedEvent>(std::bind(&FlyCameraController::OnKeyReleased, this, std::placeholders::_1));
+        return false;
+    }
+
+    Rendering::Cameras::CameraPtr FlyCameraController::GetCamera() const
+    {
+        return m_camera;
+    }
+
+    Core::Maths::Vec3f FlyCameraController::GetPosition() const
+    {
+        return m_camera->GetPosition();
+    }
+
+    void FlyCameraController::SetPosition(const Core::Maths::Vec3f& position)
+    {
+        m_camera->SetPosition(position);
+    }
+
+    void FlyCameraController::SetViewport(float width, float height)
+    {
+        m_camera->SetViewportSize(width, height);
+    }
+
+    bool FlyCameraController::OnMouseButtonReleased(MouseButtonReleasedEvent& e)
+    {
+        m_camera->OnMouseButtonUp((int) e.GetButton());
+        return false;
+    }
+
+    bool FlyCameraController::OnMouseButtonPressed(MouseButtonPressedEvent& e)
+    {
+        m_camera->OnMouseButtonDown((int) e.GetButton());
+        return false;
+    }
+
+    bool FlyCameraController::OnMouseButtonWheelMoved(MouseButtonWheelEvent& e)
+    {
+        const auto mouse_position = IDevice::As<Mouse>()->GetMousePosition(m_window);
+        m_camera->OnMouseScroll(e.GetOffetY(), mouse_position[0], mouse_position[1]);
+        return false;
+    }
+
+    bool FlyCameraController::OnMouseButtonMoved(MouseButtonMovedEvent& e)
+    {
+        m_camera->OnMouseMove(e.GetXOffset(), e.GetYOffset());
+        return false;
+    }
+
+    bool FlyCameraController::OnKeyPressed(KeyPressedEvent& e)
+    {
+        m_camera->OnKeyDown((int) e.GetKeyCode());
+        return false;
+    }
+
+    bool FlyCameraController::OnKeyReleased(KeyReleasedEvent& e)
+    {
+        m_camera->OnKeyUp((int) e.GetKeyCode());
+        return false;
+    }
+
+    void FlyCameraController::ResumeEventProcessing()
+    {
+        m_process_event.value.store(true, std::memory_order_release);
+    }
+
+    void FlyCameraController::PauseEventProcessing()
+    {
+        m_process_event.value.store(false, std::memory_order_release);
+    }
+} // namespace ZEngine::Controllers

ZEngine/ZEngine/Controllers/FlyCameraController.h

@@ -0,0 +1,36 @@
+#pragma once
+#include <Controllers/ICameraController.h>
+#include <Core/Memory/Allocator.h>
+#include <Rendering/Cameras/FlyCamera.h>
+
+namespace ZEngine::Controllers
+{
+    struct FlyCameraController : public ICameraController, public Windows::Inputs::IMouseEventCallback, public Windows::Inputs::IKeyboardEventCallback
+    {
+        FlyCameraController()          = default;
+        virtual ~FlyCameraController() = default;
+
+        void                          Update(Core::TimeStep) override;
+        bool                          OnEvent(Core::CoreEvent&) override;
+
+        Rendering::Cameras::CameraPtr GetCamera() const override;
+        virtual Core::Maths::Vec3f    GetPosition() const override;
+        virtual void                  SetPosition(const Core::Maths::Vec3f& position) override;
+
+        void                          SetViewport(float width, float height);
+        void                          ResumeEventProcessing();
+        void                          PauseEventProcessing();
+
+        virtual bool                  OnMouseButtonPressed(Windows::Events::MouseButtonPressedEvent&) override;
+        virtual bool                  OnMouseButtonReleased(Windows::Events::MouseButtonReleasedEvent&) override;
+        virtual bool                  OnMouseButtonMoved(Windows::Events::MouseButtonMovedEvent&) override;
+        virtual bool                  OnMouseButtonWheelMoved(Windows::Events::MouseButtonWheelEvent&) override;
+
+        virtual bool                  OnKeyPressed(Windows::Events::KeyPressedEvent&) override;
+        virtual bool                  OnKeyReleased(Windows::Events::KeyReleasedEvent&) override;
+
+    protected:
+        PaddedAtomic<bool>               m_process_event = {.value = false};
+        Rendering::Cameras::FlyCameraPtr m_camera        = nullptr;
+    };
+} // namespace ZEngine::Controllers