Minor, largely cosmetic tweaks

Use the changes member directly in PipelineState backends

Store simpler states by value in PipelineState

Since these are also stored by value in various objects, a pointer
comparison is not enough to tell if state needs to be changed.  There's
no guarantee that the object behind the pointer stays alive, so comparing
values through the pointer is hazardous.

Create a function for applying framebuffer state in Renderer

Make various enums use uint8_t as their underlying type

Only set pipeline resources as used when the resource changes

This avoids an issue on Vulkan where invalid descriptor set writes were
generated if a resource unused by the current shader was set to the same
value it already had and the shader wasn't changed.

I'm not really sure if the flags should be set in the common part at all,
since the OpenGL bckend barely uses them.  But other approaches are not
clearly superior either.

Use a placeholder texture when a texture has not been loaded yet

Use low-level handles when computing descriptor set hashes

The handle of a texture may change due to loading and unloading through
a resource manager.

Convert pixel components if necessary when async loading textures

Move Texture2D::AsyncLoader back to the common part

The backend-specific parts are now handled by AsyncTransfer.

Refactor Texture2D::AsyncLoader to use sub_image_async

Add an asynchronous version of Texture2D::sub_image

Require buffer to have storage for mapping

Make Buffer::AsyncTransfer default-constructible and move-assignable

Redesign asynchronous buffer uploads

The Buffer class now offers an async version of sub_data, which can
better account for exactly how the data needs to be uploaded.

Reset staging buffers in TransferQueue once the transfers are done

Improve state setting in Sky

Avoid leaking the effect's shader data to its content as it contains no
relevant uniforms.

Use a streaming buffer for ProgramData only when needed

Refactor ProgramData buffer (re)creation into a function

Multiplex streaming buffer contents on Vulkan

This ensures that the data stays valid until the draw commands using it
have finished executing.

InstanceArray doesn't need to refresh the vertex arrays

That's done in Renderer since 9b3bce7.

Add a flag to obtain an aligned size requirement from Bufferable

Use a member function to set the dirty flag in Bufferable

Keep track of the buffers of bound uniform blocks

ProgramData may recreate the buffer when creating new blocks, but existing
block objects will be retained.  As such, the block object alone isn't
enough to determine whether the binding has changed.

Increment frame after destroying objects instead of before

Things were getting destroyed one frame too early since the destroy queue
is ticked after rendering a frame.

Clamp depth reference for shadows to 1.0

This makes objects which are "behind" the shadow map volume sample the
shadow map correctly and not treat the clear value as a shadow caster.

Defer transfer and barriers until the entire render pass is recorded

This ensures that all resources needed by the render pass are prepared
before executing the pass.

Use secondary command buffers to record render pass contents

This allows greater flexibility for ordering transfers and barriers
relative to render passes.

Correctly set framebuffer layers when cube map attachments are used

Refactor projection matrix handling

Projection matrices in C++ side now always produce a depth range of 0 to
1 for the NDC Z coordinate.  Shaders will convert it to -1 to 1 when
targeting OpenGL.

Incidentally, the AmbientOcclusion effect's shaders were already written
as if the depth range was 0 to 1, so the effect was actually slightly
incorrect before this.

Fix incorrect lookup of GLSL interface variables

Refactor handling of viewport Y axis

Only invert it for the swapchain render target.  This makes it easier to
sample render target textures consistently.

Set gl_Layer separately for each vertex

EmitVertex invalidates *all* output variables so they must be written
again for the next one.

Enable geometry shaders by default

Fix render area Y coordinate calculation

Discard render target contents only if the entire mip level is used

Mark PBR precalc parameters as push constants

Re-export desertpillars data with new vertex formats

Refactor TransferQueue to require explicit finalization of transfers

This allows the data for the transfer to be written asynchronously.

Use const void * for the object pointers in TransferQueue

Bind only the first mipmap level when prefiltering an envmap

Emit a max invocations exec mode for geometry shaders

Create image views in VulkanFramebuffer if necessary

Using a specific mip level or array layer as an attachment requires a
view with suitable parameters.

Support binding individual mipmap levels of textures

Vulkan requires different layouts for sampling a texture and rendering
into, so reading from one mip level and rendering into another requires
separate views.

The OpenGL backend only allows binding level 0, since nothing currently
needs binding higher levels.  Full support requires the ARB_texture_view
extension.

Track the number of layers in Framebuffer

Don't remove individual mipmap levels from Synchronizer

Keep them around until all levels have been transitioned to shader read
only optimal, to ensure that changing the layout of a split image as a
whole works correctly.

Track different kinds of bindings separately

Populate used bindings in ReflectData

Don't try to bind descriptor sets if there aren't any

Refresh vertex setup in VulkanPipelineState::update

The buffers and offsets must be filled even if another vertex setup with
the same format has been used before.

Initialize members of VulkanVertexSetup

Use an RGBA environment map in desertpillars

Store the number of mipmap levels in the Texture base class

Use default member initializers in Texture

Avoid collisions with members of nameless interface blocks when inlining

Use RGBA as the default format for effect render targets

Convert RGB pixel data to RGBA when staging

Use the correct aspect mask for uploading texture data

Submit commands for isolated offscreen rendering

Clear the begin semaphore if Renderer::begin() is called without one

Remove the exception from Texture2DMultisample constructor

Implement mipmap generation for the Vulkan backend

Support transfers with no staged data

This can be used to transfer data within VRAM, such as for mipmap
generation.

Track the order of transfers involving the same objects

Mipmap generation requires barriers between the steps, since each level
is generated using the previous one.

Use another callback for pre-transfer synchronization

Tweaks and fixes to OpNames in SPIR-V

Interface blocks without an instance name must not have a non-empty
OpName or the reflection code gets confused.

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.