Remove support for material atlases from the Blender exporter

Support for PBR materials was never added and it's unknown if it even
works anymore.  Baking and vertex colors are better solutions.

Set debug names for pipeline and descriptor set layouts on Vulkan

Add a missing function import

Don't try to draw world properties if there's no world

Export instances created through geometry nodes

Refactor object prototype discovery in the blender exporter

Fix handling of descriptor set bindings when shader stages change

Also set only the present stages for descriptor set layouts.

Fix binding of descriptor sets of the new pipeline has more than the last

Initialize pipeline handle

Skip binding of low-numbered descriptor sets if they haven't changed

Annotate uniforms with descriptor set layout qualifiers

Higher numbered sets are used for data which is expected to change
more often.

Mask out the descriptor set part of bind point when creating layouts

Remove set layout qualifiers on OpenGL

But only if a binding qualifier is not present.  This allows using
multiple descriptor sets on Vulkan without breaking OpenGL.

Replace some local pointers with references in VulkanCommands

Only mark Result as checked if that specific value was checked

Rewrite descriptor set management

Descriptor sets have been moved from PipelineCache to a dedicated class.
PipelineState refers to descriptor sets using slot indices, allowing the
descriptor pool to be recreated if more space is needed.

Dynamic uniform buffers are no longer used.  Instead multiple copies of
the descriptor set are created if it contains dynamic uniform blocks.

Make use of the sorted nature of PipelineState resource arrays

Since descriptor set is in the high bits, lower_bound can be used to
find its first resource and then go through elements until the next set
is reached.

Some tweaks to vector component handling

Use default member initializers for ZSortedScene::SortedRenderable

Use a per-camera cache in ZSortedScene

It's very common to have multiple cameras in a scene due to effects like
shadow and environment maps.  Using a single cache for all of them is
detrimental since the order will be different for each.

Use is_ortographic in Camera instead of checking fov directly

Adapt to changes in mspmath

Move frustum culling from Scene to Camera

Also refactor it so that the camera's object matrix is accounted for
when computing the frustum planes.

Make it possible to disable Vulkan validation

This can be useful when profiling an optimized debug build.

Use persistent tags for the model matrix uniforms in Renderer

Re-hashing the names every time takes enough time to show up in a
profile.

Treat standard and camera shader data specially in Renderer

Don't add them to the generic shdata stack.  Some effects apply their own
camera, which led to two overlapping ProgramData objects on the stack.
Although the results were correct, this caused PipelineState to flag the
uniform blocks as dirty every frame and do unnecessary work.

Set debug names for shader modules on Vulkan

Remove unused stages from shader programs

A stage is deemed unused if it has no main function after optimization,
or if a SPIR-V entry point's interface variables all become unused during
specialization.

Flip normal if a surface faces away from the camera

This gives correct two-sided lighting for non-closed meshes, which may
be used for tree leaves and such.

Use mesh as the task object when exporting it

Use R8 format when extracting a single channel from an image

Refactor face cull settings in Blender

Meshes no longer have a winding test toggle.  Instead mesh winding is
always set and material's backface culling flag is exported.  The default
in RenderMethod has been changed to NO_CULL.

Change front face logic on Vulkan to match the OpenGL backend

Front face is always set, not only when face cull is enabled.  Since we
pretend that NDC has the same orientation as on OpenGL, face winding gets
inverted.

This will probably produce incorrect results if anything rendering to a
swapchain image relies on winding.

Detect and export alpha cutoff in Blender

Fix the recognition of additive blending in the Blender exporter

Implement alpha cutoff for materials

Having to implement it separately in each material's shader is not
optimal, but since they each define their own uniform block, no better
solution is readily apparent.

The occluder shader also supports alpha cutoff so that objects with
such materials can cast proper shadows.

Enable shadow map for the blended method when exporting

Blended objects may want to receive shadows even though they can't
cast them.

Support specifying enabled methods in effect templates

Create specialized versions of SPIR-V modules with default spec values

It's important to remove unused resources in this case too.

Take care of SPIR-V load IDs in ternary expressions

Normalize vertex normal and tangent vectors in vertex shader

If the normal matrix has scaling, that can throw things off.

Avoid allocating buffers and images too close together

Vulkan requires that both types of resources do not reside on the same
"page" in memory.

Minor tweaks to MemoryAllocator

Add a function to request debug information from MemoryAllocator

Handle certain shader graph patterns that occur in imported glTF files

Remove unnecessary import statements from the Blender exporter

Use bpy.path.basename instead of a custom function

Change some leftover .tex2d extensions in the exporter

Handle arbitrary channel inversions in material inputs.

Refactor the material node processing code

Don't check group in get_unlit_inputs

It's fundamentally different from the other functions and wouldn't work
properly with a group.

Make texture channel handling in the Blender exporter more flexible

Any channel can now be inverted (though the shader graph inspection does
not detect this yet), so a separate invert_green channel is no longer
needed.

Fixes for exporting objects consisting only of lines

Redesign progress and error reporting in the Blender exporter

Progress is now tracked in a context object, which also holds the Blender
context.  Tasks are represented by independent objects instead of a stack
structure.

The context/task objects also track which data object that task is about,
so the object path can be reported in errors.

Fix incorrect vertex array indexing in InstanceArray

Move ProgramData to materials

It has more users in materials and in render, and also materials is a
lower layer, so it makes more sense for it to be here.

Simplify Program by removing transient data

After some earlier refactorings it was only used on one code path, so
those variables are now directly declared where they're needed.

Align staging memory with an alignment suitable for image transfers

The source data needs to be aligned at a multiple of the texel size.  48
bytes is divisible by almost all possible pixel sizes.

Use a dummy transmittance lookup texture to render the lookup in Sky

Ideally the compiler should optimize the shader so the texture isn't
used, but that'll take some extra effort to implement.

Overhaul the Vulkan backend's memory allocator

It now sub-allocates from larger chunks of memory to avoid hitting
Vulkan's allocation count limit.

Refactor Vulkan memory mapping functions

An allocation is now always mapped in its entirety.  Unmapping is done
by ID instead of mapped address.

Refactor allocation index and ID handling in the Vulkan backend

MemoryAllocator now always uses indices internally.  Incoming IDs are
checked for validity.

Remove the unused get_allocation_size function

Use pipeline keys for objects and effects

Support multiple PipelineStates in Renderer

In the Vulkan backend it can be beneficial to keep separate pipeline
states and avoid having to repeatedly compute hashes and look them up
from the cache.  The downside is that every time the used state object
changes, shader data has to be reapplied.  But it's likely this would
be necessary anyway due to different shader or data being used.

Apply only changed parts of VulkanPipelineState

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