texture.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "gl_functions.hpp"
#include "utility.hpp"
 
#include <cstdint>
#include <span>
#include <concepts>
 
namespace staplegl {
 
struct texture_color {
    std::int32_t internal_format {};
    std::uint32_t format {};
    std::uint32_t datatype {};
};
 
struct texture_filter {
    std::int32_t min_filter {};
    std::int32_t mag_filter {};
    std::int32_t clamping {};
};
 
struct texture_antialias {
    std::uint32_t type {};
    tex_samples samples {};
};
 
 
 
static constexpr auto
to_mipmap(std::int32_t filter_type) -> std::int32_t
{
    switch (filter_type) {
    case GL_NEAREST:
    case GL_NEAREST_MIPMAP_NEAREST:
        return GL_NEAREST_MIPMAP_NEAREST;
    case GL_LINEAR:
    case GL_LINEAR_MIPMAP_LINEAR:
        return GL_LINEAR_MIPMAP_LINEAR;
    default:
        return 0;
    }
}
 
class texture_2d {
public:
    texture_2d() = default;
 
    template <typename T>
        requires std::integral<T> || std::floating_point<T>
    texture_2d(std::span<const T> data, resolution res,
        texture_color color, texture_filter filters,
        tex_samples samples = tex_samples::MSAA_X1,
        bool generate_mipmap = false) noexcept;
 
    ~texture_2d()
    {
        if (m_id != 0) {
            glDeleteTextures(1, &m_id);
        }
    }
 
    // delete copy and copy assignment operators
 
    texture_2d(const texture_2d&) = delete;
    auto operator=(const texture_2d&) -> texture_2d& = delete;
 
 
 
    texture_2d(texture_2d&& other) noexcept
        : m_id(other.m_id)
        , m_unit(other.m_unit)
        , m_color(other.m_color)
        , m_resolution(other.m_resolution)
        , m_antialias(other.m_antialias)
    {
        other.m_id = 0;
    }
 
    auto operator=(texture_2d&& other) noexcept -> texture_2d&
    {
        if (this != &other) {
            m_id = other.m_id;
            m_unit = other.m_unit;
            m_color = other.m_color;
            m_resolution = other.m_resolution;
            m_antialias = other.m_antialias;
            other.m_id = 0;
        }
        return *this;
    }
 
    void set_unit(std::uint32_t unit_offset)
    {
        m_unit = unit_offset;
        glActiveTexture(GL_TEXTURE0 + unit_offset);
        bind();
    }
 
    void set_data(std::span<const float> data, resolution res,
        texture_color color, bool generate_mipmap = false);
 
    void bind() const
    {
        glBindTexture(m_antialias.type, m_id);
    }
 
    void unbind() const
    {
        glBindTexture(m_antialias.type, 0);
    }
    [[nodiscard]] auto constexpr get_unit() const -> uint32_t
    {
        return m_unit;
    }
 
    [[nodiscard]] constexpr auto color() const -> texture_color
    {
        return m_color;
    }
 
    [[nodiscard]] constexpr  auto id() const -> std::uint32_t
    {
        return m_id;
    }
 
    [[nodiscard]] constexpr  auto get_resolution() const -> staplegl::resolution
    {
        return m_resolution;
    };
 
    [[nodiscard]] constexpr  auto filter() const -> texture_filter
    {
        return m_filter;
    }
 
    [[nodiscard]] constexpr  auto antialias() const -> texture_antialias
    {
        return m_antialias;
    }
 
 
 
private:
    std::uint32_t m_id {};
    std::uint32_t m_unit {};
    texture_color m_color {};
    texture_filter m_filter {};
    resolution m_resolution {};
    texture_antialias m_antialias {};
};
 
template <typename T>
    requires std::integral<T> || std::floating_point<T>
inline texture_2d::texture_2d(std::span<const T> data, resolution res,
    texture_color color, texture_filter filter, tex_samples samples, bool generate_mipmap) noexcept
    : m_color { color }
    , m_filter { filter }
    , m_resolution { res }
    , m_antialias { (samples == tex_samples::MSAA_X1) ? texture_antialias { GL_TEXTURE_2D, samples } : texture_antialias { GL_TEXTURE_2D_MULTISAMPLE, samples } }
{
    glGenTextures(1, &m_id);
    glBindTexture(m_antialias.type, m_id);
 
    if (m_antialias.type == GL_TEXTURE_2D) {
        glTexParameteri(m_antialias.type, GL_TEXTURE_MIN_FILTER, generate_mipmap ? to_mipmap(filter.min_filter) : filter.min_filter);
        glTexParameteri(m_antialias.type, GL_TEXTURE_MAG_FILTER, filter.mag_filter);
        glTexParameteri(m_antialias.type, GL_TEXTURE_WRAP_S, filter.clamping);
        glTexParameteri(m_antialias.type, GL_TEXTURE_WRAP_T, filter.clamping);
 
        glTexImage2D(m_antialias.type, 0, color.internal_format, m_resolution.width, m_resolution.height, 0, color.format, color.datatype, data.data());
    } else if (m_antialias.type == GL_TEXTURE_2D_MULTISAMPLE) {
        glTexImage2DMultisample(m_antialias.type, m_antialias.samples, color.internal_format,
            m_resolution.width, m_resolution.height, GL_TRUE);
    }
 
    if (generate_mipmap) {
        glGenerateMipmap(m_antialias.type);
    }
 
    glBindTexture(m_antialias.type, 0);
}
 
inline void texture_2d::set_data(std::span<const float> data, resolution res, texture_color color, bool generate_mipmap)
{
 
    if(m_antialias.type == GL_TEXTURE_2D_MULTISAMPLE) {
      return;
    }
 
    glTexImage2D(m_antialias.type, 0, m_color.internal_format, res.width, res.height, 0, m_color.format, m_color.datatype, data.data());
    m_color = color;
    m_resolution = res;
 
    if (generate_mipmap) {
        glGenerateMipmap(m_antialias.type);
    }
}
 
} // namespace staplegl