GLSL woes involving texturing

Question

I'm a beginner to OpenGL and GLSL especially, and I'm having a lot of trouble getting textures to display via shaders. My shader code compiles without any warnings or errors, but I seem completely unable to render my texture. In fact, nothing's being rendered at all; I'm getting a blank screen. Here's my current, simplified code (written in D, but should function almost exactly as it looks as if it were in C++):

int main(string[] argv) {
    try {
        ilInit();
        iluInit();
        ilutInit();                 // GOTCHA: These two calls need to be in order!
        ilutRenderer(ILUT_OPENGL);  //
        glfwInit();
        if(SDL_Init(SDL_INIT_VIDEO) > 0) writeln("ERROR");

        // Create an OpenGL context and window.
        const int VWIDTH = 1600;
        const int VHEIGHT = 900;
        const int WIDTH = 1280;
        const int HEIGHT = 720;
        glfwOpenWindowHint(GLFW_FSAA_SAMPLES, 8);
        glfwOpenWindowHint(GLFW_AUX_BUFFERS, 1);
        glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
        glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 3);
        glfwOpenWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_FALSE);
        glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_COMPAT_PROFILE);
        glfwOpenWindow(WIDTH, HEIGHT, 8, 8, 8, 8, 0, 0, GLFW_WINDOW /+ GLFW_FULLSCREEN +/);

        GL.bindClassicVersions(true);
        GL.bindModernVersions(true, GLVersion.GL33);
        GL.bindExtensions(true);    // Returns GL_INVALID_ENUM

        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        glOrtho(0, VWIDTH, 0, VHEIGHT, -100, 100);
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity(); 

        // Set clear color
        glClearColor(0.392, 0.584, 0.929, 1);

        // Set GL enables/disables
        glShadeModel(GL_SMOOTH);                                // Enables smooth shading
        glEnable(GL_TEXTURE_2D);                                // Enable 2D texturing
        glEnable(GL_BLEND);                                     // Enable alpha blending
        glDisable(GL_DEPTH_TEST);                               // Disable depth testing
        glDisable(GL_CULL_FACE);                                // Disable face culling
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        //glDepthFunc(GL_LEQUAL);                                 // The depth test type

        // Initialize and compile shaders
        GLuint vertShaderId, fragShaderId;
        vertShaderId = glCreateShader(GL_VERTEX_SHADER);
        fragShaderId = glCreateShader(GL_FRAGMENT_SHADER);

        immutable(GLchar)* vertShaderSrc = toStringz("#version 330
in vec3 vertex;
in vec2 texCoord;

out vec2 fragmentTexCoord;

void main(void) {
    fragmentTexCoord = texCoord;
    gl_Position = vec4(vertex, 1.0);
}
");
        immutable(GLchar)* fragShaderSrc = toStringz("#version 330
uniform sampler2D firstTexture;
in vec2 fragmentTexCoord;

layout(location = 0, index = 0) out vec4 fragColor;

void main(void) {
    fragColor = texture2D(firstTexture, fragmentTexCoord);
}
");

        glShaderSource(vertShaderId, 1, &vertShaderSrc, null);
        glShaderSource(fragShaderId, 1, &fragShaderSrc, null);

        glCompileShader(vertShaderId);
        tge.shader.Shader.checkCompileLog(vertShaderId);
        glCompileShader(fragShaderId);
        tge.shader.Shader.checkCompileLog(fragShaderId);

        GLuint programId = glCreateProgram();

        glAttachShader(programId, vertShaderId);
        glAttachShader(programId, fragShaderId);

        glLinkProgram(programId);
        tge.shader.Shader.checkCompileLog(programId);

        glUseProgram(programId);
        checkGLError();

        // Load texture
        auto texture = new Texture2d(r"res/test.png");
        texture.load();

        bool running = true;
        clearGLError();
        while(running) {
            // Clear viewport
            glClear(GL_COLOR_BUFFER_BIT);

            // Bind texture ID
            glActiveTexture(GL_TEXTURE0);
            glBindTexture(GL_TEXTURE_2D, texture.textureId);
            checkGLError();

            // Set texture uniform value
            auto loc = glGetUniformLocation(programId, "firstTexture");
            checkGLError();
            glUniform1i(loc, 0);
            checkGLError();

            // Render
            glBegin(GL_QUADS);
                glTexCoord2d(0, 0); glVertex2d(-0.8, -0.8);
                glTexCoord2d(1, 0); glVertex2d( 0.8, -0.8);
                glTexCoord2d(1, 1); glVertex2d( 0.8,  0.8);
                glTexCoord2d(0, 1); glVertex2d(-0.8,  0.8);
            glEnd();
            checkGLError();

            // Swap front and back rendering buffers
            glfwSwapBuffers();

            // Add a tiny delay if no work is being done in the loop.
            //glfwSleep(double.epsilon);

            // Check if ESC key was pressed or window was closed
            running = !glfwGetKey(GLFW_KEY_ESC) && glfwGetWindowParam(GLFW_OPENED);
        }
    }
    catch(Throwable t) {
        Logger.log(Severity.Error, t.msg);
    }

    return 0;
}

I'm guessing it's something simple I've overlooked due to being new. Any help would be appreciated!

Answer 1

One thing I noticed is that you commented out the actual color finding procedure:

    //fragColor = texture2D(firstTexture, fragmentTexCoord);
    fragColor = vec4(1, 0, 0, 1);

Another Problem:

    glVertex2d(-1, -1); glTexCoord2d(0, 0);

should be:

    glTexCoord2d(0, 0); glVertex2d(-1, -1); 

in all the lines