GLStateManager.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "OpenGL.hpp"
 
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Container/Array.hpp"
#include "CeresEngine/Foundation/Container/Tuple.hpp"
 
#include <array>
#include <functional>
#include <optional>
 
namespace CeresEngine {
 
    template<typename Setter> struct GLGlobalState;
 
    template<typename T, typename... Ts> GLGlobalState(void (*const&)(T, Ts...)) -> GLGlobalState<void (*)(T, Ts...)>;
 
    template<typename T, typename... Ts> struct GLGlobalState<void (*)(T, Ts...)> final {
        using Setter = void (*)(T, Ts...);
 
        using Value = std::conditional_t<sizeof...(Ts) == 0, T, Tuple<T, Ts...>>;
 
        const Setter* setter;
 
        std::optional<Value> current;
 
        CE_EXPLICIT(false) inline GLGlobalState( // NOLINT
            const Setter& setter) noexcept
                : setter(&setter) {}
 
        inline GLGlobalState& operator=(Value value) {
            if(current == value) {
                return *this;
            }
 
            if constexpr(sizeof...(Ts) == 0) {
                (*setter)(value);
            } else {
                value.apply(*setter);
            }
            current = value;
            GLThrowIfFailed("setting GLGlobalState");
 
            return *this;
        }
 
        CE_EXPLICIT(false) inline operator Value() const { // NOLINT
            return *current;
        }
 
        inline explicit operator bool() const { return *setter != nullptr && **setter != nullptr; }
    };
 
    template<typename T, typename... Ts> struct GLGlobalState<void(T, Ts...)> final {
        using Setter = void (*)(T, Ts...);
 
        using Value = std::conditional_t<sizeof...(Ts) == 0, T, Tuple<T, Ts...>>;
 
        const Setter setter;
 
        std::optional<Value> current;
 
        CE_EXPLICIT(false) inline GLGlobalState(const Setter setter) noexcept // NOLINT
                : setter(setter) {}
 
        //        /// Creates a new `GLGlobalState` object.
        //        /// \param setter   The setter function
        //        template<typename F>
        //        inline GLGlobalState(F setter) noexcept //
        //        NOLINT(google-explicit-constructor,hicpp-explicit-conversions)
        //                : setter(setter) {}
 
        inline GLGlobalState& operator=(Value value) {
            if(current == value) {
                return *this;
            }
 
            if constexpr(sizeof...(Ts) == 0) {
                setter(value);
            } else {
                std::apply(setter, value);
            }
            current = value;
            GLThrowIfFailed("setting GLGlobalState");
 
            return *this;
        }
 
        CE_EXPLICIT(false) inline operator Value() const { // NOLINT
            return *current;
        }
 
        inline explicit operator bool() const { return *setter != nullptr && **setter != nullptr; }
    };
 
    template<template<typename> class F, typename T, typename... Ts> struct GLGlobalState<F<void(T, Ts...)>> final {
        using Setter = F<void(T, Ts...)>;
 
        using Value = std::conditional_t<sizeof...(Ts) == 0, T, Tuple<T, Ts...>>;
 
        const Setter setter;
 
        std::optional<Value> current;
 
        CE_EXPLICIT(false) GLGlobalState(Setter&& setter) noexcept // NOLINT
                : setter(std::forward<decltype(setter)>(setter)) {}
 
        inline GLGlobalState& operator=(Value value) {
            if(current == value) {
                return *this;
            }
 
            if constexpr(sizeof...(Ts) == 0) {
                setter(value);
            } else {
                std::apply(setter, value);
            }
            current = value;
            GLThrowIfFailed("setting GLGlobalState");
 
            return *this;
        }
 
        CE_EXPLICIT(false) inline operator Value() const { // NOLINT
            return *current;
        }
 
        inline explicit operator bool() const { return setter != nullptr; }
    };
 
    template<typename I, typename Setter, size_t N> struct GLGlobalStateCollection;
 
    template<typename I, typename T, typename... Ts, size_t N> struct GLGlobalStateCollection<I, void(T, Ts...), N> final {
        using Index = I;
 
        using Setter = void (*)(I, T, Ts...);
 
        using Value = std::conditional_t<sizeof...(Ts) == 0, T, Tuple<T, Ts...>>;
 
        const Setter setter;
 
        Array<std::optional<Value>, N> current;
 
        struct Entry {
            const Index index;
 
            const Setter setter;
 
            std::optional<Value>& current;
 
            CE_EXPLICIT(false) inline Entry( // NOLINT
                Index index, const Setter setter, std::optional<Value>& current) noexcept
                    : index(index), setter(setter), current(current) {}
 
            inline Entry& operator=(Value value) {
                if(current == value) {
                    return *this;
                }
 
                if constexpr(sizeof...(Ts) == 0) {
                    setter(index, value);
                } else {
                    value.apply([&](auto... args) { setter(index, args...); });
                }
                current = value;
                GLThrowIfFailed("setting GLGlobalState");
 
                return *this;
            }
 
            CE_EXPLICIT(false) inline operator Value() const { // NOLINT
                return *current;
            }
 
            inline explicit operator bool() const { return setter != nullptr; }
        };
 
        CE_EXPLICIT(false) inline GLGlobalStateCollection(const Setter setter) noexcept // NOLINT
                : setter(setter) {}
 
        template<typename F>
        CE_EXPLICIT(false) inline GLGlobalStateCollection(F setter) noexcept // NOLINT
                : setter(setter) {}
 
        Entry operator[](Index index) { return Entry(index, setter, current[index]); }
    };
 
    // ---------------------------------------------------------------------------------------------
 
    template<typename O, typename Setter> struct GLObjectState;
 
    template<typename Object, typename T> struct GLObjectState<Object, void(T)> final {
        using Setter = void (*)(Object, T);
 
        const Object object;
 
        const Setter setter;
 
        std::optional<T> current;
 
        inline GLObjectState(const Object object, const Setter setter) : object(object), setter(setter) {}
 
        inline GLObjectState& operator=(T value) {
            if(current == value) {
                return *this;
            }
 
            setter(object, value);
            current = value;
 
            GLThrowIfFailed("setting GLObjectState");
 
            return *this;
        }
 
        CE_EXPLICIT(false) inline operator T() const { // NOLINT
            return *current;
        }
    };
 
    // ---------------------------------------------------------------------------------------------
 
    struct GLCapability final {
        GLenum capability;
 
        bool current;
 
        CE_EXPLICIT(false) GLCapability( // NOLINT
            const GLenum capability, const bool defaultState = false)
                : capability(capability), current(defaultState) {}
 
        inline GLCapability& operator=(const bool state) {
            if(current == state) {
                return *this;
            }
 
            if(state) {
                glEnable(capability);
            } else {
                glDisable(capability);
            }
            GLThrowIfFailed("setting GLCapability");
 
            current = state;
            return *this;
        }
 
        CE_EXPLICIT(false) inline operator bool() const { // NOLINT
            return current;
        }
    };
 
    // ---------------------------------------------------------------------------------------------
 
    template<auto T> static inline const constexpr auto bindBuffer = +[](GLuint id) constexpr { return glBindBuffer(T, id); };
 
    extern struct GLState final {
        GLGlobalState<decltype(glViewport)> viewport = glViewport;
 
        GLGlobalState<decltype(glFrontFace)> frontFace = glFrontFace;
 
        GLGlobalState<decltype(glUseProgram)> program = glUseProgram;
 
        struct {
            GLGlobalState<void(GLuint)> global = +[](const GLuint id) {
                glBindFramebuffer(GL_FRAMEBUFFER, id);
            };
 
            GLGlobalState<void(GLuint)> draw = +[](const GLuint id) {
                glBindFramebuffer(GL_DRAW_FRAMEBUFFER, id);
            };
 
            GLGlobalState<void(GLuint)> read = +[](const GLuint id) {
                glBindFramebuffer(GL_READ_FRAMEBUFFER, id);
            };
 
            GLGlobalState<decltype(glClearColor)> clearColor = glClearColor;
        } framebuffer;
 
        struct {
            GLGlobalState<decltype(glBindVertexArray)> vertexArray = glBindVertexArray;
 
            GLGlobalState<decltype(glBindTexture)> texture = glBindTexture;
 
            GLGlobalStateCollection<GLenum, void(GLuint), 96> textures = [](const GLenum index, const GLuint id) {
                if(glBindTextureUnit) {
                    glBindTextureUnit(index, id);
                    GLThrowIfFailed("glBindTextureUnit");
                } else {
                    glActiveTexture(GL_TEXTURE0 + index);
                    GLThrowIfFailed("glActiveTexture");
                    //                    bindings.texture = {
                    //                            GL_TEXTURE_2D,
                    //                            id
                    //                    };
                    //                    GLThrowIfFailed("glBindTexture");
                }
            };
 
            GLGlobalStateCollection<GLuint, void(GLenum, GLuint, GLintptr, GLsizeiptr), 96> buffers = [](const GLuint index, const GLenum target, const GLuint buffer,
                const GLintptr offset, const GLsizeiptr size) {
                glBindBufferRange(target, index, buffer, offset, size);
            };
 
            GLGlobalStateCollection<GLuint, void(GLuint), 96> samplers = [](const GLuint index, const GLuint id) {
                glBindSampler(index, id);
            };
 
            GLGlobalStateCollection<GLuint, void(GLuint, GLintptr, GLsizei), 10> vertexBuffer = [](const GLuint bindingIndex, const GLuint buffer, const GLintptr offset,
                const GLsizei stride) {
                if(glBindVertexBuffer) {
                    glBindVertexBuffer(bindingIndex, buffer, offset, stride);
                    GLThrowIfFailed("glBindVertexBuffer");
                } else {
                    glBindBuffer(GL_ARRAY_BUFFER, buffer);
                    glEnableVertexAttribArray(0);
                }
            };
 
            struct {
                GLGlobalState<void(GLuint)> array = bindBuffer<GL_ARRAY_BUFFER>;
 
                GLGlobalState<void(GLuint)> atomicCounter = bindBuffer<GL_ATOMIC_COUNTER_BUFFER>;
 
                struct {
                    GLGlobalState<void(GLuint)> read = bindBuffer<GL_COPY_READ_BUFFER>;
 
                    GLGlobalState<void(GLuint)> write = bindBuffer<GL_COPY_WRITE_BUFFER>;
                } copy;
 
                GLGlobalState<void(GLuint)> drawIndirect = bindBuffer<GL_DRAW_INDIRECT_BUFFER>;
 
                GLGlobalState<void(GLuint)> dispatchIndirect = bindBuffer<GL_DISPATCH_INDIRECT_BUFFER>;
 
                GLGlobalState<void(GLuint)> elementArray = bindBuffer<GL_ELEMENT_ARRAY_BUFFER>;
 
                GLGlobalState<void(GLuint)> pixelPack = bindBuffer<GL_PIXEL_PACK_BUFFER>;
 
                GLGlobalState<void(GLuint)> pixelUnpack = bindBuffer<GL_PIXEL_UNPACK_BUFFER>;
 
                GLGlobalState<void(GLuint)> query = bindBuffer<GL_QUERY_BUFFER>;
 
                GLGlobalState<void(GLuint)> shaderStorage = bindBuffer<GL_SHADER_STORAGE_BUFFER>;
 
                GLGlobalState<void(GLuint)> texture = bindBuffer<GL_TEXTURE_BUFFER>;
 
                GLGlobalState<void(GLuint)> transformFeedback = bindBuffer<GL_TRANSFORM_FEEDBACK_BUFFER>;
 
                GLGlobalState<void(GLuint)> uniform = bindBuffer<GL_UNIFORM_BUFFER>;
            } buffer;
        } bindings;
 
        struct {
            GLCapability enabled = GL_CULL_FACE;
 
            GLGlobalState<decltype(glCullFace)> face = glCullFace;
        } culling;
 
        struct {
            GLCapability testingEnabled = GL_DEPTH_TEST;
 
            GLCapability clamping = GL_DEPTH_CLAMP;
 
            GLGlobalState<decltype(glDepthMask)> mask = glDepthMask;
 
            GLGlobalState<decltype(glDepthFunc)> function = glDepthFunc;
 
            GLGlobalState<decltype(glDepthRangef)> range = glDepthRangef;
        } depth;
 
        struct {
            GLCapability testingEnabled = GL_STENCIL_TEST;
 
            GLGlobalState<decltype(glStencilFunc)> function = glStencilFunc;
 
            GLGlobalState<decltype(glStencilOp)> operation = glStencilOp;
        } stencil;
 
        struct {
            GLCapability testingEnabled = GL_SCISSOR_TEST;
 
            GLGlobalState<decltype(glScissor)> box = glScissor;
        } scissor;
 
        GLCapability dither = {GL_DITHER, true};
 
        struct {
            GLCapability enabled = GL_BLEND;
 
            GLGlobalState<decltype(glBlendEquationSeparate)> equation = glBlendEquationSeparate;
 
            GLGlobalState<decltype(glBlendFuncSeparate)> function = glBlendFuncSeparate;
 
            GLGlobalState<decltype(glBlendColor)> color = glBlendColor;
        } blending;
 
        GLCapability framebufferSRGB = GL_FRAMEBUFFER_SRGB;
 
        struct {
            GLGlobalState<decltype(glPolygonMode)> mode = glPolygonMode;
 
            struct {
                GLCapability offset = GL_POLYGON_OFFSET_FILL;
            } fill;
 
            struct {
                GLGlobalState<decltype(glPointSize)> size = glPointSize;
 
                GLCapability point = GL_POLYGON_OFFSET_POINT;
 
                GLCapability sizeFromProgram = GL_PROGRAM_POINT_SIZE;
            } point;
 
            struct {
                GLCapability smooth = GL_LINE_SMOOTH;
 
                GLCapability offset = GL_POLYGON_OFFSET_LINE;
 
                GLGlobalState<decltype(glLineWidth)> width = glLineWidth;
            } line;
 
            GLGlobalState<decltype(glPolygonOffset)> offset = glPolygonOffset;
 
            GLCapability smooth = GL_POLYGON_SMOOTH;
        } polygon;
 
        struct {
            GLCapability enabled = {GL_MULTISAMPLE, true};
 
            GLCapability enableCoverage = GL_SAMPLE_COVERAGE;
 
            GLGlobalState<decltype(glSampleCoverage)> coverage = glSampleCoverage;
        } multisample;
 
        struct {
            GLCapability enabled = GL_PRIMITIVE_RESTART;
 
            GLCapability withFixedIndex = GL_PRIMITIVE_RESTART_FIXED_INDEX;
 
            GLGlobalState<decltype(glPrimitiveRestartIndex)> index = glPrimitiveRestartIndex;
        } primitiveRestart;
 
        struct {
            GLCapability enabled = GL_COLOR_LOGIC_OP;
 
            GLGlobalState<decltype(glLogicOp)> operation = glLogicOp;
        } logicOp;
 
        GLCapability rasterizerDiscard = GL_RASTERIZER_DISCARD;
 
        GLCapability sampleAlphaToCoverage = GL_SAMPLE_ALPHA_TO_COVERAGE;
 
        GLCapability sampleAlphaToOne = GL_SAMPLE_ALPHA_TO_ONE;
 
        struct {
            GLCapability enabled = GL_SAMPLE_MASK;
 
            GLGlobalState<decltype(glSampleMaski)> value = glSampleMaski;
        } sampleMask;
 
        GLCapability textureCubeMapSeamless = GL_TEXTURE_CUBE_MAP_SEAMLESS;
 
        struct {
            GLCapability enabled = GL_DEBUG_OUTPUT;
 
            GLCapability synchronous = GL_DEBUG_OUTPUT_SYNCHRONOUS;
 
            GLGlobalState<decltype(glDebugMessageCallback)> callback = glDebugMessageCallback;
        } debugOutput;
 
        GLCapability clipDistance[8] = {
            GL_CLIP_DISTANCE0,
            GL_CLIP_DISTANCE1,
            GL_CLIP_DISTANCE2,
            GL_CLIP_DISTANCE3,
            GL_CLIP_DISTANCE4,
            GL_CLIP_DISTANCE5,
            GL_CLIP_DISTANCE6,
            GL_CLIP_DISTANCE7,
        };
 
        //        /// If enabled, the active fragment shader is run once for
        //        each covered
        //        /// sample, or at fraction of this rate as determined by the
        //        current
        //        /// value of GL_MIN_SAMPLE_SHADING_VALUE. See
        //        glMinSampleShading. GLCapability sampleShading =
        //        GL_SAMPLE_SHADING;
 
    } state;
 
    class GLGlobalStateManager {};
 
} // namespace CeresEngine