[__mp]

I'm currently doing something similar in C++ based on a project I worked on a couple of years ago. It is a wrapper around OpenGL for people like me who are tired of figuring out the specifics of the OpenGL calls every time they write something.

Goal: Easy access to shaders and its respective buffers with a bare bones visualization.

Example:

    Shader shader(fragment_shader, vertex_shader);
    verticesVBO.set(vertices);
    verticesVBO.map(shader, "inPosition", false);
    shader.bind();
    shader.setUniform("uViewMatrix", camera.view());
    shader.setUniform("uProjMatrix", camera.proj());
    shader.setUniform("uModelMatrix", modelMatrix());
    facesVBO.bind();
    glDrawElements(GL_TRIANGLES, facesVBO.length(), GL_UNSIGNED_INT, (void*) NULL);

I should clean it up and make it available as a library.

[pcwalton]

glium in Rust does all of this and more (managing your state for you so you don't have to remember what is bound).

[heavenlyhash]

I've been fooling around with Go bindings to GL and also want to do something similar.

I still find it kind of uncomfortable that I'm copy-pasting variable names as strings between (the middle of!) the shader code string and the use sites (e.g. `setUniform` calls) -- I'd like it if I got some sort of quick compile time sanity check that those references match up. Had you considered going that far, and if so, what were your thoughts?

[Aeolos]

Not parent, but I wrote a shader introspector to reduce the pain of uniform mismatches as a (small) part of my master thesis.

My advice would be: don't do this.

If you can afford to support OpenGL 3.1+, use uniform buffer objects with the std140 layout instead. That way, you can create a strongly-typed struct in your code and access it normally on the CPU side. Uploading to the shader then is done with a single *BufferData call.

See [1] for more information.

[1] https://www.opengl.org/wiki/Uniform_Buffer_Object