Configure several coloredl light for ch10_area_lights, add to README.

Author: Adnn

README.md

@@ -1,3 +1,13 @@
 # Real-Time Rendering Prototypes
 
-Prototypes developed while reading RTR 4th edition
+Prototypes developed while reading RTR 4th edition.
+
+## Content
+
+The repository contains several standalone applications demonstrating real-time rendering techniques.
+
+### ch10_area_lights
+
+Implement sphere lights and tube lights with fast approximations, such as most-representative point.
+
+[![area-lights roughness scale](https://adnn.github.io/assets/shared/area_lights-roughness_variations-864_646.jpg)](https://adnn.github.io/assets/shared/area_lights-roughness_variations.jpg)

src/apps/ch10_area_lights/ch10_area_lights/Scene.cpp

@@ -132,6 +132,8 @@ Scene::Scene(graphics::AppInterface & aAppInterface, const imguiui::ImguiUi & aI
     mLightProgram{mEngine.loadProgram(renderer::ReferencePath{gLightProgramPath})},
     mLineDrawer{mEngine.loadProgram(renderer::ReferencePath{gLineProgramPath})}
 {
+    setupLights();
+
     graphics::attachIndexBuffer(mIndexBuffer, mVertexSpecification.mVertexArray);
 
     graphics::appendToVertexSpecification(
@@ -168,6 +170,68 @@ Scene::Scene(graphics::AppInterface & aAppInterface, const imguiui::ImguiUi & aI
 }
 
 
+void Scene::setupLights()
+{
+    constexpr unsigned int tubeCount = 3;
+    constexpr unsigned int bulbCount = 1;
+    std::array<math::hdr::Rgb<GLfloat>, tubeCount + bulbCount> colors{{
+        {0.55f, 0.05f, 0.05f},
+        {0.13f, 0.64f, 0.62f},
+        {1.f, 0.73f, 0.29f},
+        {0.44f, 0.f, 0.37f},
+    }};
+    float height = 1.5f;
+    float radius = 3.f;
+
+    const math::Radian<GLfloat> pi{ math::pi<GLfloat> };
+    const math::Radian<GLfloat> reserve{pi / 8};
+    math::Radian<GLfloat> step{ 2 * pi / tubeCount };
+
+    auto makePosition = [&](unsigned int i, math::Radian<GLfloat> aReserve)
+        {
+            return math::Position<3, GLfloat>{
+                radius * cos(i * step + aReserve),
+                height,
+                radius * sin(i * step + aReserve)};
+        };
+
+    for (unsigned int i = 0; i != tubeCount; ++i)
+    {
+        unsigned int pointIdx = 2 * i;
+        mLights.mPointLights[pointIdx] =
+            renderer::PointLight_glsl{
+                .mPosition{makePosition(pointIdx, reserve)},
+                .mColors{
+                    .mDiffuseColor = colors[i] * 30,
+                    .mSpecularColor = colors[i] * 30,
+                },
+            };
+        mLights.mPointLights[pointIdx + 1] =
+            renderer::PointLight_glsl{
+                .mPosition{makePosition(pointIdx + 1, -reserve)},
+                .mColors{
+                    .mDiffuseColor = colors[i] * 30,
+                    .mSpecularColor = colors[i] * 30,
+                },
+            };
+    }
+    mLights.mPointCount = 2 * tubeCount;
+    mFrameControl.mTubeCount = tubeCount;
+
+    mLights.mPointLights[mLights.mPointCount++] =
+        renderer::PointLight_glsl{
+            .mPosition{2.f, -3.f, 0.f},
+            .mRadius{
+                .mMin = 1.f,
+                .mMax = 5.f,
+            },
+            .mColors{
+                .mDiffuseColor = colors[tubeCount] * 30,
+                .mSpecularColor = colors[tubeCount] * 30,
+            },
+        };
+}
+
 void Scene::loadPrograms()
 {
     mSurfaceProgram =
@@ -208,6 +272,19 @@ renderer::LightsDataCommon transformLightsData(
 }
 
 
+math::hdr::Rgb<float> capColor(math::hdr::Rgb<float> aColor)
+{
+    float maxElement = *aColor.getMaxMagnitudeElement();
+    if (maxElement > 1)
+    {
+        return aColor / maxElement;
+    }
+    else
+    {
+        return aColor;
+    }
+}
+
 void Scene::render(math::Size<2, int> aRenderResolution)
 {
     //
@@ -225,16 +302,19 @@ void Scene::render(math::Size<2, int> aRenderResolution)
         entity.mLocalToWorld =
             math::trans3d::scaleUniform(pointLight.mRadius.mMin)
             * math::trans3d::translate(pointLight.mPosition.as<math::Vec>());
-        entity.mColorFactor = pointLight.mColors.mSpecularColor;
+        entity.mColorFactor = capColor(pointLight.mColors.mSpecularColor);
 
         // Populate the line segments representing the tube lights
+        // Note: whereas for point lights we populate the entities UBO to render the spheres
+        // with classical matrix tansforms,
+        // for tube lights we populate a line segment UBO, directly with world positions
         if (pointLightIdx % 2 == 1)
         {
             mLines.mSegments.push_back(
                 renderer::LineSegment_glsl{
                     .mPointA = mLights.mPointLights[pointLightIdx - 1].mPosition,
                     .mPointB = mLights.mPointLights[pointLightIdx].mPosition,
-                    .mColor = mLights.mPointLights[pointLightIdx - 1].mColors.mSpecularColor,
+                    .mColor = capColor(mLights.mPointLights[pointLightIdx - 1].mColors.mSpecularColor),
                     .mWidth = 2 * mLights.mPointLights[pointLightIdx - 1].mRadius.mMin,
                 });
         }

src/apps/ch10_area_lights/ch10_area_lights/Scene.h

@@ -116,6 +116,8 @@ struct Scene
 
     void presentUi(bool * aOpen = nullptr);
 
+    void setupLights();
+
     Engine mEngine;
 
     scenic::geodesic::Sphere mSphere{ 4 };
@@ -147,38 +149,12 @@ struct Scene
             },
         },
     };
+    // Note: see setupLights() for point and tube lights definitions
     renderer::LightsDataCommon mLights{
         .mDirectionalCount = 0,
-        .mPointCount = 2,
         // We decode a sRGB 10% white (which is also perceptually ~10%)
         // to linear space for computation.
         .mAmbientColor = math::decode_sRGB(math::hdr::gWhite<float> * 0.1f),
-        .mDirectionalLights = {
-            renderer::DirectionalLight_glsl{
-                .mDirection = math::UnitVec<3, float>{ {0.5f, 0.f, -0.5f} },
-                // TODO: decode the srgb value to have it show correctly in Imgui
-                // (and have it perceptually proportional to the factor)
-                .mColors = renderer::LightColors_glsl{} * 0.2,
-            },
-         },
-        .mPointLights = {
-            renderer::PointLight_glsl{
-                .mPosition = {-2.f, 3.f, 0.f},
-                .mRadius{
-                    .mMin = 0.2f,
-                    .mMax = 5.f,
-                },
-                .mColors = renderer::LightColors_glsl{} * 30.f,
-            },
-            renderer::PointLight_glsl{
-                .mPosition = {+2.f, 3.f, 0.f},
-                .mRadius{
-                    .mMin = 0.2f,
-                    .mMax = 5.f,
-                },
-                .mColors = renderer::LightColors_glsl{} * 30.f,
-            },
-         },
     };
     renderer::LinesSsbo_glsl mLines;
     OrbitalCamera mOrbitalCamera;

src/apps/ch10_area_lights/ch10_area_lights/main.cpp

@@ -27,7 +27,11 @@ int main(int argc, const char * argv[])
     {
         spdlog::set_level(spdlog::level::debug);
 
-        ad::graphics::ApplicationGlfw application("ch10_area_lights", 1080, 600);
+        ad::graphics::ApplicationGlfw application{
+            "ch10_area_lights", 1080, 600,
+            ad::graphics::ApplicationFlag::None,
+            4, 6,
+            { {GLFW_SAMPLES, 8} }};
 
         // Ensures the messages are sent synchronously with the event triggering them
         // This makes debug stepping much more feasible.

src/libs/engine/engine/Lights.h

@@ -71,7 +71,7 @@ struct Radius
     // * r_0 (the distance at which the intensities are given)
     // * r_min (the distance below which light will not gain intensities anymore)
     // max is used as r_max, i.e. where both light intensity & derivative should reach zero.
-    GLfloat mMin = 0.25f;
+    GLfloat mMin = 0.2f;
     GLfloat mMax = 10.f;
     // Until the maybe_uninitialized warning works better we need
     // mMin and mMax to have default values or gcc will shout on