qquickshadereffect.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 <private/qquickshadereffect_p_p.h>
#include <private/qsgcontextplugin_p.h>
#include <private/qsgrhisupport_p.h>
#include <private/qquickwindow_p.h>
 
QT_BEGIN_NAMESPACE
 
namespace QtPrivate {
class EffectSlotMapper: public QtPrivate::QSlotObjectBase
{
public:
    typedef std::function<void()> PropChangedFunc;
 
    explicit EffectSlotMapper(PropChangedFunc func)
    : QSlotObjectBase(&impl), _signalIndex(-1), func(func)
    { ref(); }
 
    void setSignalIndex(int idx) { _signalIndex = idx; }
    int signalIndex() const { return _signalIndex; }
 
private:
    int _signalIndex;
    PropChangedFunc func;
 
    static void impl(int which, QSlotObjectBase *this_, QObject *, void **a, bool *ret)
    {
    auto thiz = static_cast<EffectSlotMapper*>(this_);
    switch (which) {
    case Destroy:
        delete thiz;
        break;
    case Call:
        thiz->func();
        break;
    case Compare:
        *ret = thiz == reinterpret_cast<EffectSlotMapper *>(a[0]);
        break;
    case NumOperations: ;
    }
    }
};
} // namespace QtPrivate
 
QQuickShaderEffect::QQuickShaderEffect(QQuickItem *parent)
    : QQuickItem(*new QQuickShaderEffectPrivate, parent)
{
    setFlag(QQuickItem::ItemHasContents);
}
 
QQuickShaderEffect::~QQuickShaderEffect()
{
    Q_D(QQuickShaderEffect);
    d->inDestructor = true;
}
 
QUrl QQuickShaderEffect::fragmentShader() const
{
    Q_D(const QQuickShaderEffect);
    return d->fragmentShader();
}
 
void QQuickShaderEffect::setFragmentShader(const QUrl &fileUrl)
{
    Q_D(QQuickShaderEffect);
    d->setFragmentShader(fileUrl);
}
 
QUrl QQuickShaderEffect::vertexShader() const
{
    Q_D(const QQuickShaderEffect);
    return d->vertexShader();
}
 
void QQuickShaderEffect::setVertexShader(const QUrl &fileUrl)
{
    Q_D(QQuickShaderEffect);
    d->setVertexShader(fileUrl);
}
 
bool QQuickShaderEffect::blending() const
{
    Q_D(const QQuickShaderEffect);
    return d->blending();
}
 
void QQuickShaderEffect::setBlending(bool enable)
{
    Q_D(QQuickShaderEffect);
    d->setBlending(enable);
}
 
QVariant QQuickShaderEffect::mesh() const
{
    Q_D(const QQuickShaderEffect);
    return d->mesh();
}
 
void QQuickShaderEffect::setMesh(const QVariant &mesh)
{
    Q_D(QQuickShaderEffect);
    d->setMesh(mesh);
}
 
QQuickShaderEffect::CullMode QQuickShaderEffect::cullMode() const
{
    Q_D(const QQuickShaderEffect);
    return d->cullMode();
}
 
void QQuickShaderEffect::setCullMode(CullMode face)
{
    Q_D(QQuickShaderEffect);
    return d->setCullMode(face);
}
 
bool QQuickShaderEffect::supportsAtlasTextures() const
{
    Q_D(const QQuickShaderEffect);
    return d->supportsAtlasTextures();
}
 
void QQuickShaderEffect::setSupportsAtlasTextures(bool supports)
{
    Q_D(QQuickShaderEffect);
    d->setSupportsAtlasTextures(supports);
}
 
QString QQuickShaderEffect::log() const
{
    Q_D(const QQuickShaderEffect);
    return d->log();
}
 
QQuickShaderEffect::Status QQuickShaderEffect::status() const
{
    Q_D(const QQuickShaderEffect);
    return d->status();
}
 
bool QQuickShaderEffect::event(QEvent *e)
{
    Q_D(QQuickShaderEffect);
    d->handleEvent(e);
    return QQuickItem::event(e);
}
 
void QQuickShaderEffect::geometryChange(const QRectF &newGeometry, const QRectF &oldGeometry)
{
    Q_D(QQuickShaderEffect);
    d->handleGeometryChanged(newGeometry, oldGeometry);
    QQuickItem::geometryChange(newGeometry, oldGeometry);
}
 
QSGNode *QQuickShaderEffect::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *updatePaintNodeData)
{
    Q_D(QQuickShaderEffect);
    return d->handleUpdatePaintNode(oldNode, updatePaintNodeData);
}
 
void QQuickShaderEffect::componentComplete()
{
    Q_D(QQuickShaderEffect);
    d->maybeUpdateShaders();
    QQuickItem::componentComplete();
}
 
void QQuickShaderEffect::itemChange(ItemChange change, const ItemChangeData &value)
{
    Q_D(QQuickShaderEffect);
    d->handleItemChange(change, value);
    QQuickItem::itemChange(change, value);
}
 
bool QQuickShaderEffect::isComponentComplete() const
{
    return QQuickItem::isComponentComplete();
}
 
bool QQuickShaderEffect::updateUniformValue(const QByteArray &name, const QVariant &value)
{
    auto node = static_cast<QSGShaderEffectNode *>(QQuickItemPrivate::get(this)->paintNode);
    if (!node)
        return false;
 
    Q_D(QQuickShaderEffect);
    return d->updateUniformValue(name, value, node);
}
 
void QQuickShaderEffectPrivate::updatePolish()
{
    Q_Q(QQuickShaderEffect);
    if (!qmlEngine(q))
        return;
    maybeUpdateShaders();
}
 
constexpr int indexToMappedId(const int shaderType, const int idx)
{
    return idx | (shaderType << 16);
}
 
constexpr int mappedIdToIndex(const int mappedId)
{
    return mappedId & 0xFFFF;
}
 
constexpr int mappedIdToShaderType(const int mappedId)
{
    return mappedId >> 16;
}
 
QQuickShaderEffectPrivate::QQuickShaderEffectPrivate()
    : m_meshResolution(1, 1)
    , m_mesh(nullptr)
    , m_cullMode(QQuickShaderEffect::NoCulling)
    , m_blending(true)
    , m_supportsAtlasTextures(false)
    , m_mgr(nullptr)
    , m_fragNeedsUpdate(true)
    , m_vertNeedsUpdate(true)
{
    qRegisterMetaType<QSGGuiThreadShaderEffectManager::ShaderInfo::Type>("ShaderInfo::Type");
    for (int i = 0; i < NShader; ++i)
        m_inProgress[i] = nullptr;
}
 
QQuickShaderEffectPrivate::~QQuickShaderEffectPrivate()
{
    for (int i = 0; i < NShader; ++i) {
        disconnectSignals(Shader(i));
        clearMappers(Shader(i));
    }
 
    delete m_mgr;
}
 
void QQuickShaderEffectPrivate::setFragmentShader(const QUrl &fileUrl)
{
    Q_Q(QQuickShaderEffect);
    if (m_fragShader == fileUrl)
        return;
 
    m_fragShader = fileUrl;
 
    m_fragNeedsUpdate = true;
    if (q->isComponentComplete())
        maybeUpdateShaders();
 
    emit q->fragmentShaderChanged();
}
 
void QQuickShaderEffectPrivate::setVertexShader(const QUrl &fileUrl)
{
    Q_Q(QQuickShaderEffect);
    if (m_vertShader == fileUrl)
        return;
 
    m_vertShader = fileUrl;
 
    m_vertNeedsUpdate = true;
    if (q->isComponentComplete())
        maybeUpdateShaders();
 
    emit q->vertexShaderChanged();
}
 
void QQuickShaderEffectPrivate::setBlending(bool enable)
{
    Q_Q(QQuickShaderEffect);
    if (m_blending == enable)
        return;
 
    m_blending = enable;
    q->update();
    emit q->blendingChanged();
}
 
QVariant QQuickShaderEffectPrivate::mesh() const
{
    return m_mesh ? QVariant::fromValue(static_cast<QObject *>(m_mesh))
                  : QVariant::fromValue(m_meshResolution);
}
 
void QQuickShaderEffectPrivate::setMesh(const QVariant &mesh)
{
    Q_Q(QQuickShaderEffect);
    QQuickShaderEffectMesh *newMesh = qobject_cast<QQuickShaderEffectMesh *>(qvariant_cast<QObject *>(mesh));
    if (newMesh && newMesh == m_mesh)
        return;
 
    if (m_mesh)
        QObject::disconnect(m_meshConnection);
 
    m_mesh = newMesh;
 
    if (m_mesh) {
        m_meshConnection = QObject::connect(m_mesh, &QQuickShaderEffectMesh::geometryChanged, q,
                                            [this] { markGeometryDirtyAndUpdate(); });
    } else {
        if (mesh.canConvert<QSize>()) {
            m_meshResolution = mesh.toSize();
        } else {
            QList<QByteArray> res = mesh.toByteArray().split('x');
            bool ok = res.size() == 2;
            if (ok) {
                int w = res.at(0).toInt(&ok);
                if (ok) {
                    int h = res.at(1).toInt(&ok);
                    if (ok)
                        m_meshResolution = QSize(w, h);
                }
            }
            if (!ok)
                qWarning("ShaderEffect: mesh property must be a size or an object deriving from QQuickShaderEffectMesh");
        }
        m_defaultMesh.setResolution(m_meshResolution);
    }
 
    m_dirty |= QSGShaderEffectNode::DirtyShaderMesh;
    q->update();
 
    emit q->meshChanged();
}
 
void QQuickShaderEffectPrivate::setCullMode(QQuickShaderEffect::CullMode face)
{
    Q_Q(QQuickShaderEffect);
    if (m_cullMode == face)
        return;
 
    m_cullMode = face;
    q->update();
    emit q->cullModeChanged();
}
 
void QQuickShaderEffectPrivate::setSupportsAtlasTextures(bool supports)
{
    Q_Q(QQuickShaderEffect);
    if (m_supportsAtlasTextures == supports)
        return;
 
    m_supportsAtlasTextures = supports;
    markGeometryDirtyAndUpdate();
    emit q->supportsAtlasTexturesChanged();
}
 
QString QQuickShaderEffectPrivate::parseLog()
{
    maybeUpdateShaders();
    return log();
}
 
QString QQuickShaderEffectPrivate::log() const
{
    QSGGuiThreadShaderEffectManager *mgr = shaderEffectManager();
    if (!mgr)
        return QString();
 
    return mgr->log();
}
 
QQuickShaderEffect::Status QQuickShaderEffectPrivate::status() const
{
    QSGGuiThreadShaderEffectManager *mgr = shaderEffectManager();
    if (!mgr)
        return QQuickShaderEffect::Uncompiled;
 
    return QQuickShaderEffect::Status(mgr->status());
}
 
void QQuickShaderEffectPrivate::handleEvent(QEvent *event)
{
    if (event->type() == QEvent::DynamicPropertyChange) {
        const auto propertyName = static_cast<QDynamicPropertyChangeEvent *>(event)->propertyName();
        for (int i = 0; i < NShader; ++i) {
            const auto mappedId = findMappedShaderVariableId(propertyName, Shader(i));
            if (mappedId)
                propertyChanged(*mappedId);
        }
    }
}
 
void QQuickShaderEffectPrivate::handleGeometryChanged(const QRectF &, const QRectF &)
{
    m_dirty |= QSGShaderEffectNode::DirtyShaderGeometry;
}
 
QSGNode *QQuickShaderEffectPrivate::handleUpdatePaintNode(QSGNode *oldNode, QQuickItem::UpdatePaintNodeData *)
{
    Q_Q(QQuickShaderEffect);
    QSGShaderEffectNode *node = static_cast<QSGShaderEffectNode *>(oldNode);
 
    if (q->width() <= 0 || q->height() <= 0) {
        delete node;
        return nullptr;
    }
 
    // Do not change anything while a new shader is being reflected or compiled.
    if (m_inProgress[Vertex] || m_inProgress[Fragment])
        return node;
 
    // The manager should be already created on the gui thread. Just take that instance.
    QSGGuiThreadShaderEffectManager *mgr = shaderEffectManager();
    if (!mgr) {
        delete node;
        return nullptr;
    }
 
    if (!node) {
        QSGRenderContext *rc = QQuickWindowPrivate::get(q->window())->context;
        node = rc->sceneGraphContext()->createShaderEffectNode(rc);
        if (!node) {
            qWarning("No shader effect node");
            return nullptr;
        }
        m_dirty = QSGShaderEffectNode::DirtyShaderAll;
        QObject::connect(node, &QSGShaderEffectNode::textureChanged, q, [this] { markGeometryDirtyAndUpdateIfSupportsAtlas(); });
    }
 
    QSGShaderEffectNode::SyncData sd;
    sd.dirty = m_dirty;
    sd.cullMode = QSGShaderEffectNode::CullMode(m_cullMode);
    sd.blending = m_blending;
    sd.vertex.shader = &m_shaders[Vertex];
    sd.vertex.dirtyConstants = &m_dirtyConstants[Vertex];
    sd.vertex.dirtyTextures = &m_dirtyTextures[Vertex];
    sd.fragment.shader = &m_shaders[Fragment];
    sd.fragment.dirtyConstants = &m_dirtyConstants[Fragment];
    sd.fragment.dirtyTextures = &m_dirtyTextures[Fragment];
    sd.materialTypeCacheKey = q->window();
    sd.viewCount = QQuickWindowPrivate::get(q->window())->multiViewCount();
 
    node->syncMaterial(&sd);
 
    if (m_dirty & QSGShaderEffectNode::DirtyShaderMesh) {
        node->setGeometry(nullptr);
        m_dirty &= ~QSGShaderEffectNode::DirtyShaderMesh;
        m_dirty |= QSGShaderEffectNode::DirtyShaderGeometry;
    }
 
    if (m_dirty & QSGShaderEffectNode::DirtyShaderGeometry) {
        const QRectF rect(0, 0, q->width(), q->height());
        QQuickShaderEffectMesh *mesh = m_mesh ? m_mesh : &m_defaultMesh;
        QSGGeometry *geometry = node->geometry();
 
        const QRectF srcRect = node->updateNormalizedTextureSubRect(m_supportsAtlasTextures);
        geometry = mesh->updateGeometry(geometry, 2, 0, srcRect, rect);
 
        node->setFlag(QSGNode::OwnsGeometry, false);
        node->setGeometry(geometry);
        node->setFlag(QSGNode::OwnsGeometry, true);
 
        m_dirty &= ~QSGShaderEffectNode::DirtyShaderGeometry;
    }
 
    m_dirty = {};
    for (int i = 0; i < NShader; ++i) {
        m_dirtyConstants[i].clear();
        m_dirtyTextures[i].clear();
    }
 
    return node;
}
 
void QQuickShaderEffectPrivate::maybeUpdateShaders()
{
    Q_Q(QQuickShaderEffect);
    if (m_vertNeedsUpdate)
        m_vertNeedsUpdate = !updateShader(Vertex, m_vertShader);
    if (m_fragNeedsUpdate)
        m_fragNeedsUpdate = !updateShader(Fragment, m_fragShader);
    if (m_vertNeedsUpdate || m_fragNeedsUpdate) {
        // This function is invoked either from componentComplete or in a
        // response to a previous invocation's polish() request. If this is
        // case #1 then updateShader can fail due to not having a window or
        // scenegraph ready. Schedule the polish to try again later. In case #2
        // the backend probably does not have shadereffect support so there is
        // nothing to do for us here.
        if (!q->window() || !q->window()->isSceneGraphInitialized())
            q->polish();
    }
}
 
bool QQuickShaderEffectPrivate::updateUniformValue(const QByteArray &name, const QVariant &value,
                                                QSGShaderEffectNode *node)
{
    Q_Q(QQuickShaderEffect);
    const auto mappedId = findMappedShaderVariableId(name);
    if (!mappedId)
        return false;
 
    const Shader type = Shader(mappedIdToShaderType(*mappedId));
    const int idx = mappedIdToIndex(*mappedId);
 
    // Update value
    m_shaders[type].varData[idx].value = value;
 
    // Insert dirty uniform
    QSet<int> dirtyConstants[NShader];
    dirtyConstants[type].insert(idx);
 
    // Sync material change
    QSGShaderEffectNode::SyncData sd;
    sd.dirty = QSGShaderEffectNode::DirtyShaderConstant;
    sd.cullMode = QSGShaderEffectNode::CullMode(m_cullMode);
    sd.blending = m_blending;
    sd.vertex.shader = &m_shaders[Vertex];
    sd.vertex.dirtyConstants = &dirtyConstants[Vertex];
    sd.vertex.dirtyTextures = {};
    sd.fragment.shader = &m_shaders[Fragment];
    sd.fragment.dirtyConstants = &dirtyConstants[Fragment];
    sd.fragment.dirtyTextures = {};
    sd.materialTypeCacheKey = q->window();
    sd.viewCount = QQuickWindowPrivate::get(q->window())->multiViewCount();
 
    node->syncMaterial(&sd);
 
    return true;
}
 
void QQuickShaderEffectPrivate::handleItemChange(QQuickItem::ItemChange change, const QQuickItem::ItemChangeData &value)
{
    if (inDestructor)
        return;
 
    // Move the window ref.
    if (change == QQuickItem::ItemSceneChange) {
        for (int shaderType = 0; shaderType < NShader; ++shaderType) {
            for (const auto &vd : std::as_const(m_shaders[shaderType].varData)) {
                if (vd.specialType == QSGShaderEffectNode::VariableData::Source) {
                    QQuickItem *source = qobject_cast<QQuickItem *>(qvariant_cast<QObject *>(vd.value));
                    if (source) {
                        if (value.window)
                            QQuickItemPrivate::get(source)->refWindow(value.window);
                        else
                            QQuickItemPrivate::get(source)->derefWindow();
                    }
                }
            }
        }
    }
}
 
QSGGuiThreadShaderEffectManager *QQuickShaderEffectPrivate::shaderEffectManager() const
{
    Q_Q(const QQuickShaderEffect);
    if (!m_mgr) {
        // return null if this is not the gui thread and not already created
        if (QThread::currentThread() != q->thread())
            return m_mgr;
        QQuickWindow *w = q->window();
        if (w) { // note: just the window, don't care about isSceneGraphInitialized() here
            m_mgr = QQuickWindowPrivate::get(w)->context->sceneGraphContext()->createGuiThreadShaderEffectManager();
            if (m_mgr) {
                QObject::connect(m_mgr, &QSGGuiThreadShaderEffectManager::logAndStatusChanged, q, &QQuickShaderEffect::logChanged);
                QObject::connect(m_mgr, &QSGGuiThreadShaderEffectManager::logAndStatusChanged, q, &QQuickShaderEffect::statusChanged);
                QObject::connect(m_mgr, &QSGGuiThreadShaderEffectManager::shaderCodePrepared, q,
                                 [this](bool ok, QSGGuiThreadShaderEffectManager::ShaderInfo::Type typeHint,
                                 const QUrl &loadUrl, QSGGuiThreadShaderEffectManager::ShaderInfo *result)
                { const_cast<QQuickShaderEffectPrivate *>(this)->shaderCodePrepared(ok, typeHint, loadUrl, result); });
            }
        }
    }
    return m_mgr;
}
 
void QQuickShaderEffectPrivate::disconnectSignals(Shader shaderType)
{
    Q_Q(QQuickShaderEffect);
    for (auto *mapper : m_mappers[shaderType]) {
        void *a = mapper;
        if (mapper)
            QObjectPrivate::disconnect(q, mapper->signalIndex(), &a);
    }
    for (const auto &vd : std::as_const(m_shaders[shaderType].varData)) {
        if (vd.specialType == QSGShaderEffectNode::VariableData::Source) {
            QQuickItem *source = qobject_cast<QQuickItem *>(qvariant_cast<QObject *>(vd.value));
            if (source) {
                if (q->window())
                    QQuickItemPrivate::get(source)->derefWindow();
                auto it = m_destroyedConnections.constFind(source);
                if (it != m_destroyedConnections.constEnd()) {
                    QObject::disconnect(*it);
                    m_destroyedConnections.erase(it);
                }
            }
        }
    }
}
 
void QQuickShaderEffectPrivate::clearMappers(QQuickShaderEffectPrivate::Shader shaderType)
{
    for (auto *mapper : std::as_const(m_mappers[shaderType])) {
        if (mapper)
            mapper->destroyIfLastRef();
    }
    m_mappers[shaderType].clear();
}
 
static inline QVariant getValueFromProperty(QObject *item, const QMetaObject *itemMetaObject,
                                            const QByteArray &name, int propertyIndex)
{
    QVariant value;
    if (propertyIndex == -1) {
        value = item->property(name);
    } else {
        value = itemMetaObject->property(propertyIndex).read(item);
    }
    return value;
}
 
using QQuickShaderInfoCache = QHash<QUrl, QSGGuiThreadShaderEffectManager::ShaderInfo>;
Q_GLOBAL_STATIC(QQuickShaderInfoCache, shaderInfoCache)
 
void qtquick_shadereffect_purge_gui_thread_shader_cache()
{
    shaderInfoCache()->clear();
}
 
bool QQuickShaderEffectPrivate::updateShader(Shader shaderType, const QUrl &fileUrl)
{
    Q_Q(QQuickShaderEffect);
    QSGGuiThreadShaderEffectManager *mgr = shaderEffectManager();
    if (!mgr)
        return false;
 
    const bool texturesSeparate = mgr->hasSeparateSamplerAndTextureObjects();
 
    disconnectSignals(shaderType);
 
    m_shaders[shaderType].shaderInfo.variables.clear();
    m_shaders[shaderType].varData.clear();
 
    if (!fileUrl.isEmpty()) {
        const QQmlContext *context = qmlContext(q);
        const QUrl loadUrl = context ? context->resolvedUrl(fileUrl) : fileUrl;
        auto it = shaderInfoCache()->constFind(loadUrl);
        if (it != shaderInfoCache()->cend()) {
            m_shaders[shaderType].shaderInfo = *it;
            m_shaders[shaderType].hasShaderCode = true;
        } else {
            // Each prepareShaderCode call needs its own work area, hence the
            // dynamic alloc. If there are calls in progress, let those run to
            // finish, their results can then simply be ignored because
            // m_inProgress indicates what we care about.
            m_inProgress[shaderType] = new QSGGuiThreadShaderEffectManager::ShaderInfo;
            const QSGGuiThreadShaderEffectManager::ShaderInfo::Type typeHint =
                    shaderType == Vertex ? QSGGuiThreadShaderEffectManager::ShaderInfo::TypeVertex
                                         : QSGGuiThreadShaderEffectManager::ShaderInfo::TypeFragment;
            // Figure out what input parameters and variables are used in the
            // shader. This is where the data is pulled in from the file.
            // (however, if there is compilation involved, that happens at a
            // later stage, up to the QRhi backend)
            mgr->prepareShaderCode(typeHint, loadUrl, m_inProgress[shaderType]);
            // the rest is handled in shaderCodePrepared()
            return true;
        }
    } else {
        m_shaders[shaderType].hasShaderCode = false;
        if (shaderType == Fragment) {
            // With built-in shaders hasShaderCode is set to false and all
            // metadata is empty, as it is left up to the node to provide a
            // built-in default shader and its metadata. However, in case of
            // the built-in fragment shader the value for 'source' has to be
            // provided and monitored like with an application-provided shader.
            QSGGuiThreadShaderEffectManager::ShaderInfo::Variable v;
            v.name = QByteArrayLiteral("source");
            v.bindPoint = 1; // fake, must match the default source bindPoint in qquickshadereffectnode.cpp
            v.type = texturesSeparate ? QSGGuiThreadShaderEffectManager::ShaderInfo::Texture
                                      : QSGGuiThreadShaderEffectManager::ShaderInfo::Sampler;
            m_shaders[shaderType].shaderInfo.variables.append(v);
        }
    }
 
    updateShaderVars(shaderType);
    m_dirty |= QSGShaderEffectNode::DirtyShaders;
    q->update();
    return true;
}
 
void QQuickShaderEffectPrivate::shaderCodePrepared(bool ok, QSGGuiThreadShaderEffectManager::ShaderInfo::Type typeHint,
                                                const QUrl &loadUrl, QSGGuiThreadShaderEffectManager::ShaderInfo *result)
{
    Q_Q(QQuickShaderEffect);
    const Shader shaderType = typeHint == QSGGuiThreadShaderEffectManager::ShaderInfo::TypeVertex ? Vertex : Fragment;
 
    // If another call was made to updateShader() for the same shader type in
    // the meantime then our results are useless, just drop them.
    if (result != m_inProgress[shaderType]) {
        delete result;
        return;
    }
 
    m_shaders[shaderType].shaderInfo = *result;
    delete result;
    m_inProgress[shaderType] = nullptr;
 
    if (!ok) {
        qWarning("ShaderEffect: shader preparation failed for %s\n%s\n",
                 qPrintable(loadUrl.toString()), qPrintable(log()));
        m_shaders[shaderType].hasShaderCode = false;
        return;
    }
 
    m_shaders[shaderType].hasShaderCode = true;
    shaderInfoCache()->insert(loadUrl, m_shaders[shaderType].shaderInfo);
    updateShaderVars(shaderType);
    m_dirty |= QSGShaderEffectNode::DirtyShaders;
    q->update();
}
 
void QQuickShaderEffectPrivate::updateShaderVars(Shader shaderType)
{
    Q_Q(QQuickShaderEffect);
    QSGGuiThreadShaderEffectManager *mgr = shaderEffectManager();
    if (!mgr)
        return;
 
    const bool texturesSeparate = mgr->hasSeparateSamplerAndTextureObjects();
 
    const int varCount = m_shaders[shaderType].shaderInfo.variables.size();
    m_shaders[shaderType].varData.resize(varCount);
 
    // Recreate signal mappers when the shader has changed.
    clearMappers(shaderType);
 
    QQmlPropertyCache::ConstPtr propCache = QQmlData::ensurePropertyCache(q);
 
    if (!m_itemMetaObject)
        m_itemMetaObject = q->metaObject();
 
    // Hook up the signals to get notified about changes for properties that
    // correspond to variables in the shader. Store also the values.
    for (int i = 0; i < varCount; ++i) {
        const auto &v(m_shaders[shaderType].shaderInfo.variables.at(i));
        QSGShaderEffectNode::VariableData &vd(m_shaders[shaderType].varData[i]);
        const bool isSpecial = v.name.startsWith("qt_"); // special names not mapped to properties
        if (isSpecial) {
            if (v.name == "qt_Opacity")
                vd.specialType = QSGShaderEffectNode::VariableData::Opacity;
            else if (v.name == "qt_Matrix")
                vd.specialType = QSGShaderEffectNode::VariableData::Matrix;
            else if (v.name.startsWith("qt_SubRect_"))
                vd.specialType = QSGShaderEffectNode::VariableData::SubRect;
            continue;
        }
 
        // The value of a property corresponding to a sampler is the source
        // item ref, unless there are separate texture objects in which case
        // the sampler is ignored (here).
        if (v.type == QSGGuiThreadShaderEffectManager::ShaderInfo::Sampler) {
            if (texturesSeparate) {
                vd.specialType = QSGShaderEffectNode::VariableData::Unused;
                continue;
            } else {
                vd.specialType = QSGShaderEffectNode::VariableData::Source;
            }
        } else if (v.type == QSGGuiThreadShaderEffectManager::ShaderInfo::Texture) {
            Q_ASSERT(texturesSeparate);
            vd.specialType = QSGShaderEffectNode::VariableData::Source;
        } else {
            vd.specialType = QSGShaderEffectNode::VariableData::None;
        }
 
        // Find the property on the ShaderEffect item.
        int propIdx = -1;
        const QQmlPropertyData *pd = nullptr;
        if (propCache) {
            pd = propCache->property(QLatin1String(v.name), nullptr, nullptr);
            if (pd) {
                if (!pd->isFunction())
                    propIdx = pd->coreIndex();
            }
        }
        if (propIdx >= 0) {
            if (pd && !pd->isFunction()) {
                if (pd->notifyIndex() == -1) {
                    qWarning("QQuickShaderEffect: property '%s' does not have notification method!", v.name.constData());
                } else {
                    const int mappedId = indexToMappedId(shaderType, i);
                    auto mapper = new QtPrivate::EffectSlotMapper([this, mappedId](){
                        this->propertyChanged(mappedId);
                    });
                    m_mappers[shaderType].append(mapper);
                    mapper->setSignalIndex(m_itemMetaObject->property(propIdx).notifySignal().methodIndex());
                    Q_ASSERT(q->metaObject() == m_itemMetaObject);
                    bool ok = QObjectPrivate::connectImpl(q, pd->notifyIndex(), q, nullptr, mapper,
                                                          Qt::AutoConnection, nullptr, m_itemMetaObject);
                    if (!ok)
                        qWarning() << "Failed to connect to property" << m_itemMetaObject->property(propIdx).name()
                                   << "(" << propIdx << ", signal index" << pd->notifyIndex()
                                   << ") of item" << q;
                }
            }
        } else {
            // Do not warn for dynamic properties.
            if (!q->property(v.name.constData()).isValid())
                qWarning("ShaderEffect: '%s' does not have a matching property", v.name.constData());
        }
 
 
        vd.propertyIndex = propIdx;
        vd.value = getValueFromProperty(q, m_itemMetaObject, v.name, vd.propertyIndex);
        if (vd.specialType == QSGShaderEffectNode::VariableData::Source) {
            QQuickItem *source = qobject_cast<QQuickItem *>(qvariant_cast<QObject *>(vd.value));
            if (source) {
                if (q->window())
                    QQuickItemPrivate::get(source)->refWindow(q->window());
 
                // Cannot just pass q as the 'context' for the connect(). The
                // order of destruction is...complicated. Having an inline
                // source (e.g. source: ShaderEffectSource { ... } in QML would
                // emit destroyed() after the connection was already gone. To
                // work that around, store the Connection and manually
                // disconnect instead.
                if (!m_destroyedConnections.contains(source))
                    m_destroyedConnections.insert(source, QObject::connect(source, &QObject::destroyed, [this](QObject *obj) { sourceDestroyed(obj); }));
            }
        }
    }
}
 
std::optional<int> QQuickShaderEffectPrivate::findMappedShaderVariableId(const QByteArray &name) const
{
    for (int shaderType = 0; shaderType < NShader; ++shaderType) {
        const auto &vars = m_shaders[shaderType].shaderInfo.variables;
        for (int idx = 0; idx < vars.size(); ++idx) {
            if (vars[idx].name == name)
                return indexToMappedId(shaderType, idx);
        }
    }
 
    return {};
}
 
std::optional<int> QQuickShaderEffectPrivate::findMappedShaderVariableId(const QByteArray &name, Shader shaderType) const
{
    const auto &vars = m_shaders[shaderType].shaderInfo.variables;
    for (int idx = 0; idx < vars.size(); ++idx) {
        if (vars[idx].name == name)
            return indexToMappedId(shaderType, idx);
    }
 
    return {};
}
 
bool QQuickShaderEffectPrivate::sourceIsUnique(QQuickItem *source, Shader typeToSkip, int indexToSkip) const
{
    for (int shaderType = 0; shaderType < NShader; ++shaderType) {
        for (int idx = 0; idx < m_shaders[shaderType].varData.size(); ++idx) {
            if (shaderType != typeToSkip || idx != indexToSkip) {
                const auto &vd(m_shaders[shaderType].varData[idx]);
                if (vd.specialType == QSGShaderEffectNode::VariableData::Source && qvariant_cast<QObject *>(vd.value) == source)
                    return false;
            }
        }
    }
    return true;
}
 
void QQuickShaderEffectPrivate::propertyChanged(int mappedId)
{
    Q_Q(QQuickShaderEffect);
    const Shader type = Shader(mappedIdToShaderType(mappedId));
    const int idx = mappedIdToIndex(mappedId);
    const auto &v(m_shaders[type].shaderInfo.variables[idx]);
    auto &vd(m_shaders[type].varData[idx]);
 
    QVariant oldValue = vd.value;
    vd.value = getValueFromProperty(q, m_itemMetaObject, v.name, vd.propertyIndex);
 
    if (vd.specialType == QSGShaderEffectNode::VariableData::Source) {
        QQuickItem *source = qobject_cast<QQuickItem *>(qvariant_cast<QObject *>(oldValue));
        if (source) {
            if (q->window())
                QQuickItemPrivate::get(source)->derefWindow();
            // If the same source has been attached to two separate
            // textures/samplers, then changing one of them would trigger both
            // to be disconnected. So check first.
            if (sourceIsUnique(source, type, idx)) {
                auto it = m_destroyedConnections.constFind(source);
                if (it != m_destroyedConnections.constEnd()) {
                    QObject::disconnect(*it);
                    m_destroyedConnections.erase(it);
                }
            }
        }
 
        source = qobject_cast<QQuickItem *>(qvariant_cast<QObject *>(vd.value));
        if (source) {
            // 'source' 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.
            // "property variant source: Image { }" instead of "property variant source: foo" -- it
            // will not get a parent. In those cases, 'source' should get the window from 'item'.
            if (q->window())
                QQuickItemPrivate::get(source)->refWindow(q->window());
            if (!m_destroyedConnections.contains(source))
                m_destroyedConnections.insert(source, QObject::connect(source, &QObject::destroyed, [this](QObject *obj) { sourceDestroyed(obj); }));
        }
 
        m_dirty |= QSGShaderEffectNode::DirtyShaderTexture;
        m_dirtyTextures[type].insert(idx);
 
     } else {
        m_dirty |= QSGShaderEffectNode::DirtyShaderConstant;
        m_dirtyConstants[type].insert(idx);
    }
 
    q->update();
}
 
void QQuickShaderEffectPrivate::sourceDestroyed(QObject *object)
{
    for (int shaderType = 0; shaderType < NShader; ++shaderType) {
        for (auto &vd : m_shaders[shaderType].varData) {
            if (vd.specialType == QSGShaderEffectNode::VariableData::Source && vd.value.canConvert<QObject *>()) {
                if (qvariant_cast<QObject *>(vd.value) == object)
                    vd.value = QVariant();
            }
        }
    }
}
 
void QQuickShaderEffectPrivate::markGeometryDirtyAndUpdate()
{
    Q_Q(QQuickShaderEffect);
    m_dirty |= QSGShaderEffectNode::DirtyShaderGeometry;
    q->update();
}
 
void QQuickShaderEffectPrivate::markGeometryDirtyAndUpdateIfSupportsAtlas()
{
    if (m_supportsAtlasTextures)
        markGeometryDirtyAndUpdate();
}
 
QT_END_NAMESPACE
 
#include "moc_qquickshadereffect_p.cpp"