limits.h

// © Joseph Cameron - MIT License
 
#ifndef GDK_GRAPHICS_LIMITS_H
#define GDK_GRAPHICS_LIMITS_H
 
#include <cstddef>
#include <limits>
 
namespace gdk::graphics {
    struct limits final {
        static constexpr std::size_t UNRESTRICTED = std::numeric_limits<std::size_t>::max();

        std::size_t texture_size = UNRESTRICTED;

        bool non_power_of_two_textures = true;

        std::size_t vertex_uniform_vectors = UNRESTRICTED;

        std::size_t fragment_uniform_vectors = UNRESTRICTED;

        std::size_t texture_units = UNRESTRICTED;

        std::size_t vertex_texture_units = UNRESTRICTED;

        std::size_t vertex_attributes = UNRESTRICTED;

        std::size_t varying_vectors = UNRESTRICTED;
 
        [[nodiscard]] bool operator==(const limits &) const = default;
    };

    [[nodiscard]] constexpr limits narrowest(const limits &aA, const limits &aB) {
        const auto least = [](const std::size_t aX, const std::size_t aY) { return aX < aY ? aX : aY; };
 
        limits out;
        out.texture_size = least(aA.texture_size, aB.texture_size);
        out.non_power_of_two_textures = aA.non_power_of_two_textures && aB.non_power_of_two_textures;
        out.vertex_uniform_vectors = least(aA.vertex_uniform_vectors, aB.vertex_uniform_vectors);
        out.fragment_uniform_vectors = least(aA.fragment_uniform_vectors, aB.fragment_uniform_vectors);
        out.texture_units = least(aA.texture_units, aB.texture_units);
        out.vertex_texture_units = least(aA.vertex_texture_units, aB.vertex_texture_units);
        out.vertex_attributes = least(aA.vertex_attributes, aB.vertex_attributes);
        out.varying_vectors = least(aA.varying_vectors, aB.varying_vectors);
 
        return out;
    }
}
 
#endif