QQuickCPainterRenderer Class

class MyRenderer : public QQuickCPainterRenderer
{
public:
    void synchronize(QQuickCPainterItem *item) override
    {
        // copy a custom property value from item in a thread-safe manner
        m_value = static_cast<MyItem *>(item)->value();
    }

    void initializeResources(QCPainter *p) override
    {
        // load assets
        if (m_image.isNull())
            m_image = p->addImage(QImage("image.png"), QCPainter::ImageFlag::Repeat);
    }

    void prePaint(QCPainter *p) override
    {
        // this is where offscreen canvases are drawn into
        if (m_canvas.isNull()) {
            m_canvas = p->createCanvas(QSize(640, 480));
            beginCanvasPainting(m_canvas);
            // ... draw into the offscreen canvas
            endCanvasPainting(m_canvas);
            m_canvasImage = p->addImage(m_canvas);
        }
    }

    void paint(QCPainter *p) override
    {
        QPointF center(width() / 2, height() / 2);
        // ... draw using m_value, m_image, and m_canvasImage
    }

    QCImage m_image;
    QCOffscreenCanvas m_canvas;
    QCImage m_canvasImage;
    float m_value;
};

Member Function Documentation

[explicit] QQuickCPainterRenderer::QQuickCPainterRenderer()

Constructs a QQuickCPainterRenderer.

[override virtual noexcept] QQuickCPainterRenderer::~QQuickCPainterRenderer()

Destroys the QQuickCPainterRenderer.

[protected] void QQuickCPainterRenderer::beginCanvasPainting(QCOffscreenCanvas &canvas)

Starts recording QCPainter draw commands targeting canvas.

beginCanvasPainting() must always be followed by corresponding endCanvasPainting() before returning from prePaint().

[protected] void QQuickCPainterRenderer::endCanvasPainting()

Indicates the end of the drawing targeting the canvas specified in beginCanvasPainting().

beginCanvasPainting() must always be followed by corresponding endCanvasPainting() before returning from prePaint().

QColor QQuickCPainterRenderer::fillColor() const

Return the current fill color of the item. This can be set by the parent QQuickCPainterItem.

[protected] void QQuickCPainterRenderer::grabCanvas(const QCOffscreenCanvas &canvas, std::function<void (const QImage &)> callback)

Issues a texture readback request for canvas.

callback is invoked either before the function returns, or later, depending on the underlying QRhi and 3D API implementation. Reading back texture contents may involve a GPU->CPU copy, depending on the GPU architecture.

bool QQuickCPainterRenderer::hasSharedPainter() const

Returns true if this item renderer uses a shared painter.

See also setSharedPainter.

float QQuickCPainterRenderer::height() const

Returns the height of the painted area, in logical units, without the scale factor (device pixel ratio). This is usually the same as the painter item's height, unless QQuickRhiItem::fixedColorBufferHeight has been set.

[override virtual protected] void QQuickCPainterRenderer::initialize(QRhiCommandBuffer *cb)

Reimplements: QQuickRhiItemRenderer::initialize(QRhiCommandBuffer *cb).

[virtual protected] void QQuickCPainterRenderer::initializeResources(QCPainter *painter)

Reimplement this method to initialize resources using painter. This will be called once before the first synchronize().

See also QCPainter::addImage and QCPainter::createCanvas.

[virtual protected] void QQuickCPainterRenderer::paint(QCPainter *painter)

Reimplement this method to paint using painter.

This will get called after the item has been filled with fillColor().

paint() is called from renderer thread. To access item data safely, copy it in synchronize().

See also synchronize().

QCPainter *QQuickCPainterRenderer::painter() const

Returns the painter attached to this painter item.

[virtual protected] void QQuickCPainterRenderer::prePaint(QCPainter *painter)

This function is called at the start of rendering using painter, before paint().

There is no render target active when this function is invoked. Call beginCanvasPainting() to initialize drawing into an offscreen canvas.

See also beginCanvasPainting() and endCanvasPainting().

[override virtual protected] void QQuickCPainterRenderer::render(QRhiCommandBuffer *cb)

Reimplements: QQuickRhiItemRenderer::render(QRhiCommandBuffer *cb).

void QQuickCPainterRenderer::setSharedPainter(bool enable)

Disable painter sharing if enable is false.

Painter sharing is enabled by default.

When painter sharing is enabled, all painter items inside the same QQuickWindow will use the same QCPainter.

If disabling painter sharing is desired, this function must be called early enough, for example from the derived class' constructor. Changing it afterwards, when the item has already initialized for painting, will have no effect.

If two items use dedicated, non-shared painters, each other's graphics resources, such as the ones backing QCImage or QOffscreenCanvas, will not be visible to them. Whereas if the items are in the same window, and sharing is enabled, they can use images or canvases created by the other item, because they both use the same QCPainter.

See also hasSharedPainter.

[virtual protected] void QQuickCPainterRenderer::synchronize(QQuickCPainterItem *item)

Reimplement this method to synchronize data between item and item painter instances. This will be called before paint() each time item needs to be repainted.

This method is the only place where it is safe for the painter and the item to read and write each others variables.

Usually you should static_cast item to your real item type, and then exchange the data.

[override virtual protected] void QQuickCPainterRenderer::synchronize(QQuickRhiItem *item)

Reimplements: QQuickRhiItemRenderer::synchronize(QQuickRhiItem *item).

float QQuickCPainterRenderer::width() const

Returns the width of the painted area, in logical units, without the scale factor (device pixel ratio). This is usually the same as the painter item's width, unless QQuickRhiItem::fixedColorBufferWidth has been set.