Rendering Engine Design-abstrakcja kodu API dla zasobów

Zdecydowałem się na podejście hybrydowe, z metodą (2), (3), (5) i ewentualnie (4) w przyszłości.

To co w zasadzie zrobiłem to:

Każdy zasób ma dołączony uchwyt. Ten uchwyt opisuje obiekt. Każdy uchwyt ma powiązany z nim identyfikator, który jest prostą liczbą całkowitą. Aby rozmawiać z GPU Z Każdym zasobem, tworzony jest interfejs dla każdego uchwytu. Ten interfejs jest w tej chwili abstrakcyjny, ale można to zrobić za pomocą szablonów, jeśli zdecyduję się to zrobić w przyszłość. Klasa zasobów ma wskaźnik do interfejsu.

Mówiąc najprościej, uchwyt opisuje rzeczywisty obiekt GPU, a zasób to tylko owijka nad uchwytem i interfejs do połączenia uchwytu i GPU razem.

Tak to w zasadzie wygląda:

// base class for resource handles
struct ResourceHandle
{  
   typedef unsigned Id;
   static const Id NULL_ID = 0;
   ResourceHandle() : id(0) {}

   bool isNull() const
   { return id != NULL_ID; }

   Id id;
};

// base class of a resource
template <typename THandle, typename THandleInterface>
struct Resource
{
    typedef THandle Handle;
    typedef THandleInterface HandleInterface;

    HandleInterface* getInterface() const { return _interface; }
    void setInterface(HandleInterface* interface) 
    { 
        assert(getHandle().isNull()); // should not work if handle is NOT null
        _interface = interface;
    }

    const Handle& getHandle() const
    { return _handle; }

protected:

    typedef Resource<THandle, THandleInterface> Base;

    Resource(HandleInterface* interface) : _interface(interface) {}

    // refer to this in base classes
    Handle _handle;

private:

    HandleInterface* _interface;
};

Pozwala mi to dość łatwo rozszerzyć i pozwala na składnię taką jak:

Renderer renderer;

// create a texture
Texture texture(renderer);

// load the texture
texture.load(Image("test.png");

Gdzie Texture pochodzi z Resource<TextureHandle, TextureHandleInterface> i gdzie renderer ma odpowiedni interfejs do ładowania tekstury obsługują obiekty.

Mam krótki działający przykład tego tutaj .

Mam nadzieję, że to zadziała, mogę zdecydować się na przeprojektowanie go w przyszłości, jeśli tak, zaktualizuję. Krytyka byłaby mile widziana.

EDIT:

Zmieniłem sposób, w jaki to robię. Rozwiązanie, którego używam, jest dość podobne do opisanego powyżej, ale tutaj jest inaczej:

1. API obraca się wokół "backendów" , są to obiekty, które posiadają wspólny interfejs i komunikują się z niskopoziomowym API (np. Direct3D lub OpenGL).
2. Uchwyty nie są już liczbami całkowitymi/identyfikatorami. Backend ma specyficzne typedef dla każdego typu obsługi zasobów (np. texture_handle_type, program_handle_type, shader_handle_type).
3. zasoby nie mają klasy bazowej i wymagają tylko jednego parametru szablonu (a GraphicsBackend). Zasób przechowuje uchwyt i odniesienie do zaplecza graficznego, do którego należy. Następnie zasób ma przyjazne dla użytkownika API i korzysta z wspólnego zaplecza obsługi i Grafiki interfejs do interakcji z "rzeczywistym" zasobem. tzn. resource objects są w zasadzie opakowaniami uchwytów, które pozwalają na RAII.
4. obiekt graphics_device jest wprowadzony w celu umożliwienia budowy zasobów (wzorzec fabryczny; np. device.createTexture() lub device.create<my_device_type::texture>(),

Na przykład:

#include <iostream>
#include <string>
#include <utility>

struct Image { std::string id; };

struct ogl_backend
{
    typedef unsigned texture_handle_type;

    void load(texture_handle_type& texture, const Image& image)
    {
        std::cout << "loading, " << image.id << '\n';
    }

    void destroy(texture_handle_type& texture)
    {
        std::cout << "destroying texture\n";
    }
};

template <class GraphicsBackend>
struct texture_gpu_resource
{
    typedef GraphicsBackend graphics_backend;
    typedef typename GraphicsBackend::texture_handle_type texture_handle;

    texture_gpu_resource(graphics_backend& backend)
        : _backend(backend)
    {
    }

    ~texture_gpu_resource()
    {
        // should check if it is a valid handle first
        _backend.destroy(_handle);
    }

    void load(const Image& image)
    {
        _backend.load(_handle, image);
    }

    const texture_handle& handle() const
    {
        return _handle;
    }

private:

    graphics_backend& _backend;
    texture_handle _handle;
};


template <typename GraphicBackend>
class graphics_device
{
    typedef graphics_device<GraphicBackend> this_type;

public:

    typedef texture_gpu_resource<GraphicBackend> texture;

    template <typename... Args>
    texture createTexture(Args&&... args)
    {
        return texture{_backend, std::forward(args)...};
    }

    template <typename Resource, typename... Args>
    Resource create(Args&&... args)
    {
             return Resource{_backend, std::forward(args)...};
        }

private:

    GraphicBackend _backend;
};


class ogl_graphics_device : public graphics_device<ogl_backend>
{
public:

    enum class feature
    {
        texturing
    };

    void enableFeature(feature f)
    {
        std::cout << "enabling feature... " << (int)f << '\n';
    }
};


// or...
// typedef graphics_device<ogl_backend> ogl_graphics_device


int main()
{
    ogl_graphics_device device;

    device.enableFeature(ogl_graphics_device::feature::texturing);

    auto texture = device.create<decltype(device)::texture>();

    texture.load({"hello"});

    return 0;
}

/*

 Expected output:
    enabling feature... 0
    loading, hello
    destroying texture

*/

Live demo: http://ideone.com/Y2HqlY

Ten projekt jest obecnie używany w mojej bibliotece rojo (Uwaga: ta Biblioteka jest nadal pod ciężkim rozwój).