OpenGLContext.hpp

#pragma once
#include <Core/Utils/Observable.hpp>
#include <Headless/RaHeadless.hpp>
 
#include <array>
#include <functional>
#include <string>
 
#include <glbinding-aux/ContextInfo.h>
#include <glbinding/Version.h>
#include <glbinding/gl/gl.h>
 
namespace Ra {
namespace Headless {
 
class HEADLESS_API OpenGLContext
{
  public:
    explicit OpenGLContext( const glbinding::Version& glVersion = { 4, 1 },
                            const std::array<int, 2>& size      = { { 1, 1 } } ) {
        CORE_UNUSED( glVersion );
        CORE_UNUSED( size );
    };
    virtual ~OpenGLContext() = default;
    virtual void makeCurrent() const = 0;
    virtual void doneCurrent() const = 0;
    virtual bool isValid() const = 0;
 
    virtual bool isWindow() const { return false; }
 
    [[nodiscard]] virtual std::string getInfo() const;
    enum class EventMode : int { POLL = 0, WAIT, TIMEOUT, NUM_MODES };
    virtual void show( EventMode /*mode*/, float /*delay*/ ) {};
    virtual void hide() {};
    virtual void resize( const std::array<int, 2>& /*size*/ ) {};
    virtual void renderLoop( std::function<void( float )> /*render*/ ) {};
 
    Ra::Core::Utils::Observable<int, int>& resizeListener() { return m_resizers; }
 
    // TODO : give access to the DPI ratio
    // https://www.glfw.org/docs/latest/window_guide.html#window_scale
 
    Ra::Core::Utils::Observable<int, int, int, int>& keyboardListener() {
        return m_keyboardObservers;
    }
 
    Ra::Core::Utils::Observable<int, int, int, int, int>& mouseListener() {
        return m_mouseObservers;
    }
 
    Ra::Core::Utils::Observable<int, int>& mouseMoveListener() { return m_mouseMoveObservers; }
 
    Ra::Core::Utils::Observable<int, int>& scrollListener() { return m_scrollObservers; }
 
  protected:
    virtual bool processEvents() { return true; };
 
    void resizeFrameBuffer( int width, int height );
    Ra::Core::Utils::Observable<int, int> m_resizers;
 
    void keyboardEventCallback( int key, int scancode, int action, int mods );
    Ra::Core::Utils::Observable<int, int, int, int> m_keyboardObservers;
 
    void mouseEventCallback( int button, int action, int mods, int x, int y );
    Ra::Core::Utils::Observable<int, int, int, int, int> m_mouseObservers;
 
    void mouseMoveEventCallback( int x, int y );
    Ra::Core::Utils::Observable<int, int> m_mouseMoveObservers;
 
    void scrollEventCallback( int xoffset, int yoffset );
    Ra::Core::Utils::Observable<int, int> m_scrollObservers;
 
    EventMode m_mode { EventMode::POLL };
    float m_delay { 1.f / 60.f };
};
 
inline std::string OpenGLContext::getInfo() const {
    std::stringstream infoText;
    using ContextInfo = glbinding::aux::ContextInfo;
    makeCurrent();
    infoText << "*** OffScreen OpenGL context ***" << std::endl;
    infoText << "Renderer (glbinding) : " << ContextInfo::renderer() << "\n";
    infoText << "Vendor   (glbinding) : " << ContextInfo::vendor() << "\n";
    infoText << "OpenGL   (glbinding) : " << ContextInfo::version().toString() << "\n";
    infoText << "GLSL                 : " << gl::glGetString( gl::GL_SHADING_LANGUAGE_VERSION )
             << "\n";
    doneCurrent();
 
    return infoText.str();
}
 
inline void OpenGLContext::resizeFrameBuffer( int width, int height ) {
    gl::glViewport( 0, 0, width, height );
    m_resizers.notify( width, height );
}
 
inline void OpenGLContext::keyboardEventCallback( int key, int scancode, int action, int mods ) {
    m_keyboardObservers.notify( key, scancode, action, mods );
}
 
inline void OpenGLContext::mouseEventCallback( int button, int action, int mods, int x, int y ) {
    m_mouseObservers.notify( button, action, mods, x, y );
}
 
inline void OpenGLContext::mouseMoveEventCallback( int x, int y ) {
    m_mouseMoveObservers.notify( x, y );
}
 
inline void OpenGLContext::scrollEventCallback( int xoffset, int yoffset ) {
    m_scrollObservers.notify( xoffset, yoffset );
}
 
} // namespace Headless
} // namespace Ra