(For more resources related to this topic, see here.)

Setting up geometry

Let’s say that our mesh (a quad formed by two triangles) has the following information: vertex positions and texture coordinates. Also, we will arrange the data interleaved in the array.

struct MyVertex
{
float x, y, z;
float s, t;
};
MyVertex geometry[] =  {{0,1,0,0,1}, {0,0,0,0,0}, {1,1,0,1,1},
{1,0,0,1,0}};

// Let's create the objects that will encapsulate our geometry data
GLuint vaoID, vboID;
glGenVertexArray(1, &vaoID);
glBindVertexArray(vaoID);

glGenBuffers(1, &vboID);
glBindBuffer(GL_ARRAY_BUFFER, vboID);

// Attach our data to the OpenGL objects
glBufferData(GL_ARRAY_BUFFER, 4 * sizeof(MyVertex), &geometry[0].x,
GL_DYNAMIC_DRAW);

// Specify the format of each vertex attribute
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(MyVertex), NULL);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(MyVertex),
(void*)(sizeof(float)*3));

At this point, we created the OpenGL objects, set up correctly each vertex attribute format and uploaded the data to GPU.

Setting up textures

Setting up textures follows the same pattern. First create the OpenGL objects, then fill the data and the format in which it is provided.

const int width = 512;
const int height = 512;
const int bpp = 32;
struct RGBColor
{
unsigned char R,G,B,A;
};
RGBColor textureData[width * height];
for(size_t y = 0; y < height; ++y)
for(size_t x = 0; x < width; ++x)
               textureData[y*height+x] = …; //fill your texture here

// Create GL object
GLuint texID;
glGenTextures(1, &texID);
glBindTexture(GL_TEXTURE_2D, texID);

// Fill up the data and set the texel format
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA,
GL_UNSIGNED_BYTE, &textureData[0].R);

// Set texture format data: interpolation and clamping modes
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_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

And that’s all about textures. Later we will use the texture ID to place the texture into a slot, and that slot number is the information that we will pass to the shader to tell it where the texture is placed in order to locate it.

Setting up shaders

In order to setup the shaders, we have to carry out some steps:  load up the source code, compile it and associate to a shader object, and link all shaders together into a program object.

char* vs[1];
vs[0] = "#version 430\nlayout (location = 0) in vec3 PosIn;
layout (location = 1) in vec2 TexCoordIn;
smooth out vec2 TexCoordOut;
uniform mat4 MVP; void main() { TexCoordOut = TexCoordIn;
gl_Position = MVP * vec4(PosIn, 1.0);}";

char fs[1];
fs = "#version 430\n uniform sampler2D Image; smooth in vec2 TexCoord;
out vec4 FBColor;
void main() {FBColor = texture(Image, TexCoord);}";

// Upload source code and compile it
GLuint pId, vsId, fsId;
vsId = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vsId, 1, (const char**)&vs, NULL);
glCompileShader(vsId);

// Check for compilation errors
GLint status = 0, bufferLength = 0;
glGetShaderiv(vsId, GL_COMPILE_STATUS, &status);
if(!status)
{
char* infolog = new char[bufferLength + 1];
glGetShaderiv(vsId, GL_INFO_LOG_LENGTH, &bufferLength);
glGetShaderInfoLog(vsId, bufferLength, NULL, infolog);
infolog[bufferLength] = 0;
printf("Shader compile errors / warnings: %s\n", infolog);
delete [] infolog;
}

The process for the fragment shader is exactly the same. The only change is that the shader object must be created as fsId = glCreateShader(GL_FRAGMENT_SHADER);

// Now let's proceed to link the shaders into the program object
pId = glCreateProgram();
glAttachShader(pId, vsId);
glAttachShader(pId, fsId);
glLinkProgram(pId);
glGetProgramiv(pId, GL_LINK_STATUS, &status);
if(!status)
{
char* infolog = new char[bufferLength + 1];
glGetProgramiv(pId, GL_INFO_LOG_LENGTH, &bufferLength);
infolog[bufferLength] = 0;
printf("Shader linking errors / warnings: %s\n", infolog);
delete [] infolog;
}
// We do not need the vs and fs anymore, so it is same mark them for deletion.
glDeleteShader(vsId);
glDeleteShader(fsId);

The last things to upload to the shader are two uniform variables: the one that corresponds with the view-projection matrix and the one that represents the texture. Those are uniform variables and are set in the following way:

// First bind the program object where we want to upload the variables
glUseProgram(pId);

// Obtain the "slot number" where the uniform is located in
GLint location = glGetUniformLocation(pId, "MVP");
float mvp[16] = {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1};

// Set the data into the uniform's location
glUniformMatrix4fv(location, 1, GL_FALSE, mvp);

// Active the texture slot 0
glActiveTexture(GL_TEXTURE0);

// Bind the texture to the active slot
glBindTexture(GL_TEXTURE_2D, texID);
location = glGetUniformLocation(pId, "Image");

// Upload the texture's slot number to the uniform variable
int imageSlot = 0;
glUniform1i(location, imageSlot);

And that’s all. For the other types of shaders, process is all the same: Create shader object, upload source code, compile and link, but using the proper OpenGL types such as GL_GEOMETRY_SHADER or GL_COMPUTE_SHADER.

A last step, to draw all these things, is to establish them as active and issue the draw call:

glBindVertexArray(vaoID);
glBindTexture(GL_TEXTURE_2D, texID);
glUseProgram(pId);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

Resources for Article:

Further resources on this subject:

• The Basics of GLSL 4.0 Shaders [Article]
• GLSL 4.0: Using Subroutines to Select Shader Functionality [Article]
• Getting Started with GLSL [Article]