Migrate to the new XML-based OpenGL API registry

Always include glext.h

There's no real reason to leave it out, and having it in multiple places
causes trouble for the upcoming OS X support.

Set read buffer as well as draw buffer for FBO

Apparently Nvidia drivers are too lax with this, but some others don't
like if the FBO has no color attachments and the read buffer is left at
its default setting of COLOR_ATTACHMENT0.

Make cube map textures loadable from datafiles

Support off-center frustum in Camera

Add a Scene type that sorts its renderables by depth

Stereographic rendering moved to a separate library (mspvr)

Add an option to export colors as sRGB

Deal with some irregularities in the Blender exporter

Things like loose vertices, non-manifold edges or zero-length edges should
no longer cause crashes.

Add some documentation to the culler system

Rename Culler::setup_frame to setup_pass

It's really called once per pass, so name it accordingly.

Add a frustum culler class

Add an interface for obtaining bounding spheres from renderables

This can be used for various forms of culling.

Add interfaces for culling

Culler implementations to come soon.

Add a flag to RenderPass to render the back faces of a mesh

This is useful for transparency effects.

Throw if trying to render an Object without a Technique

Make RenderPass easier to use

Use Renderer to bind Lighting

This fixes a problem where the matrix left behind by a pipeline pass could
interfere with the lighting of the next pass.  It's also required for
eventually supporting OpenGL 3.0+ without fixed-function lighting.

Add kerning support to Font

Make the font script compatible with new ttf2png output

Do not store generated files in the repository

Instead generate them during the build process.  This helps with managing
any changes that might be necessary when porting to new platforms.

Add a StereoCombiner subclass for the Oculus Rift

Field of view is an angle too

Add classes for stereographic rendering

Some fixes to the Build file

Render final pipeline output into the bound framebuffer

Function pointer typedefs for core functions are not available everywhere

Add overloads for rotation functions that take axis as three coordinates

Use constructors to augment and reduce vectors

Remove an obsolete #include

Fix event bindings

Use libmspmath to provide vector and matrix operations

Pulling them from a math library enables interoperability for programs
where it is desirable for some parts to avoid an OpenGL dependency.  A
full complement of vector operations helps with readable code.

The flag tracking from Matrix was removed as a benchmark showed it to
actually hurt performance with compiler optimizations enabled.

Auto smooth angle is stored in radians, not degrees

This probably got changed since Blender 2.4, but had gone unnoticed.

Add support for playing multiple stacked animations on an object

Force some c'tors and d'tors to be emitted in the library

Forward declaring class A and having a RefPtr to it in class B causes
trouble if B's constructor or destructor is synthesized at a location
where A's definition is not visible.

Fix axis interpolation to work with scaling

Disable NV_primitive_restart on Radeon cards because it's buggy

Fix shaders in the desertpillars demo

Make Texture2D::image(Graphics::Image) public

Use IO::Memory to load embedded texture image data

Verify framebuffer completeness in effect constructors

This avoids silent failures due to an unsupported framebuffer
configuration.

Improve pipeline render target management

Recreate render targets if number of samples is changed.

Don't create render targets if neither postprocessing nor multisampling is
active.  HDR is only useful with postprocessors (maybe postprocessors
should be able to request HDR?).

Call fbo.require_complete to allow trial-and-error autodetection of
rendering configuration.

Add a function to require the completeness of a framebuffer

Move uniform array name adjustment to an earlier phase

Uniforms are looked up by the map key, so it won't do any good if the name
stored in the UniformInfo is adjusted by the map key isn't.

Remove deprecated matrix APIs

Change Font::add_glyph to take a glyph struct

Did I seriously think that a function with 10 parameters was a good idea?

Remove deprecated Font features

Change font methods to better differentiate between drawing and building

Re-apply vertex array if it has been modified

More robust handling of uniform arrays

Fix some warnings about uninitialized variables

In reality they are always initialized when they're used, but the compiler
doesn't necessarily know that.

Let Batch decide whether appending is possible

Fix a comparison with restart_index

An incorrect comparison operator caused a batch meeting certain criteria
to unintentionally trigger a primitive restart with its last index instead
of rendering it properly.

Add setup/finish_render hooks to Object

Implement assignment operator for ProgramData

This is possible now that ProgramData no longer contains any references.

Use CLAMP_TO_EDGE on postprocessing textures

Remove useless GL:: qualifiers

AmbientOcclusion was initially developed outside the mspgl tree, and these
were not removed when it was brought in.

Fix type errors in ColorCurve fragment shader

Version bump; compatibility was lost weeks ago

A complex demo program to show off features of the engine

Plug a memory leak

Don't unbind the fbo until the entire cube map has been rendered

Support for anisotropic texture filtering

Make it possible to customize texture sampling in standard shaders

Deactivate all arrays when deleting the active VertexArray

Set all color attachments of a Framebuffer as draw buffers

Indexing gl_FragData selects from the active draw buffers, so this is
required for multiple fragment shader outputs.

Add an EnvironmentMap effect

Don't assume a directional light's position vector to be unit length

Bring back reflection mapping support to standard shaders

Fix a stupid copy&paste mistake

Compatibility fixes

Fix a template parameter deduction on 64-bit system

Fix a shader type mismatch

Use the frame notifications in ShadowMap

Notify Renderables about the start and end of a frame

This makes it possible for Renderables to do certain things only once per
frame.  This is particularly useful for Effects which need expensive
preparation.

Fix vertex array offsets

Since array application order may now be different from the format order,
and VertexArrayBuilder stores components in the latter, calculating the
offsets while applying arrays gives wrong results.

Add a method of getting the model matrix of a Renderable

This can be used for various position-dependent rendering techniques, such
as certain effects and frustum culling.

Include local headers with "", not <>

Rename the matrix reference version of uniform_matrix4 to uniform

This is more in line with the other uniform setters, which don't have any
type suffix when given an argument from which the type is apparent.

Add 3x3 and 2x2 uniform matrices

Renderer no longer needs to track vertex array changes

Rework vertex array application

VertexArray now tracks the currently applied array, and works out the
necessary changes as the difference from the previous one.

Standard vertex components for tangent and binormal vectors

This simplifies using normalmapped standard shaders, as the shader is
ready to use without the need to declare tangent and binormal attribute
indices.

Rearrange exporter controls and add the omitted export_uv property

Load VertexFormat for Mesh as an array of VertexComponents

The single-token approach made indexed attributes rather ugly.  Loading
each component separately also gives better diagnostics in case of
erroneous tokens.

Rearrange vertex components

The first 16 component types are now reserved for the library.  This
leaves room for adding standard generic attributes, such as TBN vectors.
To make further room, texcoords were limited to four indices.

Generic attributes are limited to 24.  Current implementations seem to
only support 16 (the minimum allowed by the spec), so this is not a huge
problem.  There's also exactly enough room for another set of 24 generic
integer attributes.

Add a helper function for making indexed vertex components

This puts the logic for checking the allowable index ranges in one place.

The base for an indexed component must now be one with a zero index.  It
didn't make much sense to add an index to an already indexed component.

VertexFormat::offset no longer takes an index, since the helper function
can be used.

Memory allocation changes

Use std::copy instead of memcpy
Call operator= from copy constructor
Allocate memory only when needed, not one byte before

Turn VertexFormat into a class and hide the data member

Outsiders have no need to access it directly

Helper functions for extracting vertex component type and size

Magic numbers are bad.  This makes the code more robust against future
changes.

Shuffle the members of VertexArray into a sensible order

Fix a type mismatch in the standard shader source

Only call update_offset() once per append operation

Fix logic with appending Batches

Allow combining Batches of any primitive type with NV_primitive_restart,
and don't use it if not necessary.

Make use of Bufferable in Batch

Move Batch members around

The helper functions for changing data type don't really need to be
members, so put them in a private namespace.  Other functions rearranged
in a more sensible way.

Shader optimization

ProgramBuilder can now collapse variables with only one reference into the
expression using it.  Fragment color expressions were tuned as well.

Exception fixes

Use out_of_range only when accessing arrays or array-like things, not for
general numeric arguments.

Armature::get_link functions now throw key_error since they behave like
map access externally.

Improvements for shadow mapping

Depth bias is now configurable, and a darkness parameter was added.

Entirely new system for building standard shaders

The old one was becoming such a huge mess that I had to spend two minutes
doing boolean analysis to figure out the conditions for a multiplication
operator.  The logic parser was also insufficient for expressing
sophisticated relationships between variables.

The new one operates with expression, starting from a target variable and
pulling in others to compute its value.  The logic parser is still there,
buts its burden is greatly reduced, as most of the work is done by the
dependency resolver.

Reflections are missing at the moment, but will be added back soon.  They
were pretty broken in the old system anyway, with the assumption that the
environment map is in eye space.

The generated shader code is rather verbose, containing a lot more local
variables than are needed.  An optimizer will be implemented in the near
future.

Don't expose the shader type enum

Instead take an object oriented approach.

Route rendering calls through Renderer and add an exclusion system

This is necessary for generating environment maps for an object, since
the object itself should not be included in the map.  The alternative is
to create a separate Scene, but that's rather clumsy.