Initial implementation of Vulkan backend

[libs/gl.git] / source / resources / resourcemanager.h

diff --git a/source/resources/resourcemanager.h b/source/resources/resourcemanager.h
index 38437a727fd9a7d94cc24b048123bb62f0a0e35d..e2926be41a82a98ba184c7a6b5194a11a24db4bc 100644 (file)
--- a/source/resources/resourcemanager.h
+++ b/source/resources/resourcemanager.h
@@ -2,8 +2,9 @@
 #define MSP_GL_RESOURCEMANAGER_H_
 
 #include <deque>
-#include <msp/core/inttypes.h>
+#include <cstdint>
 #include <msp/core/mutex.h>
+#include <msp/core/noncopyable.h>
 #include <msp/core/semaphore.h>
 #include <msp/core/thread.h>
 #include <msp/datafile/collection.h>
@@ -23,7 +24,7 @@ public:
 };
 
 
-class ResourceManager
+class ResourceManager: public NonCopyable
 {
 public:
        enum LoadingPolicy
@@ -62,7 +63,7 @@ private:
                Resource::AsyncLoader *loader;
                State state;
                unsigned last_used;
-               UInt64 data_size;
+               std::uint64_t data_size;
                std::vector<ResourceObserver *> observers;
 
                ManagedResource(Resource &);
@@ -80,7 +81,7 @@ private:
        class LoadingThread: public Thread
        {
        private:
-               Semaphore sem;
+               Msp::Semaphore sem;
                Mutex queue_mutex;
                std::deque<ManagedResource *> async_queue;
                std::deque<ManagedResource *> sync_queue;
@@ -88,7 +89,7 @@ private:
                unsigned size;
                std::list<resource_load_error> error_queue;
                Mutex data_size_mutex;
-               UInt64 loaded_data_size;
+               std::uint64_t loaded_data_size;
                volatile bool done;
 
        public:
@@ -107,35 +108,35 @@ private:
        public:
                bool sync();
                bool needs_work() const { return size<capacity; }
-               UInt64 get_and_reset_loaded_data_size();
+               std::uint64_t get_and_reset_loaded_data_size();
 
                void terminate();
        };
 
-       LoadingPolicy policy;
-       bool async_loads;
+       LoadingPolicy policy = LOAD_ON_DEMAND;
+       bool async_loads = true;
        mutable Mutex map_mutex;
        std::map<const Resource *, ManagedResource> resources;
        std::deque<ManagedResource *> queue;
-       UInt64 total_data_size;
-       UInt64 size_limit;
-       unsigned frame;
-       unsigned min_retain_frames;
-       unsigned max_retain_frames;
-       unsigned next_unload;
+       std::uint64_t total_data_size = 0;
+       std::uint64_t size_limit = 0;
+       unsigned frame = 0;
+       unsigned min_retain_frames = 30;
+       unsigned max_retain_frames = 0;
+       unsigned next_unload = 0;
        LoadingThread thread;
 
 public:
-       ResourceManager();
        ~ResourceManager();
 
        void set_loading_policy(LoadingPolicy);
        void set_async_loads(bool);
-       void set_size_limit(UInt64);
+       void set_size_limit(std::uint64_t);
        void set_min_retain_frames(unsigned);
        void set_max_retain_frames(unsigned);
 
        void add_resource(Resource &);
+       void move_resource(Resource &, Resource &);
 private:
        const ManagedResource &get_managed_resource(const Resource &) const;
        ManagedResource &get_managed_resource(const Resource &);
@@ -158,7 +159,7 @@ private:
        void unload_by_age();
        void unload_by_size();
 public:
-       UInt64 get_total_data_size() const { return total_data_size; }
+       std::uint64_t get_total_data_size() const { return total_data_size; }
 
 private:
        static bool age_order(ManagedResource *, ManagedResource *);