Así que estoy haciendo un juego corto de defensa de la torre. Compartí una compilación con ellos para que pueda comprobar si todo funciona como debería en otro host.

Y lo que realmente sucede es que mientras todo se ejecuta perfectamente de mi lado (ambos en mi mac / xcode + windows / visual studio 2012), en el lado de mi amigo, parece que la geometría está en mal estado. Cada objeto en mi pantalla está representado por un VBO que uso cada vez para renderizar en diferentes ubicaciones. Pero parece que mis VBO tienen toda la geometría importada de todos los modelos. (De ahí la torre con el árbol al lado.)

Aquí está el resultado:

(Mi computadora)(La computadora de mi amigo)

Como ahora he logrado solucionar este problema hasta cierto punto. Puedo decir que no es la forma en que estoy importando mis modelos porque estoy creando un archivo debug.txt con todos los vectores antes de enviarlos a gpu como VBO y en ambas computadoras emiten los mismos valores. Así que sus vectores no se ensucian por problemas de memoria ni nada de eso. Así que estoy pensando que tal vez es la forma en que estoy configurando o renderizando mis VBOs

Sin embargo, lo que más me sorprende es por qué las cosas funcionan en mi computadora cuando no están en la computadora de mis amigos. Una diferencia que sé con certeza es que mi computadora es una estación de desarrolladores (lo que sea que esto signifique) mientras que la computadora de mi amigo no lo es.

Esta es mi función de carga de VBO y mi función de dibujo de VBO: uso glfw para crear mi ventana y contexto e incluyo encabezados Glew para habilitar algunas de las nuevas funciones de opengl.

void               G4::Renderer::LoadObject(
                                           G4::TILE_TYPES   aType,
                                           std::vector<float> &v_data,
                                           std::vector<float> &n_data,
                                           std::vector<float> &t_data,
                                           float scale,
                                           bool has_texture,
                                           unsigned int texture_id
                                           )
{

    unsigned int vertices_id, vertices_size, normals_id, texturecoordinates_id;

    vertices_size   = static_cast<unsigned int>(v_data.size());

    glGenBuffers(1, &vertices_id);
    glGenBuffers(1, &normals_id);

    //::->Vertex array buffer upload.
    glBindBuffer(GL_ARRAY_BUFFER, vertices_id);
    glBufferData(GL_ARRAY_BUFFER, sizeof(float)*v_data.size(), &v_data.front(), GL_STATIC_DRAW);
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    //::->Normal Array buffer upload.
    glBindBuffer(GL_ARRAY_BUFFER, normals_id);
    glBufferData(GL_ARRAY_BUFFER, sizeof(float)*n_data.size(), &n_data.front(), GL_STATIC_DRAW);
    glBindBuffer(GL_ARRAY_BUFFER, 0);



    if (has_texture)
    {
        glGenBuffers(1, &texturecoordinates_id);

        glBindBuffer(GL_ARRAY_BUFFER, texturecoordinates_id);
        glBufferData(GL_ARRAY_BUFFER, sizeof(float)*t_data.size(), &(t_data[0]), GL_STATIC_DRAW);
        glBindBuffer(GL_ARRAY_BUFFER, 0);
    }


    this->vbos[aType].Update(vertices_id, vertices_size, normals_id, texture_id, texturecoordinates_id, scale, has_texture);



}

Dibujar código:

void G4::Renderer::DrawUnit(G4::VBO aVBO, bool drawWithColor, float r, float g, float b, float a)
{
    bool model_has_texture = aVBO.HasTexture();

    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_NORMAL_ARRAY);

    if (model_has_texture && !drawWithColor)  {
        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
        glEnable(GL_TEXTURE_2D);
    }

    if (drawWithColor)
    {
        glColor4f(r, g, b, a);
    }

    glScalef(aVBO.GetScaleValue(), aVBO.GetScaleValue(), aVBO.GetScaleValue());

    glBindBuffer(GL_ARRAY_BUFFER, aVBO.GetVerticesID());
    glVertexPointer(3, GL_FLOAT, 0, 0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    glBindBuffer(GL_ARRAY_BUFFER, aVBO.GetNormalsID());
    glNormalPointer(GL_FLOAT, 0, 0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);


    if (model_has_texture && !drawWithColor)
    {
        glBindTexture(GL_TEXTURE_2D, aVBO.GetTextureID());
        glBindBuffer(GL_ARRAY_BUFFER, aVBO.GetTextureCoordsID());
        glTexCoordPointer(2, GL_FLOAT, 0, 0);
        glBindBuffer(GL_ARRAY_BUFFER, 0);
    }

    glDrawArrays(GL_TRIANGLES, 0, aVBO.GetVerticesSize());

    if (model_has_texture && !drawWithColor)  {
        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
        glDisable(GL_TEXTURE_2D);

    } 

    glDisableClientState(GL_NORMAL_ARRAY);
    glDisableClientState(GL_VERTEX_ARRAY);

}

Me he quedado sin ideas. Espero que alguien pueda orientarme más sobre cómo depurar esto.