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

#ifndef __RE_WINDOWDRAWABLE_H_INCLUDED__
#define __RE_WINDOWDRAWABLE_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"

#include "RE_Render.h"
#include <UT/UT_Rect.h>
#include <UT/UT_UniquePtr.h>

#if defined(USE_QT6)
#include <QtOpenGLWidgets/QOpenGLWidget>
#else
#include <QtWidgets/QOpenGLWidget>
#endif
#include <QtWidgets/QStylePainter>

#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_WINDOW_DRAWABLE_OBJ_NAME "RE_WindowDrawable"
#define RE_WINDOW_DRAWABLE_SURFACE_OBJ_NAME \
    RE_WINDOW_DRAWABLE_OBJ_NAME "Window"
#define RE_WINDOW_DRAWABLE_WRAPPER_OBJ_NAME \
    RE_WINDOW_DRAWABLE_OBJ_NAME "Wrapper"


class QOpenGLContext;
class QSurfaceFormat;
class RE_QPainterDrawable;
class RE_Window;
class RE_WindowDrawable;
class RE_WindowDrawablePaintState;
class re_AutoPaintBlockBase;
struct re_GLState;

/// Specialized style painter class for RE_WindowDrawable.
/// The class manages transitioning between native Houdini (OpenGL) painting
/// and Qt styled painting in the window drawable.
class RE_API RE_WindowDrawablePainter : public QStylePainter
{
public:
    RE_WindowDrawablePainter();
    ~RE_WindowDrawablePainter();

    /// Pass key class to help restrict access to the methods that
    /// control the paint session.
    class PaintSessionPassKey
    {
    private:
        friend re_AutoPaintBlockBase;
        friend RE_WindowDrawable;
    };

    ///
    /// Begin a new paint session.
    /// This should only be called when not currently in a paint session.
    ///
    void beginPaintSession(
            const PaintSessionPassKey &k,
            RE_WindowDrawable *drawable, RE_QPainterDrawable *qpainter_drawable,
            RE_Render *render);

    ///
    /// End the current paint session.
    /// This should only be called when currently in a paint session.
    ///
    void endPaintSession(const PaintSessionPassKey &k);

    ///
    /// Switch to OpenGL painting mode.
    /// This should only be called when currently in a paint session.
    ///
    void beginOpenGLPainting(const PaintSessionPassKey &k);

    ///
    /// Switch to Qt styled painting mode.
    /// This should only be called when currently in a paint session.
    ///
    void endOpenGLPainting(const PaintSessionPassKey &k);

    ///
    /// Query whether in OpenGL painting mode.
    /// This should only be called when currently in a paint session.
    ///
    bool isOpenGLPainting() const;

    RE_Render *currentRender() const { return myCurRender; }
    RE_WindowDrawable *currentDrawable() const { return myCurDrawable; }

    /// For debugging.  Output the painter's state.
    void dumpState() const;

    /// Return the paint state of the current paint session.
    /// Return nullptr if there is currently no paint session.
    static RE_WindowDrawablePaintState *currentPaintState();

private:

#if UT_ASSERT_LEVEL > 0
    /// Assert that the OpenGL state matches what's cached in RE_Render.
    void assertGLStateForRender() const;
#endif

    /// Restore the OpenGL state to what's cached in RE_Render.
    void restoreGLStateForRender() const;

    /// Save parts of the OpenGL state that Qt/QPainter care about.
    void saveGLStateForQPainter();

    /// Restore parts of the OpenGL state that Qt/QPainter care about.
    void restoreGLStateForQPainter();

    // The RE_WindwoDrawable that the current painting session applies to.
    RE_WindowDrawable *myCurDrawable = nullptr;

    // The RE_QPainterDrawable that the current non-OpenGL painting session
    // applies to.
    RE_QPainterDrawable *myCurQPainterDrawable = nullptr;

    // The RE_Render used in the current painting session.
    RE_Render *myCurRender = nullptr;

    // This counter keeps track of nested calls to switch into OpenGL
    // paint mode.  We default to 0 because the painter starts in QPainter
    // paint mode.
    int myOpenGLModeLevel = 0;

    // The OpenGL state that Qt/QPainter care about.
    struct re_GLState;
    UT_UniquePtr<re_GLState>myGLState;
};

/// Class to keep track of the painter and the current paint
/// area in a paint session.  The paint area y-origin and height
/// are specified in Houdini's UI coordinate space 
/// (i.e. bottom-left origin).
class RE_API RE_WindowDrawablePaintState
{
public:
    RE_WindowDrawablePaintState(
        RE_WindowDrawablePainter *painter, 
        int paint_area_x, int paint_area_y, int paint_area_w, int paint_area_h);
    ~RE_WindowDrawablePaintState() = default;

    RE_WindowDrawablePaintState(const RE_WindowDrawablePaintState &src);
    RE_WindowDrawablePaintState &operator=(
        const RE_WindowDrawablePaintState &src);

    RE_WindowDrawablePainter *painter() const;

    /// Push onto the stack a new paint area.
    /// This is needed by UI_Viewport, for example, which paints
    /// into an FBO with a different viewport.
    void pushPaintArea(
            int paint_area_x, int paint_area_y, 
            int paint_area_w, int paint_area_h);

    /// Pop the current paint area from the stack.
    void popPaintArea();

    /// Return the current paint area.
    const UT_DimRect &paintArea() const;

#if defined(MBSD)
    /// Return true if the paint state is currently for a UI_Viewport.
    bool isForUIViewport() const;
#endif

    /// Convert the given x,y position from the Houdini UI coordinate space
    /// to Qt's QPainter coordinate space.  If x,y is for the (bottom-left)
    /// corner of a rectangle, then specify the width and height of the
    /// rectangle to convert the x,y position to the Qt (top-left)
    /// rectangle.
    void toPainterPosition(int &x, int &y, int w=0, int h=0) const;

    /// Convert the given x,y position from the Qt QPainter coordinate space
    /// to the Houdini UI coordinate space.  If x,y is for the (top-left)
    /// corner of a rectangle, then specify the width and height of the
    /// rectangle to convert the x,y position to the Houdini UI (bottom-left)
    /// rectangle.
    void toUIPosition(int &x, int &y, int w=0, int h=0) const;

private:
    RE_WindowDrawablePainter *myPainter;
    UT_Array<UT_DimRect> myPaintAreaStack;
};

class RE_API re_AutoPaintBlockBase
{
public:
    re_AutoPaintBlockBase &operator=(const re_AutoPaintBlockBase &src)
        = delete;

    /// Return the underlying paint state.
    RE_WindowDrawablePaintState *paintState()
        { return myPaintState; }

    /// Convenience method to access the paint state's painter.
    RE_WindowDrawablePainter *painter() const
        { return myPaintState->painter(); }

    /// Convenience method to access the paint state's paint area.
    const UT_DimRect &paintArea() const
        { return myPaintState->paintArea(); }
    
    /// Convenience method to call the paint state's toPainterPosition()
    /// method.
    void toPainterPosition(int &x, int &y, int w=0, int h=0) const
        { myPaintState->toPainterPosition(x, y, w, h); }
    
    /// Convenience method to call the paint state's toUIPosition()
    /// method.
    void toUIPosition(int &x, int &y, int w=0, int h=0) const
        { myPaintState->toUIPosition(x, y, w, h); }

protected:
    re_AutoPaintBlockBase(RE_Render *r);
    ~re_AutoPaintBlockBase();

    RE_WindowDrawablePaintState *getPaintState() { return myPaintState; }

private:
    RE_WindowDrawablePaintState *myPaintState = nullptr;
    RE_WindowDrawable *myDrawable = nullptr;
    RE_Render *myRender = nullptr;
};

/// Construct at the beginning of a painting code block to switch to
/// QPainter painting mode.  If there is no active paint state, then
/// begin a new paint session to create an active paint state.
class RE_API RE_AutoQPainterPaintBlock : public re_AutoPaintBlockBase
{
public:
    RE_AutoQPainterPaintBlock(RE_Render *r);
    ~RE_AutoQPainterPaintBlock();

    RE_AutoQPainterPaintBlock &operator=(
        const RE_AutoQPainterPaintBlock &src)
        = delete;

private:
    bool mySwitchedToQPainterMode = false;
};

/// Construct at the beginning of a painting code block to switch to
/// OpenGL painting mode.  If there is no active paint state, then
/// begin a new paint session to create an active paint state.
class RE_API RE_AutoOpenGLPaintBlock : public re_AutoPaintBlockBase
{
public:
    RE_AutoOpenGLPaintBlock(RE_Render *r);
    ~RE_AutoOpenGLPaintBlock();

    RE_AutoOpenGLPaintBlock &operator=(const RE_AutoOpenGLPaintBlock &src) 
        = delete;

private:
    bool mySwitchedToOpenGLMode = false;
};


/// Window drawable.
/// It currently uses an OpenGL backend via QOpenGLWidget.
class RE_API RE_WindowDrawable : public QOpenGLWidget
{
public:
    RE_WindowDrawable(const QSurfaceFormat &format);
    RE_WindowDrawable(
        const QSurfaceFormat &format, QWidget *parent, 
        QOpenGLContext *sharedContext);
    ~RE_WindowDrawable() 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; }

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

    static const char *widgetTag() { return RE_WINDOW_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_WINDOW_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_WINDOW_DRAWABLE_WRAPPER_OBJ_NAME; }

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

protected:
    void initializeGL() override;
    void paintGL() override;
    void resizeGL(int w, int h) override;
    void paintEvent(QPaintEvent *e) override;
    void showEvent(QShowEvent *event) override;

private:
    void init_(
        const QSurfaceFormat *format, QOpenGLContext *shared_context=nullptr);

    QOpenGLContext *myInitializedContext = nullptr;
    RE_Window *myREWindow = nullptr;

    bool myIsPainting = false;
    bool myNeedsOwnerUpdate = false;

    int mySamples = -1;

    RE_WindowDrawablePainter myPainter;
};


#endif // __RE_WINDOWDRAWABLE_H_INCLUDED__