opengl.h

#ifndef OE_CORE_RENDERER_OPENGL_H
#define OE_CORE_RENDERER_OPENGL_H
 
#include "config.h" // IWYU pragma: keep (Required for general configuration)
 
#include <cassert>
#include <glue_chan/glue_chan.h>
#include "../../util/non_copyable.h"
#include <memory>
 
namespace oe::render
{
    class ScreenQuad;
}
 
namespace oe::core
{
    class Window;

    class OpenGL : public oe::util::NonCopyable // TODO 'OpenGL : public Renderer'
    {
        public:
            OpenGL(Window* context_holder);
 
            ~OpenGL()
            {
                _instance = nullptr;
            }

            void resizeViewport(const int32_t x, const int32_t y, const int32_t width, const int32_t height);

            void scissor(uint32_t x, uint32_t y, uint32_t width, uint32_t height);

            std::shared_ptr<render::ScreenQuad> getScreenQuad()
            {
                assert(_instance != nullptr);
 
                return _screen_quad;
            }

            static OpenGL* getInstance()
            {
                return _instance;
            }

            static bool hasContext()
            {
                return _instance != nullptr;
            }

            const Window& getWindow() const noexcept
            {
                return *_context_holder;
            }

            void bindContextToWindow(Window& window);
 
            #ifdef OXYGEN_ENGINE_OPENGL_DEBUG_OUTPUT
                static void APIENTRY debugCallback(
                    GLenum source,
                    GLenum type,
                    uint32_t id,
                    GLenum severity,
                    GLsizei length,
                    const char* message,
                    const void* userParam
                );
            #endif
 
        protected:
            std::shared_ptr<render::ScreenQuad> _screen_quad;
 
        private:
            // Allow only one OpenGL instance per thread
            thread_local static OpenGL* _instance;
 
            Window* _context_holder = nullptr;
    };
}
 
#endif