sampler.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2023  Christopher J. Howard
 *
 * This file is part of Antkeeper source code.
 *
 * Antkeeper source code is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Antkeeper source code is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Antkeeper source code.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef ANTKEEPER_GL_SAMPLER_HPP
#define ANTKEEPER_GL_SAMPLER_HPP
 
#include <engine/gl/sampler-filter.hpp>
#include <engine/gl/sampler-mipmap-mode.hpp>
#include <engine/gl/sampler-address-mode.hpp>
#include <engine/gl/compare-op.hpp>
#include <array>
 
namespace gl {
 
class sampler
{
public:
    explicit sampler
    (
        sampler_filter mag_filter = sampler_filter::linear,
        sampler_filter min_filter = sampler_filter::nearest,
        sampler_mipmap_mode mipmap_mode = sampler_mipmap_mode::linear,
        sampler_address_mode address_mode_u = sampler_address_mode::repeat,
        sampler_address_mode address_mode_v = sampler_address_mode::repeat,
        sampler_address_mode address_mode_w = sampler_address_mode::repeat,
        float mip_lod_bias = 0.0f,
        float max_anisotropy = 0.0f,
        bool compare_enabled = false,
        gl::compare_op compare_op = gl::compare_op::less,
        float min_lod = -1000.0f,
        float max_lod = 1000.0f,
        const std::array<float, 4>& border_color = {0.0f, 0.0f, 0.0f, 0.0f}
    );
    
    ~sampler();
    
    sampler(const sampler&) = delete;
    sampler(sampler&&) = delete;
    sampler& operator=(const sampler&) = delete;
    sampler& operator=(sampler&&) = delete;
    
    void set_mag_filter(sampler_filter filter);
    
    void set_min_filter(sampler_filter filter);
    
    void set_mipmap_mode(sampler_mipmap_mode mode);
    
    void set_address_mode_u(sampler_address_mode mode);
    
    void set_address_mode_v(sampler_address_mode mode);
    
    void set_address_mode_w(sampler_address_mode mode);
    
    void set_mip_lod_bias(float bias);
    
    void set_max_anisotropy(float anisotropy);
    
    void set_compare_enabled(bool enabled);
    
    void set_compare_op(gl::compare_op op);
    
    void set_min_lod(float lod);
    
    void set_max_lod(float lod);
    
    void set_border_color(const std::array<float, 4>& color);
    
    [[nodiscard]] inline constexpr sampler_filter get_mag_filter() const noexcept
    {
        return m_mag_filter;
    }
    
    [[nodiscard]] inline constexpr sampler_filter get_min_filter() const noexcept
    {
        return m_min_filter;
    }
    
    [[nodiscard]] inline constexpr sampler_mipmap_mode get_mipmap_mode() const noexcept
    {
        return m_mipmap_mode;
    }
    
    [[nodiscard]] inline constexpr sampler_address_mode get_address_mode_u() const noexcept
    {
        return m_address_mode_u;
    }
    
    [[nodiscard]] inline constexpr sampler_address_mode get_address_mode_v() const noexcept
    {
        return m_address_mode_v;
    }
    
    [[nodiscard]] inline constexpr sampler_address_mode get_address_mode_w() const noexcept
    {
        return m_address_mode_w;
    }
    
    [[nodiscard]] inline constexpr float get_mip_lod_bias() const noexcept
    {
        return m_mip_lod_bias;
    }
    
    [[nodiscard]] inline constexpr float get_max_anisotropy() const noexcept
    {
        return m_max_anisotropy;
    }
    
    [[nodiscard]] inline constexpr float get_compare_enabled() const noexcept
    {
        return m_compare_enabled;
    }
    
    [[nodiscard]] inline constexpr compare_op get_compare_op() const noexcept
    {
        return m_compare_op;
    }
    
    [[nodiscard]] inline constexpr float get_min_lod() const noexcept
    {
        return m_min_lod;
    }
    
    [[nodiscard]] inline constexpr float get_max_lod() const noexcept
    {
        return m_max_lod;
    }
    
    [[nodiscard]] inline constexpr const std::array<float, 4>& get_border_color() const noexcept
    {
        return m_border_color;
    }
 
private:
    friend class pipeline;
    friend class gl_shader_texture_1d;
    friend class gl_shader_texture_2d;
    friend class gl_shader_texture_3d;
    friend class gl_shader_texture_cube;
    
    unsigned int m_gl_named_sampler{0};
    
    sampler_filter m_mag_filter{sampler_filter::linear};
    sampler_filter m_min_filter{sampler_filter::nearest};
    sampler_mipmap_mode m_mipmap_mode{sampler_mipmap_mode::linear};
    sampler_address_mode m_address_mode_u{sampler_address_mode::repeat};
    sampler_address_mode m_address_mode_v{sampler_address_mode::repeat};
    sampler_address_mode m_address_mode_w{sampler_address_mode::repeat};
    float m_mip_lod_bias{0.0f};
    float m_max_anisotropy{0.0f};
    bool m_compare_enabled{false};
    gl::compare_op m_compare_op{gl::compare_op::less};
    float m_min_lod{-1000.0f};
    float m_max_lod{1000.0f};
    std::array<float, 4> m_border_color{0.0f, 0.0f, 0.0f, 0.0f};
};
 
} // namespace gl
 
#endif // ANTKEEPER_GL_SAMPLER_HPP