@@ -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

@@ -11,9 +11,9 @@

 /// Constants

-constexpr auto width  = 640;

-constexpr auto height = 480;

-constexpr auto title  = "";

+constexpr auto width  = 419;

+constexpr auto height = 293;

+constexpr auto title  = "sdf-winding";

 /// Helpers

@@ -125,33 +125,44 @@ int main(int /*argc*/, char * argv[])

             gl_Position = vec4(tex_coord*2-1, 0, 1);

         }

     )";

-    auto tex_coord_program = make_program(vert_source, R"(

+    auto circle_program = make_program(vert_source, R"(

         #version 140

-        uniform int   view;

-        uniform bool  debug;

-        uniform float time;

+        uniform float sharpness;

+        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 * 1 / (1 + exp2(sharpness*sdf));

+        }

+    )");

+    auto resolve_program = make_program(vert_source, R"(

+        #version 140

+

+        uniform int       view;

+        uniform bool      debug;

+        uniform float     sharpness;

+        uniform float     smoothing;

+        uniform sampler2D windings;

         in vec2 tex_coord;

         void main()

         {

-            gl_FragColor = vec4(fract(tex_coord - float(!debug)*time), 0, 1);

-

-            // Exercise the debugging colors.

-            // <https://www.desmos.com/calculator/uijwefecqs>

-            if (view >= 2)

-            {

-                float x = tex_coord.x;

-                x -= 0.5;

-                x *= 10;

-                x  = clamp(x, -3, +3);

-                x /= (3 + x) * (3 - x);

-                x *= (3 + 1) * (3 - 1);

-                x *= 0.5;

-                x += 0.5;

-                gl_FragColor = vec4(x / (1 / float(tex_coord.y > 0.5)));

-            }

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

+            if (view == 1) winding = 0.5 + 0.25 * winding;                        // view packed, remapped

+            if (view >= 2) winding = clamp(abs(winding), 0, 1);                   // discard sign/sum

+            if (view == 3) winding = 0.5 + 0.25 * winding;                        // view flattened, remapped

+            if (view >= 4) winding = log2(1 / winding - 1) / sharpness;           // unpack (reversible)

+            if (view == 5) winding = winding / 100;                               // view unpacked, expanded

+            if (view >= 6) winding = smoothstep(-smoothing, +smoothing, winding); // smooth

+            gl_FragColor = vec4(vec3(winding), 1);

             bvec3 debug_color = bvec3(

                 any(lessThan   (gl_FragColor, vec4(0))),

@@ -164,10 +175,53 @@ int main(int /*argc*/, char * argv[])

         }

     )");

+    /// 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

+    );

+

+    //// Data

+    struct Circle

+    {

+        GLfloat center[2];

+        GLfloat radius;

+        GLint   winding;

+    }

+    circles[] =

+    {

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

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

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

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

+    };

+

     //// Main loop

-    int   view  = 1;

-    bool  debug = true;

-    float time  = (float)glfwGetTime();

+    int     view      = 1;

+    bool    debug     = true;

+    float   time      = (float)glfwGetTime();

+    float   sharpness = 1;

+    float   smoothing = 5;

+    glEnable(GL_BLEND);

+    glBlendFunc(GL_ONE, GL_ONE);

+    glBlendEquation(GL_FUNC_ADD);

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

     {

         ///// Time

@@ -176,17 +230,37 @@ int main(int /*argc*/, char * argv[])

         ///// Input

         for (int num = 0; num <= 9; ++num)

-        if (glfwGetKey(window, GLFW_KEY_0 + num)) view  = num;

-        if (glfwGetKey(window, GLFW_KEY_R))       debug = false;

-        if (glfwGetKey(window, GLFW_KEY_E))       debug = true;

+        if (glfwGetKey(window, GLFW_KEY_0 + num)) view       = num;

+        if (glfwGetKey(window, GLFW_KEY_E))       debug      = true;

+        if (glfwGetKey(window, GLFW_KEY_R))       debug      = false;

+        if (glfwGetKey(window, GLFW_KEY_H))       sharpness -= 0.5F * dt;

+        if (glfwGetKey(window, GLFW_KEY_L))       sharpness += 0.5F * dt;

+        if (glfwGetKey(window, GLFW_KEY_J))       smoothing -= 5.0F * dt;

+        if (glfwGetKey(window, GLFW_KEY_K))       smoothing += 5.0F * dt;

+        sharpness = std::max(0.1F, sharpness);

+        smoothing = std::max(0.0F, smoothing);

+

+        ///// Generate smoothed windings

+        glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);

+        glClear(GL_COLOR_BUFFER_BIT);

+        glUseProgram(circle_program);

+        for (auto const & circle : circles)

+        {

+            uniform("sharpness", sharpness);

+            uniform("center",    circle.center);

+            uniform("radius",    circle.radius);

+            uniform("winding",   circle.winding);

+            glDrawArrays(GL_TRIANGLES, 0, 3);

+        }

-        ///// Draw

+        ///// Resolve

+        glBindFramebuffer(GL_FRAMEBUFFER, 0);

         glClear(GL_COLOR_BUFFER_BIT);

-        glUseProgram(tex_coord_program);

-        uniform("view",  view);

-        uniform("debug", debug);

-        uniform("time",  time);

-        uniform("dt",    dt);

+        glUseProgram(resolve_program);

+        uniform("view",      view);

+        uniform("debug",     debug);

+        uniform("sharpness", sharpness);

+        uniform("smoothing", smoothing);

         glDrawArrays(GL_TRIANGLES, 0, 3);

         ///// Swap