আমি সিদ্ধান্ত নিয়েছি যে আমি আমার শখের গেম ইঞ্জিনের জন্য একটি কেন্দ্রীয় রিসোর্স ম্যানেজার / রিসোর্সক্যাস ক্লাস লিখতে চাই, তবে ক্যাচিং স্কিম ডিজাইন করতে সমস্যা হচ্ছে।
ধারণাটি হ'ল রিসোর্স ম্যানেজারের সমস্ত গেমের সংস্থানগুলি একত্রিত করে ব্যবহৃত মোট মেমোরির জন্য একটি নরম লক্ষ্য রয়েছে। অন্যান্য শ্রেণিগুলি রিসোর্স অবজেক্ট তৈরি করবে, যা একটি লোড করা অবস্থায় থাকবে এবং সেগুলি রিসোর্স ম্যানেজারে প্রেরণ করবে। রিসোর্স ম্যানেজার তারপরে সিদ্ধান্ত নেয় যে প্রদত্ত সংস্থানগুলি কখন লোড / আনলোড করবেন, নরম সীমাটি মাথায় রেখে।
যখন অন্য শ্রেণীর দ্বারা কোনও সংস্থান প্রয়োজন হয় তখন এর জন্য রিসোর্স ম্যানেজারের কাছে একটি অনুরোধ প্রেরণ করা হয় (স্ট্রিং আইডি বা কোনও অনন্য সনাক্তকারী ব্যবহার করে)। যদি রিসোর্সটি লোড করা হয়, তবে রিসোর্সের একটি পঠনযোগ্য রেফারেন্স কলিং ফাংশনটিতে পৌঁছে দেওয়া হবে (একটি রেফারেন্সযুক্ত গণনা দুর্বল_সেপ্টারে মোড়ানো)। যদি সংস্থানটি লোড না করা হয়, তবে ম্যানেজারটি পরবর্তী সুযোগে (সাধারণত ফ্রেম আঁকার শেষে) বস্তুটি লোড হওয়ার জন্য চিহ্নিত করবে।
দ্রষ্টব্য, যদিও আমার সিস্টেমটি কিছু রেফারেন্স গণনা করে, তবে এটি কেবল তখনই গণনা করা হয় যখন সংস্থানটি পড়া হয়, (সুতরাং রেফারেন্স গণনাটি 0 হতে পারে, তবে কোনও সত্তা এখনও এটি uid এর উপর নজর রাখতে পারে)।
প্রথম ব্যবহারের আগে ভাল লোড করার জন্য সংস্থানগুলি চিহ্নিত করাও সম্ভব। আমি যে ক্লাসগুলি ব্যবহার করছি তার একটি স্কেচ এখানে দেওয়া হল:
typedef unsigned int ResourceId;
// Resource is an abstract data type.
class Resource
{
Resource();
virtual ~Resource();
virtual bool load() = 0;
virtual bool unload() = 0;
virtual size_t getSize() = 0; // Used in determining how much memory is
// being used.
bool isLoaded();
bool isMarkedForUnloading();
bool isMarkedForReload();
void reference();
void dereference();
};
// This template class works as a weak_ptr, takes as a parameter a sub-class
// of Resource. Note it only hands give a const reference to the Resource, as
// it is read only.
template <class T>
class ResourceGuard
{
public:
ResourceGuard(T *_resource): resource(_resource)
{
resource->reference();
}
virtual ~ResourceGuard() { resource->dereference();}
const T* operator*() const { return (resource); }
};
class ResourceManager
{
// Assume constructor / destructor stuff
public:
// Returns true if resource loaded successfully, or was already loaded.
bool loadResource(ResourceId uid);
// Returns true if the resource could be reloaded,(if it is being read
// it can't be reloaded until later).
bool reloadResource(ResourceId uid)
// Returns true if the resource could be unloaded,(if it is being read
// it can't be unloaded until later)
bool unloadResource(ResourceId uid);
// Add a resource, with it's named identifier.
ResourceId addResource(const char * name,Resource *resource);
// Get the uid of a resource. Returns 0 if it doesn't exist.
ResourceId getResourceId(const char * name);
// This is the call most likely to be used when a level is running,
// load/reload/unload might get called during level transitions.
template <class T>
ResourceGuard<T> &getResource(ResourceId resourceId)
{
// Calls a private method, pretend it exits
T *temp = dynamic_cast<T*> (_getResource(resourceId));
assert(temp != NULL);
return (ResourceGuard<T>(temp));
}
// Generally, this will automatically load/unload data, and is called
// once per frame. It's also where the caching scheme comes into play.
void update();
};সমস্যাটি হ'ল, মোট ডেটা ব্যবহারকে নরম সীমাবদ্ধতার আশেপাশে / ঘোরাতে রাখতে ম্যানেজারকে কোন বিষয়গুলি আনলোড করতে হবে তা নির্ধারণের একটি স্মার্ট উপায় থাকতে হবে।
আমি কিছুটা অগ্রাধিকার ব্যবস্থা ব্যবহার করার কথা ভাবছি (যেমন অস্থায়ী অগ্রাধিকার, ঘন ঘন ব্যবহৃত অগ্রাধিকার, স্থায়ী অগ্রাধিকার), সর্বশেষ মূল্যবোধের সময় এবং সংস্থানটির আকারের সাথে মিলিয়ে কখন এটি অপসারণ করা হবে তা নির্ধারণ করতে। তবে আমি ব্যবহার করার জন্য কোনও শালীন স্কিম, বা তাদের দ্রুত পরিচালনা করার জন্য সঠিক ডেটা-স্ট্রাকচারের কথা ভাবতে পারি না।
যে কেউ এর মতো একটি সিস্টেম বাস্তবায়ন করেছে তারা কীভাবে কাজ করে তার একটি ওভারভিউ দিতে পারে? আমি কি অনুপস্থিত একটি স্পষ্ট ডিজাইন প্যাটার্ন আছে? আমি কি খুব জটিল করে তুলেছি? আদর্শভাবে আমার একটি দক্ষ, এবং সিস্টেমের অপব্যবহার করা শক্ত প্রয়োজন। কোন ধারনা?