@@ -16,6 +16,18 @@ To build, run `make`. You need the following dependencies on your system:

 -   [GLEW][]

 -   [GLFW][]

+The code prioritizes conciseness and takes a number of shortcuts:

+

+-   We don't actually generate the SDFs and winding numbers from contours, we

+    just hard code simple circle SDFs with given winding numbers.

+-   We don't always take care to explicitly bind OpenGL state at the point of

+    use if we happen to know that the currently bound thing is correct or

+    harmless, which we often do for this simple program.

+-   We abuse the blend mode to add winding numbers, to avoid juggling multiple

+    textures. If you're using clever geometry tricks to generate the SDFs this

+    might be a problem. You might be able to use some overdraw reducing

+    technique, like a depth pre-pass, to mitigate that.

+

 [`sdf-winding`]:  https://git.rcrnstn.net/rcrnstn/sdf-winding

 [glyph]:          https://en.wikipedia.org/wiki/Glyph

 [winding number]: https://en.wikipedia.org/wiki/Winding_number

@@ -3,8 +3,8 @@

 #include <GL/glew.h>

 #include <GLFW/glfw3.h>

-constexpr auto width  = 640;

-constexpr auto height = 480;

+constexpr auto width  = 419;

+constexpr auto height = 293;

 constexpr auto title  = "sdf-winding";

 static void APIENTRY debug_message_callback(

@@ -63,27 +63,118 @@ int main()

         glLinkProgram(program);

         return program;

     };

-    auto tex_coord_program = make_program(R"(

+    auto circle_program = make_program(R"(

         #version 140

+        uniform float smoothing;

+        uniform vec2  center;

+        uniform float radius;

+        uniform int   winding;

+

+        out float windings;

+

+        void main()

+        {

+            vec2  pos = gl_FragCoord.xy;

+            float sdf = length(pos - center) - radius;

+            windings = winding * smoothstep(

+                -smoothing/2,

+                +smoothing/2,

+                -sdf

+            );

+        }

+    )");

+    auto resolve_program = make_program(R"(

+        #version 140

+

+        uniform int       view;

+        uniform sampler2D windings;

+

         in vec2 tex_coord;

         void main()

         {

-            gl_FragColor = vec4(tex_coord, 0, 1);

+            float winding = texture(windings, tex_coord).r;

+            switch (view)

+            {

+                case 0: gl_FragColor = vec4(0.5 + 0.25 * winding); break;

+                case 1: gl_FragColor = vec4(abs(winding));         break;

+            }

         }

     )");

+    /// Texture

+    GLuint windings;

+    glGenTextures(1, &windings);

+    glBindTexture(GL_TEXTURE_2D, windings);

+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);

+    glTexImage2D(

+        GL_TEXTURE_2D, 0,

+        GL_R32F,

+        width, height, 0,

+        GL_RED, GL_FLOAT, nullptr

+    );

+

+    /// Framebuffer

+    GLuint framebuffer;

+    glGenFramebuffers(1, &framebuffer);

+    glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);

+    glFramebufferTexture(

+        GL_FRAMEBUFFER,

+        GL_COLOR_ATTACHMENT0,

+        windings,

+        0

+    );

+

     /// Draw loop

+    float smoothing = 10;

+    int   view      = 0;

+    struct Circle

+    {

+        float center[2];

+        float radius;

+        int   winding;

+    };

+    glEnable(GL_BLEND);

+    glBlendFunc(GL_ONE, GL_ONE);

+    glBlendEquation(GL_FUNC_ADD);

     while (glfwPollEvents(), !glfwWindowShouldClose(window))

     {

         //// Input

         if (glfwGetKey(window, GLFW_KEY_Q))

             glfwSetWindowShouldClose(window, GLFW_TRUE);

+        if (glfwGetKey(window, GLFW_KEY_J))

+            smoothing += 1;

+        if (glfwGetKey(window, GLFW_KEY_K))

+            smoothing -= smoothing < 1 ? smoothing : 1;

+        if (glfwGetKey(window, GLFW_KEY_H))

+            view = 0;

+        if (glfwGetKey(window, GLFW_KEY_L))

+            view = 1;

+

+        //// Generate smoothed windings

+        glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);

+        glClear(GL_COLOR_BUFFER_BIT);

+        glUseProgram(circle_program);

+        for (auto const & circle : {

+            Circle{{(249+ 69)/2.0+0.5, height-1-(251+ 71)/2.0+0.5}, (251- 71)/2.0, +1},

+            Circle{{(192+133)/2.0+0.5, height-1-(241+182)/2.0+0.5}, (241-182)/2.0, +1},

+            Circle{{(138+ 79)/2.0+0.5, height-1-(199+140)/2.0+0.5}, (199-140)/2.0, -1},

+            Circle{{(274+173)/2.0+0.5, height-1-(134+ 33)/2.0+0.5}, (134- 33)/2.0, -1},

+        })

+        {

+            glUniform1fv(glGetUniformLocation(circle_program, "smoothing"), 1, &smoothing);

+            glUniform2fv(glGetUniformLocation(circle_program, "center"),    1,  circle.center);

+            glUniform1fv(glGetUniformLocation(circle_program, "radius"),    1, &circle.radius);

+            glUniform1iv(glGetUniformLocation(circle_program, "winding"),   1, &circle.winding);

+            glDrawArrays(GL_TRIANGLES, 0, 3);

+        }

-        //// Draw

+        //// Resolve

+        glBindFramebuffer(GL_FRAMEBUFFER, 0);

         glClear(GL_COLOR_BUFFER_BIT);

-        glUseProgram(tex_coord_program);

+        glUseProgram(resolve_program);

+        glUniform1iv(glGetUniformLocation(resolve_program, "view"), 1, &view);

         glDrawArrays(GL_TRIANGLES, 0, 3);

         //// Swap