Trying to create a tiled background, nothing shows up.

Hi all, I’m new to OpenGL and I’m trying to learn the latest best practices. I’m working on a Qt application and so far have verified that my shaders are loaded and linked properly, my functions initialized properly, and the image I’m trying to use is properly loaded. Where I believe I am in error is my OpenGL code but I can’t figure out what I’m doing wrong. Here’s the widget object file containing the GL code and my shaders:

mywidget.cpp

#include "myglwidget.h"
#include <QDebug>
#include <QVector3D>
#include <QVector2D>
#include "locale.h"


#define BACK_TILE_S 48

struct VertexData
{
    QVector3D position;
    QVector2D texCoord;
};

MyGLWidget::MyGLWidget(QWidget *parent) :
    QGLWidget(parent)
{

}

MyGLWidget::~MyGLWidget(){
    glDeleteBuffers(2, vboid);
}

void MyGLWidget::initializeGL(){
    VertexData verts[] = {
            {QVector3D(0, 0, 0), QVector2D(0, 0)},
            {QVector3D(1, 0, 0), QVector2D(1, 0)},
            {QVector3D(0, 1, 0), QVector2D(0, 1)},
            {QVector3D(1, 1, 0), QVector2D(1, 1)}
    };
    GLushort indices[] = {
        0, 1, 2, 3
    };
    makeCurrent();
    initializeOpenGLFunctions();

    setlocale(LC_NUMERIC, "C");

    default_prog.addShaderFromSourceFile(QGLShader::Vertex, ":/shaders/default.vert");
    default_prog.addShaderFromSourceFile(QGLShader::Fragment, ":/shaders/default.frag");
    default_prog.link();

    default_prog.bind(); // this is in initgl since this is the
                         // only shader we use... FOR NOW, therefore
                         // we dont have to do it elsewhere
    setlocale(LC_ALL, "");

    glDisable(GL_DEPTH_TEST);
    glEnable(GL_TEXTURE_2D);
    // normally here we would have the QImage buffered up already
    // and would bind as needed, but again, this is the only
    // texture we use for now
    back_texture = bindTexture(QImage(":/gfx/gfx/back.png"));
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);


    glGenBuffers(2, vboid);

    glBindBuffer(GL_ARRAY_BUFFER, vboid[0]);
    glBufferData(GL_ARRAY_BUFFER, 4 * sizeof(VertexData), verts, GL_STATIC_DRAW);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboid[1]);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, 4 * sizeof(GLushort), indices, GL_STATIC_DRAW);
    glClearColor(1,0,0,1);
}

void MyGLWidget::paintGL(){
    int texw;
    int texh;
    QMatrix4x4 proj;
    QMatrix2x2 scale;
    quintptr offset;
    int vertexLoc;
    int texcoordLoc;
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    texw = (floor(width / ((double) BACK_TILE_S)) + 1);
    texh = (floor(height / ((double) BACK_TILE_S)) + 1);

    proj.setToIdentity();
    proj.scale(texw * BACK_TILE_S, texh * BACK_TILE_S);
    proj.ortho(0, width, 0, height, -1, 1);

    scale.setToIdentity();
    scale(0,0) = texw;
    scale(1,1) = texh;

    default_prog.setUniformValue("texScale", scale);
    default_prog.setUniformValue("mvp_matrix", proj);
    default_prog.setUniformValue("texture", 0);

    glBindBuffer(GL_ARRAY_BUFFER, vboid[0]);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboid[1]);

    offset = 0;

    vertexLoc = default_prog.attributeLocation("a_position");
    default_prog.enableAttributeArray(vertexLoc);
    glVertexAttribPointer(vertexLoc, 3, GL_FLOAT, GL_FALSE, sizeof(VertexData), (const void*) offset);

    offset += sizeof(QVector3D);

    texcoordLoc = default_prog.attributeLocation("a_texcoord");
    default_prog.enableAttributeArray(texcoordLoc);
    glVertexAttribPointer(texcoordLoc, 2, GL_FLOAT, GL_FALSE, sizeof(VertexData), (const void*) offset);

    glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_SHORT, 0);
    qDebug(glGetError());
}


void MyGLWidget::resizeGL(int width, int height){
    this->width = width;
    this->height = height;
}

default.vert

#version 150

uniform mat4x4 mvp_matrix;
uniform mat2x2 texScale;

in vec4 a_position;
in vec2 a_texcoord;

out vec2 v_texcoord;

void main() {
    v_texcoord = a_texcoord * texScale;
    gl_Position = mvp_matrix * a_position;
}

default.frag

#version 150

uniform sampler2D texture;

in vec2 v_texcoord;

void main()
{
    gl_FragColor = texture2D(texture, v_texcoord);
}