More efficient stack management

Vectors are better than lists, since they don't need to allocate new
memory for every element.  A suitably sized reserve() does away with any
initial reallocations in most cases.

ProgramData in Renderer can be stored in a semi-independent stack as
well, since it can only be removed with a pop.  State is now devoid of
dynamically allocated memory, making the stack operations even faster.

Fix color equations in the standard shaders

The generated shader code assigned a scalar to a vec3 if lighting was
enabled without texture or material.  An unnecessary multiplication in
the alpha equation with texture but no material was removed.

Also fix texturing in the shader demo (Mesa does funny things with
uniforms).

Provide the necessary uniforms from ShadowMap

With the recent changes to the Effect and Renderer, it's finally possible
to avoid the need to specify the shadow map texture unit everywhere, and
get rid of the hardcoded gl_EyePlane* indices.

Tweak the shader functions in Renderer

Since ProgramData is no longer tied to a single Program, we can retain it
over program changes.  This opens up some new possibilities, in
particular for Effects.

Also rename set_shader to set_shader_program.

Check the relevant extensions when using pixel formats

Complete rewrite of extension handling

Prefer the promoted versions of extensions.  This improves compatibility
with OpenGL 3.0 and OpenGL ES 2.0.

Extension availability is now checked through global identifiers rather
than strings.  This eliminates the possibility of typos.

Remove the global drawing functions

Pull glDrawRangeElements from version_1_2.h

Pass the Renderer to ObjectInstance::get_level_of_detail

As I recall, the camera was put in renderer to allow view-dependent
rendering without the need to pass data outside the rendering pipeline.
This is one of the cases where it is needed.

Remove alignment where it doesn't belong

Fix an incorrect extension name

Use DerivedObjectLoader in Texture2D

Buffer fixes in ProgramData

Set proper usage hint, and delete the buffer in the destructor.

Lots of comment updates

Improvements to Bufferable

Most members are now private, with read-only accessors, since the derived
classes should not modify them.  Some names were changed.

Add documentation to the class and all public/protected methods.

Drop support for Renderables that don't accept a Renderer

The Renderer class is the way of the future and should be used whenever
possible.

Avoid creating blocks for which there are no uniforms

Since this requires finding the relevant uniforms before the block is
created, might as well store the list with the block for faster updates.

Align uniform blocks properly

Improve performance of Bufferable::update_buffer_data

... by avoiding the walk through the entire chain every time it is
called.  It's not necessary to add up all the sizes either, since we can
just get the end of the last Bufferable.

Get all blocks for the program before applying them

This way, the correct size for the buffer can be determined right away,
rather than each block resizing it in turn.  Binding the buffer before
applying the blocks also avoids some thrashing.

Pass the UniformBlockInfo to get_block to avoid an unnecessary lookup

Sort the uniforms in Program::UniformBlockInfo by offset

Alter the working logic of Bufferable to avoid some problems

It was possible for the buffer data to be updated without going through
the dirty check in UniformBlock::apply, leaving the UniformBlock with a
null buf_range and resulting in a segfault.

Initialize buf_range as null

Don't query array/matrix stride for uniforms which are not arrays/matrices

Construct uniform buffers for named uniform blocks

Add a class to negotiate the storage of multiple objects in a buffer

Uniform handling fixes

Initialize strides to zero, and return a location of -1 for uniforms in
blocks.

Store block pointer in uniform info

It greatly simplifies figuring out which uniforms are not in blocks.

Query information about uniform blocks when linking a Program

Move Program::bind to its proper place

Use typedefs in Program

Add the uniform buffer type

Improve binding of buffers

Add a set_current function, as seen in some other classes.

Buffer type support is now also checked in bind_to.

Add glBindBufferBase/Range functions to ARB_uniform_buffer_object

For some reason those functions are not tagged for the extension in
gl.spec.

Keep track of buffer size

Move some declarations around a bit

Remove the specialized setters from UniformBlock

They were not very useful and were also getting in the way of uniform
buffer support.  UniformBlock also no longer clones the uniforms for
itself, reducing overhead.

Add definitions for the GL_ARB_uniform_buffer_object extension

Update gl.spec to latest version

Make RenderPass shprog and shdata settable from code

For consistency with other similar interfaces, the pointers are now
const.  As a consequence, a uniforms statement in a datafile overrides
any previous uniforms.

Add a shortcut constructor to Object

Avoid re-applying shader data unnecessarily

Plug a memory leak

Use uniform arrays in Bloom and AnimatedObject

Implement uniform arrays

Rewrite the Uniform classes as templates

This makes adding new uniform types easier, especially arrays.

Convert existing post-processors to use the provided common resources

Use two FBOs in Pipeline when necessary

Add a color curve post-processor

Helper functions for post-processors

Most post-processors render fullscreen quads and use a very basic vertex
shader, so it makes sense to provide these as common resources.

Simplify Pipeline pass management

Originally I planned to use Pipelines to bundle objects with effects like
environmentally mapped reflection.  However, that task was delegated to
effects themselves recently, so there's no longer need for passthrough
rendering in Pipeline.  The render_all function was also a nuisance, as
it required Pipelines to be treated differently from other Renderables.

Passes are now stored in a list instead of a map.  This allows multiple
passes with the same tag (think multipass lighting), and avoids the need
to store the pass order separately.

Move PipelinePass inside Pipeline and make the data members private

It's really simple and specific to Pipeline, so it doesn't make much
sense to have it as a separate class.  Encapsulation is necessary for
some future plans, and also more consistent with other public interfaces.

Use the hash function from mspcore

Constructing tags mostly happens when loading datafiles or otherwise
outside the rendering loop, so the small extra overhead from a
cross-library function call is not significant.  Renderables that wish to
compare the Tag against a fixed value should avoid constructing the
reference Tag on every render call anyway.

Delete multisample resources in Pipeline destructor

Lighting affecting the alpha value of a surface makes no sense

Use lighting only for RGB components, and take alpha directly from color
or material.  This should prevent problems caused by alpha>1.

Use the TexGen wrapper in ShadowMap

Add TexGen wrapper class

Turn Effect into a Renderable

They were really intended to be used this way.  This also makes it much
easier to apply an Effect to only a part of a scene.  Previously it would
have been necessary to wrap the Effect in a Pipeline, which doesn't
really support passthrough.

Restructure ProgramData to support sharing between Programs

This removes a major annoyance when dealing with ObjectInstances and
shaders.  It also paves way for Effects being able to provide uniforms,
and support for GL_ARB_uniform_buffer_object.

Generate a hash describing the layout of uniforms in a Program

This allows easy recognition of whether two Programs have compatible
uniform layouts and could use shared data.

Add a function to query if a Technique has any shaders

Also make PassMap public since it's exposed through get_passes

For a few lingering whitespace issues

The scripts had been ignored entirely in the previous conversion.  As a
result, a few newly generated extensions didn't have proper whitespace.
Pure virtual functions in headers had also slipped through.

Make the cubemap demo more interesting

It now displays two different shapes, which have reflections through an
environment map.  The same environment map is used to render a skybox.

Also uses the new direction lookup functions to create the contents for
the cube map texture.

Tangent and binormal vectors should use custom transform as well

Add a standard program feature for environment-mapped reflections

Lookup functions to determine the orientation of cube map faces

The orientations are somewhat arbitary and not deducible with a simple
algorithm.  Writing the necessary conditional ladders everywhere would
be annoying.

Fix several bugs in the animation system

Make the identity fallback matrix static so the pointers in interpolations
stay valid.

Don't crash when getting pose matrices from the first keyframe.

Matrix multiplication order for base point shift compensation was wrong.

Re-compensate for base point shift after interpolation.

Use correct comparison operator for max_index in AnimationPlayer.

Pass collection to keyframe loader to make loading poses possible.

Use Pose::set_armature rather than loading the pointer directly to get the
matrix array resized.

Support for exporting armatures and vertex groups

Restructure the exporter to make room for new stuff

Fix bugs that crept in with refactoring

Also add an additional safeguard against an infinite loop

Support for armature-based animation

Allow setting keyframe matrix from the outside

Fix uniform array element lookup

Add classes for armature-based deformation

For now, link rotations in a pose must be specified in hierarchial order,
or the matrices will be wrong.

Expose the build(Mesh &) shortcut in classes derived from GeometryBuilder

Add missing set_looping implementation

Restructure Animation to make matrix interpolation code more reusable

Don't link program with the transform feature in constructor

The transform feature produces calls to external functions, which need to
be added in a separate shader.  Trying to link in the constructor only
produces link errors.

Better way to deal with program-owned shaders

Track which shaders exactly are owned by the program rather than having
just a single flag.  This prevents double-free problems if a program
contains both owned and non-owned shaders, as might be the case with the
transform feature.

An extra sanity check for TBN export

Refactor strip generation code and add comments

Update .gitignore

A simple program to test cubemap texture functionality

Move some member functions to more logical positions

Comment updates for texture and framebuffer classes.

Fix 3D texture loading with fixed depth

Add support for cube map textures

Mipmap generation requires GL_SGIS_generate_mipmap

Update Build file for new Builder features

Add support for viewing animations

Basic animation support

Use a custom drawing function to group the properties in a sensible way

Support exporting textures with objects

Improve texture unit handling

More compilation fixes

Don't try to export a material texture if the mesh has no materials

Split mesh and object export into separate operators

Fix exporting compound objects with no materials

Adapt exporter to Blender 2.63