threadpool rollback

include/vierkant/Scene.hpp

@@ -21,7 +21,7 @@ class Scene
 public:
     virtual ~Scene() = default;
 
-    static ScenePtr create(crocore::ThreadPool *thread_pool = nullptr);
+    static ScenePtr create();
 
     virtual void add_object(const Object3DPtr &object);
 
@@ -63,11 +63,9 @@ class Scene
     vierkant::Object3DPtr create_mesh_object(const vierkant::mesh_component_t &mesh_component);
 
 protected:
-    explicit Scene(crocore::ThreadPool *thread_pool = nullptr);
-    crocore::ThreadPool *m_thread_pool = nullptr;
+    explicit Scene() = default;
 
 private:
-    vierkant::mesh_map_t m_meshes;
     std::shared_ptr<entt::registry> m_registry = std::make_shared<entt::registry>();
 
     vierkant::ImagePtr m_skybox = nullptr;

include/vierkant/model/gltf.hpp

@@ -17,6 +17,6 @@ namespace vierkant::model
  *
  *  @return an optional struct grouping the loaded assets.
  */
-std::optional<model_assets_t> gltf(const std::filesystem::path &path, crocore::ThreadPool* pool = nullptr);
+std::optional<model_assets_t> gltf(const std::filesystem::path &path, crocore::ThreadPoolClassic* pool = nullptr);
 
 }// namespace vierkant::model

include/vierkant/model/model_loading.hpp

@@ -8,7 +8,7 @@
 #include <variant>
 
 #include <crocore/Image.hpp>
-#include <crocore/ThreadPool.hpp>
+#include <crocore/ThreadPoolClassic.hpp>
 
 #include <vierkant/Geometry.hpp>
 #include <vierkant/Material.hpp>
@@ -114,7 +114,7 @@ struct load_mesh_params_t
  *
  *  @return a struct grouping the loaded assets.
  */
-std::optional<model_assets_t> load_model(const std::filesystem::path &path, crocore::ThreadPool *pool = nullptr);
+std::optional<model_assets_t> load_model(const std::filesystem::path &path, crocore::ThreadPoolClassic *pool = nullptr);
 
 /**
  * @brief   load_mesh can be used to load assets into gpu-buffers
@@ -131,7 +131,7 @@ vierkant::MeshPtr load_mesh(const load_mesh_params_t &params, const vierkant::mo
  * @param   mesh_assets     a mesh_assets struct.
  * @return  true, if all images contained in mesh_assets are compressed.
  */
-bool compress_textures(vierkant::model::model_assets_t &mesh_assets);
+bool compress_textures(vierkant::model::model_assets_t &mesh_assets, crocore::ThreadPoolClassic *pool = nullptr);
 
 /**
  * @brief   create_compressed_texture can be used to create a texture from pre-compressed bc7 blocks.

include/vierkant/model/wavefront_obj.hpp

@@ -12,7 +12,7 @@ namespace vierkant::model
  *
  *  @return an optional struct grouping the loaded assets.
  */
-std::optional<model_assets_t> wavefront_obj(const std::filesystem::path &path, crocore::ThreadPool* pool = nullptr);
+std::optional<model_assets_t> wavefront_obj(const std::filesystem::path &path,
+                                            crocore::ThreadPoolClassic *pool = nullptr);
 
 }// namespace vierkant::model
-

include/vierkant/physics_context.hpp

@@ -143,7 +143,7 @@ class PhysicsScene : public vierkant::Scene
 public:
     ~PhysicsScene() override = default;
 
-    static std::shared_ptr<PhysicsScene> create(crocore::ThreadPool *thread_pool = nullptr);
+    static std::shared_ptr<PhysicsScene> create();
 
     void add_object(const Object3DPtr &object) override;
 
@@ -156,8 +156,10 @@ class PhysicsScene : public vierkant::Scene
     vierkant::PhysicsContext &context() { return m_context; };
 
 private:
-    explicit PhysicsScene(crocore::ThreadPool *thread_pool = nullptr);
-    vierkant::PhysicsContext m_context;
+    explicit PhysicsScene() = default;
+
+    crocore::ThreadPool m_thread_pool{std::thread::hardware_concurrency() - 1};
+    vierkant::PhysicsContext m_context{&m_thread_pool};
 };
 
 }//namespace vierkant

src/Scene.cpp

@@ -48,9 +48,7 @@ vierkant::Object3DPtr Scene::create_mesh_object(const mesh_component_t &mesh_com
     return object;
 }
 
-ScenePtr Scene::create(crocore::ThreadPool *thread_pool) { return ScenePtr(new Scene(thread_pool)); }
-
-Scene::Scene(crocore::ThreadPool *thread_pool) : m_thread_pool(thread_pool) {}
+ScenePtr Scene::create() { return ScenePtr(new Scene()); }
 
 void Scene::add_object(const Object3DPtr &object) { m_root->add_child(object); }
 

src/model/gltf.cpp

@@ -807,7 +807,7 @@ struct load_image_context_t
     // cache image-futures
     std::map<uint32_t, std::future<crocore::ImagePtr>> image_cache;
 
-    crocore::ThreadPool *pool = nullptr;
+    crocore::ThreadPoolClassic *pool = nullptr;
 };
 
 bool LoadImageDataFunction(tinygltf::Image * /*tiny_image*/, const int image_idx, std::string * /*err*/,
@@ -835,7 +835,7 @@ bool LoadImageDataFunction(tinygltf::Image * /*tiny_image*/, const int image_idx
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-std::optional<model_assets_t> gltf(const std::filesystem::path &path, crocore::ThreadPool *const pool)
+std::optional<model_assets_t> gltf(const std::filesystem::path &path, crocore::ThreadPoolClassic *const pool)
 {
     tinygltf::Model model;
     tinygltf::TinyGLTF loader;

src/model/model_loading.cpp

@@ -75,18 +75,17 @@ vierkant::VkSamplerPtr create_sampler(const vierkant::DevicePtr &device, const v
     return {sampler, [device](VkSampler s) { vkDestroySampler(device->handle(), s, nullptr); }};
 }
 
-bool compress_textures(vierkant::model::model_assets_t &mesh_assets)
+bool compress_textures(vierkant::model::model_assets_t &mesh_assets, crocore::ThreadPoolClassic *pool)
 {
     std::chrono::milliseconds compress_total_duration(0);
-    crocore::ThreadPool threadpool(std::thread::hardware_concurrency());
     size_t num_pixels = 0;
 
     for(auto &[tex_id, texture_variant]: mesh_assets.textures)
     {
         try
         {
             texture_variant = std::visit(
-                    [&threadpool, &compress_total_duration, &num_pixels](auto &&img) -> texture_variant_t {
+                    [pool, &compress_total_duration, &num_pixels](auto &&img) -> texture_variant_t {
                         using T = std::decay_t<decltype(img)>;
 
                         if constexpr(std::is_same_v<T, crocore::ImagePtr>)
@@ -96,7 +95,7 @@ bool compress_textures(vierkant::model::model_assets_t &mesh_assets)
                                 bc7::compress_info_t compress_info = {};
                                 compress_info.image = img;
                                 compress_info.generate_mipmaps = true;
-                                compress_info.delegate_fn = [&threadpool](auto fn) { return threadpool.post(fn); };
+                                if(pool){compress_info.delegate_fn = [pool](auto fn) { return pool->post(fn); };}
                                 auto compressed_img = bc7::compress(compress_info);
                                 compress_total_duration += compressed_img.duration;
                                 num_pixels += img->width() * img->height();
@@ -193,10 +192,10 @@ vierkant::MeshPtr load_mesh(const load_mesh_params_t &params, const vierkant::mo
     std::unordered_map<vierkant::SamplerId, vierkant::VkSamplerPtr> sampler_cache;
 
     // generate textures with default samplers
-    for(const auto &[tex_id, tex_variant]: mesh_assets.textures)
+    for(const auto &[id, tex_variant]: mesh_assets.textures)
     {
         std::visit(
-                [&params, tex_id = tex_id, &texture_cache, &create_texture](auto &&img) {
+                [&params, tex_id = id, &texture_cache, &create_texture](auto &&img) {
                     using T = std::decay_t<decltype(img)>;
 
                     if constexpr(std::is_same_v<T, crocore::ImagePtr>) { texture_cache[tex_id] = create_texture(img); }
@@ -291,7 +290,7 @@ vierkant::ImagePtr create_compressed_texture(const vierkant::DevicePtr &device,
     return compressed_img;
 }
 
-std::optional<model_assets_t> load_model(const std::filesystem::path &path, crocore::ThreadPool *pool)
+std::optional<model_assets_t> load_model(const std::filesystem::path &path, crocore::ThreadPoolClassic *pool)
 {
     auto ext_str = path.extension().string();
     std::transform(ext_str.begin(), ext_str.end(), ext_str.begin(), ::tolower);

src/model/wavefront_obj.cpp

@@ -45,7 +45,7 @@ vierkant::GeometryPtr create_geometry(const tinyobj::attrib_t &inattrib, const s
     return geom;
 }
 
-std::optional<model_assets_t> wavefront_obj(const std::filesystem::path &path, crocore::ThreadPool * /*pool*/)
+std::optional<model_assets_t> wavefront_obj(const std::filesystem::path &path, crocore::ThreadPoolClassic * /*pool*/)
 {
     if(!exists(path) || !is_regular_file(path)) { return {}; }
 

src/physics_context.cpp

@@ -710,10 +710,6 @@ void PhysicsContext::set_callbacks(uint32_t objectId, const PhysicsContext::call
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-PhysicsScene::PhysicsScene(crocore::ThreadPool *thread_pool) : vierkant::Scene(thread_pool), m_context(thread_pool) {}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
 void PhysicsScene::add_object(const Object3DPtr &object)
 {
     vierkant::Scene::add_object(object);
@@ -733,7 +729,7 @@ void PhysicsScene::remove_object(const Object3DPtr &object)
 
 void PhysicsScene::clear()
 {
-    m_context = vierkant::PhysicsContext(m_thread_pool);
+    m_context = vierkant::PhysicsContext(&m_thread_pool);
     Scene::clear();
 }
 
@@ -766,9 +762,9 @@ void PhysicsScene::update(double time_delta)
     m_context.step_simulation(static_cast<float>(time_delta), 2);
 }
 
-std::shared_ptr<PhysicsScene> PhysicsScene::create(crocore::ThreadPool *thread_pool)
+std::shared_ptr<PhysicsScene> PhysicsScene::create()
 {
-    return std::shared_ptr<PhysicsScene>(new PhysicsScene(thread_pool));
+    return std::shared_ptr<PhysicsScene>(new PhysicsScene());
 }
 
 }//namespace vierkant