utils.hpp

Go to the documentation of this file.

#pragma once

#include <filesystem>
#include <functional>
#include <thread>

#include <magic_enum/magic_enum.hpp>

#include <Maths/quaternion.hpp>
#include <Maths/vector2.hpp>
#include <Maths/vector3.hpp>

#include "Mountain/core.hpp"

#include "Mountain/utils/concepts.hpp"
#include "Mountain/utils/meta_programming.hpp"
#include "Mountain/utils/pointer.hpp"


#define TO_STRING(x) #x
#define STRINGIFY(x) TO_STRING(x)

namespace Mountain::Utils
{
    enum class TrimOptions : uint8_t
    {
        None    = 0,
        Start   = 1 << 0,
        End     = 1 << 1,
        Both    = Start | End
    };

    template <typename T>
    using ProjectionFunc = T(*)(T);

    template <typename T>
    constexpr ProjectionFunc<T> Identity = [](T t) { return t; };

    template <typename PtrT, Concepts::IntegralT IntT>
    [[nodiscard]]
    constexpr PtrT* IntToPointer(IntT number);

    template <typename T>
    [[nodiscard]]
    size_t GetTypeHash();

    template <typename T>
    [[nodiscard]]
    size_t GetTypeHash(const T* ptr);

    MOUNTAIN_API void AlignImGuiCursor(float_t objectWidth, float_t alignment = 0.5f);

    [[nodiscard]]
    MOUNTAIN_API std::string HumanizeString(const std::string& str);

    [[nodiscard]]
    MOUNTAIN_API std::string HumanizeVariableName(const std::string& str);

    [[nodiscard]]
    MOUNTAIN_API constexpr std::string RemoveNamespaces(const std::string& str);

#ifndef SWIG
    [[nodiscard]]
    MOUNTAIN_API constexpr const char_t* RemoveNamespaces(const char_t* str);
#endif

    [[nodiscard]]
    MOUNTAIN_API constexpr float_t RemapValue(float_t oldValue, Vector2 oldRange, Vector2 newRange);

    [[nodiscard]]
    MOUNTAIN_API constexpr size_t RemapValue(size_t oldValue, Vector2i oldRange, Vector2i newRange);

    MOUNTAIN_API float_t NormalizeAngle(float_t angle);

    MOUNTAIN_API Vector3 NormalizeAngles(Vector3 angles);

    MOUNTAIN_API Vector3 GetQuaternionEulerAngles(const Quaternion& rot);

    template <typename T, typename U>
    [[nodiscard]]
    Pointer<T> DynamicPointerCast(const Pointer<U>& value);

    MOUNTAIN_API void OpenInExplorer(const std::filesystem::path& path);

    MOUNTAIN_API void OpenInExplorer(const std::filesystem::path& path, bool_t isFile);

    MOUNTAIN_API void OpenFile(const std::filesystem::path& filepath);

    template <std::ranges::input_range Container, typename T>
    [[nodiscard]]
    bool_t ArrayContains(const Container& container, T element);

    template <std::ranges::input_range Container>
    [[nodiscard]]
    bool_t StringArrayContains(const Container& container, const std::string& element);

    [[nodiscard]]
    MOUNTAIN_API bool_t StringEqualsIgnoreCase(std::string_view a, std::string_view b);

    [[nodiscard]]
    MOUNTAIN_API bool_t StringContainsIgnoreCase(std::string_view a, std::string_view b);

    template <typename Ret, typename... Args>
    [[nodiscard]]
    constexpr size_t FunctionAddress(std::function<Ret(Args...)> f);

    MOUNTAIN_API int32_t TerminalCommand(const std::string& command, bool_t asynchronous = true);

    MOUNTAIN_API void CreateEmptyFile(const std::filesystem::path& path);

    MOUNTAIN_API void SetThreadName(std::thread& thread, const std::wstring& name);

    template <typename R, typename... Args>
    R CallSafe(const std::function<R(Args...)>& function, Args&&... args);

    MOUNTAIN_API std::wstring NarrowToWide(std::string_view str);

    MOUNTAIN_API std::string WideToNarrow(std::wstring_view str);

    MOUNTAIN_API std::string ToLower(std::string_view str);

    MOUNTAIN_API std::string ToUpper(std::string_view str);

    MOUNTAIN_API std::pair<float_t, std::string_view> ByteSizeUnit(int64_t size);

    MOUNTAIN_API std::string GetBuiltinShadersPath();

    MOUNTAIN_API std::string GetBuiltinAssetsPath();

    MOUNTAIN_API std::string Trim(std::string_view str, TrimOptions options = TrimOptions::Both);

    MOUNTAIN_API std::string GetLine(const std::string& str, size_t lineIndex);

    MOUNTAIN_API uint16_t Concat16(uint8_t right, uint8_t left);

    MOUNTAIN_API uint32_t Concat32(uint8_t right0, uint8_t right1, uint8_t left0, uint8_t left1);

    template <uint64_t Offset, uint64_t Count>
    constexpr uint64_t GetBits(const uint64_t value);

    template <Concepts::EnumT T>
    constexpr Meta::Flags<T> ToFlags(T enumValue);
}

namespace Easing
{
    enum class Type : uint8_t
    {
        Linear,

        SineIn,
        SineOut,
        SineInOut,

        QuadIn,
        QuadOut,
        QuadInOut,

        CubicIn,
        CubicOut,
        CubicInOut,

        QuartIn,
        QuartOut,
        QuartInOut,

        QuintIn,
        QuintOut,
        QuintInOut,

        ExpoIn,
        ExpoOut,
        ExpoInOut,

        CircIn,
        CircOut,
        CircInOut,

        BackIn,
        BackOut,
        BackInOut,

        ElasticIn,
        ElasticOut,
        ElasticInOut,

        BounceIn,
        BounceOut,
        BounceInOut
    };
}

ENUM_FLAGS(Mountain::Utils::TrimOptions)

#include "Mountain/utils/utils.inl"