Update gl.xml to latest version

Initialize camera matrices in constructor

Delay loading matrices until they are needed

If all renderables use modern shaders, it's not necessary to touch the
system matrix stacks at all.  OpenGL ES 2.0 and OpenGL 3.0 core do not
even have system matrix stacks.

Run a tighter ship with extensions

Remove a number of rarely used legacy features

ShadowMap will now need shaders to work, but it was already broken in
fixed-function anyway due to using large texture unit numbers.  Since
all modern hardware supports shaders, even with free drivers, this is
unlikely to be an issue.

The removed pixel format GL_RED is used in ARB_texture_rg, but we don't
support that extension yet.

Enhance the extension generator to support different APIs

Refactor and optimize the extension generator script

Overly short variable names have been expanded
parse_file was getting a bit unwieldy and has been split
getElementsByTagName is recursive and slow, replaced with custom function

Don't leak AsyncUpdaters if Mesh async loading is aborted

Rewrite ResourceManager internals for more scalability

Since loading small resources can often take less than one frame,
especially with vsync enabled, the thread can now handle more than one
resource at once.  The code is also somewhat better structured for using
more than one thread in the future.

Better handling of unloaded textures

Since it's no longer guaranteed that calling ResourceManager::resource_used
will result in Resource::load being called, it's better to avoid the
binding logic entirely in the unloaded case.  In particular, parameters
must not be updated until the GL texture object has been created.

Generating an ID for the texture has been delayed to the last phase of
loading to further differentiate the loaded and unloaded states.

Avoid segfaults when LoadingThread's resource is cleared

Delay opening the resource file until loading actually starts

Opening it when the load is queued can cause large numbers of open files
to be created at once and dissipate slowly as the queue is processed.

Minor fixes

Fix TexGen unbinding

Exclude EnvironMap effect itself when creating the map

This avoids an unnecessary texture bind/unbind cycle if the EnvironmentMap
is contained within its own environment.

Put transform matrices into a uniform block too

I'm fairly certain the glBufferSubData call required to update the block
contents is no slower than the glUniformMatrix* calls to set the uniforms
directly.

Don't consider the current buffer in deciding whether to bind BufferRange

glBindBufferRange should only be called if the buffer range bound to that
index was changed.  The buffer binding gets changed as a side-effect, but
should not factor into the decision.

Rework ProgramData to do less unnecessary work

Changes are now tracked per-uniform, allowing more updates to be skipped.
The buffers used in a program are cached, making the no-changes case
faster.

Additionally, Program now creates a UniformBlockInfo struct for the
default uniform.  The program-wide uniform layout hash has been repurposed
to cover the entire program.

Tighten checks in UniformBlock

A single UniformBlock can only be a default block or a named block, not
any strange mixture of the two.

Introduce a typedef for uniform layout hashes in Program

Adjust the desert pillars demo to recent changes

Also decrease the cube's shininess from 150 to 120 for compatibility with
older OpenGL versions.

Move the reflectivity parameter to material

Logically it belongs there, even if OpenGL has no fixed-function support
for it.

Rectify some omissions in ProgramBuilder builtin variables

Fix uniform stride assignments

Fix the resource disassociation loop in ~ResourceManager

Unbind things if they are deleted while current

Failing to do so can lead to all sorts of stale-state issues, especially
if a newly created thing happens to get the exact same address as the
just deleted one.

Use uniform blocks in generated shaders if supported

Initialize StandardVariables::skylight

Emit separate declarations for struct types

I'm going to add uniform block support shortly and structs can't be
declared inside blocks.

Deal with hash collisions in assigning uniform block bind points

Improve bounding sphere handling in Object

Update Object's bounding sphere when mesh is loaded

Add a ResourceWatcher interface

Enable asynchronous loading of Meshes

This currently causes object bounding spheres to be incorrect when using
managed meshes.  The situation will be rectified shortly.

Add an asynchronous update interface to Bufferable

Refactor the internal interface of Bufferable a bit

Miscellaneous fixes to ResourceManager

Some fixes to VAO management

Minor adjustments

Add a hidden option to disable progress meter

Intended for scripts that call the MSP export operators multiple times.

Add an object property for inheriting the specified technique

This allows using object-specific textures while still sharing material
and shaders.

Use image path as texture identifier if available

This is more likely to be correct in common resource loading setups.

Take material diffuse intensity into account

Display overall progress when exporting scenes

Implement automatic unloading when a total size limit is exceeded

Implement automatic resource unloading based on age

Set dirty_params when unloading textures

This ensures that things like MIN_FILTER get set correctly when it is
reloaded.

Implement manual loading policy and async flag

Throw an exception if Resource::load did not create an AsyncLoader

This is only a safeguard against programming errors and should never be
hit in normal use.

Dissolve the association to resources when ResourceManager is destroyed

Enable resource management on Texture2D

Foundation for a resource management system

Add memory-mapping functions for Buffer

Make the viewer capable of viewing scenes

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.