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

  // как пользоваться шейдерами ты знаешь,
  // поэтому я спрячу эти детали в класс,
  // чтобы не захламлять (гомно)код
  gl::Program blur;
  {
    gl::Shader frag{gl::ShaderType::Fragment};
    const std::string srcFrag = R"(
      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(color);
      }
    )";
    frag.loadFromMemory(srcFrag);
    blur.attachShader(frag);
    blur.link();
  }
 
  GLint uDirection = blur.getUniformLocation("uDirection");
  GLint uDelta = blur.getUniformLocation("uDelta");
  
  // размеры кастомных текстур должны иметь то же соотношение сторон,
  // что и основной фрэймбуфер окна, но для повышения производительности и экономии памяти
  // путём снижения качества, можно их пропорционально уменьшить
  GLint fboSizeX = 800;
  GLint fboSizeY = 600;
  // две текстуры для фрэймбуфера
  GLuint tex[2] = {};
  gl->GenTextures(2, tex);
  for (auto texture : tex) {
    gl->BindTexture(GL_TEXTURE_2D, texture);
    gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    // на самом деле тут достаточно одноканальных текстур,
    // но мне лень пихать ещё один шейдер для заливки обводки,
    // так что будем использовать фиксированный конвейер и RGBA текстуры
    gl->TexImage2D(GL_TEXTURE_2D,
                   0,
                   GL_RGBA,
                   fboSizeX,
                   fboSizeY,
                   0,
                   GL_RGBA,
                   GL_UNSIGNED_BYTE,
                   nullptr);
  }
  gl->BindTexture(GL_TEXTURE_2D, 0);
  // фрэймбуфер
  GLuint fbo = 0;
  gl->GenFramebuffers(1, &fbo);
  gl->BindFramebuffer(GL_FRAMEBUFFER, fbo);
  gl->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex[0], 0);
  GLenum status = gl->CheckFramebufferStatus(GL_FRAMEBUFFER);
  if (status != GL_FRAMEBUFFER_COMPLETE) {
    utils::message(utils::LogType::Critical, "incomplete fbo");
  }
  gl->BindFramebuffer(GL_FRAMEBUFFER, 0);
 
  gl->GenLists(2);
  // создаём call list для куба с цветными гранями
  gl->NewList(1, GL_COMPILE);
  {
    const double a = 1.0;
    const vec3 ltf = {-a, a, -a};
    const vec3 lbf = {-a, -a, -a};
    const vec3 rbf = {a, -a, -a};
    const vec3 rtf = {a, a, -a};
    const vec3 ltn = {-a, a, a};
    const vec3 lbn = {-a, -a, a};
    const vec3 rbn = {a, -a, a};
    const vec3 rtn = {a, a, a};
    
    gl->Begin(GL_QUADS);
 
    gl->Color3d(0.8, 0.2, 0.2);
    gl->Vertex3dv(ltf.data());
    gl->Vertex3dv(lbf.data());
    gl->Vertex3dv(lbn.data());
    gl->Vertex3dv(ltn.data());
    gl->Color3d(0.8, 0.8, 0.2);
    gl->Vertex3dv(ltn.data());
    gl->Vertex3dv(lbn.data());
    gl->Vertex3dv(rbn.data());
    gl->Vertex3dv(rtn.data());
    gl->Color3d(0.2, 0.8, 0.2);
    gl->Vertex3dv(rtn.data());
    gl->Vertex3dv(rbn.data());
    gl->Vertex3dv(rbf.data());
    gl->Vertex3dv(rtf.data());
    gl->Color3d(0.2, 0.8, 0.8);
    gl->Vertex3dv(rtf.data());
    gl->Vertex3dv(rbf.data());
    gl->Vertex3dv(lbf.data());
    gl->Vertex3dv(ltf.data());
    gl->Color3d(0.2, 0.2, 0.8);
    gl->Vertex3dv(ltf.data());
    gl->Vertex3dv(ltn.data());
    gl->Vertex3dv(rtn.data());
    gl->Vertex3dv(rtf.data());
    gl->Color3d(0.8, 0.2, 0.8);
    gl->Vertex3dv(lbn.data());
    gl->Vertex3dv(lbf.data());
    gl->Vertex3dv(rbf.data());
    gl->Vertex3dv(rbn.data());
    
    gl->End();
  }
  gl->EndList();
 
  // создаём call list для текстурированного прямоугольника во весь экран
  gl->NewList(2, GL_COMPILE);
  {
    gl->PushMatrix();
    gl->LoadIdentity();
    gl->MatrixMode(GL_PROJECTION);
    gl->PushMatrix();
    gl->LoadIdentity();
    gl->MatrixMode(GL_TEXTURE);
    gl->PushMatrix();
    gl->LoadIdentity();
 
    gl->Begin(GL_QUADS);
    gl->TexCoord2d(0.0, 0.0);
    gl->Vertex2d(-1.0, -1.0);
    gl->TexCoord2d(1.0, 0.0);
    gl->Vertex2d(1.0, -1.0);
    gl->TexCoord2d(1.0, 1.0);
    gl->Vertex2d(1.0, 1.0);
    gl->TexCoord2d(0.0, 1.0);
    gl->Vertex2d(-1.0, 1.0);
    gl->End();
 
    gl->PopMatrix();
    gl->MatrixMode(GL_PROJECTION);
    gl->PopMatrix();
    gl->MatrixMode(GL_MODELVIEW);
    gl->PopMatrix();
  }
  gl->EndList();
  
  // рисование кубика
  // scale - масштаб
  // off - смещение
  // angle - угол поворота
  // axis - ось, вокруг которой поворачиваем
  auto cube = [gl](double scale, vec3 const& off, double angle, vec3 const& axis) {
    gl->PushMatrix();
 
    gl->Rotated(angle, axis[0], axis[1], axis[2]);
    gl->Translated(off[0], off[1], off[2]);
    gl->Rotated(angle * 0.5, axis[1], axis[2], axis[0]);
    gl->Scaled(scale, scale, scale);
 
    gl->CallList(1);
 
    gl->PopMatrix();
  };
 
  // перспективная проекция
  gl->MatrixMode(GL_PROJECTION);
  gl->LoadIdentity();
  gl->Frustum(-4, 4, -3, 3, 10, 100);
 
  // положение "камеры"
  gl->MatrixMode(GL_MODELVIEW);
  gl->LoadIdentity();
  gl->Translated(0.0, 0.0, -25.0);
 
  gl->Viewport(0, 0, 800, 600);
  
  gl->Enable(GL_DEPTH_TEST);
  gl->Enable(GL_CULL_FACE);
  gl->CullFace(GL_BACK);
 
  while (!glfwWindowShouldClose(window)) {
    glfwPollEvents();
////////////////////////////////////////////////////////////////////////////////
    double t = glfwGetTime();
    double angle = t * 30.0;
 
    gl->ClearColor(0.3f, 0.73f, 0.91f, 1.0f);
    gl->Clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
    // Рисуем два маленьких кубика.
    // При этом в трафарете выставляем младший бит,
    // вне зависимости от успеха теста глубины(чтоб и за "стенками" было видно).
    gl->Enable(GL_STENCIL_TEST);
    gl->StencilFunc(GL_ALWAYS, 0x01, 0xff);
    gl->StencilOp(GL_KEEP, GL_REPLACE, GL_REPLACE);
    cube(1.0, vec3{3.0, 3.0, 3.0}, angle, vec3{-1.0, 1.0, 0.0});
    cube(1.0, vec3{4.0, 5.0, 6.0}, angle, vec3{-1.0, 1.0, 0.0});
    gl->Disable(GL_STENCIL_TEST);
 
    // Опять рисуем два маленьких кубика, но в нашу текстуру
    // крася фрагменты в белый цвет
    gl->BindFramebuffer(GL_FRAMEBUFFER, fbo);
    gl->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex[0], 0);
    gl->Viewport(0, 0, fboSizeX, fboSizeY);
    gl->ClearColor(0, 0, 0, 0);
    gl->Clear(GL_COLOR_BUFFER_BIT); // очищать нужно только один раз за кадр
    gl->Enable(GL_COLOR_LOGIC_OP);
    gl->LogicOp(GL_SET); // красим в белый цвет
    cube(1.0, vec3{3.0, 3.0, 3.0}, angle, vec3{-1.0, 1.0, 0.0});
    cube(1.0, vec3{4.0, 5.0, 6.0}, angle, vec3{-1.0, 1.0, 0.0});
    gl->Disable(GL_COLOR_LOGIC_OP);
    gl->BindFramebuffer(GL_FRAMEBUFFER, 0);
    gl->Viewport(0, 0, 800, 600);
 
    // Рисуем большой кубик (ну или просто остальные объекты сцены)
    cube(2.2, vec3{}, 0.3 * angle, vec3{1.0, 0.0, 1.0});
 
    // теперь делаем обводку
    // делать это нужно один раз в конце рисования сцены
 
    // блюрим силуэты (блюр в два прохода)
    gl->Enable(GL_TEXTURE_2D);
    blur.bind();
    blur.setUniform(uDelta, gl::vec2{1.0f/fboSizeX, 1.0f/fboSizeY});
    gl->BindFramebuffer(GL_FRAMEBUFFER, fbo);
    gl->Viewport(0, 0, fboSizeX, fboSizeY);
    gl->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex[1], 0);
    gl->BindTexture(GL_TEXTURE_2D, tex[0]);
    blur.setUniform(uDirection, gl::vec2{1.0f, 0.0f});
    gl->CallList(2);
    gl->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex[0], 0);
    gl->BindTexture(GL_TEXTURE_2D, tex[1]);
    blur.setUniform(uDirection, gl::vec2{0.0f, 1.0f});
    gl->CallList(2);
    blur.unbind();
    // заливаем цветом экран там,
    // где в буфере трафарета не выставлен младший бит
    // и есть размытые силуэты объектов
    gl->BindFramebuffer(GL_FRAMEBUFFER, 0);
    gl->Viewport(0, 0, 800, 600);
    gl->BindTexture(GL_TEXTURE_2D, tex[0]);
    gl->Enable(GL_BLEND);
    gl->BlendEquation(GL_FUNC_ADD);
    gl->BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    gl->Enable(GL_STENCIL_TEST);
    gl->Disable(GL_DEPTH_TEST);
    gl->StencilFunc(GL_NOTEQUAL, 0x01, 0xff);
    gl->StencilMask(0x00);
    double a = (std::sin(std::fmod(t * 2.0, 6.2832)) + 1.0) * 0.5;
    gl->Color3d(a, a, a);
    gl->CallList(2);
    gl->StencilMask(0xff);
    gl->Disable(GL_STENCIL_TEST);
    gl->Disable(GL_BLEND);
    gl->Enable(GL_DEPTH_TEST);
    gl->Disable(GL_TEXTURE_2D);
    
    
////////////////////////////////////////////////////////////////////
    glfwSwapBuffers(window);
  }
 
  gl->DeleteLists(1, 2);
  gl->DeleteFramebuffers(1, &fbo);
  gl->DeleteTextures(2, tex);