Make FrameAttachment capable of distinguishing RGB and BGR formats

Build sequence without target format if there's no postprocessors

Replace ProgramData copy constructor with a more explicit copy function

The copy constructor left so many members uncopied that it was rather
questionable as copy constructor.  This makes it more clear that only
uniform values are being copied.

Add correct copy and move semantics to most classes

Add a safeguard into ResourceManager::add_resource

Add missing destructor to OpenGLSampler

Resolve variables after eliminating constant conditions

Fix a name conflict in certain inlining scenarios

Move the bloom shader's delta uniform into a block

Move a few bits of Renderer into a backend class

This allows the upcoming Vulkan backend to take care of submitting
command buffers.

Remove the transform function from Renderer

Renderables are encouraged to set a world-space model matrix directly, as
some scenes and effects won't work properly with incremental matrices.

Require explicit begin() and end() calls in Renderer

Reorder members of Renderer and PipelineState

Remove deprecated functions from Renderer

Always use RGBA color format when building Sequences

Add a swizzle mode for presenting an RGBA texture as RGB

Not many Vulkan implementations support RGB textures

Allow BGR format in FrameAttachment, but disallow swizzled formats

Vulkan likes to use BGR for swapchain images, at least on my machine

Move swizzling modes to pixelformat.h

Fix an incorrect check for existence of value

Don't check the address of an inline array

It always evaluates as true, not that it matters greatly in this case.

Some more default member initializers

Remove default uniform block if it has no uniforms

Recognize push constant blocks when reflecting SPIR-V modules

Store descriptor set in program reflection data

Handle descriptor sets when allocating uniform locations

Propagate locations from existing variables before optimization

Uniform location and binding qualifiers should apply to all copies of the
variable even if the one originally containing them is optimized out.

Improve layout qualifier handling with some more utility functions

Add a utility function for following a chain of base types

Refactor a common part in LocationAllocator into a function

Assign the same specialization constant IDs in all stages

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