Add a Loader for Scene, and a matching Blender exporter

Set MeshExporter default values to match those in the operator

Fix line exporting

Use a renderer in the viewer

Some renderables using more sophisticated features won't even render
properly without one.

Rework loading in viewer

It can now load external resources, and adding new types of renderables
in the future is easier.

Support hemispherical skylight in ProgramBuilder

OpenGL's fixed-function pipeline does not have any similar feature, so
this can't be supported without shaders.

Move extension requirements from ProgramData to UniformBlock

ProgramData no longer manipulates GL directly, and it's used in places
like Renderer and Material.  This changes allows those things to be used
without shader support.

Make older gcc versions happy

Use GL_VERSION_x_y to guard the enums for promoted extensions

The core names for enums are used in headers, and older systems might
have the extension present but too old core version.

Rearrange ProgramBuilder's standard variables

The rgb_light_foo names were getting a bit stupid, and the hierarchy also
makes more sense this way.  The use of gl_FrontLightProduct was dropped
as too cumbersome to maintain.  The future is with modern shaders anyway.

Texture now only affects ambient and diffuse colors, not specular.  There
will likely be support for a separate specular map in the future.

TexUnit's constructor shouldn't be public

Improve interface documentation a bit

Add support for array and multiple lights in generated shaders

Generalize shader interface handling

Refactor certain variable operations into functions

Inline variables which are simple aliases, even if not optimizing

This fixes another problem with unoptimized legacy shaders, making them
work properly again.

Tweak goal variable handling in ProgramBuilder

All variables now have types, and goal variables are recognized by the
lack of references to them.  This solves a problem where non-optimized
legacy shaders would emit an assignment to frag_color without declaring
it first.

Pass the sRGB flag when loading a Texture2D from an image file

Don't store ProgramData in Lighting

It can't be kept up to date automatically, as Lighting can't track the
individual Lights' state.  It's also hard to make optimize out unnecessary
updates.  It's typically computed very few times per frame anyway, so the
performance hit is negligible (as opposed to something like Material,
which might get used hundreds or thousands of times per frame).

Minor tweaks to the Blender exporter

Fix exporting meshes without UV coordinates

More options for exporting techniques

Add an object property to control compound exporting

Add an option to export a separate mesh file when exporting an object

Restore the progress bar in the exporter

Some fixes to UV coordinate exporting

Refactor object exporter to a separate class

Support linear to sRGB conversion when loading materials and textures

Use make_tex's wrap parameter in makefont.py

Move sRGB formulas to color.h

Add a resource collection class

It's annoying to have to implement the same collection everywhere,
especially loading textures from image files.

Add viewport support to Framebuffer

Initialize slot even when unused to silence optimizer warnings

Tweak some ProgramBuilder variables

Support sRGB pixelformats through GL_EXT_texture_sRGB

Fix component handling error in Color

Use base pixelformat when loading texture data

Add gamma correction and sRGB conversion support to ColorCurve

Add basic support for 1D textures

Convert desertpillars to use the new shader customization

More flexible system for customizing generated shaders

Any standard variable can now be overridden, and new ones added.  It's
still somewhat fragile concerning variable ordering and some other things,
but it works when used correctly.

Simplify VAO setup code

Previously buffer binding semantics caused complications, as index buffer
was unbound while a mesh was bound so batches couldn't be updated.  Now
that buffers behave better with bounds meshes, batches can take care of
themselves again.

Triggering the setup from bind() instead of draw() gets rid of another
bunch of complications, since it will only be called when the VAO is going
to be actually used.

Avoid segfault for trying to refresh a Mesh with no buffers

Throw an exception if trying to draw a Mesh with a different Mesh bound

Enforce unbinding as well as binding buffers

Present Mesh's index buffer as current while the Mesh is bound

This simplifies the internal update operations.

Use RAII binders in place of manual binding

BufferAlias is now obsolete

Add support for multiple binding points in the RAII binders

Rewrite Bind as two different classes

Boolean flag parameters are not too clear without seeing the declaration.
This new implementation also doesn't use dynamic allocation.

Make desertpillars compatible with the modernization changes

Escape from the renderer before applying postprocessors

Automatically determine texture units for effects

At the moment this breaks such effects in fixed-function mode on platforms
that support shader-only texture units.  Will devise a fix later.

Add missing initializer

Add an overload of bind_attribute that takes a VertexComponent

Add missing #include

Add shd_eye_matrix to ShadowMap's shdata

Use vector and matrix operations in ShadowMap

Integrate modern shaders and VAOs with Renderer

The Scope enum has no need to be public

Support generating modern, GLSL 1.30+ shaders with ProgramBuilder

Create ProgramData for materials and lights

Add interface for glBindFragDataLocation, required for modern shaders

Remove VertexArray's own dirty member now that it's a Bufferable

Add vertex array object support to Mesh

Renderer integration to be added soon.

Explicitly bind buffer in Bufferable::update_buffer

This reduces unnecessary bind/unbind thrashing if the buffer needs to be
resized.

Add some accessors to Buffer

Add a public refresh function to Bufferable

This is needed soon for VAO support.

Tweak buffer logic a bit in Batch::draw

Excplicitly binding the buffer first avoids unnecessary implicit binds in
the buffer update code.

Convert VertexArray into a Bufferable

Use renderer for lighting in the shaders demo

Don't bother with clearing winding test

Why was that even there?  Winding test is stored as part of Renderer's
State, so it will be cleared by a pop.

Remove vertex array tracking from Renderer

It's unnecessary because VertexArray has its own state tracking and never
needs to be unbound.

Move vertex buffer management from VertexArray to Mesh

It was getting in the way of implementing vertex array objects.

Restore old samples value if create_targets fails

An application could use try-catch to check if a certain level of
multisampling is available, and leaving samples to that value would
interfere with later operations.

Remove get(int *)

By contrast to the previous commit, this was rather useless and not
actually used anywhere in the code.

Use wrappers for single-value glGet* calls

Having to create temporary stack variables just for passing in the return
pointer is quite annoying.

Check range when attaching Lights to a Lighting

Fix some incorrect whitespace

Better state tracking for bound objects

Give TexEnv a default object since it can't be disabled

Rewrite light binding to match textures

Both have multiple multiple parallel bind points, so it makes sense they
behave in the same way.

Always bind textures in a specific texture unit

This eliminates one level of global state, simplifying the API and
offering new optimization possibilities.  Since single-texturing is a
common use case, the parameterless bind/unbind functions have been left
in but changed to operate on unit 0.

Remove ambient color from Light

It doesn't make much sense, as there's already the global ambient color in
Lighting.  I haven't ever used it either, so remove directly instead of
deprecating.

Remove some deprecated stuff

Convert Matrix to use floats

This halves matrix storage size to 64 bytes and reduces overhead from
conversions at certain places.  If an application desires greater
precision, it can use the LinAl::Matrix and Geometry::AffineTransformation
classes internally.

Make TexUnits aware of their incides

Unbind Lighting in Renderer destructor

This solves a problem where the same lightning would get bound later and
retain an incorrect matrix due to already being bound.  It's not really a
proper fix but works in the most common cases.

Check and report the use of legacy built-in variables in a program

Use sizeof when passing buffer size

Be more direct about getting uniform counts from the program object

Add function to check GLSL version

Refactor version number extraction and checks

Store and expose the projection matrix

Make better use of matrix operations in Camera

Homogenise binding semantics

Objects that wrap always-on state should restore default states when
unbound.

Enable/disable of otherwise global state should be exposed through
binding, not a flag in an object.

Deal with nontrivial image configurations

Get function pointers on OS X through weak symbols

Extract parameter and return type information from gl.xml

Have the maketex script take texture parameters as options