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.

Don't consider the current buffer in deciding whether to bind BufferRange

glBindBufferRange should only be called if the buffer range bound to that
index was changed.  The buffer binding gets changed as a side-effect, but
should not factor into the decision.

Rework ProgramData to do less unnecessary work

Changes are now tracked per-uniform, allowing more updates to be skipped.
The buffers used in a program are cached, making the no-changes case
faster.

Additionally, Program now creates a UniformBlockInfo struct for the
default uniform.  The program-wide uniform layout hash has been repurposed
to cover the entire program.

Tighten checks in UniformBlock

A single UniformBlock can only be a default block or a named block, not
any strange mixture of the two.

Introduce a typedef for uniform layout hashes in Program

Adjust the desert pillars demo to recent changes

Also decrease the cube's shininess from 150 to 120 for compatibility with
older OpenGL versions.

Move the reflectivity parameter to material

Logically it belongs there, even if OpenGL has no fixed-function support
for it.

Rectify some omissions in ProgramBuilder builtin variables

Fix uniform stride assignments

Fix the resource disassociation loop in ~ResourceManager

Unbind things if they are deleted while current

Failing to do so can lead to all sorts of stale-state issues, especially
if a newly created thing happens to get the exact same address as the
just deleted one.

Use uniform blocks in generated shaders if supported

Initialize StandardVariables::skylight

Emit separate declarations for struct types

I'm going to add uniform block support shortly and structs can't be
declared inside blocks.

Deal with hash collisions in assigning uniform block bind points

Improve bounding sphere handling in Object

Update Object's bounding sphere when mesh is loaded

Add a ResourceWatcher interface

Enable asynchronous loading of Meshes

This currently causes object bounding spheres to be incorrect when using
managed meshes.  The situation will be rectified shortly.

Add an asynchronous update interface to Bufferable

Refactor the internal interface of Bufferable a bit

Miscellaneous fixes to ResourceManager

Some fixes to VAO management

Minor adjustments

Add a hidden option to disable progress meter

Intended for scripts that call the MSP export operators multiple times.

Add an object property for inheriting the specified technique

This allows using object-specific textures while still sharing material
and shaders.

Use image path as texture identifier if available

This is more likely to be correct in common resource loading setups.

Take material diffuse intensity into account

Display overall progress when exporting scenes

Implement automatic unloading when a total size limit is exceeded

Implement automatic resource unloading based on age

Set dirty_params when unloading textures

This ensures that things like MIN_FILTER get set correctly when it is
reloaded.

Implement manual loading policy and async flag

Throw an exception if Resource::load did not create an AsyncLoader

This is only a safeguard against programming errors and should never be
hit in normal use.

Dissolve the association to resources when ResourceManager is destroyed

Enable resource management on Texture2D

Foundation for a resource management system

Add memory-mapping functions for Buffer

Make the viewer capable of viewing scenes

Add a Loader for Scene, and a matching Blender exporter

Set MeshExporter default values to match those in the operator

Fix line exporting

Use a renderer in the viewer

Some renderables using more sophisticated features won't even render
properly without one.

Rework loading in viewer

It can now load external resources, and adding new types of renderables
in the future is easier.

Support hemispherical skylight in ProgramBuilder

OpenGL's fixed-function pipeline does not have any similar feature, so
this can't be supported without shaders.

Move extension requirements from ProgramData to UniformBlock

ProgramData no longer manipulates GL directly, and it's used in places
like Renderer and Material.  This changes allows those things to be used
without shader support.

Make older gcc versions happy

Use GL_VERSION_x_y to guard the enums for promoted extensions

The core names for enums are used in headers, and older systems might
have the extension present but too old core version.

Rearrange ProgramBuilder's standard variables

The rgb_light_foo names were getting a bit stupid, and the hierarchy also
makes more sense this way.  The use of gl_FrontLightProduct was dropped
as too cumbersome to maintain.  The future is with modern shaders anyway.

Texture now only affects ambient and diffuse colors, not specular.  There
will likely be support for a separate specular map in the future.

TexUnit's constructor shouldn't be public

Improve interface documentation a bit

Add support for array and multiple lights in generated shaders