Обводка объекта с использованием шейдера

const char* fragmentSource = R"(
    #version 460
 
    uniform vec2 uDelta;
    uniform vec2 uDirection;
    uniform sampler2D uTexture;
 
    void main()
    {
        vec2 uv = gl_TexCoord[0].st;
        float color = texture2D(uTexture, uv).r;
        vec2 off1 = uDirection * 1.5;
        vec2 off2 = uDirection * 3.0;
 
        color += texture2D(uTexture, uv + uDelta * off1).r * 0.5 +
                    texture2D(uTexture, uv - uDelta * off1).r * 0.5 +
                    texture2D(uTexture, uv + uDelta * off2).r * 0.25 +
                    texture2D(uTexture, uv - uDelta * off2).r * 0.25;
 
        gl_FragColor = vec4(1.0f);
    }
)";
 
constexpr int fboSizeX = 800;
constexpr int fboSizeY = 600;
 
unsigned int tex[2] = {};
unsigned int fbo = 0;
 
void drawRectangle()
{
    glPushMatrix();
    glLoadIdentity();
    glMatrixMode(GL_PROJECTION);
    glPushMatrix();
    glLoadIdentity();
    glMatrixMode(GL_TEXTURE);
    glPushMatrix();
    glLoadIdentity();
 
    glBegin(GL_QUADS);
    glTexCoord2d(0.0, 0.0);
    glVertex2d(-1.0, -1.0);
    glTexCoord2d(1.0, 0.0);
    glVertex2d(1.0, -1.0);
    glTexCoord2d(1.0, 1.0);
    glVertex2d(1.0, 1.0);
    glTexCoord2d(0.0, 1.0);
    glVertex2d(-1.0, 1.0);
    glEnd();
 
    glPopMatrix();
    glMatrixMode(GL_PROJECTION);
    glPopMatrix();
    glMatrixMode(GL_MODELVIEW);
    glPopMatrix();
}
 
bool initialize()
{
    glGenTextures(2, tex);
 
    for (auto texture : tex)
    {
        glBindTexture(GL_TEXTURE_2D, texture);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
        glTexImage2D(GL_TEXTURE_2D,
            0,
            GL_RGBA,
            fboSizeX,
            fboSizeY,
            0,
            GL_RGBA,
            GL_UNSIGNED_BYTE,
            nullptr);
    }
 
    glBindTexture(GL_TEXTURE_2D, 0);
 
    glGenFramebuffers(1, &fbo);
    glBindFramebuffer(GL_FRAMEBUFFER, fbo);
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex[0], 0);
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
    return true;
}
 
int WINAPI mySwapBuffers(HDC pDeviceContextHandle)
{
    /* Getting OpenGL function pointers */
    const static int version = gladLoaderLoadGL();
 
    if (!version)
        return fpSwapBuffers(pDeviceContextHandle);
 
    const static bool init = initialize();
 
    const static unsigned int shader = createShader();
 
    const static int uDirection = glGetUniformLocation(shader, "uDirection");
    const static int uDelta = glGetUniformLocation(shader, "uDelta");
 
    // теперь делаем обводку
    // делать это нужно один раз в конце рисования сцены
 
    // блюрим силуэты (блюр в два прохода)
    glEnable(GL_TEXTURE_2D);
 
    glUseProgram(shader);
    glUniform2fv(uDelta, 1, value_ptr(glm::vec2{ 1.0f / fboSizeX, 1.0f / fboSizeY }));
 
    glBindFramebuffer(GL_FRAMEBUFFER, fbo);
    glViewport(0, 0, fboSizeX, fboSizeY);
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex[1], 0);
    glBindTexture(GL_TEXTURE_2D, tex[0]);
 
    glUniform2fv(uDirection, 1, value_ptr(glm::vec2{ 1.0f, 0.0f }));
    drawRectangle(); // glCallList(2);
 
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex[0], 0);
    glBindTexture(GL_TEXTURE_2D, tex[1]);
 
    glUniform2fv(uDirection, 1, value_ptr(glm::vec2{ 0.0f, 1.0f }));
    drawRectangle(); // glCallList(2);
 
    glUseProgram(0);
    // заливаем цветом экран там,
    // где в буфере трафарета не выставлен младший бит
    // и есть размытые силуэты объектов
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
    glViewport(0, 0, fboSizeX, fboSizeY);
    glBindTexture(GL_TEXTURE_2D, tex[0]);
    glEnable(GL_BLEND);
    glBlendEquation(GL_FUNC_ADD);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glEnable(GL_STENCIL_TEST);
    glDisable(GL_DEPTH_TEST);
    glStencilFunc(GL_NOTEQUAL, 0x01, 0xff);
    glStencilMask(0x00);
    glColor3d(1.0, 1.0, 1.0);
    drawRectangle(); // glCallList(2);
    glStencilMask(0xff);
    glDisable(GL_STENCIL_TEST);
    glDisable(GL_BLEND);
    glEnable(GL_DEPTH_TEST);
    glDisable(GL_TEXTURE_2D);
 
    glClear(GL_STENCIL_BUFFER_BIT);
    return fpSwapBuffers(pDeviceContextHandle);
}
 
void WINAPI myglCallList(GLuint list)
{
    glEnable(GL_STENCIL_TEST);
    glStencilFunc(GL_ALWAYS, 0x01, 0xff);
    glStencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
    fpglCallList(list);
    glDisable(GL_STENCIL_TEST);
 
    glBindFramebuffer(GL_FRAMEBUFFER, fbo);
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex[0], 0);
    glViewport(0, 0, fboSizeX, fboSizeY);
    glEnable(GL_COLOR_LOGIC_OP);
    glLogicOp(GL_SET);
    fpglCallList(list);
    glDisable(GL_COLOR_LOGIC_OP);
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
    glViewport(0, 0, fboSizeX, fboSizeY);
}

class test
{
    GLint m_width = 1;
    GLint m_height = 1;
    GLfloat m_quality = 1;
    GLint m_fbo_width = 1;
    GLint m_fbo_height = 1;
 
    GLuint m_textures[2] = {};
    GLuint m_stencil = 0;
    GLuint m_fbo = 0;
    GLuint m_shader = 0;
 
    GLint m_delta_location = -1;
    GLint m_direction_location = -1;
    GLint m_texture_location = -1;
 
    struct state_cache
    {
        GLint texturing = GL_FALSE;
        GLint texture_unit = GL_TEXTURE0;
        GLint texture = 0;
        GLint renderbuffer = 0;
        GLint program = 0;
        GLint fbo = 0;
        GLint blend = GL_FALSE;
        GLint blend_equation_rgb = GL_FUNC_ADD;
        GLint blend_equation_alpha = GL_FUNC_ADD;
        GLint blend_src_rgb = GL_ONE;
        GLint blend_src_alpha = GL_ONE;
        GLint blend_dst_rgb = GL_ZERO;
        GLint blend_dst_alpha = GL_ZERO;
        GLint color_logic_op = GL_FALSE;
        GLint logic_op = GL_COPY;
        GLint viewport[4] = {};
        GLfloat clear_color[4] = {};
        GLint depth = GL_FALSE;
        GLint stencil = GL_FALSE;
        GLint stencil_clear_value = 0;
        GLint stencil_fail = GL_KEEP;
        GLint stencil_pass_depth_fail = GL_KEEP;
        GLint stencil_pass_depth_pass = GL_KEEP;
        GLint stencil_func = GL_ALWAYS;
        GLint stencil_ref = 0;
        GLint stencil_value_mask = -1;
        GLint stencil_writemask = -1;
 
    } m_state_cache;
 
    void save_texture_state()
    {
        m_state_cache.texturing = glIsEnabled(GL_TEXTURE_2D);
        glGetIntegerv(GL_ACTIVE_TEXTURE, &m_state_cache.texture_unit);
        glActiveTexture(GL_TEXTURE0);
        glGetIntegerv(GL_TEXTURE_BINDING_2D, &m_state_cache.texture);
        
    }
 
    void restore_texture_state()
    {
        if (m_state_cache.texturing)
            glEnable(GL_TEXTURE_2D);
        else
            glDisable(GL_TEXTURE_2D);
        glBindTexture(GL_TEXTURE_2D, m_state_cache.texture);
        glActiveTexture(m_state_cache.texture_unit);
    }
 
    void save_renderbuffer_state()
    {
        glGetIntegerv(GL_RENDERBUFFER_BINDING, &m_state_cache.renderbuffer);
    }
 
    void restore_renderbuffer_state()
    {
        glBindRenderbuffer(GL_RENDERBUFFER, m_state_cache.renderbuffer);
    }
 
    void save_shader_state()
    {
        glGetIntegerv(GL_CURRENT_PROGRAM, &m_state_cache.program);
    }
 
    void restore_shader_state()
    {
        glUseProgram(m_state_cache.program);
    }
 
    void save_framebuffer_state()
    {
        glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &m_state_cache.fbo);
    }
 
    void restore_framebuffer_state()
    {
        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_state_cache.fbo);
    }
 
    void save_blend_state()
    {
        m_state_cache.blend = glIsEnabled(GL_BLEND);
        glGetIntegerv(GL_BLEND_EQUATION_RGB, &m_state_cache.blend_equation_rgb);
        glGetIntegerv(GL_BLEND_EQUATION_ALPHA, &m_state_cache.blend_equation_alpha);
        glGetIntegerv(GL_BLEND_SRC_RGB, &m_state_cache.blend_src_rgb);
        glGetIntegerv(GL_BLEND_SRC_ALPHA, &m_state_cache.blend_src_alpha);
        glGetIntegerv(GL_BLEND_DST_RGB, &m_state_cache.blend_dst_rgb);
        glGetIntegerv(GL_BLEND_DST_ALPHA, &m_state_cache.blend_dst_alpha);
    }
 
    void restore_blend_state()
    {
        if (m_state_cache.blend)
            glEnable(GL_BLEND);
        else
            glDisable(GL_BLEND);
        glBlendEquationSeparate(m_state_cache.blend_equation_rgb, m_state_cache.blend_equation_alpha);
        glBlendFuncSeparate(m_state_cache.blend_src_rgb,
                            m_state_cache.blend_dst_rgb,
                            m_state_cache.blend_src_alpha,
                            m_state_cache.blend_dst_alpha);
    }
 
    void save_logic_op_state()
    {
        m_state_cache.color_logic_op = glIsEnabled(GL_COLOR_LOGIC_OP);
        glGetIntegerv(GL_LOGIC_OP_MODE, &m_state_cache.logic_op);
    }
 
    void restore_logic_op_state()
    {
        if (m_state_cache.color_logic_op)
            glEnable(GL_COLOR_LOGIC_OP);
        else
            glDisable(GL_COLOR_LOGIC_OP);
        glLogicOp(m_state_cache.logic_op);
    }
 
    void save_viewport_state()
    {
        glGetIntegerv(GL_VIEWPORT, m_state_cache.viewport);
    }
 
    void restore_viewport_state()
    {
        glViewport(m_state_cache.viewport[0],
                   m_state_cache.viewport[1],
                   m_state_cache.viewport[2],
                   m_state_cache.viewport[3]);
    }
 
    void save_clear_color_state()
    {
        glGetFloatv(GL_COLOR_CLEAR_VALUE, m_state_cache.clear_color);
    }
 
    void restore_clear_color_state()
    {
        glClearColor(m_state_cache.clear_color[0],
                     m_state_cache.clear_color[1],
                     m_state_cache.clear_color[2],
                     m_state_cache.clear_color[3]);
    }
 
    void save_depth_stencil_state()
    {
        m_state_cache.depth = glIsEnabled(GL_DEPTH_TEST);
        m_state_cache.stencil = glIsEnabled(GL_STENCIL_TEST);
        glGetIntegerv(GL_STENCIL_CLEAR_VALUE, &m_state_cache.stencil_clear_value);
        glGetIntegerv(GL_STENCIL_FAIL, &m_state_cache.stencil_fail);
        glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, &m_state_cache.stencil_pass_depth_fail);
        glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, &m_state_cache.stencil_pass_depth_pass);
        glGetIntegerv(GL_STENCIL_FUNC, &m_state_cache.stencil_func);
        glGetIntegerv(GL_STENCIL_REF, &m_state_cache.stencil_ref);
        glGetIntegerv(GL_STENCIL_VALUE_MASK, &m_state_cache.stencil_value_mask);
        glGetIntegerv(GL_STENCIL_WRITEMASK, &m_state_cache.stencil_writemask);
    }
 
    void restore_depth_stencil_state()
    {
        if (m_state_cache.depth)
            glEnable(GL_DEPTH_TEST);
        else
            glDisable(GL_DEPTH_TEST);
 
        if (m_state_cache.stencil)
            glEnable(GL_STENCIL_TEST);
        else
            glDisable(GL_STENCIL_TEST);
 
        glClearStencil(m_state_cache.stencil_clear_value);
        glStencilOp(m_state_cache.stencil_fail,
                    m_state_cache.stencil_pass_depth_fail,
                    m_state_cache.stencil_pass_depth_pass);
        glStencilFunc(m_state_cache.stencil_func,
                      m_state_cache.stencil_ref,
                      m_state_cache.stencil_value_mask);
        glStencilMask(m_state_cache.stencil_writemask);
    }
 
    void create_shader()
    {
        GLuint shader = glCreateShader(GL_FRAGMENT_SHADER);
 
        const GLchar *data = R"(
      uniform vec2 uDelta;
      uniform vec2 uDirection;
      uniform sampler2D uTexture;
      void main() {
        vec2 uv = gl_TexCoord[0].st;
        float color = texture2D(uTexture, uv).a;
        vec2 off1 = uDirection * 1.5;
        vec2 off2 = uDirection * 3.0;
        color += texture2D(uTexture, uv + uDelta * off1).a * 0.5 +
                 texture2D(uTexture, uv - uDelta * off1).a * 0.5 +
                 texture2D(uTexture, uv + uDelta * off2).a * 0.25 +
                 texture2D(uTexture, uv - uDelta * off2).a * 0.25;
        gl_FragColor = vec4(gl_Color.rgb, color);
      }
        )";
        glShaderSource(shader, 1, &data, nullptr);
        glCompileShader(shader);
 
        GLint status = GL_FALSE;
        glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
        if (status == GL_FALSE)
        {
            std::string buf;
            GLint bufSize = 0;
            glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &bufSize);
            if (bufSize > 1)
            {
                buf.resize(bufSize);
                GLsizei length = 0;
                glGetShaderInfoLog(shader, bufSize, &length, &buf[0]);
                buf.resize(length);
            }
            std::cerr << "shader compile error:\n" << buf << std::endl;
            glDeleteShader(shader);
            return;
        }
 
        GLuint program = glCreateProgram();
        glAttachShader(program, shader);
        glLinkProgram(program);
 
        status = GL_FALSE;
        glGetProgramiv(program, GL_LINK_STATUS, &status);
        if (status == GL_FALSE)
        {
            std::string buf;
            GLint bufSize = 0;
            glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufSize);
            if (bufSize > 1)
            {
                buf.resize(bufSize);
                GLsizei length = 0;
                glGetProgramInfoLog(program, bufSize, &length, &buf[0]);
                buf.resize(length);
            }
            std::cerr << "shader link error:\n" << buf << std::endl;
            glDeleteShader(shader);
            glDeleteProgram(program);
            return;
        }
 
        m_delta_location = glGetUniformLocation(program, "uDelta");
        m_direction_location = glGetUniformLocation(program, "uDirection");
        m_texture_location = glGetUniformLocation(program, "uTexture");
 
        glDetachShader(program, shader);
        glDeleteShader(shader);
 
        m_shader = program;
    }
 
    void create_textures()
    {
        save_texture_state();
        save_renderbuffer_state();
 
        glGenTextures(2, m_textures);
        for (auto texture : m_textures)
        {
            glBindTexture(GL_TEXTURE_2D, texture);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
            
            glTexImage2D(GL_TEXTURE_2D,
                         0,
                         GL_RGBA,
                         m_fbo_width,
                         m_fbo_height,
                         0,
                         GL_RGBA,
                         GL_UNSIGNED_BYTE,
                         nullptr);
        }
 
        glGenRenderbuffers(1, &m_stencil);
        glBindRenderbuffer(GL_RENDERBUFFER, m_stencil);
        glRenderbufferStorage(GL_RENDERBUFFER, GL_STENCIL_INDEX, m_fbo_width, m_fbo_height);
 
        restore_texture_state();
        restore_renderbuffer_state();
    }
 
    void create_fbo()
    {
        save_framebuffer_state();
 
        GLuint fbo = 0;
        glGenFramebuffers(1, &fbo);
        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo);
        glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_textures[0], 0);
        glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_stencil);
        if (glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
        {
            std::cerr << "incomplete fbo\n";
            glDeleteFramebuffers(1, &fbo);
            restore_framebuffer_state();
            return;
        }
        m_fbo = fbo;
 
        save_depth_stencil_state();
        save_clear_color_state();
 
        glStencilMask(0xff);
        glClearStencil(0);
        glClearColor(0, 0, 0, 0);
        glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
 
        restore_depth_stencil_state();
        restore_clear_color_state();
        restore_framebuffer_state();
    }
 
    void draw_quad(float r = 1, float g = 1, float b = 1)
    {
        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
        glLoadIdentity();
        glMatrixMode(GL_PROJECTION);
        glPushMatrix();
        glLoadIdentity();
        glMatrixMode(GL_TEXTURE);
        glPushMatrix();
        glLoadIdentity();
 
        glColor3f(r, g, b);
        glBegin(GL_QUADS);
        glTexCoord2f(0, 0);
        glVertex2f(-1, -1);
        glTexCoord2f(1, 0);
        glVertex2f(1, -1);
        glTexCoord2f(1, 1);
        glVertex2f(1, 1);
        glTexCoord2f(0, 1);
        glVertex2f(-1, 1);
        glEnd();
 
        glPopMatrix();
        glMatrixMode(GL_PROJECTION);
        glPopMatrix();
        glMatrixMode(GL_MODELVIEW);
        glPopMatrix();
    }
 
public:
 
    void create(GLint width, GLint height, GLfloat quality = 1)
    {
        m_width = width;
        m_height = height;
        m_quality = quality;
        m_fbo_width = width * quality + 0.5f;
        m_fbo_height = height * quality + 0.5f;
        create_shader();
        create_textures();
        create_fbo();
    }
 
    void resize(GLint width, GLint height, float quality)
    {
        if (m_width == width && m_height == height && m_quality == quality)
            return;
 
        m_width = width;
        m_height = height;
        m_quality = quality;
        m_fbo_width = m_width * m_quality + 0.5f;
        m_fbo_height = m_height * m_quality + 0.5f;
 
        save_texture_state();
        save_renderbuffer_state();
 
        for (auto texture : m_textures)
        {
            glBindTexture(GL_TEXTURE_2D, texture);
            glTexImage2D(GL_TEXTURE_2D,
                         0,
                         GL_RGBA,
                         m_fbo_width,
                         m_fbo_height,
                         0,
                         GL_RGBA,
                         GL_UNSIGNED_BYTE,
                         nullptr);
        }
 
        glBindRenderbuffer(GL_RENDERBUFFER, m_stencil);
        glRenderbufferStorage(GL_RENDERBUFFER, GL_STENCIL_INDEX, m_fbo_width, m_fbo_height);
 
        restore_texture_state();
        restore_renderbuffer_state();
    }
 
    void begin_draw()
    {
        save_depth_stencil_state();
        glEnable(GL_STENCIL_TEST);
        glStencilFunc(GL_NOTEQUAL, 0x01, 0xff);
        glStencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
        glStencilMask(0xff);
        glDisable(GL_DEPTH_TEST);
 
        save_logic_op_state();
        glEnable(GL_COLOR_LOGIC_OP);
        glLogicOp(GL_SET);
 
        save_viewport_state();
        glViewport(0, 0, m_fbo_width, m_fbo_height);
 
        save_framebuffer_state();
        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_fbo);
        
    }
 
    void end_draw()
    {
        restore_depth_stencil_state();
        restore_logic_op_state();
        restore_viewport_state();
        restore_framebuffer_state();
    }
 
    void blur(float r, float g, float b)
    {
        save_depth_stencil_state();
        glDisable(GL_DEPTH_TEST);
        glDisable(GL_STENCIL_TEST);
 
        save_blend_state();
        glDisable(GL_BLEND);
 
        save_viewport_state();
        glViewport(0, 0, m_fbo_width, m_fbo_height);
 
        save_shader_state();
        glUseProgram(m_shader);
        glUniform2f(m_delta_location, 1.0f / m_fbo_width, 1.0 / m_fbo_height);
        glUniform2f(m_direction_location, 1, 0);
        glUniform1i(m_texture_location, 0);
 
        save_texture_state();
        glEnable(GL_TEXTURE_2D);
        glBindTexture(GL_TEXTURE_2D, m_textures[0]);
 
        save_framebuffer_state();
        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_fbo);
        glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_textures[1], 0);
 
        draw_quad();
 
        glBindTexture(GL_TEXTURE_2D, m_textures[1]);
        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_textures[0], 0);
        glUniform2f(m_direction_location, 0, 1);
        
        draw_quad();
 
        glBindTexture(GL_TEXTURE_2D, m_textures[0]);
        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_textures[1], 0);
 
        glUseProgram(0);
        glEnable(GL_STENCIL_TEST);
        glStencilFunc(GL_NOTEQUAL, 0x01, 0xff);
        glStencilMask(0);
        
        save_clear_color_state();
        glClearColor(0, 0, 0, 0);
        glClear(GL_COLOR_BUFFER_BIT);
 
        draw_quad();
 
        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_textures[0], 0);
        glClearStencil(0);
        glStencilMask(0xff);
        glClear(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
 
        restore_clear_color_state();
        restore_framebuffer_state();
        restore_viewport_state();
 
        glBindTexture(GL_TEXTURE_2D, m_textures[1]);
        glDisable(GL_STENCIL_TEST);
        glEnable(GL_BLEND);
        glBlendEquation(GL_FUNC_ADD);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        
        draw_quad(r, g, b);
        
        restore_depth_stencil_state();
        restore_blend_state();
        restore_shader_state();
        restore_texture_state();
    }
};