Draw the round endpoints and the line body at the same time.

Author: Adnn

src/apps/ch10_area_lights/ch10_area_lights/Scene.cpp

@@ -82,6 +82,7 @@ void validateVertexAttributes(const renderer::IntrospectProgram & aProgram)
 }
 
 
+const unsigned int gCircleResolution = 32;
 const std::filesystem::path gProgramPath = "programs/ch10_area_lights_TessellateSphere.prog";
 //const std::filesystem::path gProgramPath = "programs/WrapLighting.prog";
 const std::filesystem::path gLightProgramPath = "programs/TessSphere_PlainColor.prog";
@@ -105,6 +106,20 @@ void describe(T_witness aWitness, Scene::TessellationControl & aValue)
     aValue.mInnerLevel = math::min(aValue.mInnerLevel, maxTess.xy());
 }
 
+LineDrawer::LineDrawer(renderer::IntrospectProgram aLineProgram) :
+    mProgram{std::move(aLineProgram)}
+{
+    auto vertices = renderer::makeRoundSegment(gCircleResolution);
+    auto verticesSpan = std::span{vertices};
+    mVerticesCount = vertices.size();
+    glBindBuffer(mVertices.GLTarget_v, mVertices);
+    glBufferData(mVertices.GLTarget_v, verticesSpan.size_bytes(), verticesSpan.data(), GL_STATIC_DRAW);
+
+    glBindVertexArray(mVao);
+    glEnableVertexAttribArray(0);
+    glBindBuffer(mVertices.GLTarget_v, mVertices);
+    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
+}
 
 Scene::Scene(graphics::AppInterface & aAppInterface, const imguiui::ImguiUi & aImgui) :
     mVertexSpecification{},
@@ -115,7 +130,7 @@ Scene::Scene(graphics::AppInterface & aAppInterface, const imguiui::ImguiUi & aI
                                   graphics::BufferHint::StaticDraw)},
     mSurfaceProgram{mEngine.loadProgram(renderer::ReferencePath{gProgramPath})},
     mLightProgram{mEngine.loadProgram(renderer::ReferencePath{gLightProgramPath})},
-    mLineProgram{mEngine.loadProgram(renderer::ReferencePath{gLineProgramPath})}
+    mLineDrawer{mEngine.loadProgram(renderer::ReferencePath{gLineProgramPath})}
 {
     graphics::attachIndexBuffer(mIndexBuffer, mVertexSpecification.mVertexArray);
 
@@ -159,7 +174,7 @@ void Scene::loadPrograms()
         mEngine.loadProgram(renderer::ReferencePath{ gProgramPath });
     mLightProgram =
         mEngine.loadProgram(renderer::ReferencePath{ gLightProgramPath });
-    mLineProgram =
+    mLineDrawer.mProgram =
         mEngine.loadProgram(renderer::ReferencePath{ gLineProgramPath });
 }
 
@@ -279,29 +294,33 @@ void Scene::render(math::Size<2, int> aRenderResolution)
         sphereCount,
         0);
 
-    // Render point lights as sphere
-    validateVertexAttributes(mLightProgram);
-    glUseProgram(mLightProgram);
-    glDrawElementsInstancedBaseInstance(
-        GL_PATCHES,
-        mIndicesCount,
-        graphics::MappedGL_v<scenic::Index>,
-        0,
-        mLights.mPointCount,
-        sphereCount);
+    if (mFrameControl.mShowPunctualLights)
+    {
+        // Render point lights as sphere
+        validateVertexAttributes(mLightProgram);
+        glUseProgram(mLightProgram);
+        glDrawElementsInstancedBaseInstance(
+            GL_PATCHES,
+            mIndicesCount,
+            graphics::MappedGL_v<scenic::Index>,
+            0,
+            mLights.mPointCount,
+            sphereCount);
+    }
 
     // Render tube lights as fat lines
     {
         glDisable(GL_CULL_FACE);
-        graphics::setUniform(mLineProgram, "u_FramebufferSize", aRenderResolution);
+        graphics::setUniform(mLineDrawer.mProgram, "u_FramebufferSize", aRenderResolution);
         {
             // Binds to the general binding point, in addition to binding index 8
-            glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 8, mLinesSsbo);
+            glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 8, mLineDrawer.mLinesSsbo);
             std::span<renderer::LineSegment_glsl> lines{ mLines.mSegments };
             glBufferData(GL_SHADER_STORAGE_BUFFER, lines.size_bytes(), lines.data(), GL_STREAM_DRAW);
         }
-        glUseProgram(mLineProgram);
-        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+        glBindVertexArray(mLineDrawer.mVao);
+        glUseProgram(mLineDrawer.mProgram);
+        glDrawArrays(GL_TRIANGLES, 0, mLineDrawer.mVerticesCount);
         glEnable(GL_CULL_FACE);
     }
 }
@@ -330,6 +349,8 @@ void Scene::presentUi(bool * aOpen)
         FrameControl::gPolygonModes.end(),
         [](auto aModeIt){return graphics::to_string(*aModeIt);});
 
+    ImGui::Checkbox("Show Punctual Lights", &mFrameControl.mShowPunctualLights);
+
     DearImguiWitness witness;
 
     ImGui::Spacing();

src/apps/ch10_area_lights/ch10_area_lights/Scene.h

@@ -61,6 +61,16 @@ constexpr graphics::AttributeDescriptionList gInstanceDescription{
 //    1,
 //};
 
+struct LineDrawer 
+{
+    LineDrawer(renderer::IntrospectProgram aLineProgram);
+
+    graphics::Buffer<graphics::BufferType::Array> mVertices;
+    GLuint mVerticesCount;
+    graphics::BufferAny mLinesSsbo;
+    graphics::VertexArrayObject mVao;
+    renderer::IntrospectProgram mProgram;
+};
 
 struct Scene
 {
@@ -83,13 +93,14 @@ struct Scene
 
     struct FrameControl
     {
-       inline static constexpr std::array<GLenum, 3> gPolygonModes{
+        inline static constexpr std::array<GLenum, 3> gPolygonModes{
             GL_POINT,
             GL_LINE,
             GL_FILL,
         }; 
 
-       decltype(gPolygonModes)::const_iterator mPolygonMode = gPolygonModes.begin() + 2;
+        decltype(gPolygonModes)::const_iterator mPolygonMode = gPolygonModes.begin() + 2;
+        bool mShowPunctualLights = true;
     };
 
     Scene(graphics::AppInterface & aAppInterface, const imguiui::ImguiUi & aImgui);
@@ -115,10 +126,9 @@ struct Scene
     graphics::UniformBufferObject mViewProjectionBuffer;
     graphics::UniformBufferObject mMaterialsBlockBuffer;
     graphics::UniformBufferObject mLightsBlockBuffer;
-    graphics::BufferAny mLinesSsbo;
     renderer::IntrospectProgram mSurfaceProgram;
     renderer::IntrospectProgram mLightProgram;
-    renderer::IntrospectProgram mLineProgram;
+    LineDrawer mLineDrawer;
 
     renderer::EntitiesBlock_glsl mEntities{
         .mEntities = {

src/libs/engine/engine/CMakeLists.txt

@@ -22,6 +22,7 @@ set(${TARGET_NAME}_HEADERS
 
 set(${TARGET_NAME}_SOURCES
     IntrospectProgram.cpp
+    Lines.cpp
     Resources.cpp
     ShaderConstants.cpp
     ShaderProgramManager.cpp

src/libs/engine/engine/Lines.cpp

@@ -0,0 +1,43 @@
+#pragma once
+
+
+#include "Lines.h"
+
+#include <math/Angle.h>
+
+
+namespace ad::renderer {
+
+
+std::vector<math::Position<3, GLfloat>> makeRoundSegment(unsigned int aCircleResolution)
+{
+    std::vector<math::Position<3, GLfloat>> result = {
+        {0.0f, -0.5f, 0.0f},
+        {0.0f, -0.5f, 1.0f},
+        {0.0f,  0.5f, 1.0f},
+        {0.0f, -0.5f, 0.0f},
+        {0.0f,  0.5f, 1.0f},
+        {0.0f,  0.5f, 0.0f},
+    };
+
+    const math::Radian<GLfloat> pi{ math::pi<GLfloat> };
+    math::Radian<GLfloat> step{ 2 * pi / aCircleResolution };
+
+    auto pushCircle = [&](GLfloat aSide)
+        {
+            math::Position<3, GLfloat> center{0.f, 0.f, aSide};
+            for (unsigned int i = 0; i != aCircleResolution; ++i)
+            {
+                result.push_back(center);
+                result.push_back({0.5f * cos(i * step),       0.5f * sin(i * step),       aSide});
+                result.push_back({0.5f * cos((i + 1) * step), 0.5f * sin((i + 1) * step), aSide});
+            }
+        };
+
+    pushCircle(0.f);
+    pushCircle(1.f);
+
+    return result;
+}
+
+} // namespace ad::renderer

src/libs/engine/engine/Lines.h

@@ -25,4 +25,7 @@ struct LinesSsbo_glsl
 };
 
 
+std::vector<math::Position<3, GLfloat>> makeRoundSegment(unsigned int aCircleResolution);
+
+
 } // namespace ad::renderer

src/libs/engine/engine/resources/programs/FatLine.prog

@@ -1,4 +1,4 @@
 {
-    "vertex": "shaders/Line.vert",
+    "vertex": "shaders/LineRound.vert",
     "fragment": "shaders/PlainColor.frag"
 }

src/libs/engine/engine/resources/shaders/LineRound.vert

@@ -0,0 +1,58 @@
+#version 460
+
+
+#include "Constants.glsl"
+#include "ViewProjectionBlock.glsl"
+
+
+layout(location = 0) in vec3 v_Position;
+
+out vec4 ex_Color;
+
+uniform ivec2 u_FramebufferSize;
+
+struct LineSegment
+{
+    // We never use vec3 in buffer-backed interface blocks due to alignment complications
+    // We could use the last float for a per-point width
+    vec4 pointA;
+    vec4 pointB;
+    float width;
+};
+
+
+layout(std140, binding = 8) readonly buffer LinesSsbo
+{
+    LineSegment ub_Segments[];
+};
+
+
+// Note: the idea to use a special pattern of positions to draw the line and the round endpoints
+// was inspired by: https://wwwtyro.net/2019/11/18/instanced-lines.html
+void main() 
+{
+    ex_Color = vec4(1);
+
+    LineSegment segment = ub_Segments[gl_InstanceID];
+    float width = segment.width;
+    vec3 point = v_Position;
+
+    // Use a billboarding technique, and does not requires any extra transformation
+    // while giving equivalent results to the screen-space computation
+    vec4 A_world = vec4(segment.pointA.xyz, 1);
+    vec4 B_world = vec4(segment.pointB.xyz, 1);
+    vec4 selectedPoint_world = (point.z == 1 ? B_world : A_world);
+
+    vec3 xBasis_world = normalize((B_world - A_world).xyz);
+    // Extract the camera position (last column of the cameraToWorld matrix)
+    vec3 camera_world = ub_cameraToWorld[3].xyz;
+    vec3 quadNormal_world = camera_world - selectedPoint_world.xyz;
+
+    vec3 yBasis_world = normalize(cross(quadNormal_world, xBasis_world));
+    xBasis_world = normalize(cross(yBasis_world, quadNormal_world));
+
+    vec3 offset_world = width * (point.x * xBasis_world + point.y * yBasis_world);
+    vec4 vertex = selectedPoint_world + vec4(offset_world, 0);
+
+    gl_Position = ub_viewingProjection * vertex;
+}