Question

I’m having trouble sending both normals and a u,v pair to my shaders. If I remove the normal, things work as expected.

EDIT
It appears the v_normal is receiving the values that are intended for v_coord. I still have no idea though.
/EDIT

This is my vertex:

struct Vertex{
    Vertex(vec3 const & v) : pos(v) {}

    vec3 pos;
    vec3 normal;
    real u, v;
};

This is the initialization code:

    const int VERTEX_POS_INDX = 0;
    const int VERTEX_NORMAL_INDX = 1;
    const int VERTEX_TEXCOORD_INDX = 2;

    const int VERTEX_POS_SIZE = 3;
    const int VERTEX_NORMAL_SIZE = 3;
    const int VERTEX_TEXCOORD_SIZE = 2;

    GLuint vbo, ibo;
    glGenBuffers(1, &vbo);
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER, sphere->vertices.size()*sizeof(Vertex), &sphere->vertices[0], GL_STATIC_DRAW);

    glGenBuffers(1, &ibo);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sphere->indices.size()*sizeof(unsigned short), &sphere->indices[0], GL_STATIC_DRAW);

    glEnableVertexAttribArray ( VERTEX_POS_INDX );
    glEnableVertexAttribArray ( VERTEX_NORMAL_INDX );
    glEnableVertexAttribArray ( VERTEX_TEXCOORD_INDX );

    int offset = 0;

    glVertexAttribPointer ( VERTEX_POS_INDX, VERTEX_POS_SIZE, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offset );
    offset += VERTEX_POS_SIZE * sizeof(real);

    glVertexAttribPointer ( VERTEX_NORMAL_INDX, VERTEX_NORMAL_SIZE, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offset );
    offset += VERTEX_NORMAL_SIZE * sizeof(real);

    glVertexAttribPointer ( VERTEX_TEXCOORD_INDX, VERTEX_TEXCOORD_INDX, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)offset );

    glBindAttribLocation ( programObject, VERTEX_POS_INDX, "a_position" );
    glBindAttribLocation ( programObject, VERTEX_NORMAL_INDX, "a_normal" );
    glBindAttribLocation ( programObject, VERTEX_TEXCOORD_INDX, "a_coord" );

The vertex shader:

precision highp float;

uniform mat4 u_mv;
uniform mat4 u_mvp;
uniform vec3 u_light;
uniform vec3 u_up;

attribute vec3 a_position;
attribute vec2 a_coord;
attribute vec3 a_normal;

varying vec2 v_coord;
varying vec3 v_normal;

void main() {    
    v_coord = a_coord;
    v_normal = a_normal;
    gl_Position = u_mvp * vec4(a_position, 1);
}

The fragment shader:

precision highp float;

uniform vec3 u_up;

varying vec3 v_normal;
varying vec2 v_coord;


precision highp float;

uniform vec3 u_up;

varying vec3 v_normal;
varying vec2 v_coord;

void main()
{
    vec2 coord = v_coord;
    vec3 normal = v_normal;
    coord.x = mod(v_coord.x * 5.0, 1.0);
    coord.y = mod(v_coord.y * 5.0, 1.0);
    gl_FragColor = vec4 (
        mod(coord.x*1.0,1.0),
        mod(coord.y*1.0,1.0),
        mod(normal.z*5.0,1.0)*0.0,
        1.0 );
}

Answer 1

I just had to use glGetAttributeLocation to define the indexes instead of assuming that glBindAttributeLocation will do the trick.

EDIT
Using the bind attribute function before linking the program did the trick and preserved my intentions with the code.