Attributeless Vertex Shader with OpenGL

When doing fullscreen shader passes with openGL I often use a simple technique called "Attribute-less rendering" as described by Robert on his blog. In short this means you store the vertices that you want to render in your vertex shader using a const vec2 array and use the gl_VertexID variable to access the correct element from this array. Great thing about using this technique is that you don't need to setup an VBO or setup the offsets for a Vertex Array Object (VAO).

Recently I want to use this technique to draw simple 2D textures for my Video Capture library. Though I had to find a way to specify the (x,y) offsets and the dimensions where I wanted to draw the texture.

To solve this, I added a vec4 u_pos uniform that holds the offsets in the (x,y) elements and the scale in the (z,w) elements. The values of this u_pos uniform are percentages for of the current viewport dimensions.

Lets say the viewport is 800 x 600. I store a inv_win_w and inv_win_h that I use to convert the x/y/w/h values to percentages:

void CaptureGL::resize(int winW, int winH) {
     inv_win_w = 1.0 / winW;
     inv_win_h = 1.0 / winH;
}

Then whenever you want to draw someting in 2D at a specific location and dimension, I set the vec4 u_pos uniform values like:

void CaptureGL::draw(int x, int y, int w, int h) {
 
     GLint u_pos = glGetUniformLocation(prog, "u_pos"); // NOTE: do this somewhere in your constructor and keep a member
     glUniform4f(u_pos,
        x * inv_win_w, 
        y * inv_win_h,
        w * inv_win_w, 
        h * inv_win_h
     );
 
     glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}

The shaders that backs up this technique is pasted below. We first offset the vertex position using the u_pos.x and u_pos.y after changing the values to Normalized Device Context (NDC) ranges (-1, 1). Then we apply the scaled vertex position.

/*
 
 u_pos.x = X position in percentage of viewport 0-1. 0% means -1.0
 u_pos.y = Y position in percentage of viewport 0-1. 0% means -1.0
 u_pos.z = WIDTH scale in percentage of viewport. 
 u_pos.w = HEIGHT scale in percentage of viewport. 
 
 */
 
static const char* CAPTURE_GL_VS = ""
  "#version 330\n"
  "uniform vec4 u_pos; " 
  ""
  "const vec2 pos[] = vec2[4]("
  "  vec2(0.0, 1.0), "
  "  vec2(0.0, 0.0), "
  "  vec2(1.0, 1.0), "
  "  vec2(1.0, 0.0)  "
  ");"
  ""
  " const vec2[] tex = vec2[4]( "
  "   vec2(0.0, 0.0), "
  "   vec2(0.0, 1.0), "
  "   vec2(1.0, 0.0), "
  "   vec2(1.0, 1.0) "
  ");"
  ""
  "out vec2 v_texcoord; "
  ""
  "void main() { "
  "  vec2 p = pos[gl_VertexID]; " 
  "  vec2 offset = vec2(u_pos.x * 2.0 - 1.0, u_pos.y * 2.0 - 1.0); "
  "  vec2 scale  = vec2(u_pos.z * p.x * 2.0, u_pos.w * p.y * 2.0); " 
  "  gl_Position = vec4(offset.x + scale.x, "
  "                     offset.y + scale.y, "
  "                     0.0, 1.0);"
  "  v_texcoord = tex[gl_VertexID];"
  "}"
  "";