Lighting in place 🎉

Author: JeanPhilippeKernel

Resources/Shaders/deferred_lighting.frag

@@ -0,0 +1,71 @@
+#version 460
+#extension GL_GOOGLE_include_directive : require
+#include "fragment_common.glsl"
+
+layout (location = 0) in vec2 TexCoord;
+layout (location = 1) in vec4 ViewPos;
+
+layout (std140, set = 0, binding = 6) readonly buffer DirectionalLightSB
+{
+    uint Count;
+    DirectionalLight Data[];
+} 	DirectionalLightBuffer;
+
+layout (std140, set = 0, binding = 7) readonly buffer PointLightSB
+{
+    uint Count;
+    PointLight Data[];
+} PointLightBuffer;
+
+layout (std140, set = 0, binding = 8) readonly buffer SpotLightSB
+{
+    uint Count;
+    SpotLight Data[];
+} SpotLightBuffer;
+
+layout (set = 0, binding = 10) uniform sampler2D AlbedoSampler;
+layout (set = 0, binding = 11) uniform sampler2D PositionSampler;
+layout (set = 0, binding = 12) uniform sampler2D NormalSampler;
+layout (set = 0, binding = 13) uniform sampler2D SpecularSampler;
+
+
+layout (location = 0) out vec4 OutColor;
+
+
+vec3 ComputeDirectionalLight(DirectionalLight light, vec3 normal, vec3 viewDir, vec3 albedoMap, vec3 specularMap)
+{
+    vec3 direction  = light.Direction.xyz;
+
+    vec3 lightDir   = normalize(direction);
+    vec3 ambient    = 0.1 * light.Ambient.xyz;
+
+    float diff      = max(dot(normal, lightDir), 0.0);
+    vec3 diffuse    = diff * light.Diffuse.xyz * albedoMap;
+
+    vec3 reflectDir = reflect(-lightDir, normal);
+    float spec      = pow(max(dot(viewDir, reflectDir), 0.0), 16);
+    vec3 specular   = 0.5 * spec * light.Specular.xyz * specularMap;
+
+    return vec3(ambient + diffuse + specular);
+}
+
+
+void main()
+{
+    vec3 norm       = texture( NormalSampler, TexCoord).rgb;
+    vec4 fragPos    = texture( PositionSampler, TexCoord);
+    vec3 albedo     = texture( AlbedoSampler, TexCoord).rgb;
+    vec3 specular   = texture( SpecularSampler, TexCoord).rgb;
+
+    vec3 viewDir    = normalize( ViewPos.xyz - fragPos.xyz);
+
+    //Computing Directional Lights
+    vec3 lighting = vec3(0.0);
+    for (uint i = 0;  i < DirectionalLightBuffer.Count; ++i)
+    {
+        DirectionalLight directionalLight = DirectionalLightBuffer.Data[i];
+        lighting += ComputeDirectionalLight(directionalLight, norm, viewDir, albedo, specular);
+    }
+
+    OutColor = vec4(lighting, 1.0);
+}

Resources/Shaders/deferred_lighting.vert

@@ -0,0 +1,17 @@
+#version 460
+#extension GL_GOOGLE_include_directive : require
+#include "vertex_common.glsl"
+
+layout (location = 0) out vec2 TexCoord;
+layout (location = 1) out vec4 ViewPos;
+
+void main()
+{
+    DrawDataView dataView = GetDrawDataView();
+
+    vec4 worldPos   = dataView.Transform * dataView.Vertex;
+    ViewPos         = Camera.Position;
+    gl_Position     = Camera.Projection * Camera.View * worldPos;
+    // Convert gl_Position from NDC [-1, 1] to texture coordinates [0, 1]
+    TexCoord        = (gl_Position.xy / gl_Position.w) * 0.5 + 0.5;
+}

Resources/Shaders/final_color.frag renamed to Resources/Shaders/final_color.frag.txt

@@ -3,22 +3,65 @@
 
 struct MaterialData
 {
-    vec4 AmbientColor;
-    vec4 EmissiveColor;
-    vec4 AlbedoColor;
-    vec4 DiffuseColor;
-    vec4 RoughnessColor;
-
-    float TransparencyFactor;
-    float MetallicFactor;
-    float AlphaTest;
-
-    uint64_t EmissiveTextureMap;
-    uint64_t AlbedoTextureMap;
-    uint64_t NormalTextureMap;
-    uint64_t OpacityTextureMap;
+    vec4 Ambient;
+    vec4 Emissive;
+    vec4 Albedo;
+	vec4 Specular;
+    vec4 Roughness;
+	vec4 Factors; // {x : transparency, y : Metallic, z : AlphaTest, w : _padding}
+
+    uint64_t EmissiveMap;
+    uint64_t AlbedoMap;
+	uint64_t SpecularMap;
+    uint64_t NormalMap;
+    uint64_t OpacityMap;
+	uint64_t _padding;
 };
 
+struct DirectionalLight
+{
+	vec4 Direction;
+	vec4 Ambient;
+	vec4 Diffuse;
+	vec4 Specular;
+};
+
+struct PointLight
+{
+	vec4 Position;
+	vec4 Ambient;
+	vec4 Diffuse;
+	vec4 Specular;
+
+	float Constant;
+	float Linear;
+	float Quadratic;
+	float _padding;
+};
+
+struct SpotLight
+{
+	vec4 Position;
+	vec4 Direction;
+	vec4 Ambient;
+	vec4 Diffuse;
+	vec4 Specular;
+
+	float CutOff;
+	vec3 _padding;
+};
+
+#define INVALID_MAP_HANDLE 0xFFFFFFFFu
+
+layout(std140, set = 0, binding = 5) readonly buffer MatSB { MaterialData Data[]; } MaterialDataBuffer;
+layout(set = 0, binding = 9) uniform sampler2D TextureArray[];
+
+MaterialData FetchMaterial(uint dataIndex)
+{
+	return MaterialDataBuffer.Data[dataIndex];
+}
+
+
 // http://www.thetenthplanet.de/archives/1180
 // modified to fix handedness of the resulting cotangent frame
 mat3 cotangentFrame( vec3 N, vec3 p, vec2 uv )
@@ -73,13 +116,3 @@ void runAlphaTest(float alpha, float alphaThreshold)
 			discard;
 	}
 }
-
-#define INVALID_TEXTURE_INDEX 0xFFFFFFFFu
-
-layout(set = 0, binding = 5) readonly buffer MatSB { MaterialData Data[]; } MaterialDataBuffer;
-layout(set = 0, binding = 9) uniform sampler2D TextureArray[];
-
-MaterialData FetchMaterial(uint dataIndex)
-{
-	return MaterialDataBuffer.Data[dataIndex];
-}

Resources/Shaders/final_color.vert renamed to Resources/Shaders/final_color.vert.txt

@@ -2,27 +2,40 @@
 #extension GL_GOOGLE_include_directive : require
 #include "fragment_common.glsl"
 
-layout (location = 0) in vec3 FragmentPosition;
+layout (location = 0) in vec2 TexCoord;
 layout (location = 1) in vec3 WorldNormal;
-layout (location = 2) in vec2 TextureCoord;
+layout (location = 2) in vec4 FragPos;
 layout (location = 3) in flat uint MaterialIdx;
 
-layout (location = 0) out vec4 OutAlbedoColor;
+layout (location = 0) out vec4 OutAlbedo;
 layout (location = 1) out vec4 OutSpecular;
 layout (location = 2) out vec3 OutNormal;
-layout (location = 3) out vec3 OutPosition;
+layout (location = 3) out vec4 OutPosition;
 
 void main()
 {
     MaterialData material = FetchMaterial(MaterialIdx);
 
-    OutNormal = normalize(WorldNormal);
-    OutPosition = FragmentPosition;
-    OutSpecular = vec4(1.0);
+    OutNormal   = normalize(WorldNormal);
+    OutSpecular = material.Specular;
+    OutAlbedo   = material.Albedo;
+    OutPosition = FragPos;
 
-    if (material.AlbedoTextureMap < INVALID_TEXTURE_INDEX)
+    if (material.AlbedoMap < INVALID_MAP_HANDLE)
     {
-        uint texId  = uint(material.AlbedoTextureMap);
-        OutAlbedoColor = texture( TextureArray[nonuniformEXT(texId)], TextureCoord);
+        uint texId = uint(material.AlbedoMap);
+        OutAlbedo  = texture( TextureArray[nonuniformEXT(texId)], TexCoord );
+    }
+
+    if(material.SpecularMap < INVALID_MAP_HANDLE)
+    {
+        uint texId  = uint(material.SpecularMap);
+        OutSpecular = texture( TextureArray[nonuniformEXT(texId)], TexCoord );
+    }
+
+    if(material.NormalMap < INVALID_MAP_HANDLE)
+    {
+        uint texId  = uint(material.NormalMap);
+        OutNormal   = texture( TextureArray[nonuniformEXT(texId)], TexCoord ).rgb;
     }
 }

Resources/Shaders/fragment_common.glsl

@@ -2,24 +2,19 @@
 #extension GL_GOOGLE_include_directive : require
 #include "vertex_common.glsl"
 
-
-layout (location = 0) out vec3 FragmentPosition;
+layout (location = 0) out vec2 TexCoord;
 layout (location = 1) out vec3 WorldNormal;
-layout (location = 2) out vec2 TextureCoord;
+layout (location = 2) out vec4 FragPos;
 layout (location = 3) out flat uint MaterialIdx;
-layout (location = 4) out vec4 ViewPosition;
 
 void main()
 {
     DrawDataView dataView = GetDrawDataView();
 
-    vec4 worldPosition  = dataView.Transform * dataView.Vertex;
-    FragmentPosition    = worldPosition.xyz;
-
+    vec4 worldPos   = dataView.Transform * dataView.Vertex;
     WorldNormal     = transpose(inverse(mat3(dataView.Transform))) * dataView.Normal;
-    TextureCoord    = dataView.TexCoord;
+    TexCoord        = dataView.TexCoord;
     MaterialIdx     = dataView.MaterialId;
-    ViewPosition    = Camera.Position;
-
-    gl_Position = Camera.Projection * Camera.View * worldPosition;
+    FragPos         = worldPos;
+    gl_Position     = Camera.Projection * Camera.View * worldPos;
 }

Resources/Shaders/g_buffer.frag

@@ -8,7 +8,7 @@ layout (location = 1) out float scaleFactor;
 
 void main()
 {
-    scaleFactor = 300.0;
+    scaleFactor = 80.0;
 
     DrawDataView dataView   = GetDrawDataView();
     vec3 posScale           = vec3((dataView.Vertex * scaleFactor).xyz);

Resources/Shaders/g_buffer.vert

@@ -13,7 +13,7 @@ namespace Tetragrama::Components
 {
     HierarchyViewUIComponent::HierarchyViewUIComponent(std::string_view name, bool visibility) : UIComponent(name, visibility, false)
     {
-        m_node_flag = ImGuiTreeNodeFlags_OpenOnArrow | ImGuiTreeNodeFlags_SpanAvailWidth/* | ImGuiTreeNodeFlags_DefaultOpen*/;
+        m_node_flag = ImGuiTreeNodeFlags_OpenOnArrow | ImGuiTreeNodeFlags_SpanAvailWidth /* | ImGuiTreeNodeFlags_DefaultOpen*/;
     }
 
     HierarchyViewUIComponent::~HierarchyViewUIComponent() {}
@@ -78,6 +78,7 @@ namespace Tetragrama::Components
     void HierarchyViewUIComponent::RenderTreeNodes()
     {
         auto root_nodes = GraphicScene::GetRootSceneNodes();
+
         for (int node : root_nodes)
         {
             RenderSceneNodeTree(node);
@@ -135,7 +136,7 @@ namespace Tetragrama::Components
             if (ImGuizmo::IsUsing())
             {
                 // ZEngine::Maths::Vector3 translation, rotation, scale;
-                // ZEngine::Maths::DecomposeTransformComponent(transform, translation, rotation, scale);
+                 //ZEngine::Maths::DecomposeTransformComponent(transform, translation, rotation, scale);
 
                 // entity_transform_component.SetPosition(translation);
                 // entity_transform_component.SetScaleSize(scale);
@@ -144,7 +145,7 @@ namespace Tetragrama::Components
         }
     }
 
-    void HierarchyViewUIComponent::RenderSceneNodeTree(int32_t node_identifier)
+    void HierarchyViewUIComponent::RenderSceneNodeTree(int node_identifier)
     {
         if (node_identifier < 0)
         {
@@ -162,6 +163,10 @@ namespace Tetragrama::Components
         if (ImGui::IsItemClicked())
         {
             m_selected_node_identifier = node_identifier;
+
+            auto entity = GraphicScene::GetSceneNodeEntityWrapper(m_selected_node_identifier);
+            Messengers::IMessenger::SendAsync<ZEngine::Components::UI::UIComponent, Messengers::GenericMessage<SceneEntity>>(
+                EDITOR_COMPONENT_HIERARCHYVIEW_NODE_SELECTED, Messengers::GenericMessage<SceneEntity>{std::move(entity)});
         }
 
         if (is_node_opened)
@@ -174,6 +179,7 @@ namespace Tetragrama::Components
             {
                 if (ImGui::MenuItem("Create Empty child"))
                 {
+                    GraphicScene::CreateEntityAsync("Empty Entity", m_selected_node_identifier, node_hierarchy.DepthLevel + 1);
                 }
 
                 if (ImGui::MenuItem("Rename"))

Resources/Shaders/infinite_grid.vert

@@ -5,7 +5,8 @@
 #include <Message.h>
 #include <EditorCameraController.h>
 
-namespace Tetragrama::Components {
+namespace Tetragrama::Components
+{
     class HierarchyViewUIComponent : public ZEngine::Components::UI::UIComponent
     {
     public:
@@ -17,13 +18,10 @@ namespace Tetragrama::Components {
 
         void RenderTreeNodes();
         void RenderGuizmo();
+        void RenderSceneNodeTree(int node_identifier);
 
-    public:
         std::future<void> EditorCameraAvailableMessageHandlerAsync(Messengers::GenericMessage<ZEngine::Ref<EditorCameraController>>&);
 
-    protected:
-        void         RenderSceneNodeTree(int32_t node_identifier);
-
     private:
         ImGuiTreeNodeFlags                       m_node_flag;
         bool                                     m_is_node_opened{false};