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

Add a shortcut for specifying both texture filters

Final touches of OS X support

Include extension headers in places that need enums from them

A few places still rely on gl.h for OpenGL 1.3 or 1.4 enums.  I may look
into these later.

Check the presence of extension rather than function

Minor fixes, courtesy of Apple's compiler

It likes to complain about a lot of things.  Some of them make sense (like
unused private members), but mostly it's just being a bitch.

Add a missing initialization

Deal with extensions that are not present at compile time

Cleanup and documentation of extgen.py

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