Remove useless declarations of main() from shaders

Improve the ambient occlusion postprocessor

Now that postprocessors have access to the Renderer and its state, the
camera projection matrix can be used for more sophisticated depth
calculations.

Also re-apply standard shader data when the shader program changes

Always treat GLSL function parameters as referenced

They can't be removed so adding them to the set of unused nodes would
lead to an infinite loop.

Some fixes to assignment management in UnusedVariableLocator

Sometimes assignments were being removed when they shouldn't (reference
from a conditional sub-block).  Other times they weren't being removed
when they should (followup assignment in the same block).

Support attaching 3D and 2DArray textures to Framebuffer

Reorder declarations right after injecting the shared scope

This is necesary for InterfaceGenerator to recognize additional inputs in
shaders that import a main function with passthrough in it.  Otherwise no
passthroughs would be generated and those inputs would be unusable in
later stages.

Refactor and improve unused variable detection in ProgramCompiler

It now recognizes and marks for removal assignments to global variables
if the variable is not read in any function.

Recognize backward references in GLSL loops

A lone assignment at the end of a loop isn't unused if the next iteration
uses the value.

Compute Framebuffer size correctly when texture mipmaps are attached

Add a default tag to render functions that were missing it

Immediate update camera aspect in View::set_camera

Initialize View::camera to null

So it doesn't crash when used without a camera.

Add some more premade blend modes

Mark some functions as const that by all rights should be

Set a sensible projection matrix when there's no camera

Recognize various nonlinear flow control statement

Remove some methods that have been deprecated for a long while

Add bounding sphere passthrough to Effect

Refresh lighting and culling uniforms if the camera changes in pop_state

Add setup/finish_frame methods to OccludedScene and ZSortedScene

Use the external Renderer to render ShadowMap and EnvironmentMap

Change the setup/finish_frame interface to be non-const

There's no deprecated versions left behind because it would be impossible
to make it work with Renderables that forward the calls to a Scene.
Better to just get compile errors and fix them as I encounter them.

Store Renderables as non-const pointers or references

It's irked me for a while how some renderables (mostly effects) need to
do internal updates in setup_frame, but it's const so I end up with a ton
of mutables.  Since almost all of my use cases actually pass in non-const
Renderables anyway, I'm just going to change this.

Remove the Renderer-less overload of Renderable::render

It's been sort-of deprecated for a long time even though it wasn't marked
as such.  None of my code code uses it with anything else than Pipeline
(and that code path is being replaced with View).

Associate camera and setup/finish_frame calls with View

... instead of Pipeline.  Having a Camera in the Pipeline but using the
Renderer's camera to override it for some things feels like a hack.

Pipeline gets to keep it's top-level render function for now.

Refactor postprocessor uniform usage

A lot of the values are shared between processing passes, so it doesn't
make sense to keep multiple copies.  ProgramData will take care of only
setting the required uniforms.

Use RenderTarget objects to manage FBOs in postprocessors

Add a RenderTarget class to manage and annotate FBOs

I want to have deferred lighting support at some point, and it requires
multiple outputs from the geometry rasterization stage.  There needs to
be some way to annotate which buffer holds which information.

Don't bother with RAII here

There are already RAII objects in the outer scope.

Remove dynamic allocation from VertexFormat

On 64-bit systems the pointer takes eight bytes, and a typical malloc
implementation will have two pointers worth of overhead.  Vertex formats
hardly ever reach even eight components, so it's cheaper to just store
a fixed-size array in the class itself.

Ensure that program syntax nodes get deep-copied properly

The changes in 57c1139 prevented copies happening even when they should,
so the shared section got inserted into shader stages by reference.  This
caused some funny business with the variable resolver and unused variable
locator.

Containers of nodes must have RefPtrs inside them, since insertions will
create some temporary copies of the element and with NodePtr that would
trigger copying the node as well.  So the cloning of nodes is performed
when the container itself is copied.

Inline trivial shader functions that are only called once

I.e. functions that consist of a single return statement.

Reorder declarations in shaders

So that structs appear before variables and variables appear before
functions.  This ensures that the declarations stay visible if an
expression is moved to an earlier point while inlining functions.

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