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.

Move some common matrix operations to the header so they can be inlined

Cache the total data size in ResourceManager

Calculating it again every frame turned out to be a fairly large
performance hit in applications with many different resources.

Make ResourceManager thread-safe

Since a big part of the class is loading resources asynchronously, it
makes sense that resources can also be created from another thread.

Add an option to use shared meshes when exporting

Add missing initializer

Decrement size when removing a resource from the loading thread

Add geometry builder for sphere

Allow flagging meshes for winding test in Blender

Mark fog tokens as legacy features

Clear manager in destructors of individual resource classes

If the resource is destroyed while being loaded asynchronously, loading
has to be stopped before the derived class is destroyed.  The Resource
destructor is too late for that.

Support fog in lighting and shaders

Give meshes a higher priority when loading

It's better to load all meshes first so the geometry can be seen.

Honor the srgb conversion flag when loading textures asynchronously

Pass the resource collection to async loaders

This way they can access the loading parameters specified in that
collection.

Add option for the range of characters to use from a font

Fix PIL import

Throw a resource_load_error if the source could not be opened

Add a safeguard to resource_used

It's externally accessible and someone might call it with a resource
which is not registered with that manager.

Make is_resource_loaded const as it should be

Make resource locations externally accessible

This makes it easier to load resources e.g. from network on demand.

Add a function to stop a single animation

Also set uniforms in tick_stacked

Support animation of uniform variables

Add a missing include

Provide a getter for the number of active animations

Add a class for easier text rendering

I've written the equivalent in various applications a few times, so might
as well put it here.

Expose texture replacement functionality from Technique

Enable chaining of matrix modifiers

Support more ttf2png options in makefont.py

Now requires ttf2png 1.1 for the -m and -n options

Properly handle compound children with non-identity local matrix

Raise an exception if attempting to export a mesh with ngons

Otherwise there will be a much more confusing errors down the line

Revert changes if create_targets throws an exception

Fix some minor errors in the ambient occlusion shaders

Only require ARB_shadow when enabling texture compare mode

Alias texture lookup functions of all dimensionalities

Object's lod array must be initialized in all cases

Allow bounding sphere hints for objects and export such from Blender

Use explicit mipmap generation if necessary

Add methods to query the state of a resource

Add some accessors

Support defining and exporting object LoDs in Blender

Allow materials to be overridden when inheriting a technique

Support different techniques per LoD in objects

Pass errors from the resource loading thread to the main thread

Always update program uniforms if uniform names have changed

It's possible for pu.used to be zero, in which case the original code
would never update it.

Fix orthographic projection matrix calculation

I made some last minute changes for c90cc1f and this got missed.

Miscellaneous fixes

Add a new transform API to Renderer.

Accessing the matrix stack directly is unsafe as it allows the caller to
push and pop on it independently of Renderer states.

Adapt to the new vector/matrix slicing API in mspmath

Add overloaded setters for 2x2 and 3x3 uniform matrices

Add orthographic mode to Camera

Fix extension functions on Windows

They have to be marked with APIENTRY for the correct calling convention.
OpenGL 1.0 and 1.1 functions are not available through wglGetProcAddress,
so link them directly.

Use BindRestore for binding index buffer

Plain Bind tries to unbind the buffer afterwards, which causes trouble if
the mesh itself is bound.

Use triangle strips for creating strings

Quads are not supported by modern OpenGL.

Make postprocessor shaders compatible with modern interface

Precision must always be specified for OpenGL ES

Improve legacy mode logic in ProgramBuilder

Eliminate conflicts with Windows headers

Set the rendered flag before doing anything else

Prevents recursion back into ShadowMap::setup_frame from the rendereable.

Remove separate element_buffer from Renderer, get it from mesh instead

Use the same Renderer to render all faces of EnvironmentMap

Add begin() method to make Renderer reusable

State management improvements in Renderer

Only update modelview matrix in standard_shdata if it actually changed.

Don't re-apply all shader data unless the program changed.

React to lighting changes caused by pop_state.

Roll the various changed flags into a single mask

Move eye_obj matrices back out of the uniform block

It turns out that updating the buffer for every draw call causes trouble
for drivers, especially OpenGL ES.  Projection matrix typically does not
change during a frame, so it can stay.

Copy ProgramData::uniform_slots in copy constructor and operator=

Disallow direct access to uniform array elements

ProgramData can't track them correctly, and adding the support would be
too complex.  Uploading the entire array at once is more efficient anyway.

Clear matrices_loaded flag after resetting matrices

Fixes an issue where using legacy mode with a Pipeline would case the
matrices to be popped twice.

OpenGL ES requires floating-point precision to be declard in shaders

Improve documentation for a number of classes

Add missing initialization

Don't crash in bounding sphere generation if an object has a null mesh

Prefer glMapBufferRange over glMapBuffer

OpenGL ES does not have glMapBuffer.

Emit warnings if an extension can't be fully supported

The GLSL texture function returns a float for shadow samplers

In contrast with the legacy shadow2D function, which returned vec4.

Deprecate Renderer::escape() and replace it with end()

I never used escape() for much anything, and now it's causing problems on
OpenGL ES by trying to apply state with no shader and consequently set
system matrices.  In the future I'll add a corresponding begin() call to
allow persistent Renderers.

Legacy shader compatibility fixes for OpenGL ES

Use texture() instead of texture2D() in non-legacy mode

Because the name of the diffuse texture uniform was changed to avoid
conflicting with the function, some changes in applications may be
necessary.