Resource.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Forward.hpp"
 
#include "ResourceHandle.hpp"
#include "ResourceStream.hpp"
 
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/JSON.hpp"
#include "CeresEngine/Foundation/TypeTraits.hpp"
#include "CeresEngine/Foundation/UUID.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
#include "CeresEngine/Reflection/IReflectable.hpp"
#include "CeresEngine/Reflection/Type.hpp"
 
namespace CeresEngine {
 
    class InputStream;
    class OutputStream;
 
    class MemoryDataStream;
 
    struct ResourceID : public UUID {
        using UUID::UUID;
 
        explicit ResourceID(const UUID& uuid) : UUID(uuid) {}
 
        static const ResourceID null;
    };
 
    const inline ResourceID ResourceID::null = ResourceID();
 
    //  /// Type that uniquely represents a resource stream contained in a resource.
    //  struct ResourceStreamID : public UUID {
    //      using UUID::UUID;
    //
    //      /// Converts a raw UUID into a `ResourceStreamID`.
    //      explicit ResourceStreamID(const UUID& uuid) : UUID(uuid) {}
    //
    //      /// A null (or empty) resource stream ID.
    //      static const ResourceStreamID null;
    //  };
    //
    //  const inline ResourceStreamID ResourceStreamID::null = ResourceStreamID();
 
    struct ResourceTypeInfo final {
        const std::type_info& typeInfo;
        const Type type;
 
        ResourceTypeInfo(const std::type_info& typeInfo, const Type type) : typeInfo(typeInfo), type(type) {}
 
        [[nodiscard]] StringView getName() const noexcept { return type.getTypeName(); }
 
        template<typename T> static const ResourceTypeInfo& get() {
            static const ResourceTypeInfo typeInfo{typeid(T), getType<T>()};
            return typeInfo;
        }
    };
 
    template<typename T, typename... Args> SPtr<T> constructResource(ResourceData& resourceData, Args&&... args) {
        if constexpr(std::is_constructible_v<T, ResourceData&, Args...>) {
            return ce_shared_new<T>(resourceData, std::forward<Args>(args)...);
        } else {
            return ce_shared_new<T>(std::forward<Args>(args)...);
        }
    }
 
    class ResourceData : public RefCounted<ResourceData> {
    public:
        ResourceManager& manager;
 
        const PackagePtr package = nullptr;
 
        const ResourceID id = ResourceID::null;
 
        const WeakResourceHandle<Resource> handle = nullptr;
 
        const WeakResourceHandle<Resource> parent = nullptr;
 
        SPtr<ResourceMetadata> metadata = nullptr;
 
    private:
        Map<ResourceID, WeakResourceHandle<Resource>> mSubResources;
 
        Vector<HResource> mUnsavedResources;
 
    public:
        explicit ResourceData(ResourceManager& resourceManager) noexcept : manager(resourceManager) {}
 
        virtual ~ResourceData() noexcept = default;
 
    public:
        [[nodiscard]] virtual ResourceStreamData& createStream(const ResourceStreamFlags& flags = ResourceStreamFlag::Default) = 0;
 
        [[nodiscard]] virtual ResourceStreamDataPtr getStream(const ResourceStreamID& streamID) const = 0;
 
        [[nodiscard]] virtual Vector<ResourceStreamDataPtr> getStreams() const = 0;
 
        virtual void destroyStream(ResourceStreamData& stream) = 0;
    };
 
    class MemoryResourceData final : public ResourceData {
    private:
        using StreamMap = HashMap<ResourceStreamID, ResourceStreamDataPtr>;
 
        LockedObject<StreamMap, SharedMutex> mStreams;
 
    public:
        explicit MemoryResourceData(ResourceManager& resourceManager) noexcept : ResourceData(resourceManager) {}
 
        ~MemoryResourceData() noexcept final = default;
 
    public:
        [[nodiscard]] ResourceStreamData& createStream(const ResourceStreamFlags& flags = ResourceStreamFlag::Default) override;
 
        [[nodiscard]] ResourceStreamDataPtr getStream(const ResourceStreamID& streamID) const override;
 
        [[nodiscard]] Vector<ResourceStreamDataPtr> getStreams() const override;
 
        void destroyStream(ResourceStreamData& stream) override;
    };
 
    class Resource : public std::enable_shared_from_this<Resource>, public IReflectable {
        CE_REFLECTABLE_CLASS
 
    private:
        ResourceDataPtr mData = nullptr;
 
    public:
        Resource();
 
        explicit Resource(ResourceData& data) : mData(&data) {}
 
        virtual ~Resource() noexcept = default;
 
    public:
        [[nodiscard]] ResourceManager* getResourceManager() const noexcept { return mData != nullptr ? &mData->manager : nullptr; }
 
        [[nodiscard]] HResource getResourceHandle() const noexcept { return mData != nullptr ? mData->handle.lock() : nullptr; }
 
        [[nodiscard]] UUID getResourceID() const noexcept { return mData != nullptr ? mData->handle.getUUID() : UUID(); }
 
        [[nodiscard]] HResource getParentResource() const noexcept { return mData != nullptr ? mData->parent.lock() : nullptr; }
 
        [[nodiscard]] SPtr<ResourceMetadata> getResourceMetadata() const noexcept { return mData != nullptr ? mData->metadata : nullptr; }
 
        [[nodiscard]] const PackagePtr& getPackage() const noexcept {
            static const PackagePtr nullPackagePtr = nullptr;
            return mData != nullptr ? mData->package : nullPackagePtr;
        }
 
        template<typename T = Resource> [[nodiscard]] SPtr<T> getShared() noexcept { return static_pointer_cast<T>(shared_from_this()); }
 
        template<typename T = Resource> [[nodiscard]] SPtr<const T> getShared() const noexcept { return static_pointer_cast<const T>(shared_from_this()); }
 
    protected: // Resource Streams
        [[nodiscard]] HResourceStream createStream(const ResourceStreamFlags& flags = ResourceStreamFlag::Default);
 
        void destroyStream(HResourceStream& stream);
 
    public:
        [[nodiscard]] virtual const ResourceTypeInfo& getResourceType() const noexcept = 0;
 
    protected: // Change detection & tracking
        void markAsDirty();
 
    private:
        friend class ResourceManager;
 
    public: // Serialization
        explicit Resource(ResourceData& data, InputStream& dataStream) : Resource(data) {}
 
        virtual void serialize(OutputStream& dataStream) const = 0;
 
    public: // Reflection
        template<typename Processor> static constexpr void reflect(Processor&& RTTI) { CE_REFL_DATA_GET(resourceID, getResourceID); }
    };
 
    template<typename T, typename Base = Resource> class TResource : public Base {
        [[nodiscard]] ::CeresEngine::ClassInfo getClassInfo() noexcept override { return {::CeresEngine::getTypeID<T>(), this}; }
        [[nodiscard]] ::CeresEngine::ClassInfo getClassInfo() const noexcept override { return {::CeresEngine::getTypeID<T>(), this}; }
 
    public:
        using Base::Base;
 
    public:
        [[nodiscard]] ResourceHandle<T> getResourceHandle() const noexcept { return static_resource_cast<T>(Resource::getResourceHandle()); }
 
        [[nodiscard]] SPtr<T> getShared() noexcept { return std::static_pointer_cast<T>(Resource::getShared()); }
 
        [[nodiscard]] SPtr<const T> getShared() const noexcept { return std::static_pointer_cast<const T>(Resource::getShared()); }
 
    public:
        [[nodiscard]] const ResourceTypeInfo& getResourceType() const noexcept override { return ResourceTypeInfo::get<T>(); }
 
    public: // Serialization
        explicit TResource(ResourceData& data, InputStream& dataStream) : Base(data, dataStream) {
            // TODO: Deserialize with reflection.
        }
 
        void serialize(OutputStream& dataStream) const override {
            // TODO: Serialize with reflection.
        }
    };
 
    template<typename T, bool = std::is_final_v<T>> class ResourceObject;
 
    template<typename T> class ResourceObject<T, false> : public TResource<ResourceObject<T>>, public T {
        CE_REFLECTABLE_CLASS
 
    public:
        template<typename... Args>
        explicit ResourceObject(Args&&... args) requires(is_explicitly_constructible<T, Args...>)
                : T(std::forward<Args>(args)...) {}
 
        template<typename... Args>
        ResourceObject(Args&&... args) requires(is_implicitly_constructible<T, Args...>)
                : T(std::forward<Args>(args)...) {}
 
        template<typename... Args>
        explicit ResourceObject(ResourceData& data, Args&&... args) : TResource<ResourceObject<T>>(data), T(std::forward<Args>(args)...) {}
    };
 
    template<typename T> class ResourceObject<T, true> : public TResource<ResourceObject<T>> {
        CE_REFLECTABLE_CLASS
 
    private:
        T mValue;
 
    public:
        template<typename... Args>
        explicit ResourceObject(Args&&... args) requires(is_explicitly_constructible<T, Args...>)
                : mValue(std::forward<Args>(args)...) {}
 
        template<typename... Args>
        ResourceObject(Args&&... args) requires(is_implicitly_constructible<T, Args...>)
                : mValue(std::forward<Args>(args)...) {}
 
        template<typename... Args>
        explicit ResourceObject(ResourceData& data, Args&&... args) : TResource<ResourceObject<T>>(data), mValue(std::forward<Args>(args)...) {}
 
    public:
        T& get() { return mValue; }
 
        const T& get() const { return mValue; }
    };
 
    template<typename T> using HResourceObject = ResourceHandle<ResourceObject<T>>;
 
} // namespace CeresEngine
 
template<> struct std::hash<CeresEngine::ResourceID> : std::hash<CeresEngine::UUID> {};