Question

I’m trying to port some OpenGL rendering code I wrote for iOS to a Windows app. The code runs fine on iOS, but on Windows it doesn’t draw anything. I’ve narrowed the problem down to this bit of code as fixed function stuff (such as glutSolidTorus) draws fine, but when shaders are enabled, nothing works.

Here’s the rendering code:

glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_INDEX_ARRAY);

// Set the vertex buffer as current
this->vertexBuffer->MakeActive();

// Get a reference to the vertex description to save copying
const AT::Model::VertexDescription & vd = this->vertexBuffer->GetVertexDescription();

std::vector<GLuint> handles;

// Loop over the vertex descriptions
for (int i = 0, stride = 0; i < vd.size(); ++i)
{
    // Get a handle to the vertex attribute on the shader object using the name of the current vertex description
    GLint handle = shader.GetAttributeHandle(vd[i].first);

    // If the handle is not an OpenGL 'Does not exist' handle
    if (handle != -1)
    {
        glEnableVertexAttribArray(handle);
        handles.push_back(handle);

        // Set the pointer to the vertex attribute, with the vertex's element count,
        // the size of a single vertex and the start position of the first attribute in the array
        glVertexAttribPointer(handle, vd[i].second, GL_FLOAT, GL_FALSE, 
                                sizeof(GLfloat) * (this->vertexBuffer->GetSingleVertexLength()), 
                                (GLvoid *)stride);

    }

    // Add to the stride value with the size of the number of floats the vertex attr uses
    stride += sizeof(GLfloat) * (vd[i].second);
}

// Draw the indexed elements using the current vertex buffer
glDrawElements(GL_TRIANGLES, 
               this->vertexBuffer->GetIndexArrayLength(), 
               GL_UNSIGNED_SHORT, 0);

glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_INDEX_ARRAY);


// Disable the vertexattributearrays
for (int i = 0, stride = 0; i < handles.size(); ++i)
{
    glDisableVertexAttribArray(handles[i]);
}

It’s inside a function that takes a shader as a parameter, and the vertex description is a list of pairs: attribute handles to number of elements. Uniforms are being set outside this function. I’m enabling the shader for use before it’s passed in to the function. Here are the two shader sources:

Vertex:

attribute vec3 position;
attribute vec2 texCoord;
attribute vec3 normal;

// Uniforms

uniform mat4 Model;
uniform mat4 View;
uniform mat4 Projection;
uniform mat3 NormalMatrix;


/// OUTPUTS

varying vec2 o_texCoords;
varying vec3 o_normals;

// Vertex Shader

void main()
{
    // Do the normal position transform
    gl_Position = Projection * View * Model * vec4(position, 1.0);

    // Transform the normals to world space
    o_normals = NormalMatrix * normal;

    // Pass texture coords on for interpolation
    o_texCoords = texCoord;
}

Fragment:

varying vec2 o_texCoords;
varying vec3 o_normals;

/// Fragment Shader

void main()
{
    gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0);
}

I’m running OpenGL 2.1 with Shader language 1.2. I’d be most appreciative for any help anyone can give me.

Answer 1

I came back to this recently and it seems that I wasn’t checking for errors during rendering, it was giving me a 1285 error GL_OUT_OF_MEMORY after calling glDrawElements(). This lead me to check the vertex buffer objects to see if they contained any data and it turns out I wasn’t properly deep copying them in a wrapper class, and as a result they were being deleted before any rendering happened. Fixing this sorted the issue.

Thank you for your suggestions.