asset_manager concept

engine/src/assets/asset_manager.cpp

@@ -0,0 +1,24 @@
+#include "assets/asset_manager.hpp"
+
+#include "mesh.hpp"
+
+namespace sophia {
+
+AssetManager::AssetManager(Device& device) : device{device}, meshPool{device} {}
+
+template <>
+MeshHandle AssetManager::create<Mesh>(const Mesh::Builder& builder) {
+  return meshPool.create(builder);
+}
+
+template <>
+const Mesh& AssetManager::get<Mesh>(MeshHandle handle) const {
+  return meshPool.get(handle);
+}
+
+template <>
+void AssetManager::release<Mesh>(MeshHandle handle) {
+  meshPool.release(handle);
+}
+
+}  // namespace sophia

engine/src/assets/asset_manager.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <string>
+
+#include "device.hpp"
+#include "pools/mesh_pool.hpp"
+
+namespace sophia {
+
+class AssetManager {
+ public:
+  explicit AssetManager(Device& device);
+  ~AssetManager() = default;
+
+  AssetManager(const AssetManager&) = delete;
+  AssetManager& operator=(const AssetManager&) = delete;
+
+  template <typename T>
+  using HandleFor = typename T::HandleType;
+
+  template <typename T>
+  HandleFor<T> load(const std::string& path);
+
+  template <typename T>
+  HandleFor<T> create(const typename T::Builder& builder);
+
+  template <typename T>
+  const T& get(HandleFor<T> handle) const;
+
+  template <typename T>
+  void release(HandleFor<T> handle);
+
+ private:
+  Device& device;
+
+  MeshPool meshPool;
+  // TexturePool texturePool;
+  // MaterialPool materialPool;
+};
+
+}  // namespace sophia

engine/src/assets/pools/mesh_pool.cpp

@@ -0,0 +1,41 @@
+#include "assets/pools/mesh_pool.hpp"
+
+#include <sophia/util/assert.hpp>
+
+namespace sophia {
+
+MeshPool::MeshPool(Device& device) : device{device} {}
+
+MeshPool::~MeshPool() = default;
+
+MeshHandle MeshPool::create(const Mesh::Builder& builder) {
+  auto mesh = std::make_unique<Mesh>(device, builder);
+
+  if (!freeList.empty()) {
+    MeshHandle handle = freeList.back();
+    freeList.pop_back();
+    meshes[handle] = std::move(mesh);
+    return handle;
+  }
+
+  meshes.push_back(std::move(mesh));
+  return static_cast<MeshHandle>(meshes.size() - 1);
+}
+
+const Mesh& MeshPool::get(MeshHandle handle) const {
+  SOPHIA_ASSERT(handle < meshes.size(), "invalid MeshHandle:", handle);
+  SOPHIA_ASSERT(meshes[handle] != nullptr,
+                "MeshHandle refers to a released mesh:", handle);
+  return *meshes[handle];
+}
+
+void MeshPool::release(MeshHandle handle) {
+  SOPHIA_ASSERT(handle < meshes.size(), "invalid MeshHandle:", handle);
+  SOPHIA_ASSERT(meshes[handle] != nullptr,
+                "MeshHandle already released:", handle);
+
+  meshes[handle].reset();
+  freeList.push_back(handle);
+}
+
+}  // namespace sophia

engine/src/assets/pools/mesh_pool.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "device.hpp"
+#include "mesh.hpp"
+
+namespace sophia {
+
+class MeshPool {
+ public:
+  explicit MeshPool(Device& device);
+  ~MeshPool();
+
+  MeshPool(const MeshPool&) = delete;
+  MeshPool& operator=(const MeshPool&) = delete;
+
+  MeshHandle create(const Mesh::Builder& builder);
+  const Mesh& get(MeshHandle handle) const;
+  void release(MeshHandle handle);
+
+ private:
+  Device& device;
+
+  std::vector<std::unique_ptr<Mesh>> meshes;
+  std::vector<MeshHandle> freeList;
+};
+
+}  // namespace sophia