Make extensions compatible with OpenGL ES

Add a debug switch to the extension generator

Be much more strict about extension support

OpenGL ES has added bits and pieces of full OpenGL functionality, an the
extension generator was thinking an extension was supported when really
only a few tokens from it were.  Now all tokens must be either supported
or explicitly marked as optional for the extension to be made available.

Some features may be temporarily unavailable on OpenGL ES builds as I go
over the extensions and decide how to fix them.

Refactor the structure of extgen.py

Functionality should be more or less preserved at this stage, modulo new
or fixed bugs.  Some extensions are detected differently on OpenGL ES but
those were largely incorrect anyway and will be fixed soon.

Apply the matrix in ObjectInstance::setup_render

Derive ProgramCompiler::DeclarationCombiner from BlockModifier

Support precision qualifiers in shaders

Fix shader version declaration when minor version is zero

Basic OpenGL ES support in ProgramCompiler

Check language features against the correct version depending on the API
and emit a default precision qualifier for float types.

Cosmetic fixes

Use matrix column accessors rather than multiplication

Make use of the Light's matrix in ShadowMap

Derive Camera and Light from Placeable

Improve parameters and documentation of Light

Add a new Placeable base class

Remove useless namespace prefixes

Immediately process window size to set correct viewport size

The system framebuffer acquires its size from the window when the GL
context is created, but in some use cases the window may change size
before a View is created on it.

Simplify version comparisons

The less-than operator was implemented a while ago but these two cases
were missed.

Throw an exception if a referenced external image is not found

Use the same mesh for multiple instances of an object in scene exporter

Eliminate a useless temporary variable

Small optimization for mesh exporter performance

Fix an incorrect variable in the mesh exporter

Use correct function name in exception

Some comment updates

Don't crash if an explicitly specified backport extension is not found

Also fix formatting of the error message.

OpenGL ES compatibility fixes

Header fixes

Disable core version of primitive restart on Radeon as well

Maybe there's something wrong with my code but I can't figure what.  This
is the easy solution.

Return false from is_supported for disabled extensions

Perform ambient occlusion PRNG multiplication with 64-bit integers

Use linear filtering for ambient occlusion render target

The blurring step samples it exactly between texels so nearest filtering
may cause artifacts due to floating point math instability.

Fix some errors in the ambient occlusion shader

Properly handle the legacy replacement of fragment shader output

Assignment targets to the output variable need to be cleared, lest the
unused variable locator tries to access deleted nodes.

Don't replace in/out with attribute/varying until formatting

Some parts of the code depend on having the correct interfaces present in
the AST.

Simplify reflections in the singlepass shader

Specular reflection of the sky was dropped.  It's better implemented
through an environment map.  In the future I'll add a skybox utility
class which provides a simple environment map.

Guard against missing extensions on OS X

Symbols are linked directly so the definitions must be present in the
system OpenGL library at compile time.

Use the correct define to detect Windows

Define some GL enums in case they don't exist

Implement an assignment operator for RenderPass

Clang compains about this too when trying to assign the pass map in
Technique.

Fix some clang compile warnings

Default to mipmapped filtering if EXT_framebuffer_object is available

Even if SGIS_generate_mipmap isn't.  The latter functionality has been
removed from modern OpenGL.

Add a method to set the texture filter of RenderTarget textures

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.