qquickshadereffectsource.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qquickshadereffectsource_p.h"
 
#include "qquickitem_p.h"
#include "qquickwindow_p.h"
#include <private/qsgadaptationlayer_p.h>
#include <QtQuick/private/qsgrenderer_p.h>
#include <qsgsimplerectnode.h>
 
#include "qmath.h"
#include <QtQuick/private/qsgtexture_p.h>
#include <QtCore/QRunnable>
 
QT_BEGIN_NAMESPACE
 
class QQuickShaderEffectSourceTextureProvider : public QSGTextureProvider
{
    Q_OBJECT
public:
    QQuickShaderEffectSourceTextureProvider()
        : sourceTexture(nullptr)
        , mipmapFiltering(QSGTexture::None)
        , filtering(QSGTexture::Nearest)
        , horizontalWrap(QSGTexture::ClampToEdge)
        , verticalWrap(QSGTexture::ClampToEdge)
    {
    }
 
    QSGTexture *texture() const override {
        sourceTexture->setMipmapFiltering(mipmapFiltering);
        sourceTexture->setFiltering(filtering);
        sourceTexture->setHorizontalWrapMode(horizontalWrap);
        sourceTexture->setVerticalWrapMode(verticalWrap);
        return sourceTexture;
    }
 
    QSGLayer *sourceTexture;
 
    QSGTexture::Filtering mipmapFiltering;
    QSGTexture::Filtering filtering;
    QSGTexture::WrapMode horizontalWrap;
    QSGTexture::WrapMode verticalWrap;
};
 
class QQuickShaderEffectSourceCleanup : public QRunnable
{
public:
    QQuickShaderEffectSourceCleanup(QSGLayer *t, QQuickShaderEffectSourceTextureProvider *p)
        : texture(t)
        , provider(p)
    {}
    void run() override {
        delete texture;
        delete provider;
    }
    QSGLayer *texture;
    QQuickShaderEffectSourceTextureProvider *provider;
};
 
QQuickShaderEffectSource::QQuickShaderEffectSource(QQuickItem *parent)
    : QQuickItem(parent)
    , m_provider(nullptr)
    , m_texture(nullptr)
    , m_wrapMode(ClampToEdge)
    , m_sourceItem(nullptr)
    , m_textureSize(0, 0)
    , m_format(RGBA8)
    , m_samples(0)
    , m_live(true)
    , m_hideSource(false)
    , m_mipmap(false)
    , m_recursive(false)
    , m_grab(true)
    , m_textureMirroring(MirrorVertically)
{
    setFlag(ItemHasContents);
}
 
QQuickShaderEffectSource::~QQuickShaderEffectSource()
{
    if (window()) {
        window()->scheduleRenderJob(new QQuickShaderEffectSourceCleanup(m_texture, m_provider),
                                    QQuickWindow::AfterSynchronizingStage);
    } else {
        // If we don't have a window, these should already have been
        // released in invalidateSG or in releaseResrouces()
        Q_ASSERT(!m_texture);
        Q_ASSERT(!m_provider);
    }
 
    if (m_sourceItem) {
        QQuickItemPrivate *sd = QQuickItemPrivate::get(m_sourceItem);
        sd->removeItemChangeListener(this, QQuickItemPrivate::Geometry);
        sd->derefFromEffectItem(m_hideSource);
        if (window())
            sd->derefWindow();
    }
}
 
void QQuickShaderEffectSource::ensureTexture()
{
    if (m_texture)
        return;
 
    Q_ASSERT_X(QQuickItemPrivate::get(this)->window
               && QQuickItemPrivate::get(this)->sceneGraphRenderContext()
               && QThread::currentThread() == QQuickItemPrivate::get(this)->sceneGraphRenderContext()->thread(),
               "QQuickShaderEffectSource::ensureTexture",
               "Cannot be used outside the rendering thread");
 
    QSGRenderContext *rc = QQuickItemPrivate::get(this)->sceneGraphRenderContext();
    m_texture = rc->sceneGraphContext()->createLayer(rc);
    connect(QQuickItemPrivate::get(this)->window, SIGNAL(sceneGraphInvalidated()), m_texture, SLOT(invalidated()), Qt::DirectConnection);
    connect(m_texture, SIGNAL(updateRequested()), this, SLOT(update()));
    connect(m_texture, SIGNAL(scheduledUpdateCompleted()), this, SIGNAL(scheduledUpdateCompleted()));
}
 
static void get_wrap_mode(QQuickShaderEffectSource::WrapMode mode, QSGTexture::WrapMode *hWrap, QSGTexture::WrapMode *vWrap);
 
QSGTextureProvider *QQuickShaderEffectSource::textureProvider() const
{
    const QQuickItemPrivate *d = QQuickItemPrivate::get(this);
    if (!d->window || !d->sceneGraphRenderContext() || QThread::currentThread() != d->sceneGraphRenderContext()->thread()) {
        qWarning("QQuickShaderEffectSource::textureProvider: can only be queried on the rendering thread of an exposed window");
        return nullptr;
    }
 
    if (!m_provider) {
        const_cast<QQuickShaderEffectSource *>(this)->m_provider = new QQuickShaderEffectSourceTextureProvider();
        const_cast<QQuickShaderEffectSource *>(this)->ensureTexture();
        connect(m_texture, SIGNAL(updateRequested()), m_provider, SIGNAL(textureChanged()));
 
        get_wrap_mode(m_wrapMode, &m_provider->horizontalWrap, &m_provider->verticalWrap);
        m_provider->mipmapFiltering = mipmap() ? QSGTexture::Linear : QSGTexture::None;
        m_provider->filtering = smooth() ? QSGTexture::Linear : QSGTexture::Nearest;
        m_provider->sourceTexture = m_texture;
    }
    return m_provider;
}
 
QQuickShaderEffectSource::WrapMode QQuickShaderEffectSource::wrapMode() const
{
    return m_wrapMode;
}
 
void QQuickShaderEffectSource::setWrapMode(WrapMode mode)
{
    if (mode == m_wrapMode)
        return;
    m_wrapMode = mode;
    update();
    emit wrapModeChanged();
}
 
QQuickItem *QQuickShaderEffectSource::sourceItem() const
{
    return m_sourceItem;
}
 
void QQuickShaderEffectSource::itemGeometryChanged(QQuickItem *item, QQuickGeometryChange change, const QRectF &)
{
    Q_ASSERT(item == m_sourceItem);
    Q_UNUSED(item);
    if (change.sizeChange())
        update();
}
 
void QQuickShaderEffectSource::setSourceItem(QQuickItem *item)
{
    if (item == m_sourceItem)
        return;
    if (m_sourceItem) {
        QQuickItemPrivate *d = QQuickItemPrivate::get(m_sourceItem);
        d->derefFromEffectItem(m_hideSource);
        d->removeItemChangeListener(this, QQuickItemPrivate::Geometry);
        disconnect(m_sourceItem, SIGNAL(destroyed(QObject*)), this, SLOT(sourceItemDestroyed(QObject*)));
        if (window())
            d->derefWindow();
    }
 
    m_sourceItem = item;
 
    if (m_sourceItem) {
        if (window() == m_sourceItem->window()
                || (window() == nullptr && m_sourceItem->window())
                || (m_sourceItem->window() == nullptr && window())) {
            QQuickItemPrivate *d = QQuickItemPrivate::get(item);
            // 'item' needs a window to get a scene graph node. It usually gets one through its
            // parent, but if the source item is "inline" rather than a reference -- i.e.
            // "sourceItem: Item { }" instead of "sourceItem: foo" -- it will not get a parent.
            // In those cases, 'item' should get the window from 'this'.
            if (window())
                d->refWindow(window());
            else if (m_sourceItem->window())
                d->refWindow(m_sourceItem->window());
            d->refFromEffectItem(m_hideSource);
            d->addItemChangeListener(this, QQuickItemPrivate::Geometry);
            connect(m_sourceItem, SIGNAL(destroyed(QObject*)), this, SLOT(sourceItemDestroyed(QObject*)));
        } else {
            qWarning("ShaderEffectSource: sourceItem and ShaderEffectSource must both be children of the same window.");
            m_sourceItem = nullptr;
        }
    }
    update();
    emit sourceItemChanged();
}
 
void QQuickShaderEffectSource::sourceItemDestroyed(QObject *item)
{
    Q_ASSERT(item == m_sourceItem);
    Q_UNUSED(item);
    m_sourceItem = nullptr;
    update();
    emit sourceItemChanged();
}
 
 
QRectF QQuickShaderEffectSource::sourceRect() const
{
    return m_sourceRect;
}
 
void QQuickShaderEffectSource::setSourceRect(const QRectF &rect)
{
    if (rect == m_sourceRect)
        return;
    m_sourceRect = rect;
    update();
    emit sourceRectChanged();
}
 
QSize QQuickShaderEffectSource::textureSize() const
{
    return m_textureSize;
}
 
void QQuickShaderEffectSource::setTextureSize(const QSize &size)
{
    if (size == m_textureSize)
        return;
    m_textureSize = size;
    update();
    emit textureSizeChanged();
}
 
QQuickShaderEffectSource::Format QQuickShaderEffectSource::format() const
{
    return m_format;
}
 
void QQuickShaderEffectSource::setFormat(QQuickShaderEffectSource::Format format)
{
    if (format == m_format)
        return;
    m_format = format;
    update();
    emit formatChanged();
}
 
bool QQuickShaderEffectSource::live() const
{
    return m_live;
}
 
void QQuickShaderEffectSource::setLive(bool live)
{
    if (live == m_live)
        return;
    m_live = live;
    update();
    emit liveChanged();
}
 
bool QQuickShaderEffectSource::hideSource() const
{
    return m_hideSource;
}
 
void QQuickShaderEffectSource::setHideSource(bool hide)
{
    if (hide == m_hideSource)
        return;
    if (m_sourceItem) {
        QQuickItemPrivate::get(m_sourceItem)->refFromEffectItem(hide);
        QQuickItemPrivate::get(m_sourceItem)->derefFromEffectItem(m_hideSource);
    }
    m_hideSource = hide;
    update();
    emit hideSourceChanged();
}
 
bool QQuickShaderEffectSource::mipmap() const
{
    return m_mipmap;
}
 
void QQuickShaderEffectSource::setMipmap(bool enabled)
{
    if (enabled == m_mipmap)
        return;
    m_mipmap = enabled;
    update();
    emit mipmapChanged();
}
 
bool QQuickShaderEffectSource::recursive() const
{
    return m_recursive;
}
 
void QQuickShaderEffectSource::setRecursive(bool enabled)
{
    if (enabled == m_recursive)
        return;
    m_recursive = enabled;
    emit recursiveChanged();
}
 
QQuickShaderEffectSource::TextureMirroring QQuickShaderEffectSource::textureMirroring() const
{
    return QQuickShaderEffectSource::TextureMirroring(m_textureMirroring);
}
 
void QQuickShaderEffectSource::setTextureMirroring(TextureMirroring mirroring)
{
    if (mirroring == QQuickShaderEffectSource::TextureMirroring(m_textureMirroring))
        return;
    m_textureMirroring = mirroring;
    update();
    emit textureMirroringChanged();
}
 
int QQuickShaderEffectSource::samples() const
{
    return m_samples;
}
 
void QQuickShaderEffectSource::setSamples(int count)
{
    if (count == m_samples)
        return;
    m_samples = count;
    update();
    emit samplesChanged();
}
 
void QQuickShaderEffectSource::scheduleUpdate()
{
    if (m_grab)
        return;
    m_grab = true;
    update();
}
 
static void get_wrap_mode(QQuickShaderEffectSource::WrapMode mode, QSGTexture::WrapMode *hWrap, QSGTexture::WrapMode *vWrap)
{
    switch (mode) {
    case QQuickShaderEffectSource::RepeatHorizontally:
        *hWrap = QSGTexture::Repeat;
        *vWrap = QSGTexture::ClampToEdge;
        break;
    case QQuickShaderEffectSource::RepeatVertically:
        *vWrap = QSGTexture::Repeat;
        *hWrap = QSGTexture::ClampToEdge;
        break;
    case QQuickShaderEffectSource::Repeat:
        *hWrap = *vWrap = QSGTexture::Repeat;
        break;
    default:
        // QQuickShaderEffectSource::ClampToEdge
        *hWrap = *vWrap = QSGTexture::ClampToEdge;
        break;
    }
}
 
 
void QQuickShaderEffectSource::releaseResources()
{
    if (m_texture || m_provider) {
        window()->scheduleRenderJob(new QQuickShaderEffectSourceCleanup(m_texture, m_provider),
                                    QQuickWindow::AfterSynchronizingStage);
        m_texture = nullptr;
        m_provider = nullptr;
    }
}
 
class QQuickShaderSourceAttachedNode : public QObject, public QSGNode
{
    Q_OBJECT
public:
    Q_SLOT void markTextureDirty() {
        QSGNode *pn = QSGNode::parent();
        if (pn) {
            Q_ASSERT(pn->type() == QSGNode::GeometryNodeType);
            pn->markDirty(DirtyMaterial);
        }
    }
};
 
static QSGLayer::Format toLayerFormat(QQuickShaderEffectSource::Format format)
{
    switch (format) {
    case QQuickShaderEffectSource::RGBA8:
        return QSGLayer::RGBA8;
    case QQuickShaderEffectSource::RGBA16F:
        return QSGLayer::RGBA16F;
    case QQuickShaderEffectSource::RGBA32F:
        return QSGLayer::RGBA32F;
    default:
        return QSGLayer::RGBA8;
    }
}
 
QSGNode *QQuickShaderEffectSource::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
{
    if (!m_sourceItem || m_sourceItem->width() <= 0 || m_sourceItem->height() <= 0) {
        if (m_texture)
            m_texture->setItem(nullptr);
        delete oldNode;
        return nullptr;
    }
 
    ensureTexture();
 
    m_texture->setLive(m_live);
    m_texture->setItem(QQuickItemPrivate::get(m_sourceItem)->itemNode());
    QRectF sourceRect = m_sourceRect.width() == 0 || m_sourceRect.height() == 0
                      ? QRectF(0, 0, m_sourceItem->width(), m_sourceItem->height())
                      : m_sourceRect;
    m_texture->setRect(sourceRect);
    QQuickItemPrivate *d = static_cast<QQuickItemPrivate *>(QObjectPrivate::get(this));
    const float dpr = d->window->effectiveDevicePixelRatio();
    QSize textureSize = m_textureSize.isEmpty()
            ? QSize(qCeil(qAbs(sourceRect.width())), qCeil(qAbs(sourceRect.height()))) * dpr
            : m_textureSize;
    Q_ASSERT(!textureSize.isEmpty());
 
    const QSize minTextureSize = d->sceneGraphContext()->minimumFBOSize();
    // Keep power-of-two by doubling the size.
    while (textureSize.width() < minTextureSize.width())
        textureSize.rwidth() *= 2;
    while (textureSize.height() < minTextureSize.height())
        textureSize.rheight() *= 2;
 
    m_texture->setDevicePixelRatio(d->window->effectiveDevicePixelRatio());
    m_texture->setSize(textureSize);
    m_texture->setRecursive(m_recursive);
    m_texture->setFormat(toLayerFormat(m_format));
    m_texture->setHasMipmaps(m_mipmap);
    m_texture->setMirrorHorizontal(m_textureMirroring & MirrorHorizontally);
    m_texture->setMirrorVertical(m_textureMirroring & MirrorVertically);
    m_texture->setSamples(m_samples);
 
    if (m_grab)
        m_texture->scheduleUpdate();
    m_grab = false;
 
    QSGTexture::Filtering filtering = QQuickItemPrivate::get(this)->smooth
                                            ? QSGTexture::Linear
                                            : QSGTexture::Nearest;
    QSGTexture::Filtering mmFiltering = m_mipmap ? filtering : QSGTexture::None;
    QSGTexture::WrapMode hWrap, vWrap;
    get_wrap_mode(m_wrapMode, &hWrap, &vWrap);
 
    if (m_provider) {
        m_provider->mipmapFiltering = mmFiltering;
        m_provider->filtering = filtering;
        m_provider->horizontalWrap = hWrap;
        m_provider->verticalWrap = vWrap;
    }
 
    // Don't create the paint node if we're not spanning any area
    if (width() <= 0 || height() <= 0) {
        delete oldNode;
        return nullptr;
    }
 
    QSGInternalImageNode *node = static_cast<QSGInternalImageNode *>(oldNode);
    if (!node) {
        node = d->sceneGraphContext()->createInternalImageNode(d->sceneGraphRenderContext());
        node->setFlag(QSGNode::UsePreprocess);
        node->setTexture(m_texture);
        QQuickShaderSourceAttachedNode *attached = new QQuickShaderSourceAttachedNode;
        node->appendChildNode(attached);
        connect(m_texture, SIGNAL(updateRequested()), attached, SLOT(markTextureDirty()));
    }
 
    // If live and recursive, update continuously.
    if (m_live && m_recursive)
        node->markDirty(QSGNode::DirtyMaterial);
 
    node->setMipmapFiltering(mmFiltering);
    node->setFiltering(filtering);
    node->setHorizontalWrapMode(hWrap);
    node->setVerticalWrapMode(vWrap);
    node->setTargetRect(QRectF(0, 0, width(), height()));
    node->setInnerTargetRect(QRectF(0, 0, width(), height()));
    node->update();
 
    return node;
}
 
void QQuickShaderEffectSource::invalidateSceneGraph()
{
    if (m_texture)
        delete m_texture;
    if (m_provider)
        delete m_provider;
    m_texture = nullptr;
    m_provider = nullptr;
}
 
void QQuickShaderEffectSource::itemChange(ItemChange change, const ItemChangeData &value)
{
    if (change == QQuickItem::ItemSceneChange && m_sourceItem) {
        // See comment in QQuickShaderEffectSource::setSourceItem().
        if (value.window)
            QQuickItemPrivate::get(m_sourceItem)->refWindow(value.window);
        else
            QQuickItemPrivate::get(m_sourceItem)->derefWindow();
    }
    QQuickItem::itemChange(change, value);
}
 
QT_END_NAMESPACE
 
#include "qquickshadereffectsource.moc"
#include "moc_qquickshadereffectsource_p.cpp"