Mark C APIs as private.

They're just there to make it easier to determine platforms without
doing platform string checking and stuff, anyway. No sense in making
them seem like they're supposed to be used for stuff.
Tweak GL function defs.
Extend self to get static GL methods.
Brief documentation for GlSym, which you should not use.
Add additional check for Windows in load_gl_sym__.
Fix accidental inclusion of some GL ES commands/enums.

This happened mostly because I used 'or' in the xpath instead of 'and',
so when the API attribute was missing or not gles, but the supported did
exist and started with gles, then the GL ES command/enum was still
included in the generated commands script.
Change the generated commands script.

Commands and their type info are now kept in a hash of function names to
hashes of data types (GL_COMMAND_TYPES). This effectively allows me to query a function's info rather than just loading it and hoping it exists. As a result, the loading code can be reduce to a call to __load_gl_sym__, which is also included in the generated code. I should probably break it off into the GlSym code but for now this'll do.

The upshot to this is that loading a symbol no longer raises exceptions
if it doesn't exist. It simply returns the wrapped function if loaded or
false if not. So, if you load a symbol and it's not there, the exception
only comes from attempting to use that symbol. So, it's better now to
query whether the function is loaded first rather than using it if I
can't be certain it's available.

Also, Gl#have_gl_command? is now a thing, so the above query is now doable as well. There's also Gl#load_all_gl_commands!, which does what it says on the tin.

--

GlSym is now a submodule of Gl. __load_gl_sym__ caches the loaded function. It also stores the command types because I didn't want to make those part of the Gl module (and thereby accidentally infect the global namespace if someone does `include Gl`, which sounds pretty reasonable to me).
Make required Ruby version 2.0.0 minimum.
Note about thread-safety of have_gl_command? and load_all_gl_commands!

Not really necessary, given that this is loading commands at runtime,
but Ruby folks may not be as conscious of what counts as thread-safe and
so on. So, here's the deal: if a Gl command is being loaded, one cannot
call have_gl_command? or otherwise call an unloaded function from
another thread. This is because there is no mutex around the Gl function
Hash and so on.

If you want some amount of thread-safety, call load_all_gl_commands!
before any threads are spawned. This will ensure that no Gl commands are
loaded in the future unless you do something weird like modify
GL_COMMAND_TYPES and add a new command, which _you should not do_.
Description update.

I figure "new" is a bad term to use.
Add opengl-core/aux types/functions.

These are comprised of a handful of overridden Gl commands. All the
overridden commands are under opengl-core/aux/gl. The commands are as
follows:

Gen/Delete functions:
- glGenTextures and glDeleteTextures
- glGenVertexArrays and glDeleteVertexArrays
- glGenBuffers and glDeleteBuffers
- glGenQueries and glDeleteQueries
- glGenSamplers and glDeleteSamplers
- glGenFramebuffers and glDeleteFramebuffers
- glGenRenderbuffers and glDeleteRenderbuffers
- glGenProgramPipelines and glDeleteProgramPipelines
- glGenTransformFeedbacks and glDeleteTransformFeedbacks

All the gen functions take a single argument: the number of names to ask
GL to generate. They return an array of the names generated.

Further, all the delete functions take a single argument: either a name
to delete or an array of names. You cannot explicitly pass the size of
the array. If a single name is passed, it will be internally wrapped in
an array before attempting to delete it.

- glGetInteger, glGetInteger64, glGetFloat, glGetDouble, glGetBoolean,
  glGetString, and glGetStringi (basically the glGet* commands)

Get functions all take a single argument, the pname you want to get the
value of, with the exception of glGetStringi, which also takes an index.
These return the types their names specify, except glGetFloat and
glGetDouble which both might as well return the same type as far as Ruby
is concerned.

- glShaderSource, glGetShader, glGetShaderInfoLog, and glGetShaderSource

glShaderSource now simply takes either a string or an array of strings.
glGetShader behaves the same as other glGet functions, except you must
also provide the shader, of course. Same applies to glGetProgram below,
just to save time.
glGetShaderInfoLog takes the shader name and returns a string of the
info log or an empty string if it has none. glGetShaderSource is more or
less the same thing.

- glGetProgram, glGetProgramInfoLog, and glGetProgramBinary

The first two functions behave similar to their shader counterparts.
glGetProgramBinary takes the program as its only argument and returns
an array of the binary format and the binary string. They are always in
that order. So, to get the format and string, you'd do

format, string = glGetProgramBinary(program)

or just grab it out of the returned array.

- glVertexAttribPointer -- Overridden to convert the last argument
  into a pointer representing the offset into a bound buffer, as you
  must use this with a bound buffer in the core profile. Otherwise this
  is essentially the same function as ever. You must still pass GL_TRUE
  and GL_FALSE as booleans do not work. This ensures you're explicit
  about these sorts of things.

In addition, there are a handful of convenience functions provided that
simply wrap a few glGetString/i calls:

- version -> version string
- vendor -> vendor string
- renderer -> renderer string
- shading_language_version -> shader version string
- extensions -> returns an array of extension strings

The types provided are:

- Gl::Shader        -> opengl-core/aux/shader
- Gl::Program       -> opengl-core/aux/program
- Gl::VertexArray   -> opengl-core/aux/vertex_array
- Gl::Texture       -> opengl-core/aux/texture
- Gl::Buffer        -> opengl-core/aux/buffer

All of these must be explicitly destroyed by calling their 'delete'
methods. In addition, they may be initialized by providing a previously-
generated name, in which case the object takes ownership of the name.
This can be undone by calling the object's __unmark__ method, but this
is a private API and may change, so consider it bad practice to try to
reclaim ownership from an object.

I won't mention what is and isn't provided in each type, so just check
the sources until I write documentation for them. It's pretty small, so
it shouldn't be hard to figure out. Most just have bind/unbind methods
and nothing else (specifically VAOs, buffers, and textures).

In the case of bind-able types, they're generated only on first bind, so
allocating an object does not mean a name has been allocated.

To pull all of these in at once, just require 'opengl-core/aux' which
will pull in everything under aux. Otherwise, you can include any of the
types or sources without pulling in other types.
Version 1.1.0