Resource.hpp

Go to the documentation of this file.

#pragma once

#include <cstdint>
#include <type_traits>
#include <string>

#include <lug/Graphics/Export.hpp>

namespace lug {
namespace Graphics {

class ResourceManager;

class LUG_GRAPHICS_API Resource {
    friend class lug::Graphics::ResourceManager;

public:
    enum class Type : uint8_t {
        Scene,      
        SceneNode,  
        Material,   
        Mesh,       
        Light,      
        Texture,    
        Pipeline,   
        Camera,     
        SkyBox      
    };

    struct Handle {
        union {
            struct {
                uint32_t type : 8;      
                uint32_t index : 24;    
            };

            uint32_t value;             
        };

        explicit operator uint32_t() {
            return value;
        }

        bool operator==(const Handle& other) const {
            return value == other.value;
        }
    };

    template <typename T>
    class SharedPtr {
        template <typename RhsT>
        friend class SharedPtr;

        static_assert(
            std::is_base_of<Resource, T>::value,
            "T must inherit from Resource"
        );

    public:
        constexpr SharedPtr(T* pointer = nullptr);

        SharedPtr(const SharedPtr<T>& rhs);
        SharedPtr(SharedPtr<T>&& rhs);

        SharedPtr<T>& operator=(const SharedPtr<T>& rhs);
        SharedPtr<T>& operator=(SharedPtr<T>&& rhs);

        ~SharedPtr();

        T& operator*() const;
        T* operator->() const;

        explicit operator bool() const {
            return _resource != nullptr;
        }

        T* get() const;

    public:
        template <typename RhsT>
        static SharedPtr<T> cast(const SharedPtr<RhsT>& rhs);

    private:
        T* _resource{nullptr};
    };

    template <typename T>
    class WeakPtr {
        template <typename RhsT>
        friend class WeakPtr;

        static_assert(
            std::is_base_of<Resource, T>::value,
            "T must inherit from Resource"
        );

    public:
        constexpr WeakPtr(T* pointer = nullptr);
        constexpr WeakPtr(const SharedPtr<T>& rhs);

        WeakPtr(const WeakPtr<T>& rhs);
        WeakPtr(WeakPtr<T>&& rhs);

        WeakPtr<T>& operator=(const WeakPtr<T>& rhs);
        WeakPtr<T>& operator=(WeakPtr<T>&& rhs);

        ~WeakPtr();

        SharedPtr<T> lock() const;

    public:
        template <typename RhsT>
        static WeakPtr<T> cast(const WeakPtr<RhsT>& rhs);

    private:
        T* _resource{nullptr};
    };

public:
    Resource(Type type, const std::string& name);

    Resource(const Resource&) = delete;
    Resource(Resource&&) = delete;

    Resource& operator=(const Resource&) = delete;
    Resource& operator=(Resource&&) = delete;

    virtual ~Resource() = default;

    Type getType() const;

    Handle getHandle() const;

    const std::string& getName() const;

    void setName(const std::string &name);

protected:
    std::string _name;

private:
    Handle _handle;
};

#include <lug/Graphics/Resource.inl>

} // Graphics
} // lug