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>

#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_Window;
class RE_WindowDrawable;
class RE_WindowDrawablePaintState;

/// 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:
    ///
    /// Begin a new paint session.
    /// This should only be called when not currently in a paint session.
    ///
    void beginPaintSession(RE_WindowDrawable *drawable, RE_Render *render);

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

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

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

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

private:

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

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

/// 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;

    /// 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;
};

/// 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_AutoPaintStateBlock
{
public:
    RE_AutoPaintStateBlock(RE_Render *r);
    ~RE_AutoPaintStateBlock();

    RE_AutoPaintStateBlock &operator=(const RE_AutoPaintStateBlock &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); }

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


/// 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);

    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 true if the new UI skin should be drawn.
    static bool shouldDrawNewUI(); 

    /// 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;

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

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

    bool myIsPainting = false;

    RE_WindowDrawablePainter myPainter;
};


#endif // __RE_WINDOWDRAWABLE_H_INCLUDED__