ressource_provider.hpp

#pragma once
 
#include <cstdint>
 
#include <utility/system_io/file.hpp>
#include <utility/system_io/system_io.hpp>
 
#include <utility/graphic/pose.hpp>
#include <utility/graphic/text/font.hpp>
#include <utility/graphic/text/code_points.hpp>
#include <utility/graphic/text/text_material.hpp>
#include <utility/graphic/material.hpp>
#include <utility/graphic/texture.hpp>
#include <utility/graphic/model.hpp>
#include <utility/graphic/shader.hpp>
 
#include <utility/sound/audio_source.hpp>
#include <utility/sound/decoder/decoder_registry.hpp>
#include <utility/sound/audio_manager.hpp>
 
#include <utility/logging/loggable.hpp>
#include <utility/logging/default_logger.hpp>
 
namespace utility
{
    class RessourceProvider:
        protected utility::logging::Loggable<RessourceProvider,
                                             utility::logging::DefaultLogger>
    {
        public:
        enum class ShaderType { TEXT_SHADER, MESH_SHADER };
 
        RessourceProvider(SystemIO &systemInterface,
                          const std::string &basePath = "");
 
        ~RessourceProvider() = default;
 
        [[nodiscard]] const std::map<uint32_t,
                                     std::shared_ptr<graphic::Material>> &
            getMaterials() const;
 
        [[nodiscard]] const std::map<uint32_t,
                                     std::shared_ptr<graphic::Texture>> &
            getTextures() const;
 
        [[nodiscard]] const std::map<uint32_t,
                                     std::shared_ptr<graphic::Model>> &
            getModels() const;
 
        [[nodiscard]] const std::map<uint32_t,
                                     std::shared_ptr<graphic::Shader>> &
            getShaders() const;
 
        [[nodiscard]] const std::map<uint32_t,
                                     std::shared_ptr<graphic::CodePoints>> &
            getCodePoints() const;
 
        [[nodiscard]] uint64_t version() const noexcept;
 
        [[nodiscard]] uint32_t getShaderID(const std::string &shaderName) const;
 
        [[nodiscard]] uint32_t getMaterialID(const std::string &materialName);
 
        [[nodiscard]] uint32_t getDefaultMaterialID();
 
        [[nodiscard]] uint32_t getMeshMaterialID();
 
        std::shared_ptr<graphic::Font> loadFont(const std::string &path);
 
        std::shared_ptr<graphic::Font>
            loadFontFromAsset(std::shared_ptr<utility::File> fontAsset);
 
        // TODO: add loadFontsFromDirectory method to load all fonts from a
        // directory But needs to be implemented in the SystemIO first to
        // load all assets from a directory
 
        // TODO: add loadFontFamily method to load all fonts from a directory
        // But needs to be implemented in the SystemIO first to load all
        // assets from a directory
 
        std::shared_ptr<graphic::Font> loadFontFamilyFromAssets(
            const std::vector<std::shared_ptr<utility::File>> &fontAssets);
 
        std::shared_ptr<graphic::Material> loadMaterial(const std::string &path,
                                                        ShaderType shaderType);
 
        std::shared_ptr<graphic::Material>
            loadMaterialFromAsset(ShaderType shaderType,
                                  std::shared_ptr<utility::File> materialAsset);
 
        std::shared_ptr<graphic::Texture> loadTexture(const std::string &path);
 
        std::shared_ptr<graphic::Texture>
            loadTextureFromAsset(std::shared_ptr<utility::File> textureAsset);
 
        // TODO: add loadTexturesFromDirectory method to load all textures from
        // a directory But needs to be implemented in the SystemIO first to
        // load all assets from a directory
 
        std::shared_ptr<graphic::Material>
            loadImageMaterial(const std::string &path);
 
        std::shared_ptr<graphic::Model> loadModel(
            const std::string &path,
            const utility::graphic::PoseF &pose = utility::graphic::PoseF(),
            const std::string &material         = "default_material");
 
        std::shared_ptr<graphic::Model> loadModelFromAsset(
            std::shared_ptr<utility::File> modelAsset,
            const utility::graphic::PoseF &pose = utility::graphic::PoseF(),
            const std::string &material         = "default_material");
 
        std::shared_ptr<graphic::Model> loadModelFromAsset(
            std::shared_ptr<utility::File> modelAsset,
            graphic::Model::ModelType type,
            const utility::graphic::PoseF &pose = utility::graphic::PoseF(),
            const std::string &material         = "default_material");
 
        std::shared_ptr<graphic::Model> loadObj(
            const std::string &path,
            const utility::graphic::PoseF &pose = utility::graphic::PoseF(),
            const std::string &material         = "default_material");
 
        std::shared_ptr<graphic::Model> loadObjFromAsset(
            std::shared_ptr<utility::File> modelAsset,
            const utility::graphic::PoseF &pose = utility::graphic::PoseF(),
            const std::string &material         = "default_material");
 
        std::shared_ptr<graphic::Shader>
            loadShader(const std::string &vertexPath,
                       const std::string &fragmentPath);
 
        std::shared_ptr<graphic::Shader>
            loadShaderFromAssets(std::shared_ptr<utility::File> vertexAsset,
                                 std::shared_ptr<utility::File> fragmentAsset);
 
        std::shared_ptr<graphic::CodePoints>
            loadCodePoints(const std::string &path);
 
        std::shared_ptr<graphic::CodePoints> loadCodePointsFromAsset(
            std::shared_ptr<utility::File> codePointsAsset);
 
        std::unique_ptr<sound::AudioSource>
            loadAudioSource(const std::string &path);
 
        std::unique_ptr<sound::AudioSource>
            loadAudioSourceFromAsset(std::shared_ptr<utility::File> audioAsset);
 
        protected:
        std::string buildShaderPath(const std::string &vertexPath,
                                    const std::string &fragmentPath) const;
 
        void onFontAtlasCreated(const std::string &name,
                                std::shared_ptr<graphic::Texture> atlas);
 
        void registerShader(uint32_t id, const std::string &path,
                            const std::string &vertexPath,
                            std::shared_ptr<graphic::Shader> shader);
 
        uint32_t getNextID();
 
        void touch() noexcept;
 
        uint32_t _currentID = 1;
 
        uint64_t _version = 0;
 
        std::map<uint32_t, std::shared_ptr<graphic::Font>> _fonts;
 
        std::map<uint32_t, std::shared_ptr<graphic::Material>> _materials;
 
        std::map<uint32_t, std::shared_ptr<graphic::Texture>> _textures;
 
        std::map<uint32_t, std::shared_ptr<graphic::Model>> _models;
 
        std::map<uint32_t, std::shared_ptr<graphic::Shader>> _shaders;
 
        std::unordered_map<std::string, uint32_t> _shaderIDs;
 
        std::map<uint32_t, std::shared_ptr<graphic::CodePoints>> _codePoints;
 
        std::map<uint32_t, std::shared_ptr<sound::AudioBuffer>> _audioSources;
 
        std::unordered_map<std::string, uint32_t> _elementsIDs;
 
        SystemIO &_systemInterface;
 
        std::string _basePath;
 
        utility::sound::AudioManager _audioManager;
 
        private:
        std::string resolvePath(const std::string &path) const;
 
        std::shared_ptr<utility::File> loadDefaultTextureAsset();
 
        using Loggable::getLogger;
    };
}    // namespace utility