Added directional lights

engine/include/rev/Light.h

@@ -5,17 +5,36 @@
 namespace rev {
 
 class Light {
-public:
+protected:
     Light();
-
+public:
     const glm::vec3& getBaseColor() const;
     void setBaseColor(const glm::vec3& color);
 
+    const glm::mat4x4& getLightSpaceTransform() const;
+    void setLightSpaceTransform(const glm::mat4x4& transform);
+private:
+    glm::vec3 _baseColor;
+};
+
+class PointLight: public Light {
+public:
+    PointLight();
+
     const glm::vec3& getPosition() const;
     void setPosition(const glm::vec3& position);
 private:
-    glm::vec3 _baseColor;
     glm::vec3 _position;
 };
 
+class DirectionalLight: public Light {
+public:
+    DirectionalLight();
+
+    const glm::vec3& getDirection() const;
+    void setDirection(const glm::vec3& direction);
+private:
+    glm::vec3 _direction;
+};
+
 } // namespace rev

engine/include/rev/Scene.h

@@ -11,22 +11,26 @@
 
 namespace rev
 {
-class Light;
+class PointLight;
+class DirectionalLight;
 class IModel;
 class SceneObject;
 
 class Scene
 {
 public:
-    std::shared_ptr<Light> addLight();
+    std::shared_ptr<PointLight> addPointLight();
+    std::shared_ptr<DirectionalLight> addDirectionalLight();
 
     void renderAllObjects(Camera &camera);
-    void renderAllLights(Uniform<glm::vec3>& lightPositionUniform, Uniform<glm::vec3>& lightBaseColor);
+    void renderAllPointLights(Uniform<glm::vec3>& lightPositionUniform, Uniform<glm::vec3>& lightBaseColor);
+    void renderAllDirectionalLights(Uniform<glm::vec3>& lightDirectionUniform, Uniform<glm::vec3>& lightBaseColor);
 
     void addObjectGroup(std::shared_ptr<ISceneObjectGroup> group);
 private:
     std::vector<std::shared_ptr<ISceneObjectGroup>> _objectGroups;
-    std::set<std::shared_ptr<Light>> _lights;
+    std::set<std::shared_ptr<PointLight>> _pointLights;
+    std::set<std::shared_ptr<DirectionalLight>> _directionalLights;
 };
 
 } // namespace rev

engine/include/rev/SceneView.h

@@ -35,7 +35,8 @@ class SceneView
   std::shared_ptr<Camera> _camera;
 
   RectSize<GLsizei> _outputSize;
-  ProgramResource _lightingProgram;
+  ProgramResource _pointLightingProgram;
+  ProgramResource _directionalLightingProgram;
 
   struct WorldSpaceNormalProperty
   {
@@ -109,6 +110,7 @@ class SceneView
   Buffer _fullScreenVertexBuffer;
 
   Uniform<glm::vec3> _lightPosition;
+  Uniform<glm::vec3> _lightDirection;
   Uniform<glm::vec3> _lightBaseColor;
   Uniform<glm::vec3> _camPosition;
 };

engine/src/Light.cpp

@@ -2,9 +2,9 @@
 
 namespace rev
 {
+    // Light
     Light::Light()
     : _baseColor(glm::vec3(1.0))
-    , _position(glm::vec3(0.0))
     {
     }
 
@@ -18,13 +18,35 @@ namespace rev
         _baseColor = color;
     }
 
-    const glm::vec3& Light::getPosition() const
+    // PointLight
+    PointLight::PointLight()
+    : _position(glm::vec3(0.0))
+    {
+    }
+
+    const glm::vec3& PointLight::getPosition() const
     {
         return _position;
     }
 
-    void Light::setPosition(const glm::vec3& position)
+    void PointLight::setPosition(const glm::vec3& position)
     {
         _position = position;
     }
+
+    // DirectionalLight
+    DirectionalLight::DirectionalLight()
+    : _direction(glm::vec3(0.0, -1.0, 0.0))
+    {
+    }
+
+    const glm::vec3& DirectionalLight::getDirection() const 
+    {
+        return _direction;
+    }
+
+    void DirectionalLight::setDirection(const glm::vec3& direction)
+    {
+        _direction = direction;
+    }
 }

engine/src/Scene.cpp

@@ -6,10 +6,17 @@
 namespace rev
 {
 
-std::shared_ptr<Light> Scene::addLight()
+std::shared_ptr<PointLight> Scene::addPointLight()
 {
-    auto light = std::make_shared<Light>();
-    _lights.insert(light);
+    auto light = std::make_shared<PointLight>();
+    _pointLights.insert(light);
+    return std::move(light);
+}
+
+std::shared_ptr<DirectionalLight> Scene::addDirectionalLight()
+{
+    auto light = std::make_shared<DirectionalLight>();
+    _directionalLights.insert(light);
     return std::move(light);
 }
 
@@ -26,10 +33,22 @@ void Scene::renderAllObjects(Camera &camera)
     }
 }
 
-void Scene::renderAllLights(Uniform<glm::vec3> &lightPositionUniform,
+void Scene::renderAllDirectionalLights(Uniform<glm::vec3> &lightDirectionUniform,
+                    Uniform<glm::vec3> &lightBaseColor)
+{
+    for (const auto & light : _directionalLights)
+    {
+        lightDirectionUniform.set(light->getDirection());
+        lightBaseColor.set(light->getBaseColor());
+
+        glDrawArrays(GL_TRIANGLES, 0, 6);
+    }
+}             
+
+void Scene::renderAllPointLights(Uniform<glm::vec3> &lightPositionUniform,
                      Uniform<glm::vec3> &lightBaseColor)
 {
-    for (const auto & light : _lights)
+    for (const auto & light : _pointLights)
     {
         lightPositionUniform.set(light->getPosition());
         lightBaseColor.set(light->getBaseColor());

engine/src/SceneView.cpp

@@ -27,7 +27,54 @@ constexpr const char *kDeferredVertexShader = R"vertexShader(
 
     )vertexShader";
 
-constexpr const char *kDeferredFragmentShader = R"fragmentShader(
+constexpr const char *kDeferredDirectionalLightFragmentShader = R"fragmentShader(
+        #version 330 core
+
+        in vec2 texCoord;
+
+        uniform vec3 lightDirection;
+        uniform vec3 lightBaseColor;
+        uniform vec3 camPosition;
+
+        uniform sampler2D fragPosition;
+        uniform sampler2D normals;
+
+        uniform sampler2D ambient;
+        uniform sampler2D emissive;
+        uniform sampler2D diffuse;
+        uniform sampler2D specular;
+        uniform sampler2D specularExponent;
+
+        out vec4 fragColor;
+        void main() 
+        {
+            vec3 normal = texture(normals, texCoord).rgb;
+            vec3 diffuse = texture(diffuse, texCoord).rgb;
+
+            vec3 fragmentPosition = texture(fragPosition, texCoord).rgb;
+            vec3 lightVector = 1.0f * lightDirection;
+            float angleMultiplier = max(dot(normalize(lightVector), normalize(normal)), 0.0f);
+
+            float specularExponent = texture(specularExponent, texCoord).r;
+            vec3 specularCoefficient = texture(specular, texCoord).rgb;
+
+            vec3 eyeVector = normalize(camPosition - fragmentPosition);
+            vec3 reflectVector = normalize(reflect(lightVector, normalize(normal)));
+            float specularComponent = max(dot(eyeVector, reflectVector), 0.0f);
+
+            vec3 ambientLight = vec3(0.01f) * diffuse;
+            vec3 diffuseLight = diffuse * lightBaseColor * angleMultiplier;
+            vec3 specularLight = (specularExponent > 0.01) 
+                 ? lightBaseColor * specularCoefficient * pow(vec3(specularComponent) , vec3(specularExponent))
+                 : vec3(0.0f);
+
+            vec3 totalLight = diffuseLight + specularLight;
+            
+            fragColor = vec4(totalLight, 1.0f);
+        }
+    )fragmentShader";
+
+constexpr const char *kDeferredPointLightFragmentShader = R"fragmentShader(
         #version 330 core
 
         in vec2 texCoord;
@@ -87,22 +134,32 @@ constexpr glm::vec2 kFullScreenQuadVertices[] = {
 
 SceneView::SceneView() : _camera(std::make_shared<Camera>())
 {
-  _lightingProgram.buildWithSource(kDeferredVertexShader,
-                                   kDeferredFragmentShader);
+  _pointLightingProgram.buildWithSource(kDeferredVertexShader,
+                                   kDeferredPointLightFragmentShader);
+  {
+    ProgramContext programContext(_pointLightingProgram);
+    _pointLightingProgram.getUniform<GLint>("fragPosition").set(0);
+    _pointLightingProgram.getUniform<GLint>("normals").set(1);
+
+    _pointLightingProgram.getUniform<GLint>("ambient").set(2);
+    _pointLightingProgram.getUniform<GLint>("emissive").set(3);
+    _pointLightingProgram.getUniform<GLint>("diffuse").set(4);
+    _pointLightingProgram.getUniform<GLint>("specular").set(5);
+    _pointLightingProgram.getUniform<GLint>("specularExponent").set(6);
+  }
+
+  _directionalLightingProgram.buildWithSource(kDeferredVertexShader,
+                                   kDeferredDirectionalLightFragmentShader);
   {
-    ProgramContext programContext(_lightingProgram);
-    _lightPosition = _lightingProgram.getUniform<glm::vec3>("lightPosition");
-    _lightBaseColor = _lightingProgram.getUniform<glm::vec3>("lightBaseColor");
-    _camPosition = _lightingProgram.getUniform<glm::vec3>("camPosition");
-
-    _lightingProgram.getUniform<GLint>("fragPosition").set(0);
-    _lightingProgram.getUniform<GLint>("normals").set(1);
-
-    _lightingProgram.getUniform<GLint>("ambient").set(2);
-    _lightingProgram.getUniform<GLint>("emissive").set(3);
-    _lightingProgram.getUniform<GLint>("diffuse").set(4);
-    _lightingProgram.getUniform<GLint>("specular").set(5);
-    _lightingProgram.getUniform<GLint>("specularExponent").set(6);
+    ProgramContext programContext(_directionalLightingProgram);
+    _directionalLightingProgram.getUniform<GLint>("fragPosition").set(0);
+    _directionalLightingProgram.getUniform<GLint>("normals").set(1);
+
+    _directionalLightingProgram.getUniform<GLint>("ambient").set(2);
+    _directionalLightingProgram.getUniform<GLint>("emissive").set(3);
+    _directionalLightingProgram.getUniform<GLint>("diffuse").set(4);
+    _directionalLightingProgram.getUniform<GLint>("specular").set(5);
+    _directionalLightingProgram.getUniform<GLint>("specularExponent").set(6);
   }
 
   VertexArrayContext vaoContext(_fullScreenVao);
@@ -162,7 +219,6 @@ void SceneView::render()
 
   // Lighting pass
   {
-    ProgramContext programContext(_lightingProgram);
     auto fbContext = _lightingStage.getRenderContext();
 
     _camPosition.set(_camera->getPosition());
@@ -192,7 +248,23 @@ void SceneView::render()
 
     VertexArrayContext vaoContext(_fullScreenVao);
 
-    _scene->renderAllLights(_lightPosition, _lightBaseColor);
+    // Render all point lights
+    {
+      ProgramContext programContext(_pointLightingProgram);
+      _lightPosition = _pointLightingProgram.getUniform<glm::vec3>("lightPosition");
+      _lightBaseColor = _pointLightingProgram.getUniform<glm::vec3>("lightBaseColor");
+      _camPosition = _pointLightingProgram.getUniform<glm::vec3>("camPosition");
+      _scene->renderAllPointLights(_lightPosition, _lightBaseColor);
+    }
+
+    // Render all directional lights
+    {
+      ProgramContext programContext(_directionalLightingProgram);
+      _lightDirection = _directionalLightingProgram.getUniform<glm::vec3>("lightDirection");
+      _lightBaseColor = _directionalLightingProgram.getUniform<glm::vec3>("lightBaseColor");
+      _camPosition = _directionalLightingProgram.getUniform<glm::vec3>("camPosition");
+      _scene->renderAllDirectionalLights(_lightDirection, _lightBaseColor);
+    }
   }
 }
 

testGame/src/main.cpp

@@ -339,18 +339,22 @@ int main(void)
 
   auto bikeController = std::make_shared<BikeController>(bikeParticle, object);
 
-  auto yellowLight = scene->addLight();
+  auto yellowLight = scene->addPointLight();
   yellowLight->setPosition(glm::vec3(4.0f, 3.0f, 3.0f));
   yellowLight->setBaseColor(glm::vec3(1.0f, 1.0f, 0.8f));
 
-  auto blueLight = scene->addLight();
+  auto blueLight = scene->addPointLight();
   blueLight->setPosition(glm::vec3(-1.5f, -2.0f, 1.5f));
   blueLight->setBaseColor(glm::vec3(0.2f, 0.2f, 1.0f));
 
-  auto orangeLight = scene->addLight();
+  auto orangeLight = scene->addPointLight();
   orangeLight->setPosition(glm::vec3(3.0f, 0.75f, -2.5f));
   orangeLight->setBaseColor(glm::vec3(1.0f, 0.3f, 0.0f));
 
+  auto directionalLight = scene->addDirectionalLight();
+  directionalLight->setDirection(glm::vec3(-1.0, 0.0f, 0.0f));
+  directionalLight->setBaseColor(glm::vec3(1.0f, 1.0f, 1.0f));
+
   auto camera = sceneView->getCamera();
   camera->setTarget({0.0f, 0.0f, 0.0f});
   camera->setPosition({4.0f, 4.0f, 4.0f});