Emit descriptor set decorations for interface blocks

Add basic Vulkan support to the shader compiler

Add a constant for Vulkan backend

Account for mipmap levels when computing texture data sizes

This isn't 100% accurate, but good enough for resource management.

Perform range checks in UniformBlock in debug builds

Move the Resource function override of Texture classes into backend

There's enough differences between APIs that these can't be sensibly kept
in the common classes.

Move WindowView::render to the backend

Presenting images work very differently in Vulkan so the swap_buffers
call can't be in the common part.

Remove the LINE_LOOP primitive type

It's not supported on Vulkan and can be replaced by LINE_STRIP by adding
one extra index at the end.

Minor tweaks

Remove some stray includes and add a missing one

Ensure that creating the system framebuffer doesn't change the binding

Just in case it's for some reason created at an odd time.

Restructure system framebuffer and make WindowView own it

This works very differently on Vulkan, so the system framebuffer can't
be exposed from the Framebuffer class.

Check for empty attachments array instead of zero id in Framebuffer

The id is an OpenGL implementation detail and shouldn't be used in the
common part.

Don't store a View's target framebuffer in the base class

Instead access it through a virtual function.  Vulkan requires a separate
framebuffer per swapchain image.

Move backend information into Device

Remove obsolete includes

Create a Device class to hold the graphics context

This is necessary to make the selected backend transparent to
applications, and also because Vulkan needs access to the VkDevice.

Always apply feature conversion in the GLSL compiler

Also convert structural features before allocating locations.  This
gives flattened push constant uniforms locations too.

Use specially created features when compiling modules from GLSL

Set the latest version so all language features are retained, but limit
bindings to what the implementation actually supports.

Require passing features to SL::Compiler constructor

Using the current context's features by default seems like it could lead
to some surprises down the road.

Make the SL::Features factory functions more flexible

Passing the backend API as an argument is much better than having
separate functions for each backend.

Split FeatureConverter into two parts

Rename LegacyConverter to FeatureConverter

Store object transform in a push constant block

Allow a push constant block to be specified, but flatten it for now

It's needed for Vulkan, but OpenGL does not have push constants.

Fix flattening of GLSL interface blocks

Anonymous interface blocks are treated as nameless variables since
dfcf8eb, so the member accesses need to be converted to plain variable
references when the block is flattened.

Copy layout of InterfaceBlock

Tweak eye position calculation in shaders

Actually call the collect_builtins function in Program

This was forgotten from f82ef71.

Write access can't get into an unary operator from outside

Cache texture bindings when the shader program does not change

Restore variable load IDs for the else branch of a conditional

Isolate expressions from surrounding composite access

Recognize increment/decrement operators as modifying the target variable

Block further inlining of a variable after component assignment

Refactor assignment target overlap check into a function

Process loop initialization outside the body in UnusedVariableRemover

If it's processed inside the scope of the loop, assignments to the
iteration variable may get discarded.

Mark the start of a SPIR-V function as reachable

This fixes erroneously generated OpUnreachable instructions which
appeared at the end of some functions.

Compute correct size for SPIR-V structs if the last member is an array

Remove support for array size specialization from the engine as well

Always set uniform array size to at least one

This makes it consistent between GLSL and SPIR-V.

Move default uniform block sizing to OpenGL backend

Build the list of glUniform* calls even for SPIR-V modules

This is relevant since SPIR-V supports default block uniforms when
targeting OpenGL.

Rearrange shader reflection calls

The OpenGL-specific query calls are now done from the OpenGL backend.

Fix reflection of vector and matrix types from SPIR-V

Fix GLSL matrix construction from individual elements

Generate correct OpPhi instructions for nested ternary expressions

The parent blocks must be immediate predecessors of the block containing
the OpPhi instruction.

Don't try to access parameters with a pointer access instructior

Padding is required at the end of certain SPIR-V struct members

If the member is is itself a struct or an array, the next member must not
begin before the next alignment boundary.

Change max_lights to a fixed constant

Disallow specialization constants in certain contexts

The initialization of a specialization constant must not use other
specialization constants.

Arrays sized by a specialization constant inside structures are broken
by design because member offsets in SPIR-V are required to be literals.
Changing the size through specialization would at best leave empty space
in the struct and at worst overlap other members.

Fix size calculation for GLSL arrays

Apply implicit conversion to return expressions in GLSL functions

Add unsigned integer types to Program reflection and ProgramData

Disallow bool variables in shader interface blocks

Although OpenGL allows them in uniform blocks, SPIR-V says they can't be
used with externally visible storage classes.

Hide the allow_gl_calls member of Mesh::Loader

Remove the deprecated srgb_conversion flag from Resources

By now it didn't even have any effect anymore

Use asynchronous resource loading in desertpillars

Re-export desertpillars textures using external data storage

Avoid incorrect access to VertexSetup while async loading Mesh

Don't use resource manager for builtin data

Detecting them by the underscore at the beginning of the name feels a
little dodgy, but it will do for now.

Explicitly cast regex match to boolean

Export texture's mipmap levels as 1 if mipmaps are not used

Export raw texture data to a separate file

Support loading raw texture data from an external file

This enables async loading of pixel formats not supported by standard
image files.

Use default member initializers in async loaders

Move the whole-texture image call and raw data loading to base class

This reduces duplication in the loading code and promotes uniform
behaviour across the different texture classes.

Combine the external_image functions in Texture::Loader

Since DataFile::Loader now supports bound arguments, it can be used to
set the srgb flag.

Reorder functions in Sampler

Fix the type of a location variable

Add some checks for invalid arguments

Make the Limits struct more robust

Add missing implementation of RenderMethod::set_image_based_lighting

Improve material handling in RenderMethod

Add uint vector types to DataType

Rename "renderable" to "content" in Effects and Scenes

This name better describes the relationship.

Clean up some more unused things

Update and improve documentation

Use size_t to store sizes of buffers and such

Shader reflection data can stick to 32-bit sizes, since SPIR-V's
decorations only take 32-bit operands.

Use a sorted vector in place of set for small data

Despite having worse algorithmic performance, cache effects make the
vector faster for total data size of up to about 8 kB (YMMV).

The GLSL compiler can keep its sets for now, I'll create a proper class
for this at some point.

Remove the exclusion mechanism from Renderer

It was only ever used by EnvironmentMap, which can do the filtering
itself.  Removing it makes the rendering process more straightforward,
with less function calls.

Move sigc::trackable base from View to WindowView

Explicitly specify enum values which are relied upon

Use default member initializers in some more classes

Move Bufferable::refresh_async's definition to the header

Remove some unused and unnecessary things

Make it an error to try to refresh a Bufferable without a buffer

Assign unneeded values to _ when unpacking

Add an include path option to the command-line shader compiler

Add debug names to things in viewer

Update desertpillars to define more things in Blender

Add functions to retrieve steps and postprocessors from Sequence

Make it possible to set up and export some common effects in Blender

A sky effect can now be enabled in world properties.  If sky is enabled
and any materials use IBL, en environment map effect is added.  If any
lights have shadows enabled, a shadow map effect is exported.

Store prototype reference instead of just name in scene instances

Refactor some parts of the Blender exporter to improve reusability

Support effects and subordinate sequences inside sequence templates

Rearrange postprocessor creation code in SequenceBuilder

Previously it would have inadvertently deleted overridden postprocessors.

Require all renderables to be present when building a sequence

Use shared actions in SequenceTemplate loaders

Refactor the structure of sequence template files

Renderables are now specified separately from steps.  Post-processors are
defined with a unified keyword, with the type determined by a statement
inside the block.