OpenGL 4.x textures not working - c

Question

I'm new here.
I'm having trouble with textures in OpenGL 4.4, I just get a black screen.
Here's my code (I suspect everything before glGenBuffers() is unimportant but you never know):
#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include "eternity.h"
#include "error.h"
#define STB_IMAGE_IMPLEMENTATION
#define STBI_FAILURE_USERMSG
#include "stb_image.h"
int main(int argc, char *argv[])
{
if (argc < 2)
DIE("%s\n", "not enough arguments");
GLuint width = 0, height = 0, bpp = 0;
unsigned char *image_raw;
if ((image_raw = stbi_load("image.jpg", &width, &height, &bpp, 0)) == NULL)
DIE("stbi error: %s\n", stbi_failure_reason());
uint8_t rv;
if (rv = initialize_glfw())
DIE("%s%" PRIu8 "\n", "initialize_glfw() failed with code ", rv);
glfwSetErrorCallback(glfw_error_callback);
glfw *glfw = malloc(sizeof(glfw));
if (!(glfw->window = glfwCreateWindow(
width,
height,
"Eternity",
NULL,
NULL)))
{
glfwTerminate();
DIE("%s\n", "glfwCreateWindow failed");
}
glfwMakeContextCurrent(glfw->window);
glfwSetKeyCallback(glfw->window, glfw_key_callback);
glewExperimental = GL_TRUE;
if (glewInit() != GLEW_OK)
{
eternity_cleanup(glfw);
DIE("%s\n", "glewInit() failed");
}
printf("OpenGL %s\n", glGetString(GL_VERSION));
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
GLshort vertices[] = {
-1, 1, 0,
1, 1, 0,
-1, -1, 0,
1, -1, 0
};
GLushort texcoords[] = {
0, 0,
1, 0,
0, 1,
1, 1
};
gl gl = {0}; // This is just a struct
glGenBuffers(1, &(gl.points_vbo));
glBindBuffer(GL_ARRAY_BUFFER, gl.points_vbo);
glBufferData(GL_ARRAY_BUFFER, 12 * sizeof(GLshort), vertices, GL_STATIC_DRAW);
glGenBuffers(1, &(gl.texcoords_vbo));
glBindBuffer(GL_ARRAY_BUFFER, gl.texcoords_vbo);
glBufferData(GL_ARRAY_BUFFER, 8 * sizeof(GLushort), texcoords, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, gl.points_vbo); // EDIT: I added this line
glGenVertexArrays(1, &(gl.vao));
glBindVertexArray(gl.vao);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_SHORT, GL_FALSE, 0, NULL);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_UNSIGNED_SHORT, GL_FALSE, 0, NULL);
setup_shaders(&gl);
GLenum format;
switch (bpp * 8)
{
case 24:
format = GL_RGB;
break;
case 32:
format = GL_RGBA;
break;
}
GLuint texture_id = 0;
glGenTextures(1, &texture_id);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture_id);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, (GLint)format, width, height, 0, format, GL_UNSIGNED_BYTE, image_raw);
stbi_image_free(image_raw);
glBindTexture(GL_TEXTURE_2D, texture_id);
check_error();
while (!glfwWindowShouldClose(glfw->window))
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgram(gl.shader_program);
glBindVertexArray(gl.vao);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glfwSwapBuffers(glfw->window);
glfwPollEvents();
}
glDeleteTextures(1, &texture_id);
eternity_cleanup(glfw);
}
void setup_shaders(gl *gl)
{
const GLchar *vs_source =
"#version 440\n"
"layout(location = 0) in vec3 vp;"
"layout(location = 1) in vec2 vt;"
"out vec2 texcoord;"
"void main() { gl_Position = vec4(vp, 1.0);"
"texcoord = vt; }",
*fs_source =
"#version 440\n"
"out vec4 frag_color;"
"in vec2 texcoord;"
"uniform sampler2D texture;"
"void main() { frag_color = texture2D(texture, texcoord); }";
GLuint vs = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vs, 1, &vs_source, NULL);
glCompileShader(vs);
GLuint fs = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fs, 1, &fs_source, NULL);
glCompileShader(fs);
gl->shader_program = glCreateProgram();
glAttachShader(gl->shader_program, fs);
glAttachShader(gl->shader_program, vs);
glLinkProgram(gl->shader_program);
glDeleteShader(vs);
glDeleteShader(fs);
}
uint8_t initialize_glfw(void)
{
int major = 0, minor = 0, rev = 0;
glfwGetVersion(&major, &minor, &rev);
printf("GLFW %d.%d rev %d\n", major, minor, rev);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, major);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, minor);
glfwWindowHint(GLFW_CONTEXT_REVISION, rev);
glfwWindowHint(GLFW_SAMPLES, 8);
if (!glfwInit())
return 1;
return 0;
}
void glfw_error_callback(int error, const char *description)
{
printf("glfw error callback triggered\n");
fprintf(stderr, "%d: %s\n", error, description);
}
void glfw_key_callback(GLFWwindow *window, int key, int scancode, int action, int mods)
{
if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
glfwSetWindowShouldClose(window, GL_TRUE);
}
void eternity_cleanup(glfw* glfw)
{
glfwDestroyWindow(glfw->window);
free(glfw);
glfwTerminate();
}
I'm not sure if I've forgotten to do something here or if I'm doing something incorrectly, I have tried very hard to fix this but the black screen persists.
I feel like the problem is in my shaders (hardcoded in setup_shaders()), or maybe around glTexImage2D()?
edit:
I found that if I call glBindBuffer again right before glGenVertexArrays, then I get a light blue screen, and the specific image that I am loading is predominantly this exact shade of blue, so I believe I am sampling a single pixel.
I have updated the source code with a comment where I added a line.
My problem is now that I am sampling only one pixel.