texturewithglfw.cpp

// to keep my sanity heres a simplified version of a texture demo for my future self
// original from: github.com/progschj/OpenGL-Examples/blob/master/03texture.cpp

#define GL_GLEXT_PROTOTYPES
#include <GLFW/glfw3.h>

#include <iostream>
#include <string>
#include <vector>

int screenwidth = 640;
int screenheight = 480;
int texwidth = screenwidth * 0.15;
int texheight = screenheight * 0.15;

GLuint shader_program, vertex_shader, fragment_shader;
GLuint texture;

std::string vertex_source =
"#version 330\n"
"layout(location = 0) in vec4 vposition;\n"
"layout(location = 1) in vec2 vtexcoord;\n"
"out vec2 ftexcoord;\n"
"void main() {\n"
"   ftexcoord = vtexcoord;\n"
"   gl_Position = vposition;\n"
"}\n";
    
std::string fragment_source =
"#version 330\n"
"uniform sampler2D tex;\n"
"in vec2 ftexcoord;\n"
"layout(location = 0) out vec4 FragColor;\n"
"void main() {\n"
"   FragColor = texture(tex, ftexcoord);\n"
"}\n";


GLfloat vertexData[] = {
     1.0f, 1.0f, 0.0f,       1.0f, 1.0f,
    -1.0f, 1.0f, 0.0f,       0.0f, 1.0f,
     1.0f,-1.0f, 0.0f,       1.0f, 0.0f,
    -1.0f,-1.0f, 0.0f,       0.0f, 0.0f,
};

GLuint indexData[] = {
    0,1,2,
    2,1,3,
};

int main(){
    glfwInit();

    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
 
    GLFWwindow *window = glfwCreateWindow(screenwidth, screenheight, "Textures with OpenGL", 0, 0);
    
    glfwMakeContextCurrent(window);

    const char *source;
    int length;

    vertex_shader = glCreateShader(GL_VERTEX_SHADER);
    source = vertex_source.c_str();
    length = vertex_source.size();
    glShaderSource(vertex_shader, 1, &source, &length); 
    glCompileShader(vertex_shader);

    fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
    source = fragment_source.c_str();
    length = fragment_source.size();
    glShaderSource(fragment_shader, 1, &source, &length);   
    glCompileShader(fragment_shader);
        

    shader_program = glCreateProgram();    
    glAttachShader(shader_program, vertex_shader);
    glAttachShader(shader_program, fragment_shader);
    glLinkProgram(shader_program);
    
    GLint texture_location = glGetUniformLocation(shader_program, "tex");
    
    GLuint vao, vbo, ibo;
    
    // vao and vbo
    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);
    glGenBuffers(1, &vbo);
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertexData), vertexData, GL_STATIC_DRAW);
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5*sizeof(GLfloat), (char*)0 + 0*sizeof(GLfloat));
    glEnableVertexAttribArray(1);
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5*sizeof(GLfloat), (char*)0 + 3*sizeof(GLfloat));
    
    // ibo
    glGenBuffers(1, &ibo);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indexData), indexData, GL_STATIC_DRAW);
    
    glBindVertexArray(0);

    // texture
    glGenTextures(1, &texture);
    glBindTexture(GL_TEXTURE_2D, texture);

    std::vector<GLubyte> image(4*texwidth*texheight);
    for(int j = 0;j<texheight;++j) {
        for(int i = 0;i<texwidth;++i) {
            size_t index = j*texwidth + i;
            image[4*index + 0] = 0xFF*(rand()/(float)RAND_MAX);
            image[4*index + 1] = 0xFF*(rand()/(float)RAND_MAX);
            image[4*index + 2] = 0xFF*(rand()/(float)RAND_MAX);
            image[4*index + 3] = 0xFF;
        }
    }
    
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_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);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, texwidth, texheight, 0, GL_RGBA, GL_UNSIGNED_BYTE, &image[0]);
    
    while(!glfwWindowShouldClose(window)) {
        glfwPollEvents();
        
        glClear(GL_COLOR_BUFFER_BIT);
        
        glUseProgram(shader_program);
        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, texture);
        glUniform1i(texture_location, 0);
        
        glBindVertexArray(vao);
        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
        
        glfwSwapBuffers(window);     
    }
    
    glfwTerminate();
    return 0;
}