Refactored renderer

Renderer is basically now more C++'y, as it makes more use of classes (a lot of GL types have been wrapped), and the renderer itself is now a class. The monitor mesh is also now indexed.

Tweaked the NTSC artifacting after inadvertently fixing a bug with the way the image was loaded.

10 files changed, 1518 insertions, 0 deletions

@@ -0,0 +1,7 @@
+#ifndef GL_H_3EE4A268
+#define GL_H_3EE4A268
+
+#include <GL/glew.h>
+#include <GLFW/glfw3.h>
+
+#endif /* end of include guard: GL_H_3EE4A268 */
@@ -0,0 +1,109 @@
+#include "mesh.h"
+#include <fstream>
+#include <vector>
+#include <map>
+#include <glm/glm.hpp>
+#include "util.h"
+
+Mesh::Mesh(std::string filename)
+{
+  std::ifstream meshfile(filename);
+  if (!meshfile.is_open())
+  {
+    throw std::invalid_argument("Could not open mesh file");
+  }
+
+  std::vector<glm::vec3> tempVertices;
+  std::vector<glm::vec2> tempUvs;
+  std::vector<glm::vec3> tempNormals;
+
+  std::vector<glm::vec3> outVertices;
+  std::vector<glm::vec2> outUvs;
+  std::vector<glm::vec3> outNormals;
+  std::map<element, unsigned short> elementIds;
+  std::vector<unsigned short> indices;
+
+  while (meshfile)
+  {
+    std::string linetype;
+    meshfile >> linetype;
+
+    if (linetype == "v")
+    {
+      glm::vec3 vertex;
+      meshfile >> vertex.x >> vertex.y >> vertex.z;
+
+      tempVertices.push_back(std::move(vertex));
+    } else if (linetype == "vt")
+    {
+      glm::vec2 uv;
+      meshfile >> uv.x >> uv.y;
+
+      tempUvs.push_back(std::move(uv));
+    } else if (linetype == "vn")
+    {
+      glm::vec3 normal;
+      meshfile >> normal.x >> normal.y >> normal.z;
+
+      tempNormals.push_back(std::move(normal));
+    } else if (linetype == "f")
+    {
+      element elements[3];
+
+      meshfile
+        >> elements[0].vertexId >> chlit('/')
+        >> elements[0].uvId >> chlit('/')
+        >> elements[0].normalId
+        >> elements[1].vertexId >> chlit('/')
+        >> elements[1].uvId >> chlit('/')
+        >> elements[1].normalId
+        >> elements[2].vertexId >> chlit('/')
+        >> elements[2].uvId >> chlit('/')
+        >> elements[2].normalId;
+
+      for (size_t i = 0; i < 3; i++)
+      {
+        if (!elementIds.count(elements[i]))
+        {
+          elementIds[elements[i]] = outVertices.size();
+
+          outVertices.push_back(tempVertices[elements[i].vertexId - 1]);
+          outUvs.push_back(tempUvs[elements[i].uvId - 1]);
+          outNormals.push_back(tempNormals[elements[i].normalId - 1]);
+        }
+
+        indices.push_back(elementIds[elements[i]]);
+      }
+    }
+  }
+
+  glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer_.getId());
+  glBufferData(
+    GL_ARRAY_BUFFER,
+    outVertices.size() * sizeof(glm::vec3),
+    outVertices.data(),
+    GL_STATIC_DRAW);
+
+  glBindBuffer(GL_ARRAY_BUFFER, uvBuffer_.getId());
+  glBufferData(
+    GL_ARRAY_BUFFER,
+    outUvs.size() * sizeof(glm::vec2),
+    outUvs.data(),
+    GL_STATIC_DRAW);
+
+  glBindBuffer(GL_ARRAY_BUFFER, normalBuffer_.getId());
+  glBufferData(
+    GL_ARRAY_BUFFER,
+    outNormals.size() * sizeof(glm::vec3),
+    outNormals.data(),
+    GL_STATIC_DRAW);
+
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer_.getId());
+  glBufferData(
+    GL_ELEMENT_ARRAY_BUFFER,
+    indices.size() * sizeof(unsigned short),
+    indices.data(),
+    GL_STATIC_DRAW);
+
+  indexCount_ = indices.size();
+}
@@ -0,0 +1,62 @@
+#ifndef MESH_H_76B72E12
+#define MESH_H_76B72E12
+
+#include <string>
+#include "gl.h"
+#include "wrappers.h"
+
+class Mesh {
+public:
+
+  Mesh(std::string filename);
+
+  Mesh(const Mesh& other) = delete;
+  Mesh& operator=(const Mesh& other) = delete;
+
+  inline GLuint getVertexBufferId() const
+  {
+    return vertexBuffer_.getId();
+  }
+
+  inline GLuint getUvBufferId() const
+  {
+    return uvBuffer_.getId();
+  }
+
+  inline GLuint getNormalBufferId() const
+  {
+    return normalBuffer_.getId();
+  }
+
+  inline GLuint getIndexBufferId() const
+  {
+    return indexBuffer_.getId();
+  }
+
+  inline size_t getIndexCount() const
+  {
+    return indexCount_;
+  }
+
+private:
+
+  struct element {
+    size_t vertexId;
+    size_t uvId;
+    size_t normalId;
+
+    bool operator<(const element& other) const
+    {
+      return std::tie(vertexId, uvId, normalId) <
+        std::tie(other.vertexId, other.uvId, other.normalId);
+    }
+  };
+
+  GLBuffer vertexBuffer_;
+  GLBuffer uvBuffer_;
+  GLBuffer normalBuffer_;
+  GLBuffer indexBuffer_;
+  size_t indexCount_;
+};
+
+#endif /* end of include guard: MESH_H_76B72E12 */
@@ -0,0 +1,635 @@
+#include "renderer.h"
+#include "consts.h"
+#include "game.h"
+#include <glm/gtc/matrix_transform.hpp>
+#include "texture.h"
+
+// include stb_image
+#define STB_IMAGE_IMPLEMENTATION
+#define STBI_ONLY_PNG
+#define STBI_ONLY_BMP
+#include "stb_image.h"
+
+void setFramebufferSize(GLFWwindow* w, int width, int height)
+{
+  Game& game = *static_cast<Game*>(glfwGetWindowUserPointer(w));
+  Renderer& renderer = game.getRenderer();
+
+  renderer.width_ = width;
+  renderer.height_ = height;
+
+  renderer.bloomFb_ = {};
+  renderer.bloomDepth_ = {};
+  renderer.preBloomTex_ = {};
+  renderer.bloomPassTex1_ = {};
+  renderer.bloomPassTex2_ = {};
+
+  renderer.initializeFramebuffers();
+}
+
+bool Renderer::singletonInitialized_ = false;
+
+Renderer::Window::Window()
+{
+  // Initialize GLFW
+  if (!glfwInit())
+  {
+    throw std::runtime_error("Failed to initialize GLFW");
+  }
+
+  glfwWindowHint(GLFW_SAMPLES, 4); // 4x antialiasing
+  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); // We want version 3.3
+  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+  glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // Mac requires this
+  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+
+  // Create a window
+  window_ = glfwCreateWindow(1024, 768, "Aromatherapy", nullptr, nullptr);
+  if (window_ == nullptr)
+  {
+    throw std::runtime_error("Failed to open GLFW window");
+  }
+
+  glfwMakeContextCurrent(window_);
+
+  glewExperimental = true; // Needed in core profile
+  if (glewInit() != GLEW_OK)
+  {
+    throw std::runtime_error("Failed to initialize GLEW");
+  }
+
+  glfwSetFramebufferSizeCallback(window_, &setFramebufferSize);
+}
+
+Renderer::Window::~Window()
+{
+  glfwTerminate();
+}
+
+Renderer::Renderer() :
+  monitor_("res/monitor-old.obj"),
+  ntscShader_("ntsc"),
+  finalShader_("final"),
+  blitShader_("blit"),
+  fillShader_("fill"),
+  bloom1Shader_("bloom1"),
+  bloom2Shader_("bloom2")
+{
+  if (singletonInitialized_)
+  {
+    throw std::logic_error("Singleton renderer already initialized");
+  }
+
+  singletonInitialized_ = true;
+
+  // Set up vertex array object
+  glBindVertexArray(vao_.getId());
+
+  // Enable depth testing
+  glEnable(GL_DEPTH_TEST);
+  glDepthFunc(GL_LESS);
+
+  // Enable blending
+  glEnable(GL_BLEND);
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+  // Set up the rendering buffers and textures
+  glfwGetFramebufferSize(window_.getHandle(), &width_, &height_);
+
+  initializeFramebuffers();
+
+  // Load the vertices of a flat surface
+  GLfloat g_quad_vertex_buffer_data[] = {
+                -1.0f, -1.0f, 0.0f,
+                 1.0f, -1.0f, 0.0f,
+                -1.0f,  1.0f, 0.0f,
+                -1.0f,  1.0f, 0.0f,
+                 1.0f, -1.0f, 0.0f,
+                 1.0f,  1.0f, 0.0f,
+        };
+
+  glBindBuffer(GL_ARRAY_BUFFER, quadBuffer_.getId());
+  glBufferData(
+    GL_ARRAY_BUFFER,
+    sizeof(GLfloat) * 18,
+    g_quad_vertex_buffer_data,
+    GL_STATIC_DRAW);
+
+  // Load NTSC artifacts
+  int atdw, atdh;
+  unsigned char* artifactsData =
+    stbi_load("res/artifacts.bmp", &atdw, &atdh, 0, 3);
+
+  flipImageData(artifactsData, atdw, atdh, 3);
+
+  glBindTexture(GL_TEXTURE_2D, artifactsTex_.getId());
+  glTexImage2D(
+    GL_TEXTURE_2D,
+    0,
+    GL_RGB,
+    atdw,
+    atdh,
+    0,
+    GL_RGB,
+    GL_UNSIGNED_BYTE,
+    artifactsData);
+
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  glTexParameteri(
+    GL_TEXTURE_2D,
+    GL_TEXTURE_MIN_FILTER,
+    GL_NEAREST_MIPMAP_NEAREST);
+
+  glGenerateMipmap(GL_TEXTURE_2D);
+  stbi_image_free(artifactsData);
+
+  // Load NTSC scanlines
+  unsigned char* scanlinesData =
+    stbi_load("res/scanlines_333.bmp", &atdw, &atdh, 0, 3);
+
+  flipImageData(scanlinesData, atdw, atdh, 3);
+
+  glBindTexture(GL_TEXTURE_2D, scanlinesTex_.getId());
+  glTexImage2D(
+    GL_TEXTURE_2D,
+    0,
+    GL_RGB,
+    atdw,
+    atdh,
+    0,
+    GL_RGB,
+    GL_UNSIGNED_BYTE,
+    scanlinesData);
+
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  glTexParameteri(
+    GL_TEXTURE_2D,
+    GL_TEXTURE_MIN_FILTER,
+    GL_NEAREST_MIPMAP_NEAREST);
+
+  glGenerateMipmap(GL_TEXTURE_2D);
+  stbi_image_free(scanlinesData);
+}
+
+void Renderer::initializeFramebuffers()
+{
+  // Set up the framebuffer
+  glBindFramebuffer(GL_FRAMEBUFFER, genericFb_.getId());
+  GLenum DrawBuffers[1] = {GL_COLOR_ATTACHMENT0};
+  glDrawBuffers(1, DrawBuffers);
+
+  // Set up the bloom framebuffer and depthbuffer
+  glBindFramebuffer(GL_FRAMEBUFFER, bloomFb_.getId());
+  GLenum DrawBuffers2[1] = {GL_COLOR_ATTACHMENT1};
+  glDrawBuffers(1, DrawBuffers2);
+
+  glBindRenderbuffer(GL_RENDERBUFFER, bloomDepth_.getId());
+  glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, width_, height_);
+  glFramebufferRenderbuffer(
+    GL_FRAMEBUFFER,
+    GL_DEPTH_ATTACHMENT,
+    GL_RENDERBUFFER,
+    bloomDepth_.getId());
+
+  // Set up the NTSC rendering buffers
+  glBindTexture(GL_TEXTURE_2D, renderPages_[0].getId());
+  glTexImage2D(
+    GL_TEXTURE_2D,
+    0,
+    GL_RGB,
+    GAME_WIDTH,
+    GAME_HEIGHT,
+    0,
+    GL_RGB,
+    GL_UNSIGNED_BYTE,
+    0);
+
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+  glBindTexture(GL_TEXTURE_2D, renderPages_[1].getId());
+  glTexImage2D(
+    GL_TEXTURE_2D,
+    0,
+    GL_RGB,
+    GAME_WIDTH,
+    GAME_HEIGHT,
+    0,
+    GL_RGB,
+    GL_UNSIGNED_BYTE,
+    0);
+
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+  // Set up bloom rendering buffers
+  glBindTexture(GL_TEXTURE_2D, preBloomTex_.getId());
+  glTexImage2D(
+    GL_TEXTURE_2D,
+    0,
+    GL_RGB,
+    width_,
+    height_,
+    0,
+    GL_RGB,
+    GL_UNSIGNED_BYTE,
+    0);
+
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_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);
+
+  glBindTexture(GL_TEXTURE_2D, bloomPassTex1_.getId());
+  glTexImage2D(
+    GL_TEXTURE_2D,
+    0,
+    GL_RGB,
+    width_ / 4,
+    height_ / 4,
+    0,
+    GL_RGB,
+    GL_UNSIGNED_BYTE,
+    0);
+
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_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);
+
+  glBindTexture(GL_TEXTURE_2D, bloomPassTex2_.getId());
+  glTexImage2D(
+    GL_TEXTURE_2D,
+    0,
+    GL_RGB,
+    width_ / 4,
+    height_ / 4,
+    0,
+    GL_RGB,
+    GL_UNSIGNED_BYTE,
+    0);
+
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_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);
+}
+
+Renderer::~Renderer()
+{
+  singletonInitialized_ = false;
+}
+
+void Renderer::fill(Texture& tex, Rectangle dstrect, int r, int g, int b)
+{
+  // Target the framebuffer
+  glBindFramebuffer(GL_FRAMEBUFFER, genericFb_.getId());
+  glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex.getId(), 0);
+
+  // Set up the vertex attributes
+  int width = tex.getWidth();
+  int height = tex.getHeight();
+
+  GLfloat minx = (GLfloat) dstrect.x / width * 2.0 - 1.0;
+  GLfloat miny = -((GLfloat) dstrect.y / height * 2.0 - 1.0);
+  GLfloat maxx = (GLfloat) (dstrect.x + dstrect.w) / width * 2.0 - 1.0;
+  GLfloat maxy = -((GLfloat) (dstrect.y + dstrect.h) / height * 2.0 - 1.0);
+
+  GLfloat vertexData[] = {
+    minx, miny,
+    maxx, miny,
+    maxx, maxy,
+    minx, miny,
+    minx, maxy,
+    maxx, maxy
+  };
+
+  GLBuffer vertexBuffer;
+  glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer.getId());
+  glBufferData(
+    GL_ARRAY_BUFFER,
+    sizeof(GLfloat) * 12,
+    vertexData, GL_STATIC_DRAW);
+
+  glEnableVertexAttribArray(0);
+  glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
+
+  glViewport(0, 0, tex.getWidth(), tex.getHeight());
+  glClear(GL_DEPTH_BUFFER_BIT);
+
+  fillShader_.use();
+  glUniform3f(
+    fillShader_.getUniformLocation("vecColor"),
+    r / 255.0,
+    g / 255.0,
+    b / 255.0);
+
+  glDrawArrays(GL_TRIANGLES, 0, 6);
+
+  glDisableVertexAttribArray(0);
+}
+
+void Renderer::blit(
+  const Texture& src,
+  Texture& dst,
+  Rectangle srcrect,
+  Rectangle dstrect,
+  double alpha)
+{
+  alpha = glm::clamp(alpha, 0.0, 1.0);
+
+  // Target the framebuffer
+  glBindFramebuffer(GL_FRAMEBUFFER, genericFb_.getId());
+  glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, dst.getId(), 0);
+
+  // Set up the vertex attributes
+  int width = dst.getWidth();
+  int height = dst.getHeight();
+
+  GLfloat minx = (GLfloat) dstrect.x / width * 2.0 - 1.0;
+  GLfloat miny = -((GLfloat) dstrect.y / height * 2.0 - 1.0);
+  GLfloat maxx = (GLfloat) (dstrect.x + dstrect.w) / width * 2.0 - 1.0;
+  GLfloat maxy = -((GLfloat) (dstrect.y + dstrect.h) / height * 2.0 - 1.0);
+
+  GLfloat vertexData[] = {
+    minx, miny,
+    maxx, miny,
+    minx, maxy,
+    maxx, maxy
+  };
+
+  GLBuffer vertexBuffer;
+  glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer.getId());
+  glBufferData(
+    GL_ARRAY_BUFFER,
+    sizeof(GLfloat) * 8,
+    vertexData,
+    GL_STATIC_DRAW);
+
+  glEnableVertexAttribArray(0);
+  glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
+
+  GLfloat minu = (GLfloat) srcrect.x / src.getWidth();
+  GLfloat minv = 1 - ((GLfloat) srcrect.y / src.getHeight());
+  GLfloat maxu = (GLfloat) (srcrect.x + srcrect.w) / src.getWidth();
+  GLfloat maxv = 1 - ((GLfloat) (srcrect.y + srcrect.h) / src.getHeight());
+
+  GLfloat uvData[] = {
+    minu, minv,
+    maxu, minv,
+    minu, maxv,
+    maxu, maxv
+  };
+
+  GLBuffer uvBuffer;
+  glBindBuffer(GL_ARRAY_BUFFER, uvBuffer.getId());
+  glBufferData(
+    GL_ARRAY_BUFFER,
+    sizeof(GLfloat) * 8,
+    uvData,
+    GL_STATIC_DRAW);
+
+  glEnableVertexAttribArray(1);
+  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
+
+  // Set up the shader
+  blitShader_.use();
+  glClear(GL_DEPTH_BUFFER_BIT);
+  glViewport(0, 0, dst.getWidth(), dst.getHeight());
+
+  glActiveTexture(GL_TEXTURE0);
+  glBindTexture(GL_TEXTURE_2D, src.getId());
+  glUniform1i(blitShader_.getUniformLocation("srctex"), 0);
+  glUniform1f(blitShader_.getUniformLocation("alpha"), alpha);
+
+  // Blit!
+  glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+
+  // Unload everything
+  glDisableVertexAttribArray(1);
+  glDisableVertexAttribArray(0);
+}
+
+void Renderer::bloomPass1(
+  const GLTexture& src,
+  GLTexture& dst,
+  bool horizontal,
+  glm::vec2 srcRes,
+  glm::vec2 dstRes)
+{
+  glBindFramebuffer(GL_FRAMEBUFFER, genericFb_.getId());
+  glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, dst.getId(), 0);
+  glViewport(0,0,dstRes.x,dstRes.y);
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  bloom1Shader_.use();
+
+  glActiveTexture(GL_TEXTURE0);
+  glBindTexture(GL_TEXTURE_2D, src.getId());
+  glUniform1i(bloom1Shader_.getUniformLocation("inTex"), 0);
+
+  glm::vec2 offset = glm::vec2(0.0);
+  if (horizontal)
+  {
+    offset.x = 1.2/srcRes.x;
+  } else {
+    offset.y = 1.2/srcRes.y;
+  }
+
+  glUniform2f(bloom1Shader_.getUniformLocation("offset"), offset.x, offset.y);
+
+  glEnableVertexAttribArray(0);
+  glBindBuffer(GL_ARRAY_BUFFER, quadBuffer_.getId());
+  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
+  glDrawArrays(GL_TRIANGLES, 0, 6);
+  glDisableVertexAttribArray(0);
+}
+
+void Renderer::renderScreen(const Texture& tex)
+{
+  // First we're going to composite our frame with the previous frame
+  // We start by setting up the framebuffer
+  glBindFramebuffer(GL_FRAMEBUFFER, genericFb_.getId());
+  glFramebufferTexture(
+    GL_FRAMEBUFFER,
+    GL_COLOR_ATTACHMENT0,
+    renderPages_[curBuf_].getId(),
+    0);
+
+  // Set up the shader
+  glViewport(0,0,GAME_WIDTH,GAME_HEIGHT);
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  ntscShader_.use();
+
+  // Use the current frame texture, nearest neighbor and clamped to edge
+  glActiveTexture(GL_TEXTURE0);
+  glBindTexture(GL_TEXTURE_2D, tex.getId());
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+  glUniform1i(ntscShader_.getUniformLocation("curFrameSampler"), 0);
+
+  // Use the previous frame composite texture, nearest neighbor and clamped to
+  // edge
+  glActiveTexture(GL_TEXTURE1);
+  glBindTexture(GL_TEXTURE_2D, renderPages_[(curBuf_ + 1) % 2].getId());
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+  glUniform1i(ntscShader_.getUniformLocation("prevFrameSampler"), 1);
+
+  // Load the NTSC artifact texture
+  glActiveTexture(GL_TEXTURE2);
+  glBindTexture(GL_TEXTURE_2D, artifactsTex_.getId());
+  glUniform1i(ntscShader_.getUniformLocation("NTSCArtifactSampler"), 2);
+  glUniform1f(ntscShader_.getUniformLocation("NTSCLerp"), curBuf_ * 1.0);
+
+  // Change the 0.0 to a 1.0 or a 10.0 for a glitchy effect!
+  glUniform1f(ntscShader_.getUniformLocation("Tuning_NTSC"), 0.0);
+
+  // Render our composition
+  glEnableVertexAttribArray(0);
+  glBindBuffer(GL_ARRAY_BUFFER, quadBuffer_.getId());
+  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
+  glDrawArrays(GL_TRIANGLES, 0, 6);
+  glDisableVertexAttribArray(0);
+
+  // We're going to render the screen now
+  glBindFramebuffer(GL_FRAMEBUFFER, bloomFb_.getId());
+  glFramebufferTexture(
+    GL_FRAMEBUFFER,
+    GL_COLOR_ATTACHMENT1,
+    preBloomTex_.getId(),
+    0);
+
+  glViewport(0,0,width_,height_);
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  finalShader_.use();
+
+  // Use the composited frame texture, linearly filtered and filling in black
+  // for the border
+  glActiveTexture(GL_TEXTURE0);
+  glBindTexture(GL_TEXTURE_2D, renderPages_[curBuf_].getId());
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
+
+  float borderColor[] = {0.0f, 0.0f, 0.0f, 1.0f};
+  glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, borderColor);
+
+        glGenerateMipmap(GL_TEXTURE_2D);
+  glUniform1i(finalShader_.getUniformLocation("rendertex"), 0);
+
+  // Use the scanlines texture
+  glActiveTexture(GL_TEXTURE1);
+  glBindTexture(GL_TEXTURE_2D, scanlinesTex_.getId());
+  glUniform1i(finalShader_.getUniformLocation("scanlinestex"), 1);
+
+  // Initialize the MVP matrices
+  glm::mat4 p_matrix = glm::perspective(
+    glm::radians(25.0f),
+    static_cast<float>(width_) / static_cast<float>(height_),
+    0.1f,
+    100.0f);
+
+  glm::mat4 v_matrix = glm::lookAt(
+    glm::vec3(3.75,0,0), // Camera
+    glm::vec3(0,0,0),    // Center
+    glm::vec3(0,1,0));   // Up
+
+  glm::mat4 m_matrix = glm::mat4(1.0);
+  glm::mat4 mvp_matrix = p_matrix * v_matrix * m_matrix;
+
+  glUniformMatrix4fv(
+    finalShader_.getUniformLocation("MVP"),
+    1,
+    GL_FALSE,
+    &mvp_matrix[0][0]);
+
+  glUniformMatrix4fv(
+    finalShader_.getUniformLocation("worldMat"),
+    1,
+    GL_FALSE,
+    &m_matrix[0][0]);
+
+  glUniform2f(finalShader_.getUniformLocation("resolution"), width_, height_);
+  glUniform1f(finalShader_.getUniformLocation("iGlobalTime"), glfwGetTime());
+
+  glUniform3f(
+    finalShader_.getUniformLocation("frameColor"),
+    0.76f,
+    0.78f,
+    0.81f);
+
+  glEnableVertexAttribArray(0);
+  glBindBuffer(GL_ARRAY_BUFFER, monitor_.getVertexBufferId());
+  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
+
+  glEnableVertexAttribArray(1);
+  glBindBuffer(GL_ARRAY_BUFFER, monitor_.getNormalBufferId());
+  glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
+
+  glEnableVertexAttribArray(2);
+  glBindBuffer(GL_ARRAY_BUFFER, monitor_.getUvBufferId());
+  glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
+
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, monitor_.getIndexBufferId());
+  glDrawElements(
+    GL_TRIANGLES,
+    monitor_.getIndexCount(),
+    GL_UNSIGNED_SHORT,
+    nullptr);
+
+  glDisableVertexAttribArray(2);
+  glDisableVertexAttribArray(1);
+  glDisableVertexAttribArray(0);
+
+  // First pass of bloom!
+  glm::vec2 bufferSize = glm::vec2(width_, height_);
+
+  bloomPass1(
+    preBloomTex_,
+    bloomPassTex1_,
+    true,
+    bufferSize,
+    bufferSize / 4.0f);
+
+  bloomPass1(
+    bloomPassTex1_,
+    bloomPassTex2_,
+    false,
+    bufferSize / 4.0f,
+    bufferSize / 4.0f);
+
+  // Do the second pass of bloom and render to screen
+  glBindFramebuffer(GL_FRAMEBUFFER, 0);
+  glViewport(0, 0, width_, height_);
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  bloom2Shader_.use();
+
+  glActiveTexture(GL_TEXTURE0);
+  glBindTexture(GL_TEXTURE_2D, preBloomTex_.getId());
+  glUniform1i(bloom2Shader_.getUniformLocation("clearTex"), 0);
+
+  glActiveTexture(GL_TEXTURE1);
+  glBindTexture(GL_TEXTURE_2D, bloomPassTex2_.getId());
+  glUniform1i(bloom2Shader_.getUniformLocation("blurTex"), 1);
+
+  glUniform1f(bloom2Shader_.getUniformLocation("iGlobalTime"), glfwGetTime());
+
+  glEnableVertexAttribArray(0);
+  glBindBuffer(GL_ARRAY_BUFFER, quadBuffer_.getId());
+  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
+  glDrawArrays(GL_TRIANGLES, 0, 6);
+  glDisableVertexAttribArray(0);
+
+  glfwSwapBuffers(window_.getHandle());
+
+  curBuf_ = (curBuf_ + 1) % 2;
+}
@@ -0,0 +1,114 @@
+#ifndef RENDERER_H
+#define RENDERER_H
+
+#include "gl.h"
+#include "wrappers.h"
+#include "mesh.h"
+#include "shader.h"
+#include <glm/glm.hpp>
+
+class Texture;
+struct Rectangle;
+
+class Renderer {
+public:
+
+  class Window {
+  public:
+
+    Window();
+
+    Window(const Window& other) = delete;
+    Window& operator=(const Window& other) = delete;
+
+    ~Window();
+
+    inline GLFWwindow* getHandle()
+    {
+      return window_;
+    }
+
+  private:
+
+    GLFWwindow* window_;
+  };
+
+  static inline bool isSingletonInitialized()
+  {
+    return singletonInitialized_;
+  }
+
+  Renderer();
+
+  Renderer(const Renderer& other) = delete;
+  Renderer& operator=(const Renderer& other) = delete;
+
+  ~Renderer();
+
+  inline Window& getWindow()
+  {
+    return window_;
+  }
+
+  void fill(
+    Texture& tex,
+    Rectangle loc,
+    int r,
+    int g,
+    int b);
+
+  void blit(
+    const Texture& src,
+    Texture& dst,
+    Rectangle srcrect,
+    Rectangle dstrect,
+    double alpha = 1.0);
+
+  void renderScreen(const Texture& tex);
+
+private:
+
+  friend void setFramebufferSize(GLFWwindow* w, int width, int height);
+
+  void initializeFramebuffers();
+
+  void bloomPass1(
+    const GLTexture& src,
+    GLTexture& dst,
+    bool horizontal,
+    glm::vec2 srcRes,
+    glm::vec2 dstRes);
+
+  static bool singletonInitialized_;
+
+  Window window_;
+  GLVertexArray vao_;
+
+  GLFramebuffer genericFb_;
+  GLFramebuffer bloomFb_;
+  GLRenderbuffer bloomDepth_;
+
+  GLTexture renderPages_[2];
+  GLTexture preBloomTex_;
+  GLTexture bloomPassTex1_;
+  GLTexture bloomPassTex2_;
+
+  Mesh monitor_;
+  GLBuffer quadBuffer_;
+
+  GLTexture artifactsTex_;
+  GLTexture scanlinesTex_;
+
+  Shader ntscShader_;
+  Shader finalShader_;
+  Shader blitShader_;
+  Shader fillShader_;
+  Shader bloom1Shader_;
+  Shader bloom2Shader_;
+
+  size_t curBuf_ = 0;
+  int width_;
+  int height_;
+};
+
+#endif
@@ -0,0 +1,84 @@
+#include "shader.h"
+#include <fstream>
+#include <vector>
+#include "util.h"
+
+Shader::Shader(std::string name)
+{
+  GLShader vertexShader(GL_VERTEX_SHADER);
+  GLShader fragmentShader(GL_FRAGMENT_SHADER);
+
+  std::ifstream vertexFile("shaders/" + name + ".vertex");
+  std::ifstream fragmentFile("shaders/" + name + ".fragment");
+
+  std::string vertexCode(slurp(vertexFile));
+  std::string fragmentCode(slurp(fragmentFile));
+
+  const char* vertexCodePtr = vertexCode.c_str();
+  const char* fragmentCodePtr = fragmentCode.c_str();
+
+  glShaderSource(vertexShader.getId(), 1, &vertexCodePtr, nullptr);
+  glShaderSource(fragmentShader.getId(), 1, &fragmentCodePtr, nullptr);
+
+  glCompileShader(vertexShader.getId());
+  glCompileShader(fragmentShader.getId());
+
+#ifdef DEBUG
+  GLint result = GL_FALSE;
+  int infoLogLength;
+
+  glGetShaderiv(vertexShader.getId(), GL_COMPILE_STATUS, &result);
+
+  if (result == GL_FALSE)
+  {
+    glGetShaderiv(vertexShader.getId(), GL_INFO_LOG_LENGTH, &infoLogLength);
+
+    std::vector<char> errMsg(infoLogLength);
+    glGetShaderInfoLog(
+      vertexShader.getId(),
+      infoLogLength,
+      nullptr,
+      errMsg.data());
+
+    throw std::gl_error("Could not compile shader", errMsg.data());
+  }
+
+  glGetShaderiv(fragmentShader.getId(), GL_COMPILE_STATUS, &result);
+
+  if (result == GL_FALSE)
+  {
+    glGetShaderiv(fragmentShader.getId(), GL_INFO_LOG_LENGTH, &infoLogLength);
+
+    std::vector<char> errMsg(infoLogLength);
+    glGetShaderInfoLog(
+      fragmentShader.getId(),
+      infoLogLength,
+      nullptr,
+      errMsg.data());
+
+    throw std::gl_error("Could not compile shader", errMsg.data());
+  }
+#endif
+
+  glAttachShader(program_.getId(), vertexShader.getId());
+  glAttachShader(program_.getId(), fragmentShader.getId());
+  glLinkProgram(program_.getId());
+
+#ifdef DEBUG
+  glGetProgramiv(program_.getId(), GL_LINK_STATUS, &result);
+
+  if (result == GL_FALSE)
+  {
+    glGetProgramiv(program_.getId(), GL_INFO_LOG_LENGTH, &infoLogLength);
+
+    std::vector<char> errMsg(infoLogLength);
+    glGetProgramInfoLog(
+      program_.getId(),
+      infoLogLength,
+      nullptr,
+      errMsg.data());
+
+    throw std::gl_error("Could not link shader program", errMsg.data());
+  }
+#endif
+}
@@ -0,0 +1,58 @@
+#ifndef SHADER_H_25115B63
+#define SHADER_H_25115B63
+
+#include <string>
+#include <stdexcept>
+#include "gl.h"
+#include "wrappers.h"
+
+class gl_error : public std::logic_error {
+public:
+
+  gl_error(
+    const char* msg,
+    std::string info) :
+      std::logic_error(msg),
+      info_(std::move(info))
+  {
+  }
+
+  gl_error(
+    std::string& msg,
+    std::string info) :
+      std::logic_error(msg),
+      info_(std::move(info))
+  {
+  }
+
+  inline const std::string& getInfo() const
+  {
+    return info_;
+  }
+
+private:
+
+  std::string info_;
+};
+
+class Shader {
+public:
+
+  Shader(std::string name);
+
+  inline void use()
+  {
+    glUseProgram(program_.getId());
+  }
+
+  inline GLint getUniformLocation(const GLchar* name)
+  {
+    return glGetUniformLocation(program_.getId(), name);
+  }
+
+private:
+
+  GLProgram program_;
+};
+
+#endif /* end of include guard: SHADER_H_25115B63 */
@@ -0,0 +1,124 @@
+#include "texture.h"
+#include <stdexcept>
+#include "renderer.h"
+#include "util.h"
+
+// include stb_image
+#define STBI_ONLY_PNG
+#define STBI_ONLY_BMP
+#include "stb_image.h"
+
+Texture::Texture(
+  int width,
+  int height) :
+    width_(width),
+    height_(height)
+{
+  if (!Renderer::isSingletonInitialized())
+  {
+    throw std::logic_error("Renderer needs to be initialized");
+  }
+
+  glBindTexture(GL_TEXTURE_2D, texture_.getId());
+  glTexImage2D(
+    GL_TEXTURE_2D,
+    0,
+    GL_RGBA,
+    width_,
+    height_,
+    0,
+    GL_RGBA,
+    GL_UNSIGNED_BYTE,
+    0);
+
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+}
+
+Texture::Texture(const char* filename)
+{
+  if (!Renderer::isSingletonInitialized())
+  {
+    throw std::logic_error("Renderer needs to be initialized");
+  }
+
+  glBindTexture(GL_TEXTURE_2D, texture_.getId());
+  unsigned char* data = stbi_load(filename, &width_, &height_, 0, 4);
+  flipImageData(data, width_, height_, 4);
+  glTexImage2D(
+    GL_TEXTURE_2D,
+    0,
+    GL_RGBA,
+    width_,
+    height_,
+    0,
+    GL_RGBA,
+    GL_UNSIGNED_BYTE,
+    data);
+
+  stbi_image_free(data);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+}
+
+Texture::Texture(
+  const Texture& tex) :
+    width_(tex.width_),
+    height_(tex.height_)
+{
+  if (!Renderer::isSingletonInitialized())
+  {
+    throw std::logic_error("Renderer needs to be initialized");
+  }
+
+  unsigned char* data = new unsigned char[4 * width_ * height_];
+  glBindTexture(GL_TEXTURE_2D, tex.getId());
+  glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
+
+  glBindTexture(GL_TEXTURE_2D, texture_.getId());
+  glTexImage2D(
+    GL_TEXTURE_2D,
+    0,
+    GL_RGBA,
+    width_,
+    height_,
+    0,
+    GL_RGBA,
+    GL_UNSIGNED_BYTE,
+    data);
+
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+
+  delete[] data;
+}
+
+Texture::Texture(Texture&& tex) : Texture(0, 0)
+{
+  swap(*this, tex);
+}
+
+Texture& Texture::operator= (Texture tex)
+{
+  swap(*this, tex);
+
+  return *this;
+}
+
+void swap(Texture& tex1, Texture& tex2)
+{
+  std::swap(tex1.width_, tex2.width_);
+  std::swap(tex1.height_, tex2.height_);
+  std::swap(tex1.texture_, tex2.texture_);
+}
+
+Rectangle Texture::entirety() const
+{
+  return {0, 0, width_, height_};
+}
@@ -0,0 +1,52 @@
+#ifndef TEXTURE_H_84EC6DF6
+#define TEXTURE_H_84EC6DF6
+
+#include "wrappers.h"
+
+struct Rectangle {
+  int x;
+  int y;
+  int w;
+  int h;
+};
+
+class Texture {
+public:
+
+  Texture(int width, int height);
+
+  Texture(const char* file);
+
+  Texture(const Texture& tex);
+
+  Texture(Texture&& tex);
+
+  Texture& operator= (Texture tex);
+
+  friend void swap(Texture& tex1, Texture& tex2);
+
+  Rectangle entirety() const;
+
+  inline GLuint getId() const
+  {
+    return texture_.getId();
+  }
+
+  inline int getWidth() const
+  {
+    return width_;
+  }
+
+  inline int getHeight() const
+  {
+    return height_;
+  }
+
+private:
+
+  GLTexture texture_;
+  int width_;
+  int height_;
+};
+
+#endif /* end of include guard: TEXTURE_H_84EC6DF6 */
@@ -0,0 +1,273 @@
+#ifndef WRAPPERS_H_1EE0965B
+#define WRAPPERS_H_1EE0965B
+
+#include "gl.h"
+#include <utility>
+
+class GLVertexArray {
+public:
+
+  GLVertexArray()
+  {
+    glGenVertexArrays(1, &id_);
+  }
+
+  GLVertexArray(const GLVertexArray& other) = delete;
+  GLVertexArray& operator=(const GLVertexArray& other) = delete;
+
+  GLVertexArray(GLVertexArray&& other) : GLVertexArray()
+  {
+    std::swap(id_, other.id_);
+  }
+
+  GLVertexArray& operator=(GLVertexArray&& other)
+  {
+    std::swap(id_, other.id_);
+
+    return *this;
+  }
+
+  ~GLVertexArray()
+  {
+    glDeleteVertexArrays(1, &id_);
+  }
+
+  inline GLuint getId() const
+  {
+    return id_;
+  }
+
+private:
+
+  GLuint id_;
+};
+
+class GLFramebuffer {
+public:
+
+  GLFramebuffer()
+  {
+    glGenFramebuffers(1, &id_);
+  }
+
+  GLFramebuffer(const GLFramebuffer& other) = delete;
+  GLFramebuffer& operator=(const GLFramebuffer& other) = delete;
+
+  GLFramebuffer(GLFramebuffer&& other) : GLFramebuffer()
+  {
+    std::swap(id_, other.id_);
+  }
+
+  GLFramebuffer& operator=(GLFramebuffer&& other)
+  {
+    std::swap(id_, other.id_);
+
+    return *this;
+  }
+
+  ~GLFramebuffer()
+  {
+    glDeleteFramebuffers(1, &id_);
+  }
+
+  inline GLuint getId() const
+  {
+    return id_;
+  }
+
+private:
+
+  GLuint id_;
+};
+
+class GLRenderbuffer {
+public:
+
+  GLRenderbuffer()
+  {
+    glGenRenderbuffers(1, &id_);
+  }
+
+  GLRenderbuffer(const GLRenderbuffer& other) = delete;
+  GLRenderbuffer& operator=(const GLRenderbuffer& other) = delete;
+
+  GLRenderbuffer(GLRenderbuffer&& other) : GLRenderbuffer()
+  {
+    std::swap(id_, other.id_);
+  }
+
+  GLRenderbuffer& operator=(GLRenderbuffer&& other)
+  {
+    std::swap(id_, other.id_);
+
+    return *this;
+  }
+
+  ~GLRenderbuffer()
+  {
+    glDeleteRenderbuffers(1, &id_);
+  }
+
+  inline GLuint getId() const
+  {
+    return id_;
+  }
+
+private:
+
+  GLuint id_;
+};
+
+class GLBuffer {
+public:
+
+  GLBuffer()
+  {
+    glGenBuffers(1, &id_);
+  }
+
+  GLBuffer(const GLBuffer& other) = delete;
+  GLBuffer& operator=(const GLBuffer& other) = delete;
+
+  GLBuffer(GLBuffer&& other) : GLBuffer()
+  {
+    std::swap(id_, other.id_);
+  }
+
+  GLBuffer& operator=(GLBuffer&& other)
+  {
+    std::swap(id_, other.id_);
+
+    return *this;
+  }
+
+  ~GLBuffer()
+  {
+    glDeleteBuffers(1, &id_);
+  }
+
+  inline GLuint getId() const
+  {
+    return id_;
+  }
+
+private:
+
+  GLuint id_;
+};
+
+class GLTexture {
+public:
+
+  GLTexture()
+  {
+    glGenTextures(1, &id_);
+  }
+
+  GLTexture(const GLTexture& other) = delete;
+  GLTexture& operator=(const GLTexture& other) = delete;
+
+  GLTexture(GLTexture&& other) : GLTexture()
+  {
+    std::swap(id_, other.id_);
+  }
+
+  GLTexture& operator=(GLTexture&& other)
+  {
+    std::swap(id_, other.id_);
+
+    return *this;
+  }
+
+  ~GLTexture()
+  {
+    glDeleteTextures(1, &id_);
+  }
+
+  inline GLuint getId() const
+  {
+    return id_;
+  }
+
+private:
+
+  GLuint id_;
+};
+
+class GLShader {
+public:
+
+  GLShader(GLenum type)
+  {
+    id_ = glCreateShader(type);
+  }
+
+  GLShader(const GLShader& other) = delete;
+  GLShader& operator=(const GLShader& other) = delete;
+
+  GLShader(GLShader&& other) : GLShader(GL_VERTEX_SHADER)
+  {
+    std::swap(id_, other.id_);
+  }
+
+  GLShader& operator=(GLShader&& other)
+  {
+    std::swap(id_, other.id_);
+
+    return *this;
+  }
+
+  ~GLShader()
+  {
+    glDeleteShader(id_);
+  }
+
+  inline GLuint getId() const
+  {
+    return id_;
+  }
+
+private:
+
+  GLuint id_;
+};
+
+class GLProgram {
+public:
+
+  GLProgram()
+  {
+    id_ = glCreateProgram();
+  }
+
+  GLProgram(const GLProgram& other) = delete;
+  GLProgram& operator=(const GLProgram& other) = delete;
+
+  GLProgram(GLProgram&& other) : GLProgram()
+  {
+    std::swap(id_, other.id_);
+  }
+
+  GLProgram& operator=(GLProgram&& other)
+  {
+    std::swap(id_, other.id_);
+
+    return *this;
+  }
+
+  ~GLProgram()
+  {
+    glDeleteProgram(id_);
+  }
+
+  inline GLuint getId() const
+  {
+    return id_;
+  }
+
+private:
+
+  GLuint id_;
+};
+
+#endif /* end of include guard: WRAPPERS_H_1EE0965B */