RE_Visual.h

Go to the documentation of this file.

#ifndef __RE_Visual_h__
#define __RE_Visual_h__

#include "RE_API.h"
#include "RE_Types.h"

#include <UT/UT_Lock.h>
#include <UT/UT_ThreadSpecificValue.h>

// Include this before including any QOpenGL files.
// This ensures that our OpenGL core profile API is included
// instead of the one shipped with Qt.
// TODO: We should look into moving over to Qt's OpenGL API
//       (i.e. include QtGui/qopengl.h or maybe QtGui/QOpenGLFunctions.h
//       instead of glcorearb.h)
#include "RE_OGL.h"

class RE_Server;
class RE_OpenGLDrawable;
class RE_QPainterDrawable;
class RE_Window;
class RE_WindowDrawable;

class QOpenGLContext;
class QSurfaceFormat;
class QWidget;


class RE_API RE_Visual
{
public:
    RE_Visual(RE_DisplayMode newmode);
    ~RE_Visual();

    /// ======================================================================
    /// For new 2D UI drawing.
    
    // These methods manage drawables that support OpenGL painting.
    // {
    RE_WindowDrawable   *createDrawable(RE_Window *win) const;
    void                 deleteDrawable(RE_WindowDrawable *drawable) const;

    RE_WindowDrawable   *grabDrawable(RE_Window *win, bool attach = true);
    void                 returnDrawable(
                            RE_Window *win, RE_WindowDrawable *drawable);

    RE_OpenGLDrawable   *createOpenGLDrawable(RE_Window *win) const;
    void                 deleteOpenGLDrawable(
                            RE_OpenGLDrawable *drawable) const;

    RE_OpenGLDrawable   *grabOpenGLDrawable(RE_Window *win, bool attach = true);
    void                 returnOpenGLDrawable(
                            RE_Window *win, RE_OpenGLDrawable *drawable);
    // }
    
    // These methods manage drawables that only supports QPainter painting
    // (no OpenGL painting).
    // {
    RE_QPainterDrawable *createQPainterDrawable(RE_Window *win) const;
    void                 deleteQPainterDrawable(
                            RE_QPainterDrawable *drawable) const;

    RE_QPainterDrawable *grabQPainterDrawable(RE_Window *win, bool attach = true);
    void                 returnQPainterDrawable(
                            RE_Window *win, RE_QPainterDrawable *drawable);
    // }


    /// ======================================================================
    //

    /// ======================================================================
    /// For OpenGL 2D UI drawing.
    RE_OGLContext createContext(RE_Window *win) const;
    void         deleteContext(RE_OGLContext) const;

    RE_OGLContext grabContext(RE_Window *win, bool attach = true);
    void        returnContext(RE_Window *win, RE_OGLContext ctx);
    /// ======================================================================

    // isMode() returns true on an exact match. isCompatibleWithMode() returns
    // true if this visual is equal to or a superset of the features in 'match'
    bool        isMode(RE_DisplayMode match) const;
    bool        isCompatibleWithMode(RE_DisplayMode match) const;

    bool        isRGB() const;

    /// Returns the display mode used for the request to create this visual.
    RE_DisplayMode getMode() const { return myVisualMode; }

    const QSurfaceFormat *      getPixelFormat() const;
    static QOpenGLContext *     getSharedGLContext();
    static void                 initDefaultGLFormat();

    /// Return the tag we use to identify our GL widgets.
    /// This is useful when handling events in the event loop.
    static const char *         glWidgetTag();

    /// Return the tag we use to identify our GL widget wrappers.
    /// This is useful when handling events in the event loop.
    static const char *         glWidgetWrapperTag();

    /// Return the window widget that is bound to the specified GL widget.
    static QWidget *            ownerWindowWidget(QWidget *gl_widget);

    /// ======================================================================
    /// For new 2D UI drawing.
    bool                       canOpenGLDrawableSupportQuadBufferStereo(
                                RE_OpenGLDrawable *drawable);
    bool                       canDrawableSupportQuadBufferStereo(
                                RE_WindowDrawable *drawable);
    /// ======================================================================

    /// ======================================================================
    /// For OpenGL 2D UI drawing.
    bool                       canSupportQuadBufferStereo(OGLDrawable drawable);
    /// ======================================================================

private:
    void                        initPixelFormat_(RE_DisplayMode mode);
    void                        createSharedGLWidget_();
    void                        testGLVersions_();
    bool                        canCreateGLContext_(
                                    int gl_major, int gl_minor, 
                                    bool use_core_profile);

    RE_DisplayMode          myVisualMode;

    /// ======================================================================
    /// For new 2D UI drawing.

    UT_Lock                 myDrawableLock;
    UT_Array<RE_WindowDrawable *> myVisibleDrawables[7];

    UT_Lock                 myOpenGLDrawableLock;
    UT_Array<RE_OpenGLDrawable *> myVisibleOpenGLDrawables[7];

    UT_Lock                 myQPainterDrawableLock;
    UT_Array<RE_QPainterDrawable *> myVisibleQPainterDrawables;
    /// ======================================================================

    /// ======================================================================
    /// For OpenGL 2D UI drawing.
    UT_Lock                 myContextLock;
    UT_Array<RE_OGLContext> myVisibleContexts;
    /// ======================================================================

    // This widget is for stashing away returned GL widgets by containing them
    // as children.  This causes the GL widgets to be parented at all times so
    // that their window flags do not change.
    QWidget *myStashWidget;

    QSurfaceFormat *            myPixelFormat;
};

#endif