Refactor Synchronizer to deal with individual mipmap levels

Some algorithms read from one mipmap level and write to another.  On the
other hand, there's currently no need for layer granularity.

Don't create no-op barriers

Apply implicit conversions to function arguments

Automatically determine array sizes in GLSL if possible

Consequently the SPIR-V backend no longer needs to deal with missing
array sizes.

Vulkan doesn't support uniform locations

Unify handling of variables and interface blocks in the GLSL compiler

In SPIR-V interface blocks are just variables with a struct type marked
as block.  Treating them this way in the AST reduces duplcation a fair
bit.

Fixes for handling extended alignment in GLSL

Use correct variable to access values

Consider arrays to have matching size if both are unsized

Refactor adding types in SL::Parser

Fix a GLSL testcase

The constant IDs got perturbed in 8c379c40.

Add missing includes

Reuse previously allocated command buffers

Set push constants only for enabled shader stages

Implement textures and samplers for Vulkan

Currently render target textures get a useless layout transition to
SHADER_READ_ONLY_OPTIMAL if there's any transfers on the same frame.

Mipmap generation and asynchronous uploading of textures does not work
yet.

Move PipelineState refresh to just before draw call

Shouldn't matter much, but it makes more sense here

Always apply push constants

The changed flag is no longer valid at this point.  This could in theory
result in unnecessary CmdPushConstants calls, but in practice they change
for every draw call (if they're used in the first place).

Track the in-use state of resource bindings in PipelineState

Update all descriptor sets when the used shader changes

Set color write mask if no blending is used

Add a subpass dependency to ensure the rendering result is available

Only do layout transitions in render pass for swapchain images

Transitions for other images will be handles through Synchronizer.

Make framebuffer attachment accessors public

Add a synchronization helper class to the Vulkan backend

Use PRESENT_SRC as the initial layout for swapchain images

This makes the layout transition work if for some reason a clear command
is not used for the swapchain.

Convert some constructors to default member initializers

Use RGBA format render target for Bloom

Don't generate warnings about internal types with duplicate names

Use extended alignment in SPIR-V struct layout when necessary

Do discard-clears in individual postprocessors, not the sequence

It should be done just before rendering into the target starts.

Cache framebuffer and viewport in VulkanCommands

Since PipelineState is not immutable, this is necessary to detect when
they have changed.

Check if render target is swapchain and set to_present accordingly

Treat clear() with null parameter as invalidate

Also use it in Sequence for postprocessor render targets, since
postprocessors are supposed to render the entire screen.

Create specialized copies of SPIR-V modules

It turns out Vulkan does want all declared resources in the descriptor
sets, even if they're unused.  Manual specialization avoids the need to
deal with them when binding stuff.

Initial implementation of Vulkan backend

Some functionalities are still missing, in particular textures and
samplers.  Drawing simple geometry works.

Add checks for invalid state in OpenGLCommands

Refactor low-level state management

The global context state is now held in Device.

The changes mask in PipelineState was also moved to the backend class,
because pipeline state is applied very differently in Vulkan.

Colorize the debug output of the GLSL compiler

Store primitive type in PipelineState

Vulkan needs it to be here

Create default context options in the device backend

Use emplace_back when a new object is being constructed

Don't try to apply push constants as uniforms in OpenGL

They shouldn't exist anyway.

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