Streamline interface declarations

Out variables can now be declared inside functions and will be exported
to global scope.  In variables don't need to be declared at all; they are
pulled in from the previous stage.  There's a new passthrough statement
to copy all inputs to outputs.

Remove unused variable and struct declarations from the syntax tree

Inject the global context to the syntax tree

... rather than concatenating its text with the other contexts.

Implement an actual expression parser

Doing pretty much anything interesting with the syntax tree requires
having access to expressions.

Begin implementing a new shader program generator system

ProgramBuilder is good enough when working within its standard features,
but it's difficult to expand.  Custom variables are overly sensitive to
declration order.  Adding loops or conditionals (other than the operator
flavor) requires using an additional shader.  It's not possible to modify
a variable's expression without replicating it in its entirety.

All of the internal processing with coordinate spaces, interfaces and
indices can also be difficult to understand.  Not to mention the reverse
processing order which starts from the goal variables and works backwards
to figure out how they can be computed.

The new ProgramCompiler system, as its name implies, works more like a
compiler.  It's designed to take GLSL as input, apply transformations to
it and produce different GLSL as output.  Storing the progrem as an
abstract syntax tree allows much more comprehensive processing than the
old system which barely understood what an identifier is.

At the moment it doesn't do much yet.  The only transformation is to
split a single source file into vertex, geometry and fragment parts and
add a common section at the beginning of each of them.  More will be
added soon.

Restructure the extension detection code

Extension disabling is now more forceful and will prevent the use of the
relevant functionality even if it was promoted to core.

Add a less-than operator to Version

Detect deprecation versions for extensions

If the core profile is in use, deprecated extensions will be made
unavailable unless the driver explicitly advertises them.  In particular,
MSP_legacy_features is made unavailable so code that tries to access
legacy features with a core profile context will throw an exception.
Additionally no enable/disable calls will be generated for textures, as
they are only used for legacy texture units.

Add a function to determine the active GL profile

Be smarter when detecting the core version of extensions

Use an orthographic camera for rendering the shadow map

Properly compute frustum culling for orthographic cameras

It's still incorrect for skewed frustums but I'll fix that later.

Also convert RenderBuffer formats to sized variants if possible

Prefer RG pixelformats over LUMINANCE

LUMINANCE formats were deprecated in OpenGL 3.0.  ARB_texture_swizzle
was not promoted to core until 3.3, so it's possible this won't work on
some transition period hardware.

SLUMINANCE formats are marked as deprecated in mspgl since it's not
possible to properly emulate them through swizzling.

Expand the PixelFormat conversion API

Get_sized_pixelformat now takes an explicit size parameter.  The decision
between 16-bit and 32-bit depth component formats has been moved to
Texture::set_internal_format.

Get_unsized_pixelformat was added as an intermediate step for
get_base_pixelformat.  It preserves sRGB information.

Fix Texture2D::get_data_size to use get_pixel_size

Have get_component_size return zero for unsized formats

Get_pixel_size still assumes a component size of at least one byte.

Move internal format management to the Texture base class

Use indexed string query to get extensions on OpenGL 3.0 and above

Add the ARB_texture_rg extension

Add properties to export materials as texture array layers

Use ARB_direct_state_access to avoid some bind calls

Refactor TextureCube face information functions with lookup tables

Refactor Framebuffer::update_attachment for less indentation

Use the correct form of glTexParameter to set maximum anisotropy

Rearrange texture bind calls to keep them closer to where they're needed

Prefer explicit mipmap generation with glGenerateMipmap

Implicit generation with the texture parameter was deprecated in
OpenGL 3.0 and removed in OpenGL 3.2.

Use ARB_texture_storage for defining texture storage

Add some utility functions for textures

Implement sub_image for TextureCube also

I thought it was already implemented but in turned out there was only a
declaration.

Prefer sized internal formats when possible

Pull in sized depth component formats from ARB_depth_texture

Implement 2D array textures

Cosmetic tweaks

Remove the obsolete storage statement with border

Add a datafile statement to use an external image for a texture

It can be useful for non-2D textures which can't be loaded directly from
an image file by the resource collection.

Implement sub_image for Texture1D

Implement loading functionality for texture classes that were missing it

Move srgb handling to storage_pixelformat_from_graphics

Use the core version of primitive restart if possible

Pick the correct source for an extension function if there's multiple

Use correct form of GET_PROC_ADDRESS for unpromoted functions

None compares as less than any list.

Use ARB_geometry_shader4 rather than the EXT version

The ARB version is what actually got promoted.

Be smarter about detecting backport extensions

Sometimes a more recent and completely unrelated extension reuses some
tokens with their core names, causing them to seem like backport
extensions to the script.

Give the LIGHTING and CLIPPING flags a LEGACY prefix

Track whether implicit shader data needs to be re-applied

Always print shader and program info logs in debug mode

They may contain useful warnings even if the code was accepted.

Add uniform integer vectors of 2, 3 and 4 elements

Fix Camera::unproject

It was lacking un-perspective division.  There's also a Vector3 overload
now.

Check glGetString result for being null

Add a geometry flag to ProgramBuilder

It does not generate a geometry shader yet but allows one to be manually
inserted into the program.

Add basic support for geometry shaders

Perform culling in eye space and account for Renderer's matrix

This allows container renderables to apply intermediate transforms to the
Renderer.  Sometimes it may be inconvenient to propagate every matrix
change down through the hierarchy.

Add a convenience method to get the aspect ratio of View

Inherit View from sigc::trackable

It connects to the resize signal of Window.

Add new matrix manipulation functions to VertexBuilder

For symmetry with Renderer.

Add some accessors to View

Fix some #defines for Windows

Require libsigc++-2.0 since View connects to a signal

Add a new View class to tie up some presentation tasks

Don't attempt to create buffers by default if they are not supported

Rendering from client memory is a relic from the past but since the
change is rather trivial might as well support it.

Align batches at the index size

Add check for more modern AMD video cards

They no longer have "Radeon" as part of the renderer string, at least
with the amdgpu driver.

Support loading uniform arrays from data files

Add aliases for uniform statements without the type suffix

Consistently use the same spelling for diffuse_map and normal_map

It appears that spelling them as two separate words is more correct than
a compound word.

Access clipping through the extension mechanism

It's not supported on OpenGL ES.

Use RAII to restore the output FBO in Pipeline::render

Do not attempt to unwatch a mesh that was already removed

Notify watchers of a resource being removed from the manager

Most likely this is a consequence of it being deleted.

Fix some uninitialized variables

Add integer overload of ProgramData::uniform1_array

Support custom functions in ProgramBuilder

Add a new API to Pipeline that ties Renderables and passes together

The old API is now deprecated and will eventually go away.  There are
two reasons for this change:

1. Pipeline was a sort of pseudo-scene, and in many simple use cases it
was not clear which should be used to hold Renderables.  Scenes are
intended as grouping primitives.

2. It was possible to add multiple passes with the same tag and different
rendering state, but there was no way to add a Renderable for only one of
them.  This led to tags doubling as a way to filter different passes at
the level of individual Renderables.  The intended purpose of tags is to
select between different presentations of a Renderable.

Unbind Clipping in Renderer::end

Fully unbind Clipping when legacy mode changes

Failing to do so may leave ClipPlanes bound to ClipUnits, leading to
undesirable behaviour later on.

Require legacy features when binding plain clip planes

Add loader support for clipping in standard shaders

Binding fixes for Clipping when mixing legacy and modern mode

Implement the previously forgotten Clipping::unbind

Some fixes to lighting management

Support user clip planes in generated shaders

Handle clipping in Pipeline and Renderer

Restore user clip planes in a form compatible with modern OpenGL

They work much the same as lights, with the ability to add uniforms to a
ProgramData object.

Support rotating the camera frustum

The rotation is applied as the very last step of projection, alllowing
screen rotation to be easily implemented in software.

Don't do a potentially expensive mesh update if nothing changed

Fix incorrect multiple inclusion guards

Use cap height instead of ascent for midline alignment

Add cap height and x height metrics to Font

Since FreeType (and consequently ttf2png) doesn't provide these metrics,
they are estimated by the makefont script.

Use UNSIGNED_SHORT for allocating DEPTH_COMPONENT textures

OpenGL ES doesn't accept DEPTH_COMPONENT together with BYTE types.

Adjust OccludedScene to be more compatible with OpenGL ES

GL_SAMPLES_PASSED is not available in OpenGL ES so use occlusion_query2
for GL_ANY_SAMPLES_PASSED.  In theory it's possible for an implementation
to support occlusion_query but not the 2 variant; I'll deal with that
case if I ever come across such a combination of hardware and drivers.

Rearrange things in ZSortedScene a bit

Implement a scene class that performs occlusion culling on renderables

Add a class for building icosahedron-based spheres

It doesn't do texture coordinates because there's no straightforward
mapping between a plane and an icosahedral surface.

Use a persistent sorted array in ZSortedScene

Typically the order of renderables changes very little between frames, so
it's possible to use insertion sort which is very fast for almost-sorted
arrays.

Calculate depths in ZSortedScene more efficiently

Immediately add renderables to the cache in SimpleScene::add

Cache renderables in SimpleScene into a vector

Set iteration is rather expensive, but I want to retain the O(logn)
performance of add and remove operations.

Further tweak frustum culling to be more efficient

Remove the culler abstraction and move frustum culling to Scene

It turns out that different culling methods (such as occlusion queries)
have different enough requirements that putting them behind a single
abstraction is not feasible.  This also seems to provide a slight
performance boost.