Remove some VariableResolver calls that are no longer needed

Now that nodes don't get copied when moving around the previously
resolved declaration pointers will stay valid.

Upgrade NodePtr to RefPtr

Allows Nodes to be moved from one Block to another without copying them.
When targeting GLSL 1.30 LegacyConverter has a sequence where it flattens
an interface block and later checks the type of those variables through
their declaration pointer.  This caused memory errors because the
original nodes were destroyed in the flatten operation.

Some fixes for the scene exporter

Improve the color curve postprocessor

Properly scale the the bounding sphere for frustum culling

The original radius must be squared too.  Also, negative distances mean
the sphere is inside the frustum and should not be culled.

Use Renderer for rendering PostProcessors

Ensure that DepthTest and Blend get unbound for PostProcessors

Deprecate Renderer::begin() and remove the already deprecated escape()

Make the camera part of changeable Renderer state

I'd like to move to a single, persistent renderer at some point and this
is a necessary step towards that.  Some effects want to use their own
camera to render into an FBO.

Set the appropriate flags on Renderer state changes

Account for scale when performing frustum culling

It will still break with non-uniform scaling.

Evaluate parenthesized expression as the contained expression's value

Use layout declarations to set attribute and fragment data locations

A fallback to glBind*Location functions is provided in case the
implementation does not support GLSL 3.30.

Support layout declarations on variables

Eliminate the separate matrix stack in Renderer

Instead incorporate the modelview matrix into the main render state.

Allow redeclarations to override the type of a variable

This can be used to e.g. change the sampler type of the diffuse map.  At
the moment the appropriate sampling function also needs to be overridden
since texcoord dimensions are not handled automatically.

Move postprocessor shaders to the builtin shaderlib

Generate the entire shaderlib into a single file

Generating lots of small files seemed rather silly, and I found no good
way to automatically generate the builtin init code.

Automatically backport shaders to earlier GLSL versions if necessary

Fragment shader output replacement is a bit crude and will just replace
any output with gl_FragColor.  It will be made better later.

Refactor block modification operations into an intermediate base class

Add a builtin module for standard shaders

It doesn't support multiple lights as generating the necessary array
interfaces through a geometry shader turned out to be rather non-trivial.
I plan to add deferred rendering modules with multi-light support later.

Remove unused functions from the shader source

Remove conditionals and loops that can be determined to never run

This is the other major step required for standard shader generation.
Currently the constant condition eliminator is pretty conservative and
will only consider the initialization values of variables.  Globals are
only considered if they are declared const.

Implement an import system

This is the first of two major steps required to replicate the core
functionality of the old ProgramBuilder system, namely generating
standard shaders.  The other is conditionally including pieces of code,
which will be added soon.

Further reduce overhead of applying ProgramCompiler visitors

Check if blocks need braces at formatting time

Parse true and false as literals rather than identifiers

Fix formatting issues with else ifs

Overhaul assignment tracking to work properly with conditionals

Generate a passthrough for gl_Position in geometry shader

Add a module for builtin interface variables

Required to make unused assignment removal work for gl_Position.

Better handling of array flag for generated interfaces

Move unused aggregate detection to UnusedVariableDetector

It isn't really NodeRemover's job.

Fix unused variable decetion for self-referenging assignments

Extend it to initialization expressions as well.

Integrate ProgramCompiler with Program and Resources

Return back to first stage after some optimization happens

Unused variable removal can propagate towards earlier stages so those
have to be checked again.

Process existing inputs in passthrough

Vertex shader inputs are not linked to any outputs so they weren't being
recognized for passthrough.  Also, some inputs might have already been
declared either explicitly or implicitly so those declarations should be
preferred over creating new ones.

Recognize superceded assignments even for out variables

Assorted refactoring and fixes

Refactor module and stage management

Originally I envisioned that ProgramParser would handle imports, but it's
non-trivial to make re-entrant.  The parser will now only hold one module
at a time and ProgramCompiler will handle combining them.

Rename ProgramSyntax::Context to Stage

Extend unused variable analysis to assignments and across interfaces

Assignments are removed if there are no further references to the
assigned variable, except if it's a linked out variable.

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