Load textures in a type-generic way

Add keywords for light and material to Resources::Loader

Since they're loaded with a generic loader now, the standard keyword
mechanism can't handle them.

Use set_manager instead of passing the manager to the constructor

This allows always using the parameterless constructor, making some
things easier.

Rename OpenGLTexture::generate_id to create

Always delay texture creation until it is allocated

This allows greateer flexibility with setting a resource manager.

Fix loading of inline materials and lights

Split the Light class into subclasses by light type

There are some cases where it would be inconvenient for a light to
suddenly change type.

Store materials and scenes using actual types

Adjust creator and notify functions in Resources

Use DynamicObjectLoader for Material and Scene generic loaders

Remove collection-less constructor overloads from most loaders

These classes are extremely likely to require references to other
objects, and requiring a collection makes the code more straightforward.

Unify the loader wrappers for Material and Scene

Refactor ShadowMap to support multiple lights

Set viewport and scissor before clear commands

Since this requires applying the pipeline state, using DSA for the clear
commands seems pointless and was removed to simplify the code.

Remove conditional and iteration statements with no effect from GLSL

Fix a compile error in the GLSL compiler test runner

Support multiple lights in a single pass

Light direction is now computed in fragment shader because interface
variable locations can't use specialization constants.

Shadow map currently only affects the first light but will be improved
soon.

Remove unused world_halfway_dir variable from common.glsl

Re-export desertpillars data

Rename RenderPass to RenderMethod

This is mostly to avoid confusion with Vulkan's render passes, which are
an entirely different thing.

Remove deprecated interfaces from material and lighting code

Access the tag name map with a function

Otherwise declaring tag constants as static members of classes is
unreliable because of the undefined initialization order of globals
in different translation units.

Use constructor delegation instead of init functions when possible

Don't use an internal depth test in ShadowMap

It's expected that the content renderable is a Sequence which supplies
the necessary state.

Some more cleanup of includes and forward declarations

Store query pool size separately, in the common part of the class

Move all OpenGL-specific code to a separate directory

Use QueryPool in OccludedScene

Refactor VertexSetup format checking

Always require EXT_texture3D and ARB_shadow for samplers

These are fairly old extensions and can be assumed to be always
available.

Tweak handling flags in PipelineState::set_framebuffer

Viewports work slightly differently on Vulkan, so set only the
framebuffer flag here and instead check both when applying the state.

Use friend declaration to access hidden data in Batch

Add an abstraction for queries

Add color write mask to blend state

Make backend idenfication more generic

The API and version queries are now in their own file and extension.h is
reserved for the OpenGL extension mechanism.

Store GLSL features in DeviceInfo

This makes the GLSL compiler independent of any OpenGL-specific code.

Wrap Limits into a DeviceInfo struct

This allows adding more types of information.

Always use instanced rendering in InstanceArray

All the required extensions are present in OpenGL 3.3, so there's little
reason to keep the fallback code.

Clean up includes and forward declarations for the core classes

Completely hide OpenGL from the public headers

Refactor uploading texture data from a buffer

This allows getting rid of Buffer::get_id() and using a friend
declaration instead.

Add an srgb flag to pixelformat_from_image

This simplifies the pixel format handling in the texture classes.

Eliminate the polymorphic Uniform class hierarchy

Dynamically allocating a separate object for every uniform is not very
cache friendly.  ProgramData now stores uniform values in a single memory
block instead.

Add a TypeTraits struct to convert C++ types into DataType enum values

Remove the deprecated texunit-based texture assignments from RenderPass

Store default-block uniform data in a memory block

This is more cache-friendly than using individually allocated polymorphic
objects.  It also makes it easier to use push constants in Vulkan.

Set array and matrix strides for default-block uniforms

These are based on the client memory layout required by glUniform* calls.

Restructure Program to remove linking from the public interface

It doesn't map to Vulkan at all.  Doing it from add_stages also
simplifies handling some temporary data.

Split reflection data from Program to a separate struct

This is necessary for splitting the API-specific code.

Remove the misc.h header

It was mostly unused already.

Remove the now unused BufferBits enum

Automatically detect which multisample buffers to resolve

Clear the pipeline state through Commands

Restore sampler refresh call

This got accidentally removed in 2e09b4f.

Re-export desertpillars data with clear values

Make it possible to specify explicit clear values

Make clearing the render target a responsibility of Sequence

Allow creating sequences without size

Also require a frame format when a size is specified.  Sequences used as
content renderables of effects commonly have no postprocessors, in which
case internal render targets are not needed either and the size is not
meaningful.

Remove the View and Framebuffer constructors from Sequence

They had no other purpose than to take the size from the other object,
and that fits better in SequenceBuilder.

Query the attachments of the default framebuffer

The exact pixel formats are unimportant for now and would be somewhat
convoluted to query.

Check supported attachment formats in Framebuffer::set_format

Remove the FramebufferStatus enum

It's not easily supportable on Vulkan.

Initialize Texture's format to an invalid value

This makes it possible to determine if a texture has storage defined or
not.

Use friend declarations to access OpenGL IDs of objects

This seems neater than exposing get_id() methods to the public.

Texture2D::AsyncLoader still uses get_id() on the PBO for now, since
it's not reasonably possible to name that class as a friend.

Add missing Require to Commands::resolve_multisample

Make the sampler-related enums independent of OpenGL constants

Make the TextureCubeFace enum independent of OpenGL constants

Mark constant data as const

Only enable seamless cube map once

Remove the separate allocation step from textures and buffers

It was conceived as a way to avoid unnecessary OpenGL calls if the object
is initialized by uploading full contents.  However the storage extensions
are almost universally supported now and data uploads are not something
that usually happens every frame, so this optimization is no longer
relevant.

Remove remaining deprecated things from the core classes

Remove unnecessary std:: qualifiers

Specify underlying type for format descriptor enums

This makes it possible to use them directory in the associated format
structs without increasing their size.

Use standard fixed-size integer types

Fix an apparent logic bug in ProgramData

Deleting the blocks but leaving the pointers seems like a recipe for
disaster.  This hails from all the way back in 5ae4b00.

Improve exceptions in armature lookups

Prefer more compact containers

Use C++11 features with containers

Require C++11 for building

Change ManagedResource::load_priority to int

For unknown reasons it was made bool in 574abfb even though
Resource::get_load_priority returns an int.

Remove automatic mipmap generation from the public interface of Texture

The flag is now only used in conjunction of textures loaded from
datafiles.  Mipmap generation can still be manually triggered.

This causes some lossage with the allocation flags if the texture storage
extension is not supported.  I'll likely refactor the allocation system
soon.

Use a scratch binding to modify textures and buffers

This simplifies the code quite a bit.  It's assumed that textures are
not modified during rendering, as that would potentially interfere with
the rendering pipeline state.

Remove some obsolete things

Change the vertex group attribute to be an integer vector

Add support for integer vertex attributes

Nudge the FrameFormat floating-point flag one bit to the left

This puts it in the same position as the corresponding flag in
VertexAttribute.

Re-export desert pillars data with attribute types

Use more compact data types when exporting meshes

Make VertexFormat capable of storing type information

Remove deprecated things related to vertex formats and arrays

Explicitly specify the target format of Sequence

Fix a logic error in Sequence

This condition accidentally got flipped in 3ac3a51.

Fix valgrind warnings

Remove obsolete stuff from Sequence

Simplify pipeline state management

Instead of unbinding things immediately, defer it to when the state is
cleared.  This results in less binding calls overall.  The only reason
to unbind anything is to allow those objects to be destroyed, and that
shouldn't happen in the middle of rendering anyway.

Remove deprecated constructors from effects

Tweak the comma operator between VertexAttribute and unsigned

It now returns VertexAttribute instead of VertexFormat, avoiding the need
to call make_indexed_attribute in some cases.

Consider all attachments when determining Framebuffer's size

Tweak some texture allocation checks

Sub_image calls allocate_ internally, so it should avoid doing
unnecessary work.

Fix a bug in Renderer::resolve_multisample

Apply_state requires a shader program to be set, but it's not actually
needed here.