pipeline.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_PIPELINE_HPP
#define ANTKEEPER_GL_PIPELINE_HPP
 
#include <engine/gl/pipeline-viewport-state.hpp>
#include <engine/gl/pipeline-rasterization-state.hpp>
#include <engine/gl/pipeline-depth-stencil-state.hpp>
#include <engine/gl/pipeline-input-assembly-state.hpp>
#include <engine/gl/pipeline-vertex-input-state.hpp>
#include <engine/gl/pipeline-color-blend-state.hpp>
#include <engine/gl/vertex-array.hpp>
#include <engine/gl/vertex-buffer.hpp>
#include <engine/gl/clear-value.hpp>
#include <engine/gl/framebuffer.hpp>
#include <engine/gl/shader-program.hpp>
#include <engine/gl/clear-bits.hpp>
#include <engine/gl/stencil-face-bits.hpp>
#include <array>
#include <cstdint>
#include <span>
 
namespace app { class sdl_window_manager; }
 
namespace gl {
 
class pipeline
{
public:
    pipeline();
    
    
    // void set_vertex_input(std::span<const vertex_input_binding> vertex_bindings, std::span<const vertex_input_attribute> vertex_attributes);
    
    void bind_framebuffer(const gl::framebuffer* framebuffer);
    void bind_shader_program(const gl::shader_program* shader_program);
    
    void bind_vertex_array(const vertex_array* array);
    
    void bind_vertex_buffers(std::uint32_t first_binding, std::span<const vertex_buffer* const> buffers, std::span<const std::size_t> offsets, std::span<const std::size_t> strides);
    
    
    
    void set_primitive_topology(primitive_topology topology);
    
    void set_primitive_restart_enabled(bool enabled);
    
    
    
    void set_viewport(std::uint32_t first_viewport, std::span<const viewport> viewports);
    
    void set_scissor(std::uint32_t first_scissor, std::span<const scissor_region> scissors);
    
    
    
    void set_rasterizer_discard_enabled(bool enabled);
    
    void set_fill_mode(fill_mode mode);
    
    void set_cull_mode(cull_mode mode);
    
    void set_front_face(front_face face);
    
    void set_depth_bias_enabled(bool enabled);
    
    void set_depth_bias_factors(float constant_factor, float slope_factor);
    
    void set_depth_clamp_enabled(bool enabled);
    
    void set_scissor_test_enabled(bool enabled);
    
    void set_provoking_vertex_mode(provoking_vertex_mode mode);
    
    void set_point_size(float size);
    
    void set_line_width(float width);
    
    
    
    void set_depth_test_enabled(bool enabled);
    
    void set_depth_write_enabled(bool enabled);
    
    void set_depth_compare_op(gl::compare_op compare_op);
    
    void set_stencil_test_enabled(bool enabled);
    
    void set_stencil_op(std::uint8_t face_mask, stencil_op fail_op, stencil_op pass_op, stencil_op depth_fail_op, gl::compare_op compare_op);
    
    void set_stencil_compare_mask(std::uint8_t face_mask, std::uint32_t compare_mask);
    
    void set_stencil_reference(std::uint8_t face_mask, std::uint32_t reference);
    
    void set_stencil_write_mask(std::uint8_t face_mask, std::uint32_t write_mask);
    
    
    
    void set_logic_op_enabled(bool enabled);
    
    void set_logic_op(gl::logic_op logic_op);
    
    void set_color_blend_enabled(bool enabled);
    
    void set_color_blend_equation(const color_blend_equation& equation);
    
    void set_color_write_mask(std::uint8_t mask);
    
    void set_blend_constants(const std::array<float, 4>& blend_constants);
    
    
    
    void draw(std::uint32_t vertex_count, std::uint32_t instance_count, std::uint32_t first_vertex, std::uint32_t first_instance);
    
    void draw_indexed(std::uint32_t index_count, std::uint32_t instance_count, std::uint32_t first_index, std::int32_t vertex_offset, std::uint32_t first_instance);
    
    
    
    void clear_attachments(std::uint8_t mask, const clear_value& value);
    
    
    
    [[nodiscard]] inline constexpr const std::array<std::uint32_t, 2>& get_default_framebuffer_dimensions() const noexcept
    {
        return m_default_framebuffer_dimensions;
    }
    
    [[nodiscard]] inline constexpr std::uint32_t get_max_viewports() const noexcept
    {
        return m_max_viewports;
    }
    
    [[nodiscard]] inline constexpr float get_max_sampler_anisotropy() const noexcept
    {
        return m_max_sampler_anisotropy;
    }
    
    
private:
    friend class app::sdl_window_manager;
    
    void defaut_framebuffer_resized(std::uint32_t width, std::uint32_t height) noexcept;
    
    void fetch_vertex_input_state();
    void fetch_input_assembly_state();
    void fetch_viewport_state();
    void fetch_rasterization_state();
    void fetch_depth_stencil_state();
    void fetch_color_blend_state();
    void fetch_clear_value();
    
    std::uint32_t m_max_viewports{1};
    float m_max_sampler_anisotropy{0.0f};
    std::array<std::uint32_t, 2> m_default_framebuffer_dimensions{0, 0};
    
    pipeline_vertex_input_state m_vertex_input_state;
    pipeline_input_assembly_state m_input_assembly_state;
    pipeline_viewport_state m_viewport_state;
    pipeline_rasterization_state m_rasterization_state;
    pipeline_depth_stencil_state m_depth_stencil_state;
    pipeline_color_blend_state m_color_blend_state;
    clear_value m_clear_value;
    
    const framebuffer* m_framebuffer{};
    const shader_program* m_shader_program{};
    const vertex_array* m_vertex_array{};
};
 
} // namespace gl
 
#endif // ANTKEEPER_GL_PIPELINE_HPP