GLContext.hpp

Go to the documentation of this file.

/*
 *  Copyright (C) 2010 - 2016 Leonid Kostrykin
 *
 *  Chair of Medical Engineering (mediTEC)
 *  RWTH Aachen University
 *  Pauwelsstr. 20
 *  52074 Aachen
 *  Germany
 * 
 * 
 *  Copyright (C) 2021 - 2025 Leonid Kostrykin
 * 
 */
 
#ifndef GLCONTEXT_H_6014714286
#define GLCONTEXT_H_6014714286
 
#include <LibCarna/LibCarna.hpp>
#include <LibCarna/base/LibCarnaException.hpp>
#include <LibCarna/base/noncopyable.hpp>
#include <LibCarna/base/Log.hpp>
#include <memory>
 
namespace LibCarna
{
 
namespace base
{
 
 
 
// ----------------------------------------------------------------------------------
// GLContext
// ----------------------------------------------------------------------------------
 
class LIBCARNA GLContext
{
 
    NON_COPYABLE
 
    struct Details;
    const std::unique_ptr< Details > pimpl;
 
protected:
 
    explicit GLContext( bool isDoubleBuffered );
 
    friend class RenderState;
    
    void pushRenderState( const RenderState& rs );
    
    void popRenderState();
    
    const RenderState& currentRenderState() const;
 
public:
 
    const static unsigned int DEPTH_BUFFER_BIT; 
    const static unsigned int COLOR_BUFFER_BIT; 
 
    const bool isDoubleBuffered;
 
    virtual ~GLContext();
 
    const std::string& vendor() const; 
 
    const std::string& renderer() const; 
 
    static GLContext& current();
 
    void makeCurrent() const;
 
    bool isCurrent() const;
 
    void setShader( const ShaderProgram& shader );
 
    const ShaderProgram& shader() const;
 
    void clearBuffers( unsigned int flags );
    
protected:
 
    virtual void activate() const = 0;
 
}; // GLContext
 
 
 
// ----------------------------------------------------------------------------------
// QGLContextAdapter
// ----------------------------------------------------------------------------------
 
template< typename QGLContext, typename QGLFormat >
class QGLContextAdapter : public GLContext
{
 
    QGLContext& qglcontext;
 
public:
 
    QGLContextAdapter();
    
    static QGLFormat desiredFormat();
    
protected:
 
    virtual void activate() const override;
 
}; // QGLContextAdapter
 
 
template< typename QGLContext, typename QGLFormat >
QGLContextAdapter< QGLContext, QGLFormat >::QGLContextAdapter()
    : GLContext( QGLContext::currentContext()->format().doubleBuffer() )
    , qglcontext( const_cast< QGLContext& >( *QGLContext::currentContext() ) )
{
    const QGLFormat& format = QGLContext::currentContext()->format();
    if( format.majorVersion() < 3 || ( format.majorVersion() == 3 && format.minorVersion() < 3 ) )
    {
        std::stringstream msg;
        msg << "OpenGL context version " << format.majorVersion() << "." << format.minorVersion() << " is too low.";
        LIBCARNA_FAIL( msg.str() );
    }
    else
    {
        LIBCARNA_ASSERT( format.profile() != QGLFormat::NoProfile );
        std::stringstream msg;
        msg << "Recognized OpenGL " << format.majorVersion() << "." << format.minorVersion() << " context (";
        msg << ( format.profile() == QGLFormat::CoreProfile ? "core" : "compatibility" ) << " profile)";
        Log::instance().record( Log::debug, msg.str() );
    }
}
 
    
template< typename QGLContext, typename QGLFormat >
QGLFormat QGLContextAdapter< QGLContext, QGLFormat >::desiredFormat()
{
    QGLFormat format = QGLFormat::defaultFormat();
    format.setVersion( 3, 3 );
    format.setProfile( QGLFormat::CompatibilityProfile );
    return format;
}
 
 
template< typename QGLContext, typename QGLFormat >
void QGLContextAdapter< QGLContext, QGLFormat >::activate() const
{
    qglcontext.makeCurrent();
}
 
 
 
}  // namespace LibCarna :: base
 
}  // namespace LibCarna
 
#endif // GLCONTEXT_H_6014714286