Use different heuristics for applying shader data

Since later shdata can override values from earlier ones, the stack must
be replayed even if items are only removed.  However we can detect if the
exact same items are added back as might happen when multiple objects
using the same technique are rendered in succession.

Visit generated assignments in InterfaceGenerator

Rename imported interface variables in InterfaceGenerator

Doing it as a separate pass caused trouble when a variable was accessed
both with passthrough and explicitly.  Two input variable declarations
were generated and only one of them was linked to the output variable of
the previous stage, leading to the output variable being removed.

Add location specifiers to postprocess.glsl

Split the interfaces from singlepass.glsl to a separate module

Sometimes it's desirable to make a fully custom shader but still use the
common interface.  It's also likely that I'll add other types of standard
shader templates in the future.

Allow imported GLSL modules to import other modules

Use a #pragma as shader stage delimiter

The special comment was a bad idea with poorly defined semantics.

Add file and line information to ProgramParser errors

Use individual component swizzle constants on OpenGL ES

Add a loader to Camera

Rename various get/set_aspect functions to aspect_ratio

That's the correct term.  The old versions have been left in and marked
as deprecated for now.

Give Placeable a virtual destructor

Add a system for creating Pipelines from loadable templates

Add loaders for Lighting and Light

Rename Lighting::sky_direction to zenith_direction

That name more accurately describes its purpose.

Add a constructor to Pipeline which takes the size from a View

Split the Window-specific parts out of View

This should allow other types of views, such as VR::StereoView, to derive
from GL::View and present a uniform API.

Add lexical conversions for BlendFactor and Predicate

Check for maximum number of samples

This makes it more apparent what the error is if a too large sample count
is requested.  Otherwise it would result in an "incomplete attachment"
error from the framebuffer object.

Call the non-multisample version of storage if samples is zero

OpenGL defines it like this.  Do the check in application code so it works
even if EXT_framebuffer_multisample is not supported.

Check for EXT_gpu_shader4 support when binding fragment data locations

Additional framebuffer incompleteness errors

Fix a stupid bug in the extension generator

Add a get_default_sized_pixelformat function

Floating point depth buffers are now preferred also on OpenGL ES when
available.

Simplification in get_sized_pixelformat

This switch block got overlooked when I introduced
get_unsized_pixelformat.

Remove the fake MSP_stereo_rendering extension

I originally created it because I thought it might be useful with VR
headsets.  Now it's apparent that VR rendering is done with different
APIs and the left/right constants are useless.  The other values of the
RWbuffer enum weren't being used for anything either.

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.