Path.h

Go to the documentation of this file.

#pragma once
#include <array>
#include <string>
#include <filesystem>
#include <ostream>
#include <string_view>
 
#include "Engine/Files/GeneratedAssetManifest.h"
 
namespace Engine::Core {
 
    template <size_t N>
    class ConstexprPath
    {
    public:
        constexpr ConstexprPath() = default;
 
        constexpr explicit ConstexprPath(const char (&literal)[N])
        {
            for (size_t i = 0; i < N; ++i) {
                path_[i] = literal[i];
            }
            length_ = N - 1;
        }
 
        [[nodiscard]] constexpr std::string_view view() const { return {path_.data(), length_}; }
 
        [[nodiscard]] std::filesystem::path fsPath() const
        {
            return std::filesystem::path(view());
        }
 
        [[nodiscard]] std::string string() const
        {
            return std::string(view());
        }
 
        [[nodiscard]] constexpr const char* c_str() const
        {
            return path_.data();
        }
 
        operator std::filesystem::path() const { return fsPath(); }
 
        template <size_t M>
        [[nodiscard]] constexpr auto operator/(const char (&other)[M]) const
        {
            constexpr size_t leftChars = N - 1;
            constexpr size_t rightChars = M - 1;
            constexpr size_t resultChars = leftChars + 1 + rightChars;
 
            ConstexprPath<resultChars + 1> result;
            size_t out = 0;
            for (size_t i = 0; i < length_; ++i) {
                result.path_[out++] = path_[i];
            }
            if (length_ > 0 && result.path_[out - 1] != '/') {
                result.path_[out++] = '/';
            }
            for (size_t i = 0; i < rightChars; ++i) {
                result.path_[out++] = other[i];
            }
            result.path_[out] = '\0';
            result.length_ = out;
            return result;
        }
 
        std::filesystem::path operator/(const std::filesystem::path & other ) const
        {
            return fsPath() / other;
        }
 
        std::filesystem::path operator/(std::string_view other) const
        {
            return fsPath() / other;
        }
 
    private:
        template <size_t>
        friend class ConstexprPath;
 
        std::array<char, N> path_{};
        size_t length_ = 0;
    };
 
    template <size_t N>
    ConstexprPath(const char (&)[N]) -> ConstexprPath<N>;
 
    template <size_t N>
    std::ostream& operator<<(std::ostream& stream, const ConstexprPath<N>& path)
    {
        return stream << path.view();
    }
 
    template <size_t N>
    [[nodiscard]] consteval bool assetExists(const ConstexprPath<N>& path)
    {
        return Assets::GeneratedAssetManifest::contains(path.view());
    }
 
    class Path {
    public:
        static std::string getEngineRoot();

        static constexpr std::string getProjectRoot();
        static constexpr auto engineGeometry() {
            return ConstexprPath( "assets/Engine/geometry/" );
        }

        static constexpr auto engineShaders() {
            return ConstexprPath( "assets/Engine/shaders/" );
        }

        static constexpr auto engineTextures() {
            return ConstexprPath( "assets/Engine/textures/" );
        }

        static constexpr auto engineFonts()
        {
            return ConstexprPath( "assets/Engine/fonts/" );
        }

        static constexpr auto engineSounds()
        {
            return ConstexprPath( "assets/Engine/sounds/" );
        }
 
        static bool doesFileExist(const std::filesystem::path &path);
        static bool doesGltfFileExist(const std::filesystem::path &path);
        static bool doesExrFileExist(const std::filesystem::path &path);
    };
 
}
 
#define CREATE_ASSET_PATH(assetPath)                                      \
    [] {                                                                  \
        constexpr auto verifiedAssetPath = (assetPath);                   \
        static_assert(::Engine::Core::assetExists(verifiedAssetPath),      \
                      "Asset path is not present in GeneratedAssetManifest"); \
        return verifiedAssetPath;                                         \
    }()