WIP

include/merian/vk/sync/semaphore_binary.hpp

@@ -3,11 +3,19 @@
 #include "merian/vk/sync/semaphore.hpp"
 
 namespace merian {
+
+class BinarySemaphore;
+using BinarySemaphoreHandle = std::shared_ptr<BinarySemaphore>;
+
 class BinarySemaphore : public Semaphore {
-  public:
+  private:
     BinarySemaphore(const ContextHandle& context)
         : Semaphore(context, {vk::SemaphoreType::eBinary, 0}) {}
+
+  public:
+    static BinarySemaphoreHandle create(const ContextHandle& context) {
+        return std::shared_ptr<BinarySemaphore>(new BinarySemaphore(context));
+    }
 };
 
-using BinarySemaphoreHandle = std::shared_ptr<BinarySemaphore>;
 } // namespace merian

include/merian/vk/sync/semaphore_timeline.hpp

@@ -3,10 +3,15 @@
 #include "merian/vk/sync/semaphore.hpp"
 
 namespace merian {
+
+class TimelineSemaphore;
+using TimelineSemaphoreHandle = std::shared_ptr<TimelineSemaphore>;
+
 class TimelineSemaphore : public Semaphore {
-  public:
+  private:
     TimelineSemaphore(const ContextHandle& context, const uint64_t initial_value = 0);
 
+  public:
     uint64_t get_counter_value() const;
 
     // Waits until the semaphore holds a value that is >= the supplied value.
@@ -16,7 +21,12 @@ class TimelineSemaphore : public Semaphore {
     bool wait(const uint64_t value, const uint64_t timeout_nanos = UINT64_MAX);
 
     void signal(const uint64_t value);
+
+  public:
+    static TimelineSemaphoreHandle create(const ContextHandle& context,
+                                          const uint64_t initial_value = 0) {
+        return std::shared_ptr<TimelineSemaphore>(new TimelineSemaphore(context, initial_value));
+    }
 };
 
-using TimelineSemaphoreHandle = std::shared_ptr<TimelineSemaphore>;
 } // namespace merian

include/merian/vk/sync/sync_dispatcher.hpp

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "merian/vk/sync/semaphore_timeline.hpp"
+
+namespace merian {
+
+/* A Dispatches callbacks after dependent on a semaphore value.
+ * 
+ * The callbacks run on the contexts' thread pool.
+ */
+class SyncDispatcher {
+
+  public:
+    SyncDispatcher(const ContextHandle& context) : context(context), interrupt_semaphore(TimelineSemaphore::create(context)) {
+        dispatcher_thread = std::thread([](){
+            SPDLOG_DEBUG("dispatcher thread started");
+
+            SPDLOG_DEBUG("dispatcher thread quitting");
+
+        });
+
+
+    }
+
+    ~SyncDispatcher() {
+        SPDLOG_DEBUG("stopping dispatcher thread.");
+        stop.store(true);
+        interrupt_semaphore->signal(interrupt_wait_value);
+        dispatcher_thread.join();
+    }
+
+  private:
+    const ContextHandle context;
+    const TimelineSemaphoreHandle interrupt_semaphore;
+    std::thread dispatcher_thread;
+    std::atomic_bool stop = false;
+    std::atomic<uint64_t> interrupt_wait_value = 1;
+};
+
+} // namespace merian

src/merian/vk/window/swapchain.cpp

@@ -253,8 +253,8 @@ vk::Extent2D Swapchain::create_swapchain(const uint32_t width, const uint32_t he
     for (std::size_t i = 0; i < info->images.size(); i++) {
         SyncGroup& sync_group = sync_groups[i];
 
-        sync_group.read_semaphore = std::make_shared<BinarySemaphore>(context);
-        sync_group.written_semaphore = std::make_shared<BinarySemaphore>(context);
+        sync_group.read_semaphore = BinarySemaphore::create(context);
+        sync_group.written_semaphore = BinarySemaphore::create(context);
         sync_group.acquire_finished = Fence::create(context);
     }