pipeline.cpp

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/>.
 */
 
#include <engine/gl/pipeline.hpp>
#include <engine/gl/clear-bits.hpp>
#include <engine/gl/stencil-face-bits.hpp>
#include <engine/gl/color-component-bits.hpp>
#include <engine/debug/log.hpp>
#include <glad/gl.h>
#include <algorithm>
#include <stdexcept>
#include <bit>
 
namespace {
 
    static constexpr GLenum stencil_face_lut[] =
    {
        GL_NONE,          // 0
        GL_FRONT,         // stencil_face_front_bit
        GL_BACK,          // stencil_face_back_bit
        GL_FRONT_AND_BACK // stencil_face_front_and_back
    };
    
    static constexpr GLenum stencil_op_lut[] =
    {
        GL_KEEP,      // stencil_op::keep
        GL_ZERO,      // stencil_op::zero
        GL_REPLACE,   // stencil_op::replace
        GL_INCR,      // stencil_op::increment_and_clamp
        GL_DECR,      // stencil_op::decrement_and_clamp
        GL_INVERT,    // stencil_op::invert
        GL_INCR_WRAP, // stencil_op::increment_and_wrap
        GL_DECR_WRAP  // stencil_op::decrement_and_wrap
    };
    
    static constexpr GLenum compare_op_lut[] =
    {
        GL_NEVER,    // compare_op::never
        GL_LESS,     // compare_op::less
        GL_EQUAL,    // compare_op::equal
        GL_LEQUAL,   // compare_op::less_or_equal
        GL_GREATER,  // compare_op::greater
        GL_NOTEQUAL, // compare_op::not_equal
        GL_GEQUAL,   // compare_op::greater_or_equal
        GL_ALWAYS    // compare_op::always
    };
    
    static constexpr GLenum provoking_vertex_mode_lut[] =
    {
        GL_FIRST_VERTEX_CONVENTION, // provoking_vertex_mode::first
        GL_LAST_VERTEX_CONVENTION   // provoking_vertex_mode::last
    };
    
    static constexpr GLenum primitive_topology_lut[] =
    {
        GL_POINTS,                   // primitive_topology::point_list
        GL_LINES,                    // primitive_topology::line_list
        GL_LINE_STRIP,               // primitive_topology::line_strip,
        GL_TRIANGLES,                // primitive_topology::triangle_list
        GL_TRIANGLE_STRIP,           // primitive_topology::triangle_strip
        GL_TRIANGLE_FAN,             // primitive_topology::triangle_fan
        GL_LINES_ADJACENCY,          // primitive_topology::line_list_with_adjacency
        GL_LINE_STRIP_ADJACENCY,     // primitive_topology::line_strip_with_adjacency
        GL_TRIANGLES_ADJACENCY,      // primitive_topology::triangle_list_with_adjacency
        GL_TRIANGLE_STRIP_ADJACENCY, // primitive_topology::triangle_strip_with_adjacency
        GL_PATCHES                   // primitive_topology::patch_list
    };
    
    static constexpr GLenum logic_op_lut[] =
    {
        GL_CLEAR        , // logic_op::bitwise_clear
        GL_AND          , // logic_op::bitwise_and
        GL_AND_REVERSE  , // logic_op::bitwise_and_reverse
        GL_COPY         , // logic_op::bitwise_copy
        GL_AND_INVERTED , // logic_op::bitwise_and_inverted
        GL_NOOP         , // logic_op::bitwise_no_op
        GL_XOR          , // logic_op::bitwise_xor
        GL_OR           , // logic_op::bitwise_or
        GL_NOR          , // logic_op::bitwise_nor
        GL_EQUIV        , // logic_op::bitwise_equivalent
        GL_INVERT       , // logic_op::bitwise_invert
        GL_OR_REVERSE   , // logic_op::bitwise_or_reverse
        GL_COPY_INVERTED, // logic_op::bitwise_copy_inverted
        GL_OR_INVERTED  , // logic_op::bitwise_or_inverted
        GL_NAND         , // logic_op::bitwise_nand
        GL_SET            // logic_op::bitwise_set
    };
 
    static constexpr GLenum blend_factor_lut[] =
    {
        GL_ZERO                    , // blend_factor::zero
        GL_ONE                     , // blend_factor::one
        GL_SRC_COLOR               , // blend_factor::src_color
        GL_ONE_MINUS_SRC_COLOR     , // blend_factor::one_minus_src_color
        GL_DST_COLOR               , // blend_factor::dst_color
        GL_ONE_MINUS_DST_COLOR     , // blend_factor::one_minus_dst_color
        GL_SRC_ALPHA               , // blend_factor::src_alpha
        GL_ONE_MINUS_SRC_ALPHA     , // blend_factor::one_minus_src_alpha
        GL_DST_ALPHA               , // blend_factor::dst_alpha
        GL_ONE_MINUS_DST_ALPHA     , // blend_factor::one_minus_dst_alpha
        GL_CONSTANT_COLOR          , // blend_factor::constant_color
        GL_ONE_MINUS_CONSTANT_COLOR, // blend_factor::one_minus_constant_color
        GL_CONSTANT_ALPHA          , // blend_factor::constant_alpha
        GL_ONE_MINUS_CONSTANT_ALPHA, // blend_factor::one_minus_constant_alpha
        GL_SRC_ALPHA_SATURATE      , // blend_factor::src_alpha_saturate
        GL_SRC1_COLOR              , // blend_factor::src1_color
        GL_ONE_MINUS_SRC1_COLOR    , // blend_factor::one_minus_src1_color
        GL_SRC1_ALPHA              , // blend_factor::src1_alpha
        GL_ONE_MINUS_SRC1_ALPHA      // blend_factor::one_minus_src1_alpha
    };
    
    static constexpr GLenum blend_op_lut[] =
    {
        GL_FUNC_ADD             , // blend_op::add
        GL_FUNC_SUBTRACT        , // blend_op::subtract
        GL_FUNC_REVERSE_SUBTRACT, // blend_op::reverse_subtract
        GL_MIN                  , // blend_op::min
        GL_MAX                    // blend_op::max
    };
    
    void gl_debug_message_callback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message, const void* user_param)
    {
        const auto src_str = [source]() -> const char*
        {
            switch (source)
            {
                case GL_DEBUG_SOURCE_API:
                    return "API";
                case GL_DEBUG_SOURCE_WINDOW_SYSTEM:
                    return "window system";
                case GL_DEBUG_SOURCE_SHADER_COMPILER:
                    return "shader compiler";
                case GL_DEBUG_SOURCE_THIRD_PARTY:
                    return "third party";
                case GL_DEBUG_SOURCE_APPLICATION:
                    return "application";
                case GL_DEBUG_SOURCE_OTHER:
                default:
                    return "other";
            }
        }();
        
        const auto type_str = [type]() -> const char*
        {
            switch (type)
            {
                case GL_DEBUG_TYPE_ERROR:
                    return "error";
                case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR:
                    return "deprecated behavior";
                case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR:
                    return "undefined behavior";
                case GL_DEBUG_TYPE_PORTABILITY:
                    return "portability";
                case GL_DEBUG_TYPE_PERFORMANCE:
                    return "performance";
                case GL_DEBUG_TYPE_MARKER:
                    return "marker";
                case GL_DEBUG_TYPE_OTHER:
                default:
                    return "message";
            }
        }();
        
        const auto severity_str = [severity]() -> const char*
        {
            switch (severity)
            {
                case GL_DEBUG_SEVERITY_LOW:
                    return "low severity";
                case GL_DEBUG_SEVERITY_MEDIUM:
                    return "medium severity";
                case GL_DEBUG_SEVERITY_HIGH:
                    return "high severity";
                case GL_DEBUG_SEVERITY_NOTIFICATION:
                default:
                    return "notification";
            }
        }();
        
        switch (type)
        {
            case GL_DEBUG_TYPE_ERROR:
            {
                std::string formatted_message;
                std::format_to(std::back_inserter(formatted_message), "OpenGL {} {} ({}) {}: {}", src_str, type_str, severity_str, id, message);
                debug::log_fatal("{}", formatted_message);
                throw std::runtime_error(formatted_message);
                break;
            }
            
            case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR:
            case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR:
                debug::log_error("OpenGL {} {} ({}) {}: {}", src_str, type_str, severity_str, id, message);
                break;
            
            case GL_DEBUG_TYPE_PORTABILITY:
            case GL_DEBUG_TYPE_PERFORMANCE:
                debug::log_warning("OpenGL {} {} ({}) {}: {}", src_str, type_str, severity_str, id, message);
                break;
            
            case GL_DEBUG_TYPE_MARKER:
            case GL_DEBUG_TYPE_OTHER:
            default:
                debug::log_debug("OpenGL {} {} ({}) {}: {}", src_str, type_str, severity_str, id, message);
                break;
        }
    }
}
 
namespace gl {
 
pipeline::pipeline()
{
    #if defined(DEBUG)
        glEnable(GL_DEBUG_OUTPUT);
        glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
        glDebugMessageCallback(gl_debug_message_callback, nullptr);
    #endif
    
    // Fetch limitations
    glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &m_max_sampler_anisotropy);
    
    // Fetch dimensions of default framebuffer
    GLint gl_scissor_box[4] = {0, 0, 0, 0};
    glGetIntegerv(GL_SCISSOR_BOX, gl_scissor_box);
    m_default_framebuffer_dimensions[0] = static_cast<std::uint32_t>(gl_scissor_box[2]);
    m_default_framebuffer_dimensions[1] = static_cast<std::uint32_t>(gl_scissor_box[3]);
    
    // Enable seamless cubemap filtering
    glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
    
    // Set clip control to lower left, 0 to 1
    glClipControl(GL_LOWER_LEFT, GL_ZERO_TO_ONE);
    
    // Disable multisampling
    glDisable(GL_MULTISAMPLE);
    
    // Set byte-alignment for packing and unpacking pixel rows
    glPixelStorei(GL_PACK_ALIGNMENT, 1);
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    
    // Fetch pipeline state
    fetch_vertex_input_state();
    fetch_input_assembly_state();
    fetch_viewport_state();
    fetch_rasterization_state();
    fetch_depth_stencil_state();
    fetch_color_blend_state();
    fetch_clear_value();
}
 
// void pipeline::set_vertex_input(std::span<const vertex_input_binding> vertex_bindings, std::span<const vertex_input_attribute> vertex_attributes)
// {
    // m_vertex_input_state.vertex_bindings.assign(vertex_bindings.begin(), vertex_bindings.end());
    // m_vertex_input_state.vertex_attributes.assign(vertex_attributes.begin(), vertex_attributes.end());
// }
 
void pipeline::bind_framebuffer(const gl::framebuffer* framebuffer)
{
    if (m_framebuffer != framebuffer)
    {
        m_framebuffer = framebuffer;
        
        if (m_framebuffer)
        {
            glBindFramebuffer(GL_FRAMEBUFFER, m_framebuffer->m_gl_named_framebuffer);
        }
        else
        {
            glBindFramebuffer(GL_FRAMEBUFFER, 0);
        }
    }
}
 
void pipeline::bind_shader_program(const gl::shader_program* shader_program)
{
    if (m_shader_program != shader_program)
    {
        m_shader_program = shader_program;
        
        if (m_shader_program)
        {
            glUseProgram(m_shader_program->gl_program_id);
        }
        else
        {
            glUseProgram(0);
        }
    }
}
 
void pipeline::bind_vertex_array(const vertex_array* array)
{
    if (m_vertex_array != array)
    {
        m_vertex_array = array;
        
        if (m_vertex_array)
        {
            glBindVertexArray(m_vertex_array->m_gl_named_array);
        }
        else
        {
            glBindVertexArray(0);
        }
    }
}
 
void pipeline::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)
{
    if (!m_vertex_array)
    {
        throw std::runtime_error("Failed to bind vertex buffer: no vertex array bound.");
    }
    
    if (offsets.size() < buffers.size())
    {
        throw std::out_of_range("Vertex binding offset out of range.");
    }
    
    if (strides.size() < buffers.size())
    {
        throw std::out_of_range("Vertex binding stride out of range.");
    }
    
    for (std::size_t i = 0; i < buffers.size(); ++i)
    {
        glVertexArrayVertexBuffer
        (
            m_vertex_array->m_gl_named_array,
            static_cast<GLuint>(first_binding + i),
            buffers[i]->m_gl_named_buffer,
            static_cast<GLintptr>(offsets[i]),
            static_cast<GLsizei>(strides[i])
        );
    }
}
 
void pipeline::set_primitive_topology(primitive_topology topology)
{
    if (m_input_assembly_state.topology != topology)
    {
        m_input_assembly_state.topology = topology;
    }
}
 
void pipeline::set_primitive_restart_enabled(bool enabled)
{
    if (m_input_assembly_state.primitive_restart_enabled != enabled)
    {
        if (enabled)
        {
            glEnable(GL_PRIMITIVE_RESTART_FIXED_INDEX);
        }
        else
        {
            glDisable(GL_PRIMITIVE_RESTART_FIXED_INDEX);
        }
        
        m_input_assembly_state.primitive_restart_enabled = enabled;
    }
}
 
void pipeline::set_viewport(std::uint32_t first_viewport, std::span<const gl::viewport> viewports)
{
    // Bounds check
    if (first_viewport + viewports.size() > m_max_viewports)
    {
        throw std::out_of_range("Viewport index out of range.");
    }
    
    // Ignore empty commands
    if (!viewports.size())
    {
        return;
    }
    
    const auto& active_viewport = m_viewport_state.viewports.front();
    const auto& viewport = viewports.front();
    
    // Update viewport position and dimensions
    if (active_viewport.width != viewport.width ||
        active_viewport.height != viewport.height ||
        active_viewport.x != viewport.x ||
        active_viewport.y != viewport.y)
    {
        glViewport
        (
            static_cast<GLint>(viewport.x),
            static_cast<GLint>(viewport.y),
            std::max(0, static_cast<GLsizei>(viewport.width)),
            std::max(0, static_cast<GLsizei>(viewport.height))
        );
    }
    
    // Update viewport depth range
    if (active_viewport.min_depth != viewport.min_depth ||
        active_viewport.max_depth != viewport.max_depth)
    {
        glDepthRange(viewport.min_depth, viewport.max_depth);
    }
    
    // Update viewport state
    std::copy(viewports.begin(), viewports.end(), m_viewport_state.viewports.begin() + first_viewport);
}
 
void pipeline::set_scissor(std::uint32_t first_scissor, std::span<const gl::scissor_region> scissors)
{
    // Bounds check
    if (first_scissor + scissors.size() > m_max_viewports)
    {
        throw std::out_of_range("Scissor region index out of range.");
    }
    
    // Ignore empty commands
    if (scissors.empty())
    {
        return;
    }
    
    const auto& active_scissor = m_viewport_state.scissors.front();
    const auto& scissor = scissors.front();
    
    // Update scissor region
    if (active_scissor.width != scissor.width ||
        active_scissor.height != scissor.height ||
        active_scissor.x != scissor.x ||
        active_scissor.y != scissor.y)
    {
        glScissor
        (
            static_cast<GLint>(scissor.x),
            static_cast<GLint>(scissor.y),
            std::max(0, static_cast<GLsizei>(scissor.width)),
            std::max(0, static_cast<GLsizei>(scissor.height))
        );
    }
    
    // Update viewport state
    std::copy(scissors.begin(), scissors.end(), m_viewport_state.scissors.begin() + first_scissor);
}
 
void pipeline::set_rasterizer_discard_enabled(bool enabled)
{
    if (m_rasterization_state.rasterizer_discard_enabled != enabled)
    {
        if (enabled)
        {
            glEnable(GL_RASTERIZER_DISCARD);
        }
        else
        {
            glDisable(GL_RASTERIZER_DISCARD);
        }
        
        m_rasterization_state.rasterizer_discard_enabled = enabled;
    }
}
 
void pipeline::set_fill_mode(fill_mode mode)
{
    if (m_rasterization_state.fill_mode != mode)
    {
        switch (mode)
        {
            case fill_mode::fill:
                glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
                break;
            
            case fill_mode::line:
                glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
                break;
            
            case fill_mode::point:
                glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
                break;
            
            default:
                break;
        }
        
        m_rasterization_state.fill_mode = mode;
    }
}
 
void pipeline::set_cull_mode(cull_mode mode)
{
    if (m_rasterization_state.cull_mode != mode)
    {
        if (mode == cull_mode::none)
        {
            glDisable(GL_CULL_FACE);
        }
        else
        {
            if (m_rasterization_state.cull_mode == cull_mode::none)
            {
                glEnable(GL_CULL_FACE);
            }
            
            switch (mode)
            {
                case cull_mode::back:
                    glCullFace(GL_BACK);
                    break;
                
                case cull_mode::front:
                    glCullFace(GL_FRONT);
                    break;
                
                case cull_mode::front_and_back:
                    glCullFace(GL_FRONT_AND_BACK);
                    break;
                
                default:
                    break;
            }
        }
        
        m_rasterization_state.cull_mode = mode;
    }
}
 
void pipeline::set_front_face(front_face face)
{
    if (m_rasterization_state.front_face != face)
    {
        glFrontFace(face == front_face::counter_clockwise ? GL_CCW : GL_CW);
        
        m_rasterization_state.front_face = face;
    }
}
 
void pipeline::set_depth_bias_enabled(bool enabled)
{
    if (m_rasterization_state.depth_bias_enabled != enabled)
    {
        if (enabled)
        {
            glEnable(GL_POLYGON_OFFSET_FILL);
            glEnable(GL_POLYGON_OFFSET_LINE);
            glEnable(GL_POLYGON_OFFSET_POINT);
        }
        else
        {
            glDisable(GL_POLYGON_OFFSET_FILL);
            glDisable(GL_POLYGON_OFFSET_LINE);
            glDisable(GL_POLYGON_OFFSET_POINT);
        }
        
        m_rasterization_state.depth_bias_enabled = enabled;
    }
}
 
void pipeline::set_depth_bias_factors(float constant_factor, float slope_factor)
{
    // Update depth bias factors
    if (m_rasterization_state.depth_bias_constant_factor != constant_factor ||
        m_rasterization_state.depth_bias_slope_factor != slope_factor)
    {
        glPolygonOffset(slope_factor, constant_factor);
        
        m_rasterization_state.depth_bias_constant_factor = constant_factor;
        m_rasterization_state.depth_bias_slope_factor = slope_factor;
    }
}
 
void pipeline::set_depth_clamp_enabled(bool enabled)
{
    if (m_rasterization_state.depth_clamp_enabled != enabled)
    {
        if (enabled)
        {
            glEnable(GL_DEPTH_CLAMP);
        }
        else
        {
            glDisable(GL_DEPTH_CLAMP);
        }
        
        m_rasterization_state.depth_clamp_enabled = enabled;
    }
}
 
void pipeline::set_scissor_test_enabled(bool enabled)
{
    if (m_rasterization_state.scissor_test_enabled != enabled)
    {
        if (enabled)
        {
            glEnable(GL_SCISSOR_TEST);
        }
        else
        {
            glDisable(GL_SCISSOR_TEST);
        }
        
        m_rasterization_state.scissor_test_enabled = enabled;
    }
}
 
void pipeline::set_provoking_vertex_mode(provoking_vertex_mode mode)
{
    if (m_rasterization_state.provoking_vertex_mode != mode)
    {
        const auto gl_provoking_vertex_mode = provoking_vertex_mode_lut[std::to_underlying(mode)];
        glProvokingVertex(gl_provoking_vertex_mode);
        m_rasterization_state.provoking_vertex_mode = mode;
    }
}
 
void pipeline::set_point_size(float size)
{
    if (m_rasterization_state.point_size != size)
    {
        glPointSize(size);
        
        m_rasterization_state.point_size = size;
    }
}
 
void pipeline::set_line_width(float width)
{
    if (m_rasterization_state.line_width != width)
    {
        glLineWidth(width);
        
        m_rasterization_state.line_width = width;
    }
}
 
void pipeline::set_depth_test_enabled(bool enabled)
{
    if (m_depth_stencil_state.depth_test_enabled != enabled)
    {
        m_depth_stencil_state.depth_test_enabled = enabled;
        
        if (enabled)
        {
            glEnable(GL_DEPTH_TEST);
        }
        else
        {
            glDisable(GL_DEPTH_TEST);
        }
    }
}
 
void pipeline::set_depth_write_enabled(bool enabled)
{
    if (m_depth_stencil_state.depth_write_enabled != enabled)
    {
        m_depth_stencil_state.depth_write_enabled = enabled;
        glDepthMask(enabled);
    }
}
 
void pipeline::set_depth_compare_op(gl::compare_op compare_op)
{
    if (m_depth_stencil_state.depth_compare_op != compare_op)
    {
        m_depth_stencil_state.depth_compare_op = compare_op;
        const auto gl_compare_op = compare_op_lut[std::to_underlying(compare_op)];
        glDepthFunc(gl_compare_op);
    }
}
 
void pipeline::set_stencil_test_enabled(bool enabled)
{
    if (m_depth_stencil_state.stencil_test_enabled != enabled)
    {
        m_depth_stencil_state.stencil_test_enabled = enabled;
        
        if (enabled)
        {
            glEnable(GL_STENCIL_TEST);
        }
        else
        {
            glDisable(GL_STENCIL_TEST);
        }
    }
}
 
void pipeline::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)
{
    bool stencil_op_updated = false;
    bool compare_op_updated = false;
    
    if (face_mask & stencil_face_front_bit)
    {
        if (m_depth_stencil_state.stencil_front.fail_op != fail_op ||
            m_depth_stencil_state.stencil_front.pass_op != pass_op ||
            m_depth_stencil_state.stencil_front.depth_fail_op != depth_fail_op)
        {
            m_depth_stencil_state.stencil_front.fail_op = fail_op;
            m_depth_stencil_state.stencil_front.pass_op = pass_op;
            m_depth_stencil_state.stencil_front.depth_fail_op = depth_fail_op;
            stencil_op_updated = true;
        }
        
        if (m_depth_stencil_state.stencil_front.compare_op != compare_op)
        {
            m_depth_stencil_state.stencil_front.compare_op = compare_op;
            compare_op_updated = true;
        }
    }
    
    if (face_mask & stencil_face_back_bit)
    {
        if (m_depth_stencil_state.stencil_back.fail_op != fail_op ||
            m_depth_stencil_state.stencil_back.pass_op != pass_op ||
            m_depth_stencil_state.stencil_back.depth_fail_op != depth_fail_op)
        {
            m_depth_stencil_state.stencil_back.fail_op = fail_op;
            m_depth_stencil_state.stencil_back.pass_op = pass_op;
            m_depth_stencil_state.stencil_back.depth_fail_op = depth_fail_op;
            stencil_op_updated = true;
        }
        
        if (m_depth_stencil_state.stencil_back.compare_op != compare_op)
        {
            m_depth_stencil_state.stencil_back.compare_op = compare_op;
            compare_op_updated = true;
        }
    }
    
    if (stencil_op_updated || compare_op_updated)
    {
        const auto gl_face = stencil_face_lut[face_mask];
        
        if (stencil_op_updated)
        {
            const auto gl_fail_op = stencil_op_lut[std::to_underlying(fail_op)];
            const auto gl_pass_op = stencil_op_lut[std::to_underlying(pass_op)];
            const auto gl_depth_fail_op = stencil_op_lut[std::to_underlying(depth_fail_op)];
            glStencilOpSeparate(gl_face, gl_fail_op, gl_depth_fail_op, gl_pass_op);
        }
        
        if (compare_op_updated)
        {
            const auto gl_compare_op = compare_op_lut[std::to_underlying(compare_op)];
            
            if (face_mask == stencil_face_front_and_back)
            {
                if (m_depth_stencil_state.stencil_front.reference == m_depth_stencil_state.stencil_back.reference &&
                    m_depth_stencil_state.stencil_front.compare_mask == m_depth_stencil_state.stencil_back.compare_mask)
                {
                    glStencilFuncSeparate(gl_face, gl_compare_op, std::bit_cast<GLint>(m_depth_stencil_state.stencil_front.reference), std::bit_cast<GLuint>(m_depth_stencil_state.stencil_front.compare_mask));
                }
                else
                {
                    glStencilFuncSeparate(GL_FRONT, gl_compare_op, std::bit_cast<GLint>(m_depth_stencil_state.stencil_front.reference), std::bit_cast<GLuint>(m_depth_stencil_state.stencil_front.compare_mask));
                    glStencilFuncSeparate(GL_BACK, gl_compare_op, std::bit_cast<GLint>(m_depth_stencil_state.stencil_back.reference), std::bit_cast<GLuint>(m_depth_stencil_state.stencil_back.compare_mask));
                }
            }
            else if (face_mask == stencil_face_front_bit)
            {
                glStencilFuncSeparate(gl_face, gl_compare_op, std::bit_cast<GLint>(m_depth_stencil_state.stencil_front.reference), std::bit_cast<GLuint>(m_depth_stencil_state.stencil_front.compare_mask));
            }
            else
            {
                glStencilFuncSeparate(gl_face, gl_compare_op, std::bit_cast<GLint>(m_depth_stencil_state.stencil_back.reference), std::bit_cast<GLuint>(m_depth_stencil_state.stencil_back.compare_mask));
            }
        }
    }
}
 
void pipeline::set_stencil_compare_mask(std::uint8_t face_mask, std::uint32_t compare_mask)
{
    bool compare_mask_updated = false;
    
    if (face_mask & stencil_face_front_bit)
    {
        if (m_depth_stencil_state.stencil_front.compare_mask != compare_mask)
        {
            m_depth_stencil_state.stencil_front.compare_mask = compare_mask;
            compare_mask_updated = true;
        }
    }
    
    if (face_mask & stencil_face_back_bit)
    {
        if (m_depth_stencil_state.stencil_back.compare_mask != compare_mask)
        {
            m_depth_stencil_state.stencil_back.compare_mask = compare_mask;
            compare_mask_updated = true;
        }
    }
    
    if (compare_mask_updated)
    {
        const auto gl_face = stencil_face_lut[face_mask];
        
        if (face_mask == stencil_face_front_and_back)
        {
            if (m_depth_stencil_state.stencil_front.reference == m_depth_stencil_state.stencil_back.reference &&
                m_depth_stencil_state.stencil_front.compare_op == m_depth_stencil_state.stencil_back.compare_op)
            {
                const auto gl_compare_op = compare_op_lut[std::to_underlying(m_depth_stencil_state.stencil_front.compare_op)];
                glStencilFuncSeparate(gl_face, gl_compare_op, std::bit_cast<GLint>(m_depth_stencil_state.stencil_front.reference), static_cast<GLuint>(compare_mask));
            }
            else
            {
                const auto gl_compare_op_front = compare_op_lut[std::to_underlying(m_depth_stencil_state.stencil_front.compare_op)];
                const auto gl_compare_op_back = compare_op_lut[std::to_underlying(m_depth_stencil_state.stencil_back.compare_op)];
                glStencilFuncSeparate(GL_FRONT, gl_compare_op_front, std::bit_cast<GLint>(m_depth_stencil_state.stencil_front.reference), std::bit_cast<GLuint>(compare_mask));
                glStencilFuncSeparate(GL_BACK, gl_compare_op_back, std::bit_cast<GLint>(m_depth_stencil_state.stencil_back.reference), std::bit_cast<GLuint>(compare_mask));
            }
        }
        else if (face_mask == stencil_face_front_bit)
        {
            const auto gl_compare_op = compare_op_lut[std::to_underlying(m_depth_stencil_state.stencil_front.compare_op)];
            glStencilFuncSeparate(gl_face, gl_compare_op, std::bit_cast<GLint>(m_depth_stencil_state.stencil_front.reference), std::bit_cast<GLuint>(compare_mask));
        }
        else
        {
            const auto gl_compare_op = compare_op_lut[std::to_underlying(m_depth_stencil_state.stencil_back.compare_op)];
            glStencilFuncSeparate(gl_face, gl_compare_op, std::bit_cast<GLint>(m_depth_stencil_state.stencil_back.reference), std::bit_cast<GLuint>(compare_mask));
        }
    }
}
 
void pipeline::set_stencil_reference(std::uint8_t face_mask, std::uint32_t reference)
{
    bool reference_updated = false;
    
    if (face_mask & stencil_face_front_bit)
    {
        if (m_depth_stencil_state.stencil_front.reference != reference)
        {
            m_depth_stencil_state.stencil_front.reference = reference;
            reference_updated = true;
        }
    }
    
    if (face_mask & stencil_face_back_bit)
    {
        if (m_depth_stencil_state.stencil_back.reference != reference)
        {
            m_depth_stencil_state.stencil_back.reference = reference;
            reference_updated = true;
        }
    }
    
    if (reference_updated)
    {
        const auto gl_face = stencil_face_lut[face_mask];
        
        if (face_mask == stencil_face_front_and_back)
        {
            if (m_depth_stencil_state.stencil_front.compare_mask == m_depth_stencil_state.stencil_back.compare_mask &&
                m_depth_stencil_state.stencil_front.compare_op == m_depth_stencil_state.stencil_back.compare_op)
            {
                const auto gl_compare_op = compare_op_lut[std::to_underlying(m_depth_stencil_state.stencil_front.compare_op)];
                glStencilFuncSeparate(gl_face, gl_compare_op, std::bit_cast<GLint>(reference), std::bit_cast<GLuint>(m_depth_stencil_state.stencil_front.compare_mask));
            }
            else
            {
                const auto gl_compare_op_front = compare_op_lut[std::to_underlying(m_depth_stencil_state.stencil_front.compare_op)];
                const auto gl_compare_op_back = compare_op_lut[std::to_underlying(m_depth_stencil_state.stencil_back.compare_op)];
                glStencilFuncSeparate(GL_FRONT, gl_compare_op_front, std::bit_cast<GLint>(reference), std::bit_cast<GLuint>(m_depth_stencil_state.stencil_front.compare_mask));
                glStencilFuncSeparate(GL_BACK, gl_compare_op_back, std::bit_cast<GLint>(reference), std::bit_cast<GLuint>(m_depth_stencil_state.stencil_back.compare_mask));
            }
        }
        else if (face_mask == stencil_face_front_bit)
        {
            const auto gl_compare_op = compare_op_lut[std::to_underlying(m_depth_stencil_state.stencil_front.compare_op)];
            glStencilFuncSeparate(gl_face, gl_compare_op, std::bit_cast<GLint>(reference), std::bit_cast<GLuint>(m_depth_stencil_state.stencil_front.compare_mask));
        }
        else
        {
            const auto gl_compare_op = compare_op_lut[std::to_underlying(m_depth_stencil_state.stencil_back.compare_op)];
            glStencilFuncSeparate(gl_face, gl_compare_op, std::bit_cast<GLint>(reference), std::bit_cast<GLuint>(m_depth_stencil_state.stencil_back.compare_mask));
        }
    }
}
 
void pipeline::set_stencil_write_mask(std::uint8_t face_mask, std::uint32_t write_mask)
{
    bool write_mask_updated = false;
    
    if (face_mask & stencil_face_front_bit)
    {
        if (m_depth_stencil_state.stencil_front.write_mask != write_mask)
        {
            m_depth_stencil_state.stencil_front.write_mask = write_mask;
            write_mask_updated = true;
        }
    }
    
    if (face_mask & stencil_face_back_bit)
    {
        if (m_depth_stencil_state.stencil_back.write_mask != write_mask)
        {
            m_depth_stencil_state.stencil_back.write_mask = write_mask;
            write_mask_updated = true;
        }
    }
    
    if (write_mask_updated)
    {
        const auto gl_face = stencil_face_lut[face_mask];
        glStencilMaskSeparate(gl_face, std::bit_cast<GLuint>(write_mask));
    }
}
 
void pipeline::set_logic_op_enabled(bool enabled)
{
    if (m_color_blend_state.logic_op_enabled != enabled)
    {
        m_color_blend_state.logic_op_enabled = enabled;
        
        if (enabled)
        {
            glEnable(GL_COLOR_LOGIC_OP);
        }
        else
        {
            glDisable(GL_COLOR_LOGIC_OP);
        }
    }
}
 
void pipeline::set_logic_op(gl::logic_op logic_op)
{
    if (m_color_blend_state.logic_op != logic_op)
    {
        m_color_blend_state.logic_op = logic_op;
        
        const auto gl_logic_op = logic_op_lut[std::to_underlying(logic_op)];
        glLogicOp(gl_logic_op);
    }
}
 
void pipeline::set_color_blend_enabled(bool enabled)
{
    if (m_color_blend_state.blend_enabled != enabled)
    {
        m_color_blend_state.blend_enabled = enabled;
        
        if (enabled)
        {
            glEnable(GL_BLEND);
        }
        else
        {
            glDisable(GL_BLEND);
        }
    }
}
 
void pipeline::set_color_blend_equation(const color_blend_equation& equation)
{
    if (m_color_blend_state.color_blend_equation.src_color_blend_factor != equation.src_color_blend_factor ||
        m_color_blend_state.color_blend_equation.dst_color_blend_factor != equation.dst_color_blend_factor ||
        m_color_blend_state.color_blend_equation.src_alpha_blend_factor != equation.src_alpha_blend_factor ||
        m_color_blend_state.color_blend_equation.dst_alpha_blend_factor != equation.dst_alpha_blend_factor)
    {
        m_color_blend_state.color_blend_equation.src_color_blend_factor = equation.src_color_blend_factor;
        m_color_blend_state.color_blend_equation.dst_color_blend_factor = equation.dst_color_blend_factor;
        m_color_blend_state.color_blend_equation.src_alpha_blend_factor = equation.src_alpha_blend_factor;
        m_color_blend_state.color_blend_equation.dst_alpha_blend_factor = equation.dst_alpha_blend_factor;
        
        const auto gl_src_rgb = blend_factor_lut[std::to_underlying(equation.src_color_blend_factor)];
        const auto gl_dst_rgb = blend_factor_lut[std::to_underlying(equation.dst_color_blend_factor)];
        const auto gl_src_alpha = blend_factor_lut[std::to_underlying(equation.src_alpha_blend_factor)];
        const auto gl_dst_alpha = blend_factor_lut[std::to_underlying(equation.dst_alpha_blend_factor)];
        
        glBlendFuncSeparate(gl_src_rgb, gl_dst_rgb, gl_src_alpha, gl_dst_alpha);
    }
    
    if (m_color_blend_state.color_blend_equation.color_blend_op != equation.color_blend_op ||
        m_color_blend_state.color_blend_equation.alpha_blend_op != equation.alpha_blend_op)
    {
        m_color_blend_state.color_blend_equation.color_blend_op = equation.color_blend_op;
        m_color_blend_state.color_blend_equation.alpha_blend_op = equation.alpha_blend_op;
        
        const auto gl_mode_rgb = blend_op_lut[std::to_underlying(equation.color_blend_op)];
        const auto gl_mode_alpha = blend_op_lut[std::to_underlying(equation.alpha_blend_op)];
        
        glBlendEquationSeparate(gl_mode_rgb, gl_mode_alpha);
    }
}
 
void pipeline::set_color_write_mask(std::uint8_t mask)
{
    if (m_color_blend_state.color_write_mask != mask)
    {
        m_color_blend_state.color_write_mask = mask;
        
        glColorMask
        (
            mask & color_component_r_bit,
            mask & color_component_g_bit,
            mask & color_component_b_bit,
            mask & color_component_a_bit
        );
    }
}
 
void pipeline::set_blend_constants(const std::array<float, 4>& blend_constants)
{
    if (m_color_blend_state.blend_constants != blend_constants)
    {
        m_color_blend_state.blend_constants = blend_constants;
        glBlendColor(blend_constants[0], blend_constants[1], blend_constants[2], blend_constants[3]);
    }
}
 
void pipeline::draw(std::uint32_t vertex_count, std::uint32_t instance_count, std::uint32_t first_vertex, std::uint32_t first_instance)
{
    glDrawArraysInstancedBaseInstance
    (
        primitive_topology_lut[std::to_underlying(m_input_assembly_state.topology)],
        static_cast<GLint>(first_vertex),
        static_cast<GLsizei>(vertex_count),
        static_cast<GLsizei>(instance_count),
        static_cast<GLuint>(first_instance)
    );
}
 
void pipeline::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)
{
    glDrawElementsInstancedBaseInstance
    (
        primitive_topology_lut[std::to_underlying(m_input_assembly_state.topology)],
        static_cast<GLsizei>(instance_count),
        GL_UNSIGNED_INT,// GL_UNSIGNED_SHORT, GL_UNSIGNED_BYTE
        reinterpret_cast<const GLvoid*>(first_index * sizeof(unsigned int)),
        static_cast<GLsizei>(instance_count),
        static_cast<GLuint>(first_instance)
    );
}
 
void pipeline::clear_attachments(std::uint8_t mask, const clear_value& value)
{
    GLbitfield gl_clear_mask = 0;
    
    if (mask & color_clear_bit)
    {
        // Add color attachment to OpenGL clear mask
        gl_clear_mask |= GL_COLOR_BUFFER_BIT;
        
        if (m_clear_value.color != value.color)
        {
            // Update color clear value
            glClearColor(value.color[0], value.color[1], value.color[2], value.color[3]);
            m_clear_value.color = value.color;
        }
    }
    
    if (mask & depth_clear_bit)
    {
        // Add depth attachment to OpenGL clear mask
        gl_clear_mask |= GL_DEPTH_BUFFER_BIT;
        
        if (m_clear_value.depth != value.depth)
        {
            // Update depth clear value
            glClearDepth(value.depth);
            m_clear_value.depth = value.depth;
        }
    }
    
    if (mask & stencil_clear_bit)
    {
        // Add stencil attachment to OpenGL clear mask
        gl_clear_mask |= GL_STENCIL_BUFFER_BIT;
        
        if (m_clear_value.stencil != value.stencil)
        {
            // Update stencil clear value
            glClearStencil(static_cast<GLint>(value.stencil));
            m_clear_value.stencil = value.stencil;
        }
    }
    
    // Clear attachments
    glClear(gl_clear_mask);
}
 
void pipeline::defaut_framebuffer_resized(std::uint32_t width, std::uint32_t height) noexcept
{
    m_default_framebuffer_dimensions = {width, height};
}
 
void pipeline::fetch_vertex_input_state()
{
}
 
void pipeline::fetch_input_assembly_state()
{
    m_input_assembly_state.primitive_restart_enabled = glIsEnabled(GL_PRIMITIVE_RESTART);
}
 
void pipeline::fetch_viewport_state()
{
    // Query viewport position and dimensions
    GLint gl_viewport[4];
    glGetIntegerv(GL_VIEWPORT, gl_viewport);
    
    // Query viewport depth range
    GLfloat gl_depth_range[2];
    glGetFloatv(GL_DEPTH_RANGE, gl_depth_range);
    
    // Query scissor box
    GLint gl_scissor_box[4] = {0, 0, 0, 0};
    glGetIntegerv(GL_SCISSOR_BOX, gl_scissor_box);
    
    // Match viewport state
    m_viewport_state.viewports =
    {{
        static_cast<float>(gl_viewport[0]),
        static_cast<float>(gl_viewport[1]),
        static_cast<float>(gl_viewport[2]),
        static_cast<float>(gl_viewport[3]),
        gl_depth_range[0],
        gl_depth_range[1]
    }};
    m_viewport_state.scissors =
    {{
        static_cast<std::int32_t>(gl_scissor_box[0]),
        static_cast<std::int32_t>(gl_scissor_box[1]),
        static_cast<std::uint32_t>(std::max(0, gl_scissor_box[2])),
        static_cast<std::uint32_t>(std::max(0, gl_scissor_box[3]))
    }};
}
 
void pipeline::fetch_rasterization_state()
{
    // Query rasterizer discard
    bool gl_rasterizer_discard_enabled = glIsEnabled(GL_RASTERIZER_DISCARD);
    
    // Query fill mode
    GLint gl_fill_mode;
    glGetIntegerv(GL_POLYGON_MODE, &gl_fill_mode);
    
    // Query cull mode
    bool gl_cull_enabled = glIsEnabled(GL_CULL_FACE);
    GLint gl_cull_mode;
    glGetIntegerv(GL_CULL_FACE_MODE, &gl_cull_mode);
    
    // Query front face
    GLint gl_front_face;
    glGetIntegerv(GL_FRONT_FACE, &gl_front_face);
    
    // Query depth bias
    bool gl_depth_bias_enabled = glIsEnabled(GL_POLYGON_OFFSET_FILL) &&
        glIsEnabled(GL_POLYGON_OFFSET_LINE) &&
        glIsEnabled(GL_POLYGON_OFFSET_POINT);
    float gl_depth_bias_constant_factor;
    float gl_depth_bias_slope_factor;
    glGetFloatv(GL_POLYGON_OFFSET_UNITS, &gl_depth_bias_constant_factor);
    glGetFloatv(GL_POLYGON_OFFSET_FACTOR, &gl_depth_bias_slope_factor);
    
    // Query depth clamp
    bool gl_depth_clamp_enabled = glIsEnabled(GL_DEPTH_CLAMP);
    
    // Query scissor test
    bool gl_scissor_test_enabled = glIsEnabled(GL_SCISSOR_TEST);
    
    // Query provoking vertex
    GLint gl_provoking_vertex;
    glGetIntegerv(GL_PROVOKING_VERTEX, &gl_provoking_vertex);
    
    // Query point size
    float gl_point_size;
    glGetFloatv(GL_POINT_SIZE, &gl_point_size);
    
    // Query line width
    float gl_line_width;
    glGetFloatv(GL_LINE_WIDTH, &gl_line_width);
    
    // Match rasterizer state
    m_rasterization_state.rasterizer_discard_enabled = gl_rasterizer_discard_enabled;
    m_rasterization_state.fill_mode = (gl_fill_mode == GL_POINT ? fill_mode::point : gl_fill_mode == GL_LINE ? fill_mode::line : fill_mode::fill);
    if (gl_cull_enabled)
    {
        m_rasterization_state.cull_mode = (gl_cull_mode == GL_FRONT_AND_BACK ? cull_mode::front_and_back : gl_fill_mode == GL_FRONT ? cull_mode::front : cull_mode::back);
    }
    else
    {
        m_rasterization_state.cull_mode = cull_mode::none;
    }
    m_rasterization_state.front_face = (gl_front_face == GL_CW ? front_face::clockwise : front_face::counter_clockwise);
    m_rasterization_state.depth_bias_enabled = gl_depth_bias_enabled;
    m_rasterization_state.depth_bias_constant_factor = gl_depth_bias_constant_factor;
    m_rasterization_state.depth_bias_slope_factor = gl_depth_bias_slope_factor;
    m_rasterization_state.depth_clamp_enabled = gl_depth_clamp_enabled;
    m_rasterization_state.scissor_test_enabled = gl_scissor_test_enabled;
    m_rasterization_state.provoking_vertex_mode = (gl_provoking_vertex == GL_FIRST_VERTEX_CONVENTION ? provoking_vertex_mode::first : provoking_vertex_mode::last);
    m_rasterization_state.point_size = gl_point_size;
    m_rasterization_state.line_width = gl_line_width;
}
 
void pipeline::fetch_depth_stencil_state()
{
    auto inv_compare_op_lut = [](GLint func) -> gl::compare_op
    {
        switch (func)
        {
            case GL_NEVER:
                return compare_op::never;
            case GL_LESS:
                return compare_op::less;
            case GL_EQUAL:
                return compare_op::equal;
            case GL_LEQUAL:
                return compare_op::less_or_equal;
            case GL_GREATER:
                return compare_op::greater;
            case GL_NOTEQUAL:
                return compare_op::not_equal;
            case GL_GEQUAL:
                return compare_op::greater_or_equal;
            case GL_ALWAYS:
            default:
                return compare_op::always;
        }
    };
    
    auto inv_stencil_op_lut = [](GLint op) -> gl::stencil_op
    {
        switch (op)
        {
            case GL_KEEP:
                return stencil_op::keep;
            case GL_ZERO:
                return stencil_op::zero;
            case GL_REPLACE:
                return stencil_op::replace;
            case GL_INCR:
                return stencil_op::increment_and_clamp;
            case GL_DECR:
                return stencil_op::decrement_and_clamp;
            case GL_INVERT:
                return stencil_op::invert;
            case GL_INCR_WRAP:
                return stencil_op::increment_and_wrap;
            case GL_DECR_WRAP:
            default:
                return stencil_op::decrement_and_wrap;
        }
    };
    
    m_depth_stencil_state.depth_test_enabled = glIsEnabled(GL_DEPTH_TEST);
    
    GLboolean gl_depth_write_enabled;
    glGetBooleanv(GL_DEPTH_WRITEMASK, &gl_depth_write_enabled);
    m_depth_stencil_state.depth_write_enabled = gl_depth_write_enabled;
    
    GLint gl_depth_compare_op;
    glGetIntegerv(GL_DEPTH_FUNC, &gl_depth_compare_op);
    m_depth_stencil_state.depth_compare_op = inv_compare_op_lut(gl_depth_compare_op);
    
    m_depth_stencil_state.stencil_test_enabled = glIsEnabled(GL_STENCIL_TEST);
    
    // Stencil front
    {
        GLint gl_stencil_front_fail;
        GLint gl_stencil_front_pass_depth_pass;
        GLint gl_stencil_front_pass_depth_fail;
        GLint gl_stencil_front_func;
        GLint gl_stencil_front_value_mask;
        GLint gl_stencil_front_write_mask;
        GLint gl_stencil_front_ref;
        
        glGetIntegerv(GL_STENCIL_FAIL, &gl_stencil_front_fail);
        glGetIntegerv(GL_STENCIL_PASS_DEPTH_PASS, &gl_stencil_front_pass_depth_pass);
        glGetIntegerv(GL_STENCIL_PASS_DEPTH_FAIL, &gl_stencil_front_pass_depth_fail);
        glGetIntegerv(GL_STENCIL_FUNC, &gl_stencil_front_func);
        glGetIntegerv(GL_STENCIL_VALUE_MASK, &gl_stencil_front_value_mask);
        glGetIntegerv(GL_STENCIL_WRITEMASK, &gl_stencil_front_write_mask);
        glGetIntegerv(GL_STENCIL_REF, &gl_stencil_front_ref);
        
        m_depth_stencil_state.stencil_front.fail_op = inv_stencil_op_lut(gl_stencil_front_fail);
        m_depth_stencil_state.stencil_front.pass_op = inv_stencil_op_lut(gl_stencil_front_pass_depth_pass);
        m_depth_stencil_state.stencil_front.depth_fail_op = inv_stencil_op_lut(gl_stencil_front_pass_depth_fail);
        m_depth_stencil_state.stencil_front.compare_op = inv_compare_op_lut(gl_stencil_front_func);
        m_depth_stencil_state.stencil_front.compare_mask = std::bit_cast<std::uint32_t>(gl_stencil_front_value_mask);
        m_depth_stencil_state.stencil_front.write_mask = std::bit_cast<std::uint32_t>(gl_stencil_front_write_mask);
        m_depth_stencil_state.stencil_front.reference = std::bit_cast<std::uint32_t>(gl_stencil_front_ref);
    }
    
    // Stencil back
    {
        GLint gl_stencil_back_fail;
        GLint gl_stencil_back_pass_depth_pass;
        GLint gl_stencil_back_pass_depth_fail;
        GLint gl_stencil_back_func;
        GLint gl_stencil_back_value_mask;
        GLint gl_stencil_back_write_mask;
        GLint gl_stencil_back_ref;
        
        glGetIntegerv(GL_STENCIL_BACK_FAIL, &gl_stencil_back_fail);
        glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_PASS, &gl_stencil_back_pass_depth_pass);
        glGetIntegerv(GL_STENCIL_BACK_PASS_DEPTH_FAIL, &gl_stencil_back_pass_depth_fail);
        glGetIntegerv(GL_STENCIL_BACK_FUNC, &gl_stencil_back_func);
        glGetIntegerv(GL_STENCIL_BACK_VALUE_MASK, &gl_stencil_back_value_mask);
        glGetIntegerv(GL_STENCIL_BACK_WRITEMASK, &gl_stencil_back_write_mask);
        glGetIntegerv(GL_STENCIL_BACK_REF, &gl_stencil_back_ref);
        
        m_depth_stencil_state.stencil_back.fail_op = inv_stencil_op_lut(gl_stencil_back_fail);
        m_depth_stencil_state.stencil_back.pass_op = inv_stencil_op_lut(gl_stencil_back_pass_depth_pass);
        m_depth_stencil_state.stencil_back.depth_fail_op = inv_stencil_op_lut(gl_stencil_back_pass_depth_fail);
        m_depth_stencil_state.stencil_back.compare_op = inv_compare_op_lut(gl_stencil_back_func);
        m_depth_stencil_state.stencil_back.compare_mask = std::bit_cast<std::uint32_t>(gl_stencil_back_value_mask);
        m_depth_stencil_state.stencil_back.write_mask = std::bit_cast<std::uint32_t>(gl_stencil_back_write_mask);
        m_depth_stencil_state.stencil_back.reference = std::bit_cast<std::uint32_t>(gl_stencil_back_ref);
    }
}
 
void pipeline::fetch_color_blend_state()
{
    auto inv_logic_op_lut = [](GLint op) -> gl::logic_op
    {
        switch (op)
        {
            case GL_CLEAR:
                return gl::logic_op::bitwise_clear;
            case GL_AND:
                return gl::logic_op::bitwise_and;
            case GL_AND_REVERSE:
                return gl::logic_op::bitwise_and_reverse;
            case GL_COPY:
                return gl::logic_op::bitwise_copy;
            case GL_AND_INVERTED:
                return gl::logic_op::bitwise_and_inverted;
            case GL_NOOP:
                return gl::logic_op::bitwise_no_op;
            case GL_XOR:
                return gl::logic_op::bitwise_xor;
            case GL_OR:
                return gl::logic_op::bitwise_or;
            case GL_NOR:
                return gl::logic_op::bitwise_nor;
            case GL_EQUIV:
                return gl::logic_op::bitwise_equivalent;
            case GL_INVERT:
                return gl::logic_op::bitwise_invert;
            case GL_OR_REVERSE:
                return gl::logic_op::bitwise_or_reverse;
            case GL_COPY_INVERTED:
                return gl::logic_op::bitwise_copy_inverted;
            case GL_OR_INVERTED:
                return gl::logic_op::bitwise_or_inverted;
            case GL_NAND:
                return gl::logic_op::bitwise_nand;
            case GL_SET:
            default:
                return gl::logic_op::bitwise_set;
        }
    };
    
    auto inv_blend_factor_lut = [](GLint func) -> gl::blend_factor
    {
        switch (func)
        {
            case GL_ZERO:
                return blend_factor::zero;
            case GL_ONE:
                return blend_factor::one;
            case GL_SRC_COLOR:
                return blend_factor::src_color;
            case GL_ONE_MINUS_SRC_COLOR:
                return blend_factor::one_minus_src_color;
            case GL_DST_COLOR:
                return blend_factor::dst_color;
            case GL_ONE_MINUS_DST_COLOR:
                return blend_factor::one_minus_dst_color;
            case GL_SRC_ALPHA:
                return blend_factor::src_alpha;
            case GL_ONE_MINUS_SRC_ALPHA:
                return blend_factor::one_minus_src_alpha;
            case GL_DST_ALPHA:
                return blend_factor::dst_alpha;
            case GL_ONE_MINUS_DST_ALPHA:
                return blend_factor::one_minus_dst_alpha;
            case GL_CONSTANT_COLOR:
                return blend_factor::constant_color;
            case GL_ONE_MINUS_CONSTANT_COLOR:
                return blend_factor::one_minus_constant_color;
            case GL_CONSTANT_ALPHA:
                return blend_factor::constant_alpha;
            case GL_ONE_MINUS_CONSTANT_ALPHA:
                return blend_factor::one_minus_constant_alpha;
            case GL_SRC_ALPHA_SATURATE:
                return blend_factor::src_alpha_saturate;
            case GL_SRC1_COLOR:
                return blend_factor::src1_color;
            case GL_ONE_MINUS_SRC1_COLOR:
                return blend_factor::one_minus_src1_color;
            case GL_SRC1_ALPHA:
                return blend_factor::src1_alpha;
            case GL_ONE_MINUS_SRC1_ALPHA:
            default:
                return blend_factor::one_minus_src1_alpha;
        }
    };
    
    auto inv_blend_op_lut = [](GLint mode) -> gl::blend_op
    {
        switch (mode)
        {
            case GL_FUNC_ADD:
                return blend_op::add;
            case GL_FUNC_SUBTRACT:
                return blend_op::subtract;
            case GL_FUNC_REVERSE_SUBTRACT:
                return blend_op::reverse_subtract;
            case GL_MIN:
                return blend_op::min;
            case GL_MAX:
                default:
                return blend_op::max;
        }
    };
    
    m_color_blend_state.logic_op_enabled = glIsEnabled(GL_COLOR_LOGIC_OP);
    
    GLint gl_logic_op;
    glGetIntegerv(GL_LOGIC_OP_MODE, &gl_logic_op);
    
    m_color_blend_state.logic_op = inv_logic_op_lut(gl_logic_op);
    
    m_color_blend_state.blend_enabled = glIsEnabled(GL_BLEND);
    
    GLint gl_blend_src_rgb;
    GLint gl_blend_dst_rgb;
    GLint gl_blend_equation_rgb;
    GLint gl_blend_src_alpha;
    GLint gl_blend_dst_alpha;
    GLint gl_blend_equation_alpha;
    glGetIntegerv(GL_BLEND_SRC_RGB, &gl_blend_src_rgb);
    glGetIntegerv(GL_BLEND_DST_RGB, &gl_blend_dst_rgb);
    glGetIntegerv(GL_BLEND_EQUATION_RGB, &gl_blend_equation_rgb);
    glGetIntegerv(GL_BLEND_SRC_ALPHA, &gl_blend_src_alpha);
    glGetIntegerv(GL_BLEND_DST_ALPHA, &gl_blend_dst_alpha);
    glGetIntegerv(GL_BLEND_EQUATION_ALPHA, &gl_blend_equation_alpha);
    
    m_color_blend_state.color_blend_equation.src_color_blend_factor = inv_blend_factor_lut(gl_blend_src_rgb);
    m_color_blend_state.color_blend_equation.dst_color_blend_factor = inv_blend_factor_lut(gl_blend_dst_rgb);
    m_color_blend_state.color_blend_equation.color_blend_op = inv_blend_op_lut(gl_blend_equation_rgb);
    m_color_blend_state.color_blend_equation.src_alpha_blend_factor = inv_blend_factor_lut(gl_blend_src_alpha);
    m_color_blend_state.color_blend_equation.dst_alpha_blend_factor = inv_blend_factor_lut(gl_blend_dst_alpha);
    m_color_blend_state.color_blend_equation.alpha_blend_op = inv_blend_op_lut(gl_blend_equation_alpha);
    
    GLboolean gl_color_writemask[4];
    glGetBooleanv(GL_COLOR_WRITEMASK, gl_color_writemask);
    
    m_color_blend_state.color_write_mask =
        static_cast<std::uint8_t>(gl_color_writemask[0]) |
        (static_cast<std::uint8_t>(gl_color_writemask[1]) << 1) |
        (static_cast<std::uint8_t>(gl_color_writemask[2]) << 2) |
        (static_cast<std::uint8_t>(gl_color_writemask[3]) << 3);
    
    glGetFloatv(GL_BLEND_COLOR, m_color_blend_state.blend_constants.data());
}
 
void pipeline::fetch_clear_value()
{
    // Query clear values
    GLfloat gl_color_clear[4];
    GLfloat gl_depth_clear;
    GLint gl_stencil_clear;
    glGetFloatv(GL_COLOR_CLEAR_VALUE, gl_color_clear);
    glGetFloatv(GL_DEPTH_CLEAR_VALUE, &gl_depth_clear);
    glGetIntegerv(GL_STENCIL_CLEAR_VALUE, &gl_stencil_clear);
    
    // Match clear state
    m_clear_value.color = {gl_color_clear[0], gl_color_clear[1], gl_color_clear[2], gl_color_clear[3]};
    m_clear_value.depth = gl_depth_clear;
    m_clear_value.stencil = static_cast<std::uint32_t>(gl_stencil_clear);
}
 
} // namespace gl