使纹理在OpenGL 3.2中工作

Question

I have been staring at this code for a while now with no luck. I'm working on integrating librocket into my own project (the library isn't that important to the question) and part of that requires writing a renderer class. I've been trying to do just that but can't get the textures to display. The vertex color and position work fine.

I'm using OpenGL3.2.

I've temporarily modified the code to try to draw a single quad. The only parameter being used is the texture parameter, which is just a GLuint cast to another type.

There's a good chance that I'm missing something stupid, but I can't see it. Hopefully another set of eyes will help. Feel free to ask for more code/info.

// Called by Rocket when it wants to render geometry that it does not wish to optimise.
void SDLRenderInterface::RenderGeometry(Rocket::Core::Vertex* vertices, int num_vertices, int* indices, int num_indices, const Rocket::Core::TextureHandle texture, const Rocket::Core::Vector2f& translation)
{
    GLuint program;
    GLuint vertexBuffer;
    GLuint indexBuffer;
    GLuint vertexPosLoc      = 0;
    GLuint vertexColorLoc    = 0;
    GLuint vertexTexCoordLoc = 0;
    GLuint texSamplerLoc     = 0;
    GLuint translationLoc    = 0;
    GLuint viewDimLoc        = 0;


    int offset = 8;
    int vertexCount = 4;
    float vertexData[] = {-0.5, -0.5, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0,
                           0.5, -0.5, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0,
                           0.5,  0.5, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
                          -0.5,  0.5, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0};
    int indexData[] = {0,1,2,0,2,3};
    int indexCount = 6;

    // Populate vertex buffer
    glGenBuffers(1, &vertexBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(float)*offset*vertexCount,
                 vertexData, GL_STATIC_DRAW);

    // Populate index buffer
    glGenBuffers(1, &indexBuffer);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(int) * indexCount,
                 indexData, GL_STATIC_DRAW);

    program = shaderManager->getProgram(2, "rocketTex.vert",
                                           "rocketTex.frag");
    glUseProgram(program);
    // Set up the texture
    texSamplerLoc = glGetUniformLocation(program, "texSampler");
    vertexTexCoordLoc = glGetAttribLocation(program, "vertexTexCoord");
    if(texSamplerLoc == -1)
    {
        std::cerr << "Error: cannot find texture location." << std::endl;
        return;
    }
    if(vertexTexCoordLoc == -1)
    {
        std::cerr << "Error: cannot find texture coord location."
                  << std::endl;
        return;
    }

    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, (GLuint) texture);
    glUniform1i(texSamplerLoc, 0);

    // Set up the per vertex texture coords 
    glEnableVertexAttribArray(vertexTexCoordLoc);
    glVertexAttribPointer(vertexTexCoordLoc, 2, GL_FLOAT, GL_FALSE,
                          offset * sizeof(float),
                          (void*) (sizeof(float) * 6));

    // Set up uniforms
    translationLoc = glGetUniformLocation(program, "translation");
    viewDimLoc = glGetUniformLocation(program, "viewDimensions");
    if(translationLoc == -1)
    {
        std::cerr << "Error: cannot find translation location."
                  << std::endl;
        return;
    }
    if(viewDimLoc == -1)
    {
        std::cerr << "Error: cannot find viewDim location."
                  << std::endl;
        return;
    }
    glUniform2f(translationLoc, 0,0);
    glUniform2f(viewDimLoc, 1,1);


    // Set up per-vertex attributes
    vertexPosLoc = glGetAttribLocation(program, "vertexPosition");
    vertexColorLoc = glGetAttribLocation(program, "vertexColor");
    if(vertexPosLoc == -1)
    {
        std::cerr << "Error: cannot find vertex position location."
                  << std::endl;
        return;
    }
    if(vertexColorLoc == -1)
    {
        std::cerr << "Error: cannot find vertex color location."
                  << std::endl;
        return;
    }
    glEnableVertexAttribArray(vertexPosLoc);
    glEnableVertexAttribArray(vertexColorLoc);
    glVertexAttribPointer(vertexPosLoc, 2, GL_FLOAT, GL_FALSE,
                              offset * sizeof(float), 0);
    glVertexAttribPointer(vertexColorLoc, 4, GL_FLOAT, GL_TRUE,
                              offset * sizeof(float),
                              (void*) (sizeof(float) * 2));

    // Draw the geometry
    glDrawElements(GL_TRIANGLES, indexCount, GL_UNSIGNED_INT, 0);

    glDisableVertexAttribArray(vertexPosLoc);
    glDisableVertexAttribArray(vertexColorLoc);
    glDisableVertexAttribArray(vertexTexCoordLoc);
    glDeleteBuffers(1, &vertexBuffer);
    glDeleteBuffers(1, &indexBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
    glUseProgram(0);

}

Vertex Shader:

#version 120

uniform vec2 translation;
uniform vec2 viewDimensions;

attribute vec2 vertexPosition;
attribute vec4 vertexColor;
attribute vec2 vertexTexCoord;

varying vec2 texCoord;
varying vec4 fragColor;

void main(void)
{
    vec2 ndcPos = ((vertexPosition + translation)/(viewDimensions));

    texCoord = vertexTexCoord;
    fragColor = vertexColor;
    gl_Position = vec4(ndcPos, 0.0, 1.0);
}

Fragment Shader:

#version 120

uniform sampler2D texSampler;

varying vec2 texCoord;
varying vec4 fragColor;

void main(void)
{
    vec4 objectColor = texture2D(texSampler, texCoord);
    gl_FragColor = vec4((objectColor * fragColor).xyz, 1.0);
}

Answer 1

So, I finally figured it out. jozxyqk's advice for testing the texture coords confirmed my suspicions that the texture coordinates were off (every vertex was getting the same coordinate). The problem ended up being that I was calling glVertexAttribDivisor(attributeLoc, 1) in another part of my code and never setting it back to per vertex, so it was affecting my other shaders. Thinking about the design of OpenGL, it makes sense that this would be necessary.

Glad that's settled!