Add Decal rendering

Source/Game-Lib/Game-Lib/ECS/Components/AABB.h

@@ -16,4 +16,6 @@ namespace ECS::Components
         vec3 min;
         vec3 max;
     };
+
+    struct DirtyAABB {};
 }

Source/Game-Lib/Game-Lib/ECS/Components/Decal.h

@@ -0,0 +1,18 @@
+#pragma once
+#include <Base/Types.h>
+#include <Base/Math/Color.h>
+
+namespace ECS::Components
+{
+    struct Decal
+    {
+        std::string texturePath;
+        Color colorMultiplier = Color::White;
+        hvec2 thresholdMinMax = hvec2(0.0f, 1.0f);
+        hvec2 minUV = hvec2(0.0f, 0.0f);
+        hvec2 maxUV = hvec2(1.0f, 1.0f);
+        u32 flags = 0; // DecalFlags
+    };
+
+    struct DirtyDecal {};
+}

Source/Game-Lib/Game-Lib/ECS/Systems/CalculateCameraMatrices.cpp

@@ -83,8 +83,6 @@ namespace ECS::Systems
 
                 if (CVAR_CameraLockCullingFrustum.Get() == 0)
                 {
-                    mat4x4 m = glm::transpose(camera.worldToClip);
-
                     glm::vec3 Front = glm::vec3(0, 0, 1);
                     glm::vec3 Right = glm::vec3(1, 0, 0);
                     glm::vec3 Up = glm::vec3(0, 1, 0);

Source/Game-Lib/Game-Lib/ECS/Systems/UpdateAABBs.cpp

@@ -8,42 +8,55 @@
 
 namespace ECS::Systems
 {
+    void UpdateWorldAABB(const Components::Transform& transform, const Components::AABB& aabb, Components::WorldAABB& worldAABB)
+    {
+        // Calculate the world AABB
+        glm::vec3 min = aabb.centerPos - aabb.extents;
+        glm::vec3 max = aabb.centerPos + aabb.extents;
+
+        glm::vec3 corners[8] = {
+            glm::vec3(min.x, min.y, min.z),
+            glm::vec3(min.x, min.y, max.z),
+            glm::vec3(min.x, max.y, min.z),
+            glm::vec3(min.x, max.y, max.z),
+            glm::vec3(max.x, min.y, min.z),
+            glm::vec3(max.x, min.y, max.z),
+            glm::vec3(max.x, max.y, min.z),
+            glm::vec3(max.x, max.y, max.z)
+        };
+
+        const mat4x4 transformMatrix = transform.GetMatrix();
+        for (i32 i = 0; i < 8; ++i)
+        {
+            corners[i] = transformMatrix * glm::vec4(corners[i], 1.0f);
+        }
+
+        worldAABB.min = vec3(1000000000.0f);
+        worldAABB.max = vec3(-1000000000.0f);
+
+        for (i32 i = 1; i < 8; ++i)
+        {
+            worldAABB.min = glm::min(worldAABB.min, corners[i]);
+            worldAABB.max = glm::max(worldAABB.max, corners[i]);
+        }
+    }
+
     void UpdateAABBs::Update(entt::registry& registry, f32 deltaTime)
     {
         ZoneScopedN("ECS::UpdateAABBs");
 
-        auto view = registry.view<Components::Transform, Components::AABB, Components::WorldAABB, Components::DirtyTransform>();
-        view.each([&](entt::entity entity, Components::Transform& transform, Components::AABB& aabb, Components::WorldAABB& worldAABB, ECS::Components::DirtyTransform& dirtyTransform)
+        // Update AABBs for entities with dirty transforms
+        auto dirtyTransformView = registry.view<Components::Transform, Components::AABB, Components::WorldAABB, Components::DirtyTransform>();
+        dirtyTransformView.each([&](entt::entity entity, Components::Transform& transform, Components::AABB& aabb, Components::WorldAABB& worldAABB, ECS::Components::DirtyTransform& dirtyTransform)
+        {
+            UpdateWorldAABB(transform, aabb, worldAABB);
+        });
+
+        // Update AABBs for entities with dirty AABBs
+        auto dirtyAABBView = registry.view<Components::Transform, Components::AABB, Components::WorldAABB, Components::DirtyAABB>();
+        dirtyAABBView.each([&](entt::entity entity, Components::Transform& transform, Components::AABB& aabb, Components::WorldAABB& worldAABB)
         {
-            // Calculate the world AABB
-            glm::vec3 min = aabb.centerPos - aabb.extents;
-            glm::vec3 max = aabb.centerPos + aabb.extents;
-
-            glm::vec3 corners[8] = {
-                glm::vec3(min.x, min.y, min.z),
-                glm::vec3(min.x, min.y, max.z),
-                glm::vec3(min.x, max.y, min.z),
-                glm::vec3(min.x, max.y, max.z),
-                glm::vec3(max.x, min.y, min.z),
-                glm::vec3(max.x, min.y, max.z),
-                glm::vec3(max.x, max.y, min.z),
-                glm::vec3(max.x, max.y, max.z)
-            };
-
-            const mat4x4 transformMatrix = transform.GetMatrix();
-            for (i32 i = 0; i < 8; ++i)
-            {
-                corners[i] = transformMatrix * glm::vec4(corners[i], 1.0f);
-            }
-
-            worldAABB.min = vec3(1000000000.0f);
-            worldAABB.max = vec3(-1000000000.0f);
-
-            for (i32 i = 1; i < 8; ++i)
-            {
-                worldAABB.min = glm::min(worldAABB.min, corners[i]);
-                worldAABB.max = glm::max(worldAABB.max, corners[i]);
-            }
+            UpdateWorldAABB(transform, aabb, worldAABB);
         });
     }
 }

Source/Game-Lib/Game-Lib/Editor/Inspector.cpp

@@ -1,20 +1,12 @@
 #include "Inspector.h"
 
-#include <Game-Lib/Util/ServiceLocator.h>
-#include <Game-Lib/Util/ImguiUtil.h>
 #include <Game-Lib/Application/EnttRegistries.h>
-#include <Game-Lib/Rendering/GameRenderer.h>
-#include <Game-Lib/Rendering/Terrain/TerrainRenderer.h>
-#include <Game-Lib/Rendering/Model/ModelLoader.h>
-#include <Game-Lib/Rendering/Model/ModelRenderer.h>
-#include <Game-Lib/Rendering/Debug/DebugRenderer.h>
-#include <Game-Lib/Rendering/PixelQuery.h>
-#include <Game-Lib/Rendering/Camera.h>
 #include <Game-Lib/ECS/Singletons/ActiveCamera.h>
 #include <Game-Lib/ECS/Singletons/FreeflyingCameraSettings.h>
 #include <Game-Lib/ECS/Singletons/RenderState.h>
 #include <Game-Lib/ECS/Singletons/Database/TextureSingleton.h>
 #include <Game-Lib/ECS/Components/Camera.h>
+#include <Game-Lib/ECS/Components/Decal.h>
 #include <Game-Lib/ECS/Components/Model.h>
 #include <Game-Lib/ECS/Components/Name.h>
 #include <Game-Lib/ECS/Components/Unit.h>
@@ -23,6 +15,15 @@
 #include <Game-Lib/Editor/ActionStack.h>
 #include <Game-Lib/Editor/Hierarchy.h>
 #include <Game-Lib/Editor/Viewport.h>
+#include <Game-Lib/Rendering/GameRenderer.h>
+#include <Game-Lib/Rendering/Terrain/TerrainRenderer.h>
+#include <Game-Lib/Rendering/Model/ModelLoader.h>
+#include <Game-Lib/Rendering/Model/ModelRenderer.h>
+#include <Game-Lib/Rendering/Debug/DebugRenderer.h>
+#include <Game-Lib/Rendering/PixelQuery.h>
+#include <Game-Lib/Rendering/Camera.h>
+#include <Game-Lib/Util/ServiceLocator.h>
+#include <Game-Lib/Util/ImguiUtil.h>
 
 #include <Renderer/RenderSettings.h>
 
@@ -322,8 +323,12 @@ namespace Editor
 
         InspectEntityTransform(entity);
 
+        InspectEntityAABB(entity);
+
         InspectEntityModel(entity);
 
+        InspectEntityDecal(entity);
+
         if (ECS::Components::Unit* unit = registry->try_get<ECS::Components::Unit>(entity))
         {
             ImGui::Text("Body ID: %d", unit->bodyID);
@@ -521,6 +526,119 @@ namespace Editor
         ImGui::PopStyleColor();
     }
 
+    void Inspector::InspectEntityAABB(entt::entity entity)
+    {
+        entt::registry* registry = ServiceLocator::GetEnttRegistries()->gameRegistry;
+
+        ECS::Components::AABB* aabb = registry->try_get<ECS::Components::AABB>(entity);
+
+        ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(0.4f, 0.4f, 0.4f, 1.0f));
+
+        if (aabb)
+        {
+            if (Util::Imgui::BeginGroupPanel("AABB"))
+            {
+                bool isDirty = false;
+
+                // Center Pos
+                vec3 centerPos = aabb->centerPos;
+                if (ImGui::DragFloat3("center pos", &centerPos.x))
+                {
+                    aabb->centerPos = centerPos;
+                    isDirty = true;
+                }
+
+                // Extents
+                vec3 extents = aabb->extents;
+                if (ImGui::DragFloat3("extents", &extents.x))
+                {
+                    aabb->extents = extents;
+                    isDirty = true;
+                }
+
+                if (isDirty)
+                {
+                    registry->emplace_or_replace<ECS::Components::DirtyAABB>(entity);
+                }
+            }
+            Util::Imgui::EndGroupPanel();
+        }
+        ImGui::PopStyleColor();
+    }
+
+    void Inspector::InspectEntityDecal(entt::entity entity)
+    {
+        entt::registry* registry = ServiceLocator::GetEnttRegistries()->gameRegistry;
+
+        ECS::Components::Decal* decal = registry->try_get<ECS::Components::Decal>(entity);
+
+        ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(0.4f, 0.4f, 0.4f, 1.0f));
+
+        if (decal)
+        {
+            if (Util::Imgui::BeginGroupPanel("Decal"))
+            {
+                bool isDirty = false;
+
+                std::string texturePath = decal->texturePath;
+                if (ImGui::InputText("Texture Path", &texturePath))
+                {
+                    decal->texturePath = texturePath;
+                    isDirty = true;
+                }
+
+                Color color = decal->colorMultiplier;
+                if (ImGui::ColorEdit3("Color Multiplier", &color.r))
+                {
+                    decal->colorMultiplier = color;
+                    isDirty = true;
+                }
+
+                f32 thresholdMin = f32(decal->thresholdMinMax.x);
+                if (ImGui::SliderFloat("Threshold Min", &thresholdMin, -1.0f, 1.0f))
+                {
+                    decal->thresholdMinMax.x = f16(thresholdMin);
+                    isDirty = true;
+                }
+
+                f32 thresholdMax = f32(decal->thresholdMinMax.y);
+                if (ImGui::SliderFloat("Threshold Max", &thresholdMax, -1.0f, 1.0f))
+                {
+                    decal->thresholdMinMax.y = f16(thresholdMax);
+                    isDirty = true;
+                }
+
+                vec2 minUV = vec2(decal->minUV);
+                if (ImGui::DragFloat2("Min UV", &minUV.x, 0.01f, 0.0f, 1.0f))
+                {
+                    decal->minUV = hvec2(minUV);
+                    isDirty = true;
+                }
+
+                vec2 maxUV = vec2(decal->maxUV);
+                if (ImGui::DragFloat2("Max UV", &maxUV.x, 0.01f, 0.0f, 1.0f))
+                {
+                    decal->maxUV = hvec2(maxUV);
+                    isDirty = true;
+                }
+
+                u32 flags = decal->flags;
+                if (ImGui::InputScalar("Flags", ImGuiDataType_U32, &flags, nullptr, nullptr, "%u", ImGuiInputTextFlags_CharsHexadecimal))
+                {
+                    decal->flags = flags;
+                    isDirty = true;
+                }
+
+                if (isDirty)
+                {
+                    registry->emplace_or_replace<ECS::Components::DirtyDecal>(entity);
+                }
+            }
+            Util::Imgui::EndGroupPanel();
+        }
+        ImGui::PopStyleColor();
+    }
+
     bool Inspector::DrawGizmo(entt::registry* registry, entt::entity entity, ECS::Components::Transform& transform)
     {
         entt::registry::context& ctx = registry->ctx();

Source/Game-Lib/Game-Lib/Editor/Inspector.h

@@ -51,6 +51,8 @@ namespace Editor
         void InspectEntity(entt::entity entity);
         void InspectEntityTransform(entt::entity entity);
         void InspectEntityModel(entt::entity entity);
+        void InspectEntityAABB(entt::entity entity);
+        void InspectEntityDecal(entt::entity entity);
         bool DrawGizmo(entt::registry* registry, entt::entity entity, ECS::Components::Transform& transform);
         void DrawGizmoControls();
 

Source/Game-Lib/Game-Lib/Rendering/GameRenderer.cpp

@@ -3,6 +3,7 @@
 #include "UIRenderer.h"
 #include "Debug/DebugRenderer.h"
 #include "Debug/JoltDebugRenderer.h"
+#include "Light/LightRenderer.h"
 #include "Terrain/TerrainRenderer.h"
 #include "Terrain/TerrainLoader.h"
 #include "Terrain/TerrainManipulator.h"
@@ -145,7 +146,8 @@ GameRenderer::GameRenderer(InputManager* inputManager)
     _joltDebugRenderer = new JoltDebugRenderer(_renderer, _debugRenderer);
 
     _modelRenderer = new ModelRenderer(_renderer, _debugRenderer);
-    _modelLoader = new ModelLoader(_modelRenderer);
+    _lightRenderer = new LightRenderer(_renderer, _debugRenderer, _modelRenderer);
+    _modelLoader = new ModelLoader(_modelRenderer, _lightRenderer);
     _modelLoader->Init();
 
     _liquidRenderer = new LiquidRenderer(_renderer, _debugRenderer);
@@ -159,8 +161,8 @@ GameRenderer::GameRenderer(InputManager* inputManager)
     _modelLoader->SetTerrainLoader(_terrainLoader);
 
     _mapLoader = new MapLoader(_terrainLoader, _modelLoader, _liquidLoader);
-
-    _materialRenderer = new MaterialRenderer(_renderer, _terrainRenderer, _modelRenderer);
+    
+    _materialRenderer = new MaterialRenderer(_renderer, _terrainRenderer, _modelRenderer, _lightRenderer);
     _skyboxRenderer = new SkyboxRenderer(_renderer, _debugRenderer);
     _editorRenderer = new EditorRenderer(_renderer, _debugRenderer);
     _canvasRenderer = new CanvasRenderer(_renderer, _debugRenderer);
@@ -206,6 +208,7 @@ void GameRenderer::UpdateRenderers(f32 deltaTime)
     _materialRenderer->Update(deltaTime);
     _joltDebugRenderer->Update(deltaTime);
     _debugRenderer->Update(deltaTime);
+    _lightRenderer->Update(deltaTime);
     _pixelQuery->Update(deltaTime);
     _editorRenderer->Update(deltaTime);
     _canvasRenderer->Update(deltaTime);
@@ -383,6 +386,8 @@ f32 GameRenderer::Render()
     _liquidRenderer->AddCullingPass(&renderGraph, _resources, _frameIndex);
     _liquidRenderer->AddGeometryPass(&renderGraph, _resources, _frameIndex);
 
+    _lightRenderer->AddClassificationPass(&renderGraph, _resources, _frameIndex);
+
     _materialRenderer->AddPreEffectsPass(&renderGraph, _resources, _frameIndex);
     _effectRenderer->AddSSAOPass(&renderGraph, _resources, _frameIndex);
 
@@ -396,6 +401,8 @@ f32 GameRenderer::Render()
     _canvasRenderer->AddCanvasPass(&renderGraph, _resources, _frameIndex);
     _debugRenderer->Add2DPass(&renderGraph, _resources, _frameIndex);
 
+    _lightRenderer->AddDebugPass(&renderGraph, _resources, _frameIndex);
+
     Renderer::ImageID finalTarget = isEditorMode ? _resources.finalColor : _resources.sceneColor;
     _uiRenderer->AddImguiPass(&renderGraph, _resources, _frameIndex, finalTarget);
 
@@ -532,6 +539,17 @@ void GameRenderer::CreatePermanentResources()
     sceneColorDesc.clearColor = Color(0.43f, 0.50f, 0.56f, 1.0f); // Slate gray
     _resources.finalColor = _renderer->CreateImage(sceneColorDesc);
 
+    // Debug rendertarget
+    Renderer::ImageDesc debugColorDesc;
+    debugColorDesc.debugName = "DebugColor";
+    debugColorDesc.dimensions = vec2(1.0f, 1.0f);
+    debugColorDesc.dimensionType = Renderer::ImageDimensionType::DIMENSION_SCALE_RENDERSIZE;
+    debugColorDesc.format = _renderer->GetSwapChainImageFormat();
+    debugColorDesc.sampleCount = Renderer::SampleCount::SAMPLE_COUNT_1;
+    debugColorDesc.clearColor = Color::Clear;
+
+    _resources.debugColor = _renderer->CreateImage(debugColorDesc);
+
     // SSAO
     Renderer::ImageDesc ssaoTargetDesc;
     ssaoTargetDesc.debugName = "SSAOTarget";

Source/Game-Lib/Game-Lib/Rendering/GameRenderer.h

@@ -32,6 +32,7 @@ class MaterialRenderer;
 class SkyboxRenderer;
 class EditorRenderer;
 class DebugRenderer;
+class LightRenderer;
 class JoltDebugRenderer;
 class CanvasRenderer;
 class LiquidLoader;
@@ -134,6 +135,7 @@ class GameRenderer
     MaterialRenderer* _materialRenderer = nullptr;
     SkyboxRenderer* _skyboxRenderer = nullptr;
     DebugRenderer* _debugRenderer = nullptr;
+    LightRenderer* _lightRenderer = nullptr;
     JoltDebugRenderer* _joltDebugRenderer = nullptr;
     EditorRenderer* _editorRenderer = nullptr;
     CanvasRenderer* _canvasRenderer = nullptr;