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.

Don't enable/disable textures on non-legacy units

Replace Texturing::Attachment with a simple Texture pointer

No point to have the struct now that TexEnv is gone.

Support OpenGL ES on Android

Some features are still likely to be broken, but basic rendering works
at least.

Prefer glDrawBuffers over glDrawBuffer

OpenGL ES does not have glDrawBuffer, so this logic change makes porting
a bit easier.

Only check against number of light units when binding Lighting

Feeding lights to shaders through ProgramData is not subject to
GL_MAX_LIGHTS, it makes sense to remove that limit from attaching them.

Tweak extension behavior on Radeon

Don't bind the default object if nothing was bound before

Allow applying a VertexArray in non-legacy mode

Mesh::bind now has consistent results whether or not vertex array objects
are available.  This is unlikely to be needed on full OpenGL, but is
necessary for OpenGL ES 2.0 support (ES 3.0 has VAOs).

Fallback to glDrawElements if EXT_draw_range_elements is unavailable

Add facilities to disable extensions and force lower versions

Useful for testing some exotic combinations without actually having to
dig up suitable hardware.

Update gl.xml to latest version

Initialize camera matrices in constructor

Delay loading matrices until they are needed

If all renderables use modern shaders, it's not necessary to touch the
system matrix stacks at all.  OpenGL ES 2.0 and OpenGL 3.0 core do not
even have system matrix stacks.

Run a tighter ship with extensions

Remove a number of rarely used legacy features

ShadowMap will now need shaders to work, but it was already broken in
fixed-function anyway due to using large texture unit numbers.  Since
all modern hardware supports shaders, even with free drivers, this is
unlikely to be an issue.

The removed pixel format GL_RED is used in ARB_texture_rg, but we don't
support that extension yet.

Enhance the extension generator to support different APIs

Refactor and optimize the extension generator script

Overly short variable names have been expanded
parse_file was getting a bit unwieldy and has been split
getElementsByTagName is recursive and slow, replaced with custom function

Don't leak AsyncUpdaters if Mesh async loading is aborted

Rewrite ResourceManager internals for more scalability

Since loading small resources can often take less than one frame,
especially with vsync enabled, the thread can now handle more than one
resource at once.  The code is also somewhat better structured for using
more than one thread in the future.

Better handling of unloaded textures

Since it's no longer guaranteed that calling ResourceManager::resource_used
will result in Resource::load being called, it's better to avoid the
binding logic entirely in the unloaded case.  In particular, parameters
must not be updated until the GL texture object has been created.

Generating an ID for the texture has been delayed to the last phase of
loading to further differentiate the loaded and unloaded states.

Avoid segfaults when LoadingThread's resource is cleared

Delay opening the resource file until loading actually starts

Opening it when the load is queued can cause large numbers of open files
to be created at once and dissipate slowly as the queue is processed.

Minor fixes

Fix TexGen unbinding

Exclude EnvironMap effect itself when creating the map

This avoids an unnecessary texture bind/unbind cycle if the EnvironmentMap
is contained within its own environment.

Put transform matrices into a uniform block too

I'm fairly certain the glBufferSubData call required to update the block
contents is no slower than the glUniformMatrix* calls to set the uniforms
directly.