Referencing engine resources

Question

Let's assume for the sake of argument, that we have a resource engine in place, and that we use OpenGL. My question is how the engine/game classes should reference the resources.

Lightweight example : among others, we probably have a texture resource. If we now have a class that uses this resource, do we store:

1. a resource id?
2. a resource pointer?
3. the resultant resource (e.g. the GLID of the Texture)

1 gives us the most flexibility, and neat features like being able to reload all textures on the fly (after context destruction), but costs us a lookup each time it is used, and might require a mutex lock.

Another example - a font resource, same questions -- do we hold an id, pointer or a direct font class?

Third example, a model resource has a reference to a texture it uses. Does it store id, pointer or direct link?

If the answers differ between uses, is there a sensible set of rules one can follow to decide what should be used in what case?

---

EDIT: we're talking about a general use, heavy duty (3d, streaming, resource groups, memory managing) resource manager here in a threaded environment.

Answer 1

I would always go with the first. Let's see why we should eliminate the other two:

Having a pointer directly to the resource object is not great. In terms of performance, it's really about the same as an index lookup (assuming an array or hash table of resources). However, it's not flexible. It's meaningless to have it stored in an external file, and requires an extra field for any magic number (to prevent temporal issues).

Storing the library handle directly is borderline useless. My biggest gripe is that it prevents you from associating various levels of detail as the same resource. The resource header that you look up with the ID should have an array or list that contains the library handles associated with detail levels. This also suffers from the same problems as the pointer on top of that.

---

In terms of implementation, you're best off doing something like this.

// 4 bytes in total
struct ResourceHandle
{
    unsigned int index :24;
    unsigned int magic :8;
};

The index field is used to look up the resource itself in an array or map. The magic field is used to ensure that if a resource is deleted and another is created that uses the same index, an old handle will correctly report that its resource has been deleted, rather than accessing the new, unrelated resource.

Each resource index has a magic field of its own, that is incremented each time the resource at that index is deleted. When returning the handle for a new resource, the magic value of that index is part of the result.