Adjust access to main class members from backend classes

Rename some stencil test constants

This makes it more apparent what the difference between these and the
_WRAP variants is.

Don't assume vertex arrays start from the beginning of the buffer

Hide the use of the tangent variable in common.glsl behind an if

Adjust attribute order in mesh exporter and add padding if necessary

Add support for padding in vertex formats

Vulkan requires attributes to be correctly aligned, so depending on the
combination of types padding may be necessary.  It's better to make it
explicit so support for raw mesh data files can be added in the future.

Only use location-based offsets for the default uniform block

The push constant block must follow the layout specified in the shader.

Use OriginUpperLeft execution mode on Vulkan as required by the spec

Comment fixes

Avoid emitting duplicate specialization constants in SPIR-V

Collect uniforms which have a binding, even if they have no location

Reflect the control flow graph from SPIR-V and check variable accesses

Specialization constants may cause some declared variables to become
unused, and those shouldn't appear in Vulkan descriptor set layouts.

Fix handling of constants in Spir-V reflection

Fix reflection of image types from Spir-V modules

Add a backend for SpirVModule and make it non-copyable

In Vulkan shader modules are objects of their own.

Pack descriptor set and binding in a single variable

This makes them easier to pass around and there's plenty of bits
available.  Also add a variable for descriptor set count.

Remove empty default block before adding uniforms to blocks

Otherwise the block pointers of the uniforms will be incorrect

Add validation for mapping buffers

On Vulkan static buffers will be stored on non-host-visible memory and
can't be mapped.  Already-mapped buffers also can't be mapped.

Add a usage parameter to Buffer

It has no real meaning on OpenGL but is needed on Vulkan

Update usage of hash functions

Calculating hashes directly from the binary values is faster than first
creating a string.

Enable clearing in the viewer's default sequence

Make WindowView override the parameterless render function

This works better with the new begin/end sequence of Renderer.

Expose the maximum number of attributes and attachments

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.