RE_GLDrawable.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        RE_GLDrawable.h (RE Library, C++)
 *
 * COMMENTS:
 */

#ifndef __RE_GLDRAWABLE_H_INCLUDED__
#define __RE_GLDRAWABLE_H_INCLUDED__

#include "RE_API.h"

// We must include this before the Qt OpenGL headers in order to ensure the
// correct linkage on Windows.
#include "RE_OGL.h"

#if defined(USE_QT6)
#include <UT/UT_UniquePtr.h>
#endif

#if defined(EXPERIMENTAL_QOPENGLWIDGET)
#include <QtWidgets/QOpenGLWidget>
#else
#include <QtGui/QOpenGLContext>
#include <QtWidgets/QWidget>
#endif

#if defined(EXPERIMENTAL_VOLT_STYLE)
#include <UI/UI_Look.h>
#include <UT/UT_Array.h>
#include <QtGui/QPainter>
#endif

#undef emit


// Object names for QWidget and QWindow (drawable surface) objects used
// for OpenGL rendering.  Note that the drawable surface name must be exactly
// equal to the drawable name plus "Window" as the suffix.  This is a
// restriction of the QWidgetWindow class.
#define RE_GL_DRAWABLE_OBJ_NAME "RE_GLDrawable"
#define RE_GL_DRAWABLE_SURFACE_OBJ_NAME RE_GL_DRAWABLE_OBJ_NAME "Window"

#define RE_GL_DRAWABLE_WRAPPER_OBJ_NAME RE_GL_DRAWABLE_OBJ_NAME "Wrapper"


#if defined(EXPERIMENTAL_QOPENGLWIDGET)
class QOpenGLContext;
#endif
class QSurfaceFormat;
class RE_GLDrawable;
#if defined(EXPERIMENTAL_QOPENGLWIDGET)
class RE_Window;
#endif

#if !defined(USE_QT6) && !defined(EXPERIMENTAL_QOPENGLWIDGET)
class RE_GLContext : public QOpenGLContext
{
public:
    RE_GLContext() :
        myDrawable(nullptr)
    {}

    ~RE_GLContext() override {}

    RE_GLDrawable *drawable() const { return myDrawable; }
    void setDrawable(RE_GLDrawable *drawable) { myDrawable = drawable; }

private:
    RE_GLDrawable *myDrawable;
};
#endif


#if defined(EXPERIMENTAL_QOPENGLWIDGET)
/// GL drawable for Qt5.
class RE_API RE_GLDrawable : public QOpenGLWidget
#else
/// GL drawable for Qt5.
/// It's basically a plain Qt widget that manages a GL context.
class RE_API RE_GLDrawable : public QWidget
#endif
{
public:
    RE_GLDrawable(const QSurfaceFormat &format);
    RE_GLDrawable(
        const QSurfaceFormat &format, QWidget *parent, 
        QOpenGLContext *sharedContext);
    ~RE_GLDrawable() override;

#if defined(EXPERIMENTAL_QOPENGLWIDGET)
    /// Assign the GL drawable to the given window.
    /// The given GL drawable will be used to render the contents of the window.
    void setREWindow(RE_Window *window);
#else
#if defined(USE_QT6)
    QOpenGLContext *context() { return myContext.get(); }
#else
    RE_GLContext *context() { return &myContext; }
#endif

    QPaintEngine *paintEngine() const override { return nullptr; };
#endif

    static const char *widgetTag() { return RE_GL_DRAWABLE_OBJ_NAME; }

    /// Return the string tag used to identify whether a QWindow
    /// is used a drawable surface for Houdini.
    static const char * drawableSurfaceTag() 
        { return RE_GL_DRAWABLE_SURFACE_OBJ_NAME; }

    /// Return the string tag used to identify whether a QWidget
    /// is the wrapper widget of a GL drawable in Houdini.
    static const char *widgetWrapperTag()
        { return RE_GL_DRAWABLE_WRAPPER_OBJ_NAME; }

#if defined(EXPERIMENTAL_VOLT_STYLE)
    void updatePixmap(UI_Look *look, QPixmap pixmap)
    {
        for (int i = 0; i < myPixmapBuffer.size(); i++)
        {
            if (myPixmapBuffer[i].first == look)
            {
                myPixmapBuffer.removeIndex(i);
                break;
            }
        }
        myPixmapBuffer.append(std::make_pair(look, pixmap));
    }
#endif

protected:
#if defined(EXPERIMENTAL_QOPENGLWIDGET)
    void initializeGL() override;
    void paintGL() override;
    void resizeGL(int w, int h) override;

#else
    void paintEvent(QPaintEvent *event) override;
    void resizeEvent(QResizeEvent *event) override;
#endif
    void mousePressEvent(QMouseEvent *event) override;

private:
#if defined(USE_QT6)
    void init_(
        const QSurfaceFormat *format, QOpenGLContext *shared_context=nullptr);
#else
    void init_();
#endif

#if defined(EXPERIMENTAL_QOPENGLWIDGET)
    QOpenGLContext *myInitializedContext = nullptr;
    RE_Window *myREWindow = nullptr;

    bool myIsPainting = false;
#else
#if defined(USE_QT6)
    UT_UniquePtr<QOpenGLContext> myContext;
#else
    RE_GLContext myContext;
#endif
#endif

#if defined(EXPERIMENTAL_VOLT_STYLE)
    // Acts as a buffer for UI elements to store their pixmaps in when each of
    // their render() functions is called. All pixmaps in this map get drawn to
    // the screen during each paintEvent().
    UT_Array<std::pair<UI_Look *, QPixmap>> myPixmapBuffer;
#endif
};


#endif // __RE_GLDRAWABLE_H_INCLUDED__