RE_OpenGLDrawable.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_OpenGLDrawable.h (RE Library, C++)
 *
 * COMMENTS:
 */

#ifndef __RE_OPENGLDRAWABLE_H_INCLUDED__
#define __RE_OPENGLDRAWABLE_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"

// Needed for RE_WindowDrawablePainter.
#include "RE_WindowDrawable.h"
#include <UT/UT_UniquePtr.h>

#include <QtGui/QOpenGLContext>
#include <QtGui/QSurfaceFormat>
#include <QtOpenGL/QOpenGLPaintDevice>
#include <QtWidgets/QWidget>

#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_OPENGL_DRAWABLE_OBJ_NAME "RE_OpenGLDrawable"
#define RE_OPENGL_DRAWABLE_SURFACE_OBJ_NAME \
    RE_OPENGL_DRAWABLE_OBJ_NAME "Window"
#define RE_OPENGL_DRAWABLE_WRAPPER_OBJ_NAME \
    RE_OPENGL_DRAWABLE_OBJ_NAME "Wrapper"

class QPaintDevice;
class QPaintEngine;
class RE_Window;

/// Window drawable that uses OpenGL and QPainter for the new UI path.
/// The drawable is a QWidget that manages its own OpenGL context and
/// is backed by a QWindow with a OpenGL surface type.
class RE_API RE_OpenGLDrawable : public QWidget
{
public:
    RE_OpenGLDrawable(const QSurfaceFormat &format);
    RE_OpenGLDrawable(
        const QSurfaceFormat &format, QWidget *parent, 
        QOpenGLContext *sharedContext);
    ~RE_OpenGLDrawable() override;

    /// Assign the drawable to the given window.
    /// The given drawable will be used to render the contents of the window.
    void setREWindow(RE_Window *window);

    /// Return the window that the drawable is currently assigned to.
    const RE_Window *getREWindow() const { return myREWindow; }

    /// Return the OpenGL context tied to this drawable.
    /// If the context has not yet been initialized, then return nullptr.
    QOpenGLContext *context();

    /// Make this drawable's context the current OpenGL context.
    void makeCurrent();

    /// Clear this drawable's context as the current context.
    /// Do nothing if the drawable's context is not the current context.
    void doneCurrent();

    /// Swap the front and back buffers in the drawable's OpenGL context.
    void swapBuffers();

    /// Return the drawable's paint device that QPainter objects should paint
    /// to.
    QPaintDevice *stylePaintDevice();

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

    /// Multisample sample count this drawable was created with (-1 if none).
    int              samples() const { return mySamples; }

    static const char *widgetTag() { return RE_OPENGL_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_OPENGL_DRAWABLE_SURFACE_OBJ_NAME; }

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

    /// Return the Painter used to paint the contents of the drawable.
    RE_WindowDrawablePainter &painter();

    void initializeGL();

protected:
    void paintEvent(QPaintEvent *event) override;
    void resizeEvent(QResizeEvent *event) override;
    void showEvent(QShowEvent *event) override;

private:
    void init_(const QSurfaceFormat *format);

    void createGLContext_();
    void render_();
    void paintGL_();

    QSurfaceFormat myFormat;
    UT_UniquePtr<QOpenGLContext> myContext;
    UT_UniquePtr<QOpenGLPaintDevice> myStylePaintDevice;
    QOpenGLContext *mySharedContext = nullptr;
    bool myIsContextInitialized = false;
    RE_Window *myREWindow = nullptr;
    bool myIsPainting = false;
    bool myNeedsOwnerUpdate = false;
    int mySamples = -1;

    RE_WindowDrawablePainter myPainter;
};


#endif // __RE_OPENGLDRAWABLE_H_INCLUDED__