ResourceImporter.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 "CeresEngine/Resource/Forward.hpp"
 
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Async.hpp"
#include "CeresEngine/Foundation/UUID.hpp"
#include "CeresEngine/Foundation/Container/Variant.hpp"
#include "CeresEngine/Foundation/IO/URLSession.hpp"
 
#include "CeresEngine/Resource/Resource.hpp"
 
namespace CeresEngine {
 
    class URLSession;
 
    struct ImportedResource {
        Variant<HResource, ResourcePtr> resource;
 
        UUID suggestedUUID;
 
        String suggestedName;
 
        ImportedResource() = default;
 
        CE_EXPLICIT(false) ImportedResource(ResourcePtr resource, const UUID suggestedUUID = {}, String suggestedName = {})
                : resource(resource), suggestedUUID(suggestedUUID), suggestedName(std::move(suggestedName)) {}
 
        template<typename T>
        CE_EXPLICIT(false) ImportedResource(SPtr<T> resource, const UUID suggestedUUID = {}, String suggestedName = {})
                : resource(resource), suggestedUUID(suggestedUUID), suggestedName(std::move(suggestedName)) {}
 
        CE_EXPLICIT(false) ImportedResource(HResource resource, const UUID suggestedUUID = {}, String suggestedName = {})
                : resource(resource), suggestedUUID(suggestedUUID), suggestedName(std::move(suggestedName)) {}
 
        template<typename T>
        CE_EXPLICIT(false) ImportedResource(ResourceHandle<T> resource, const UUID suggestedUUID = {}, String suggestedName = {})
                : resource(HResource(resource)), suggestedUUID(suggestedUUID), suggestedName(std::move(suggestedName)) {}
    };
 
    struct ImportedResources {
        Vector<ImportedResource> resources;
 
        ImportedResources() = default;
 
        CE_EXPLICIT(false) ImportedResources(const std::initializer_list<ImportedResource> resources) : resources(resources) {}
 
        CE_EXPLICIT(false) ImportedResources(Vector<ImportedResource> resources) : resources(resources) {}
 
        CE_EXPLICIT(false) ImportedResources(ImportedResource importedResource) : resources({importedResource}) {}
 
        CE_EXPLICIT(false) ImportedResources(ResourcePtr resource, const UUID suggestedUUID = {}, String suggestedName = {})
                : resources({ImportedResource(std::move(resource), suggestedUUID, std::move(suggestedName))}) {}
 
        template<typename T>
        CE_EXPLICIT(false) ImportedResources(SPtr<T> resource, UUID suggestedUUID = {}, String suggestedName = {})
                : resources({ImportedResource(std::move(resource), suggestedUUID, std::move(suggestedName))}) {}
 
        CE_EXPLICIT(false) ImportedResources(HResource resource, const UUID suggestedUUID = {}, String suggestedName = {})
                : resources({ImportedResource(std::move(resource), suggestedUUID, std::move(suggestedName))}) {}
 
        template<typename T>
        CE_EXPLICIT(false) ImportedResources(ResourceHandle<T> resource, UUID suggestedUUID = {}, String suggestedName = {})
                : resources({ImportedResource(std::move(resource), suggestedUUID, std::move(suggestedName))}) {}
    };
 
    struct ResourceImportDescriptor {
        ResourceTypeInfo desiredResource;
        const ResourceImportOptions& options;
    };
 
    struct ResourceImporterPeekSession {
        const ResourceTypeInfo* typeInfo;
 
        URLResponse urlResponse;
 
        InputStream inputStream;
    };
 
    struct ResourceImporterPeekResponse {
        UPtr<ResourceImportOptions> importOptions;
    };
 
    struct ResourceImporterSession {
        const UPtr<ResourceImportOptions> importOptions;
 
        const ResourceTypeInfo* typeInfo;
 
        ResourceImporter* const importer;
 
        URLResponse urlResponse;
 
        InputStream inputStream;
    };
 
    class ResourceImporter2 {
    protected:
        ResourceManager& mResourceManager;
 
        URLSession& mURLSession;
 
        ExecutionContext& mExecutionContext;
 
    public:
        explicit ResourceImporter2(ResourceManager& resourceManager);
 
        virtual ~ResourceImporter2() = default;
 
    public:
        virtual Async<Optional<ResourceImporterPeekResponse>> peek(const ResourceURL& url, const ResourceImporterPeekSession& session) = 0;
 
        virtual Async<ImportedResources> importResource(const ResourceURL& url, ResourceImporterSession& session) = 0;
    };
 
    class ResourceImporter {
    protected:
        ResourceManager& mResourceManager;
 
        URLSession& mURLSession;
 
        ExecutionContext& mExecutionContext;
 
    public:
        explicit ResourceImporter(ResourceManager& resourceManager);
 
        virtual ~ResourceImporter() = default;
 
    public:
        [[nodiscard]] virtual Async<ImportedResources> import(const ResourceURL& url, const ResourceImportOptions& options) = 0;
 
        enum class SupportStatus {
            Supported,
 
            Generic,
 
            Unsupported
        };
 
        [[nodiscard]] virtual Async<SupportStatus> supports(const ResourceURL& url) = 0;
    };
 
    template<typename T, typename O = ResourceImportOptions> class TResourceImporter : public ResourceImporter {
    public:
        using ResourceImporter::ResourceImporter;
 
    public:
        [[nodiscard]] Async<ImportedResources> import(const ResourceURL& url, const ResourceImportOptions& options) final {
//            const O* castedOptions = dynamic_cast<const O*>(&options);
//            if(castedOptions == nullptr) {
                static const O defaultOptions;
//                castedOptions = &defaultOptions;
//            }
            return import(url, defaultOptions);
        }
 
        [[nodiscard]] virtual Async<ImportedResources> import(const ResourceURL& url, const O& options) = 0;
    };
 
    template<typename T> class TResourceImporter<T, ResourceImportOptions> : public ResourceImporter {
    public:
        using ResourceImporter::ResourceImporter;
    };
 
} // namespace CeresEngine