Add offscreen render targets and rename AssetRegistry to ResourceRegistry

Add a RenderTarget resource so the scene can render offscreen instead of
straight to the swapchain. The editor uses it to show the scene inside the
Viewport panel.

- Rename AssetRegistry to ResourceRegistry (AssetTraits -> ResourceTraits,
  assets() -> resources()) and move the pools from engine/src/assets to
  engine/src/resources. It now covers non-asset GPU resources as well.
- Replace loadMesh() with create<T>(...), and add create<RenderTarget>(),
  requestResize(), getExtent() and isAlive().
- Add RenderTarget and RenderTargetPool with RenderTargetHandle.
  Resizes are deferred and applied at the start of the next frame, when the
  GPU is idle.
- Add Application::setSceneTarget(). With no target set, the scene still
  renders to the swapchain. With a target set, the scene renders offscreen
  and the swapchain receives only the UI. Frame extent and camera projection
  follow the target's size.
- Add sophia::UI (Application::ui()) with image() and getTextureId() to draw
  a render target in an ImGui window, sizing the target to the available
  space. ImGuiRenderer now registers the target textures for this.
- ViewportPanel takes the UI and a target, and draws the scene image in place
  of the flat background fill.
- Update the testbed, the boids example, and the glossary for the rename.

engine/src/resources/resource_registry.cpp

@@ -0,0 +1,104 @@
+#include <sophia/resource_registry.hpp>
+#include <sophia/util/assert.hpp>
+
+#include "mesh.hpp"
+#include "pools/mesh_pool.hpp"
+#include "pools/render_target_pool.hpp"
+#include "render_target.hpp"
+
+namespace sophia {
+
+class ResourceRegistry::Impl {
+ public:
+  Impl(Device& device, vk::Format renderTargetFormat)
+      : meshPool{device}, renderTargetPool{device, renderTargetFormat} {}
+
+  MeshPool meshPool;
+  RenderTargetPool renderTargetPool;
+  // TexturePool texturePool;
+  // MaterialPool materialPool;
+};
+
+ResourceRegistry::ResourceRegistry(Device& device, u32 renderTargetFormat)
+    : impl{std::make_unique<Impl>(
+          device, static_cast<vk::Format>(renderTargetFormat))} {}
+
+ResourceRegistry::~ResourceRegistry() = default;
+
+template <>
+MeshHandle ResourceRegistry::load<Mesh>(const std::string& path) {
+  (void)path;
+  SOPHIA_ASSERT(false,
+                "Mesh::load(path) is not implemented yet - no model file "
+                "format is supported; build one via Mesh::Builder for now");
+  return MeshHandle{};
+}
+
+template <typename T>
+typename ResourceTraits<T>::Handle load(const std::string&) {
+  static_assert(sizeof(T) == 0,
+                "load<T> is not implemented for this resource type");
+}
+
+template <>
+void ResourceRegistry::release<Mesh>(MeshHandle handle) {
+  impl->meshPool.release(handle);
+}
+
+template <>
+void ResourceRegistry::release<RenderTarget>(RenderTargetHandle handle) {
+  impl->renderTargetPool.release(handle);
+}
+
+template <>
+const Mesh& ResourceRegistry::get<Mesh>(MeshHandle handle) const {
+  return impl->meshPool.get(handle);
+}
+
+MeshHandle ResourceRegistry::createResource(std::type_identity<Mesh>,
+                                            std::vector<CanvasVertex> vertices,
+                                            std::vector<u32> indices) {
+  Mesh::Builder builder{};
+  builder.vertices.reserve(vertices.size());
+  for (const CanvasVertex& vertex : vertices) {
+    builder.vertices.push_back({vertex.position, vertex.color});
+  }
+  builder.indices = std::move(indices);
+
+  return impl->meshPool.create(builder);
+}
+
+RenderTargetHandle ResourceRegistry::createResource(
+    std::type_identity<RenderTarget>, u32 width, u32 height) {
+  return impl->renderTargetPool.create(width, height);
+}
+
+void ResourceRegistry::requestResize(RenderTargetHandle handle, u32 width,
+                                     u32 height) {
+  impl->renderTargetPool.get(handle).requestResize(width, height);
+}
+
+glm::vec2 ResourceRegistry::getExtent(RenderTargetHandle handle) const {
+  vk::Extent2D extent =
+      std::as_const(impl->renderTargetPool).get(handle).getExtent();
+  return {static_cast<float>(extent.width), static_cast<float>(extent.height)};
+}
+
+bool ResourceRegistry::isAlive(RenderTargetHandle handle) const {
+  return impl->renderTargetPool.isAlive(handle);
+}
+
+RenderTarget& ResourceRegistry::getRenderTarget(RenderTargetHandle handle) {
+  return impl->renderTargetPool.get(handle);
+}
+
+const RenderTarget& ResourceRegistry::getRenderTarget(
+    RenderTargetHandle handle) const {
+  return std::as_const(impl->renderTargetPool).get(handle);
+}
+
+void ResourceRegistry::applyPendingResizes() {
+  impl->renderTargetPool.applyPendingResizes();
+}
+
+}  // namespace sophia