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.

Fix an uninitialized variable

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