added a lighting descriptor

Author: rfdickerson

shaders/triangle.frag

@@ -1,16 +1,38 @@
 #version 450
 
-layout(location = 1) in vec3 vNormal;
+// input from vertex shader
+layout(location = 1) in vec3 inNormal;
+
+// Uniform buffer for lighting data
+layout(binding = 1) uniform LightUBO {
+    vec4 lightDirection;
+    vec4 lightColor;
+    float lightIntensity;
+} ubo;
 
 // Final output color
 layout(location = 0) out vec4 outColor;
 
 void main() {
-    // Normalize the incoming normal vector to ensure unit vector.
-    vec3 normal = normalize(vNormal);
 
-    // map normal components in (-1, 1) to (0, 1)
-    vec3 normalColor = (normal + 1.0) * 0.5;
+    // Define a base color for object
+    vec3 objectColor = vec3(0.8, 0.8, 0.8);
+
+    // Ensure the normal is a unit vector
+    vec3 normal = normalize(inNormal);
+
+    // The direction vector from the uniform is pointing *to* the light.
+    // We use it directly for the dot product.
+    vec3 lightDir = normalize(ubo.lightDirection.xyz);
+
+    // Calculate the diffuse factor (Lambertian reflectance)
+    // max(..., 0.0) ensures that we don't have negative light
+    float diffuseFactor = max(dot(normal, lightDir), 0.0);
+
+    // Calculate the final diffuse light color
+    vec3 diffuse = ubo.lightColor.rgb * ubo.lightIntensity * diffuseFactor;
+
+    // The final color is the object's base color modulated by the diffuse light
+    outColor = vec4(objectColor * diffuse, 1.0);
 
-    outColor = vec4(normalColor, 1.0);
 }

src/core/Uniforms.hpp

@@ -6,10 +6,11 @@ struct SceneUBO {
     glm::mat4 projection;
 };
 
-struct LightingUBO {
-    glm::vec4 lightPosition;
-    glm::vec4 lightColor;
-    float lightIntensity;
+struct DirectionalLightUBO
+{
+    glm::vec4 lightPosition = glm::vec4(-0.5f, 1.0f, -0.5f, 0.0f);
+    glm::vec4 lightColor = glm::vec4(1.0f, 1.0f, 1.0f, 1.0f);
+    float lightIntensity = 1.0f;
 };
 
 struct CompositeUBO {

src/vulkan/VulkanRenderer.cpp

@@ -21,6 +21,7 @@ VulkanRenderer::VulkanRenderer(const RendererConfig& config, Window& window, Cam
     m_uniformManager = std::make_unique<UniformManager>(*m_allocator, m_frameManager->getFramesInFlightCount());
     m_uniformManager->registerUBO<SceneUBO>("scene");
     m_uniformManager->registerUBO<CompositeUBO>("composite");
+    m_uniformManager->registerUBO<DirectionalLightUBO>("lighting");
 
     createPipelineAndDescriptors();
     setupUI();
@@ -60,6 +61,8 @@ void VulkanRenderer::createPipelineAndDescriptors()
 
     const std::vector bindings = {
         vk::DescriptorSetLayoutBinding(0, vk::DescriptorType::eUniformBuffer, 1, vk::ShaderStageFlagBits::eVertex),
+        vk::DescriptorSetLayoutBinding(1, vk::DescriptorType::eUniformBuffer, 1, vk::ShaderStageFlagBits::eFragment)
+
     };
     m_descriptorSet = std::make_unique<DescriptorSet>(m_context->device(), 2, bindings);
     const std::vector setLayouts = {m_descriptorSet->getLayout()};
@@ -266,17 +269,31 @@ void VulkanRenderer::drawFrame()
     ubo.view = m_camera.getViewMatrix();
     ubo.projection = m_camera.getProjectionMatrix();
 
+    m_uniformManager->update<DirectionalLightUBO>(frameIdx, m_light);
+
     m_uniformManager->update<SceneUBO>(frameIdx, ubo);
 
+    // Get descriptor info for both UBOs
     vk::DescriptorBufferInfo sceneBufferInfo = m_uniformManager->getDescriptorInfo<SceneUBO>(frameIdx);
+    vk::DescriptorBufferInfo lightBufferInfo = m_uniformManager->getDescriptorInfo<DirectionalLightUBO>(frameIdx);
+
+    // Create write for Scene UBO at binding 0
     vk::WriteDescriptorSet sceneWrite{};
     sceneWrite.dstSet = m_descriptorSet->getCurrentSet(frameIdx);
     sceneWrite.dstBinding = 0;
     sceneWrite.descriptorType = vk::DescriptorType::eUniformBuffer;
     sceneWrite.descriptorCount = 1;
     sceneWrite.pBufferInfo = &sceneBufferInfo;
 
-    m_descriptorSet->updateSet({sceneWrite});
+    // Create write for Light UBO at binding 1
+    vk::WriteDescriptorSet lightWrite{};
+    lightWrite.dstSet = m_descriptorSet->getCurrentSet(frameIdx);
+    lightWrite.dstBinding = 1; // Target binding 1
+    lightWrite.descriptorType = vk::DescriptorType::eUniformBuffer;
+    lightWrite.descriptorCount = 1;
+    lightWrite.pBufferInfo = &lightBufferInfo;
+
+    m_descriptorSet->updateSet({sceneWrite, lightWrite});
 
     beginCommandBuffer(cmd);
 

src/vulkan/VulkanRenderer.hpp

@@ -17,6 +17,7 @@
 #include "VulkanContext.hpp"
 #include "Mesh.hpp"
 #include "MeshGenerators.hpp"
+#include "../core/Uniforms.hpp"
 
 namespace reactor
 {
@@ -79,6 +80,7 @@ class VulkanRenderer
     std::vector<vk::ImageView> m_depthViews;
     std::vector<vk::DescriptorSet> m_depthImageDescriptorSets;
 
+    DirectionalLightUBO m_light;
     std::vector<RenderObject> m_objects;
 
     void createCoreVulkanObjects();