Add the skeleton for the new, more generic shader effect impl

which should route and place most of its work into the scenegraph.

And fix a test.

Change-Id: I04f29cba53c2bab62e41b3b524794d3c4d20a472
Reviewed-by: Andy Nichols <andy.nichols@theqtcompany.com>

src/particles/qquickcustomparticle.cpp

@@ -94,6 +94,7 @@ struct PlainVertices {
 
 QQuickCustomParticle::QQuickCustomParticle(QQuickItem* parent)
     : QQuickParticlePainter(parent)
+    , m_common(this)
     , m_dirtyUniforms(true)
     , m_dirtyUniformValues(true)
     , m_dirtyTextureProviders(true)

src/quick/items/items.pri

@@ -75,6 +75,7 @@ HEADERS += \
     $$PWD/qquickshadereffectsource_p.h \
     $$PWD/qquickshadereffectmesh_p.h \
     $$PWD/qquickshadereffect_p.h \
+    $$PWD/qquickgenericshadereffect_p.h \
     $$PWD/qquickrendercontrol.h \
     $$PWD/qquickrendercontrol_p.h
 
@@ -128,6 +129,7 @@ SOURCES += \
     $$PWD/qquickshadereffectsource.cpp \
     $$PWD/qquickshadereffectmesh.cpp \
     $$PWD/qquickshadereffect.cpp \
+    $$PWD/qquickgenericshadereffect.cpp \
     $$PWD/qquickrendercontrol.cpp
 
 # Items that depend on OpenGL Renderer

src/quick/items/qquickgenericshadereffect.cpp

@@ -0,0 +1,127 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQuick module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <private/qquickgenericshadereffect_p.h>
+
+QT_BEGIN_NAMESPACE
+
+// The generic shader effect is used when the scenegraph backend indicates
+// SupportsShaderEffectV2. This, unlike the monolithic and interconnected (e.g.
+// with particles) OpenGL variant, passes most of the work to a scenegraph node
+// created via the adaptation layer, thus allowing different implementation in
+// the backends.
+
+QQuickGenericShaderEffect::QQuickGenericShaderEffect(QQuickShaderEffect *item, QObject *parent)
+    : QObject(parent)
+    , m_item(item)
+    , m_meshResolution(1, 1)
+    , m_mesh(0)
+    , m_cullMode(QQuickShaderEffect::NoCulling)
+    , m_status(QQuickShaderEffect::Uncompiled)
+    , m_blending(true)
+    , m_supportsAtlasTextures(false)
+{
+}
+
+QQuickGenericShaderEffect::~QQuickGenericShaderEffect()
+{
+}
+
+void QQuickGenericShaderEffect::setFragmentShader(const QByteArray &code)
+{
+    Q_UNUSED(code);
+}
+
+void QQuickGenericShaderEffect::setVertexShader(const QByteArray &code)
+{
+    Q_UNUSED(code);
+}
+
+void QQuickGenericShaderEffect::setBlending(bool enable)
+{
+    Q_UNUSED(enable);
+}
+
+QVariant QQuickGenericShaderEffect::mesh() const
+{
+    return m_mesh ? qVariantFromValue(static_cast<QObject *>(m_mesh))
+                  : qVariantFromValue(m_meshResolution);
+}
+
+void QQuickGenericShaderEffect::setMesh(const QVariant &mesh)
+{
+    Q_UNUSED(mesh);
+}
+
+void QQuickGenericShaderEffect::setCullMode(QQuickShaderEffect::CullMode face)
+{
+    Q_UNUSED(face);
+}
+
+void QQuickGenericShaderEffect::setSupportsAtlasTextures(bool supports)
+{
+    Q_UNUSED(supports);
+}
+
+void QQuickGenericShaderEffect::handleEvent(QEvent *event)
+{
+    Q_UNUSED(event);
+}
+
+void QQuickGenericShaderEffect::handleGeometryChanged(const QRectF &, const QRectF &)
+{
+}
+
+QSGNode *QQuickGenericShaderEffect::handleUpdatePaintNode(QSGNode *oldNode, QQuickItem::UpdatePaintNodeData *)
+{
+    Q_UNUSED(oldNode);
+    return nullptr;
+}
+
+void QQuickGenericShaderEffect::handleComponentComplete()
+{
+}
+
+void QQuickGenericShaderEffect::handleItemChange(QQuickItem::ItemChange change, const QQuickItem::ItemChangeData &value)
+{
+    Q_UNUSED(change);
+    Q_UNUSED(value);
+}
+
+QT_END_NAMESPACE

src/quick/items/qquickgenericshadereffect_p.h

@@ -0,0 +1,113 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQuick module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QQUICKGENERICSHADEREFFECT_P_H
+#define QQUICKGENERICSHADEREFFECT_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtQuick/qquickitem.h>
+#include <private/qtquickglobal_p.h>
+#include "qquickshadereffect_p.h"
+#include "qquickshadereffectmesh_p.h"
+
+QT_BEGIN_NAMESPACE
+
+class Q_QUICK_PRIVATE_EXPORT QQuickGenericShaderEffect : public QObject
+{
+    Q_OBJECT
+
+public:
+    QQuickGenericShaderEffect(QQuickShaderEffect *item, QObject *parent = 0);
+    ~QQuickGenericShaderEffect();
+
+    QByteArray fragmentShader() const { return QByteArray(); }
+    void setFragmentShader(const QByteArray &code);
+
+    QByteArray vertexShader() const { return QByteArray(); }
+    void setVertexShader(const QByteArray &code);
+
+    bool blending() const { return m_blending; }
+    void setBlending(bool enable);
+
+    QVariant mesh() const;
+    void setMesh(const QVariant &mesh);
+
+    QQuickShaderEffect::CullMode cullMode() const { return m_cullMode; }
+    void setCullMode(QQuickShaderEffect::CullMode face);
+
+    QString log() const { return m_log; }
+    QQuickShaderEffect::Status status() const { return m_status; }
+
+    bool supportsAtlasTextures() const { return m_supportsAtlasTextures; }
+    void setSupportsAtlasTextures(bool supports);
+
+    void handleEvent(QEvent *);
+    void handleGeometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry);
+    QSGNode *handleUpdatePaintNode(QSGNode *, QQuickItem::UpdatePaintNodeData *);
+    void handleComponentComplete();
+    void handleItemChange(QQuickItem::ItemChange change, const QQuickItem::ItemChangeData &value);
+
+    QString parseLog() { return QString(); }
+
+private:
+    QQuickShaderEffect *m_item;
+    QSize m_meshResolution;
+    QQuickShaderEffectMesh *m_mesh;
+    QQuickGridMesh m_defaultMesh;
+    QQuickShaderEffect::CullMode m_cullMode;
+    QString m_log;
+    QQuickShaderEffect::Status m_status;
+
+    uint m_blending : 1;
+    uint m_supportsAtlasTextures : 1;
+};
+
+QT_END_NAMESPACE
+
+#endif // QQUICKGENERICSHADEREFFECT_P_H

src/quick/items/qquickopenglshadereffect.cpp

@@ -193,13 +193,13 @@ void QQuickOpenGLShaderEffectCommon::disconnectPropertySignals(QQuickItem *item,
         const UniformData &d = uniformData[shaderType].at(i);
         QSignalMapper *mapper = signalMappers[shaderType].at(i);
         QObject::disconnect(item, 0, mapper, SLOT(map()));
-        QObject::disconnect(mapper, SIGNAL(mapped(int)), item, SLOT(propertyChanged(int)));
+        QObject::disconnect(mapper, SIGNAL(mapped(int)), host, SLOT(propertyChanged(int)));
         if (d.specialType == UniformData::Sampler) {
             QQuickItem *source = qobject_cast<QQuickItem *>(qvariant_cast<QObject *>(d.value));
             if (source) {
                 if (item->window())
                     QQuickItemPrivate::get(source)->derefWindow();
-                QObject::disconnect(source, SIGNAL(destroyed(QObject*)), item, SLOT(sourceDestroyed(QObject*)));
+                QObject::disconnect(source, SIGNAL(destroyed(QObject*)), host, SLOT(sourceDestroyed(QObject*)));
             }
         }
     }
@@ -219,7 +219,7 @@ void QQuickOpenGLShaderEffectCommon::connectPropertySignals(QQuickItem *item, Ke
             const QByteArray signalName = '2' + mp.notifySignal().methodSignature();
             QSignalMapper *mapper = signalMappers[shaderType].at(i);
             QObject::connect(item, signalName, mapper, SLOT(map()));
-            QObject::connect(mapper, SIGNAL(mapped(int)), item, SLOT(propertyChanged(int)));
+            QObject::connect(mapper, SIGNAL(mapped(int)), host, SLOT(propertyChanged(int)));
         } else {
             // If the source is set via a dynamic property, like the layer is, then we need this
             // check to disable the warning.
@@ -232,7 +232,7 @@ void QQuickOpenGLShaderEffectCommon::connectPropertySignals(QQuickItem *item, Ke
             if (source) {
                 if (item->window())
                     QQuickItemPrivate::get(source)->refWindow(item->window());
-                QObject::connect(source, SIGNAL(destroyed(QObject*)), item, SLOT(sourceDestroyed(QObject*)));
+                QObject::connect(source, SIGNAL(destroyed(QObject*)), host, SLOT(sourceDestroyed(QObject*)));
             }
         }
     }
@@ -499,7 +499,7 @@ void QQuickOpenGLShaderEffectCommon::propertyChanged(QQuickItem *item, int mappe
             // would trigger both to be disconnected. Without the connection we'll end up
             // with a dangling pointer in the uniformData.
             if (qquick_uniqueInUniformData(source, uniformData, shaderType, index))
-                QObject::disconnect(source, SIGNAL(destroyed(QObject*)), item, SLOT(sourceDestroyed(QObject*)));
+                QObject::disconnect(source, SIGNAL(destroyed(QObject*)), host, SLOT(sourceDestroyed(QObject*)));
         }
 
         d.value = item->property(d.name.constData());
@@ -512,7 +512,7 @@ void QQuickOpenGLShaderEffectCommon::propertyChanged(QQuickItem *item, int mappe
             // will not get a parent. In those cases, 'source' should get the window from 'item'.
             if (item->window())
                 QQuickItemPrivate::get(source)->refWindow(item->window());
-            QObject::connect(source, SIGNAL(destroyed(QObject*)), item, SLOT(sourceDestroyed(QObject*)));
+            QObject::connect(source, SIGNAL(destroyed(QObject*)), host, SLOT(sourceDestroyed(QObject*)));
         }
         if (textureProviderChanged)
             *textureProviderChanged = true;
@@ -530,6 +530,7 @@ QQuickOpenGLShaderEffect::QQuickOpenGLShaderEffect(QQuickShaderEffect *item, QOb
     , m_mesh(0)
     , m_cullMode(QQuickShaderEffect::NoCulling)
     , m_status(QQuickShaderEffect::Uncompiled)
+    , m_common(this)
     , m_blending(true)
     , m_dirtyUniforms(true)
     , m_dirtyUniformValues(true)
@@ -563,9 +564,9 @@ void QQuickOpenGLShaderEffect::setFragmentShader(const QByteArray &code)
     m_item->update();
     if (m_status != QQuickShaderEffect::Uncompiled) {
         m_status = QQuickShaderEffect::Uncompiled;
-        emit statusChanged();
+        emit m_item->statusChanged();
     }
-    emit fragmentShaderChanged();
+    emit m_item->fragmentShaderChanged();
 }
 
 void QQuickOpenGLShaderEffect::setVertexShader(const QByteArray &code)
@@ -583,9 +584,9 @@ void QQuickOpenGLShaderEffect::setVertexShader(const QByteArray &code)
     m_item->update();
     if (m_status != QQuickShaderEffect::Uncompiled) {
         m_status = QQuickShaderEffect::Uncompiled;
-        emit statusChanged();
+        emit m_item->statusChanged();
     }
-    emit vertexShaderChanged();
+    emit m_item->vertexShaderChanged();
 }
 
 void QQuickOpenGLShaderEffect::setBlending(bool enable)
@@ -596,7 +597,7 @@ void QQuickOpenGLShaderEffect::setBlending(bool enable)
     m_blending = enable;
     m_item->update();
 
-    emit blendingChanged();
+    emit m_item->blendingChanged();
 }
 
 QVariant QQuickOpenGLShaderEffect::mesh() const
@@ -638,7 +639,7 @@ void QQuickOpenGLShaderEffect::setMesh(const QVariant &mesh)
     m_dirtyMesh = true;
     m_dirtyParseLog = true;
     m_item->update();
-    emit meshChanged();
+    emit m_item->meshChanged();
 }
 
 void QQuickOpenGLShaderEffect::setCullMode(QQuickShaderEffect::CullMode face)
@@ -647,7 +648,7 @@ void QQuickOpenGLShaderEffect::setCullMode(QQuickShaderEffect::CullMode face)
         return;
     m_cullMode = face;
     m_item->update();
-    emit cullModeChanged();
+    emit m_item->cullModeChanged();
 }
 
 void QQuickOpenGLShaderEffect::setSupportsAtlasTextures(bool supports)
@@ -656,7 +657,7 @@ void QQuickOpenGLShaderEffect::setSupportsAtlasTextures(bool supports)
         return;
     m_supportsAtlasTextures = supports;
     updateGeometry();
-    emit supportsAtlasTexturesChanged();
+    emit m_item->supportsAtlasTexturesChanged();
 }
 
 QString QQuickOpenGLShaderEffect::parseLog()
@@ -702,16 +703,16 @@ void QQuickOpenGLShaderEffect::updateLogAndStatus(const QString &log, int status
 {
     m_log = parseLog() + log;
     m_status = QQuickShaderEffect::Status(status);
-    emit logChanged();
+    emit m_item->logChanged();
-    emit statusChanged();
+    emit m_item->statusChanged();
 }
 
-void QQuickOpenGLShaderEffect::handleSourceDestroyed(QObject *object)
+void QQuickOpenGLShaderEffect::sourceDestroyed(QObject *object)
 {
     m_common.sourceDestroyed(object);
 }
 
-void QQuickOpenGLShaderEffect::handlePropertyChanged(int mappedId)
+void QQuickOpenGLShaderEffect::propertyChanged(int mappedId)
 {
     bool textureProviderChanged;
     m_common.propertyChanged(m_item, mappedId, &textureProviderChanged);
@@ -829,8 +830,8 @@ QSGNode *QQuickOpenGLShaderEffect::handleUpdatePaintNode(QSGNode *oldNode, QQuic
                 m_log += QLatin1String("*** Mesh ***\n");
                 m_log += log;
                 m_status = QQuickShaderEffect::Error;
-                emit logChanged();
+                emit m_item->logChanged();
-                emit statusChanged();
+                emit m_item->statusChanged();
             }
             delete node;
             return 0;

src/quick/items/qquickopenglshadereffect_p.h

@@ -74,6 +74,7 @@ struct Q_QUICK_PRIVATE_EXPORT QQuickOpenGLShaderEffectCommon
     typedef QQuickOpenGLShaderEffectMaterialKey Key;
     typedef QQuickOpenGLShaderEffectMaterial::UniformData UniformData;
 
+    QQuickOpenGLShaderEffectCommon(QObject *host) : host(host) { }
     ~QQuickOpenGLShaderEffectCommon();
     void disconnectPropertySignals(QQuickItem *item, Key::ShaderType shaderType);
     void connectPropertySignals(QQuickItem *item, Key::ShaderType shaderType);
@@ -88,6 +89,7 @@ struct Q_QUICK_PRIVATE_EXPORT QQuickOpenGLShaderEffectCommon
     void sourceDestroyed(QObject *object);
     void propertyChanged(QQuickItem *item, int mappedId, bool *textureProviderChanged);
 
+    QObject *host;
     Key source;
     QVector<QByteArray> attributes;
     QVector<UniformData> uniformData[Key::ShaderTypeCount];
@@ -127,29 +129,18 @@ public:
 
     QString parseLog();
 
-Q_SIGNALS:
-    void fragmentShaderChanged();
-    void vertexShaderChanged();
-    void blendingChanged();
-    void meshChanged();
-    void cullModeChanged();
-    void logChanged();
-    void statusChanged();
-    void supportsAtlasTexturesChanged();
-
-protected:
     void handleEvent(QEvent *);
     void handleGeometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry);
     QSGNode *handleUpdatePaintNode(QSGNode *, QQuickItem::UpdatePaintNodeData *);
     void handleComponentComplete();
     void handleItemChange(QQuickItem::ItemChange change, const QQuickItem::ItemChangeData &value);
-    void handleSourceDestroyed(QObject *object);
-    void handlePropertyChanged(int mappedId);
 
 private Q_SLOTS:
     void updateGeometry();
     void updateGeometryIfAtlased();
     void updateLogAndStatus(const QString &log, int status);
+    void sourceDestroyed(QObject *object);
+    void propertyChanged(int mappedId);
 
 private:
     friend class QQuickCustomMaterialShader;
@@ -178,8 +169,6 @@ private:
     uint m_dirtyGeometry : 1;
     uint m_customVertexShader : 1;
     uint m_supportsAtlasTextures : 1;
-
-    friend class QQuickShaderEffect;
 };
 
 QT_END_NAMESPACE

src/quick/items/qquickshadereffect.cpp

@@ -42,6 +42,7 @@
 #ifndef QT_NO_OPENGL
 #include <private/qquickopenglshadereffect_p.h>
 #endif
+#include <private/qquickgenericshadereffect_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -196,16 +197,18 @@ QT_BEGIN_NAMESPACE
 QSGContextFactoryInterface::Flags qsg_backend_flags();
 
 QQuickShaderEffect::QQuickShaderEffect(QQuickItem *parent)
-    : QQuickItem(parent)
+    : QQuickItem(parent),
+      m_glImpl(nullptr),
+      m_impl(nullptr)
 {
     setFlag(QQuickItem::ItemHasContents);
 
 #ifndef QT_NO_OPENGL
     if (!qsg_backend_flags().testFlag(QSGContextFactoryInterface::SupportsShaderEffectV2))
         m_glImpl = new QQuickOpenGLShaderEffect(this, this);
-    else
-        m_glImpl = nullptr;
 #endif
+    if (!m_glImpl)
+        m_impl = new QQuickGenericShaderEffect(this, this);
 }
 
 /*!
@@ -223,16 +226,18 @@ QByteArray QQuickShaderEffect::fragmentShader() const
     if (m_glImpl)
         return m_glImpl->fragmentShader();
 #endif
-    return QByteArray();
+    return m_impl->fragmentShader();
 }
 
 void QQuickShaderEffect::setFragmentShader(const QByteArray &code)
 {
 #ifndef QT_NO_OPENGL
-    if (m_glImpl)
+    if (m_glImpl) {
         m_glImpl->setFragmentShader(code);
+        return;
+    }
 #endif
-    Q_UNUSED(code);
+    m_impl->setFragmentShader(code);
 }
 
 /*!
@@ -249,16 +254,18 @@ QByteArray QQuickShaderEffect::vertexShader() const
     if (m_glImpl)
         return m_glImpl->vertexShader();
 #endif
-    return QByteArray();
+    return m_impl->vertexShader();
 }
 
 void QQuickShaderEffect::setVertexShader(const QByteArray &code)
 {
 #ifndef QT_NO_OPENGL
-    if (m_glImpl)
+    if (m_glImpl) {
         m_glImpl->setVertexShader(code);
+        return;
+    }
 #endif
-    Q_UNUSED(code);
+    m_impl->setVertexShader(code);
 }
 
 /*!
@@ -276,16 +283,18 @@ bool QQuickShaderEffect::blending() const
     if (m_glImpl)
         return m_glImpl->blending();
 #endif
-    return true;
+    return m_impl->blending();
 }
 
 void QQuickShaderEffect::setBlending(bool enable)
 {
 #ifndef QT_NO_OPENGL
-    if (m_glImpl)
+    if (m_glImpl) {
         m_glImpl->setBlending(enable);
+        return;
+    }
 #endif
-    Q_UNUSED(enable);
+    m_impl->setBlending(enable);
 }
 
 /*!
@@ -307,16 +316,18 @@ QVariant QQuickShaderEffect::mesh() const
     if (m_glImpl)
         return m_glImpl->mesh();
 #endif
-    return QVariant();
+    return m_impl->mesh();
 }
 
 void QQuickShaderEffect::setMesh(const QVariant &mesh)
 {
 #ifndef QT_NO_OPENGL
-    if (m_glImpl)
+    if (m_glImpl) {
         m_glImpl->setMesh(mesh);
+        return;
+    }
 #endif
-    Q_UNUSED(mesh);
+    m_impl->setMesh(mesh);
 }
 
 /*!
@@ -339,16 +350,18 @@ QQuickShaderEffect::CullMode QQuickShaderEffect::cullMode() const
     if (m_glImpl)
         return m_glImpl->cullMode();
 #endif
-    return NoCulling;
+    return m_impl->cullMode();
 }
 
 void QQuickShaderEffect::setCullMode(CullMode face)
 {
 #ifndef QT_NO_OPENGL
-    if (m_glImpl)
+    if (m_glImpl) {
         m_glImpl->setCullMode(face);
+        return;
+    }
 #endif
-    Q_UNUSED(face);
+    return m_impl->setCullMode(face);
 }
 
 /*!
@@ -378,16 +391,18 @@ bool QQuickShaderEffect::supportsAtlasTextures() const
     if (m_glImpl)
         return m_glImpl->supportsAtlasTextures();
 #endif
-    return false;
+    return m_impl->supportsAtlasTextures();
 }
 
 void QQuickShaderEffect::setSupportsAtlasTextures(bool supports)
 {
 #ifndef QT_NO_OPENGL
-    if (m_glImpl)
+    if (m_glImpl) {
         m_glImpl->setSupportsAtlasTextures(supports);
+        return;
+    }
 #endif
-    Q_UNUSED(supports);
+    m_impl->setSupportsAtlasTextures(supports);
 }
 
 /*!
@@ -424,7 +439,7 @@ QString QQuickShaderEffect::log() const
     if (m_glImpl)
         return m_glImpl->log();
 #endif
-    return QString();
+    return m_impl->log();
 }
 
 QQuickShaderEffect::Status QQuickShaderEffect::status() const
@@ -433,24 +448,31 @@ QQuickShaderEffect::Status QQuickShaderEffect::status() const
     if (m_glImpl)
         return m_glImpl->status();
 #endif
-    return Uncompiled;
+    return m_impl->status();
 }
 
 bool QQuickShaderEffect::event(QEvent *e)
 {
 #ifndef QT_NO_OPENGL
-    if (m_glImpl)
+    if (m_glImpl) {
         m_glImpl->handleEvent(e);
+        return QQuickItem::event(e);
+    }
 #endif
+    m_impl->handleEvent(e);
     return QQuickItem::event(e);
 }
 
 void QQuickShaderEffect::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
 {
 #ifndef QT_NO_OPENGL
-    if (m_glImpl)
+    if (m_glImpl) {
         m_glImpl->handleGeometryChanged(newGeometry, oldGeometry);
+        QQuickItem::geometryChanged(newGeometry, oldGeometry);
+        return;
+    }
 #endif
+    m_impl->handleGeometryChanged(newGeometry, oldGeometry);
     QQuickItem::geometryChanged(newGeometry, oldGeometry);
 }
 
@@ -460,24 +482,32 @@ QSGNode *QQuickShaderEffect::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeDa
     if (m_glImpl)
         return m_glImpl->handleUpdatePaintNode(oldNode, updatePaintNodeData);
 #endif
-    return nullptr;
+    return m_impl->handleUpdatePaintNode(oldNode, updatePaintNodeData);
 }
 
 void QQuickShaderEffect::componentComplete()
 {
 #ifndef QT_NO_OPENGL
-    if (m_glImpl)
+    if (m_glImpl) {
         m_glImpl->handleComponentComplete();
+        QQuickItem::componentComplete();
+        return;
+    }
 #endif
+    m_impl->handleComponentComplete();
     QQuickItem::componentComplete();
 }
 
 void QQuickShaderEffect::itemChange(ItemChange change, const ItemChangeData &value)
 {
 #ifndef QT_NO_OPENGL
-    if (m_glImpl)
+    if (m_glImpl) {
         m_glImpl->handleItemChange(change, value);
+        QQuickItem::itemChange(change, value);
+        return;
+    }
 #endif
+    m_impl->handleItemChange(change, value);
     QQuickItem::itemChange(change, value);
 }
 
@@ -486,22 +516,13 @@ bool QQuickShaderEffect::isComponentComplete() const
     return QQuickItem::isComponentComplete();
 }
 
-void QQuickShaderEffect::sourceDestroyed(QObject *object)
+QString QQuickShaderEffect::parseLog()
 {
 #ifndef QT_NO_OPENGL
     if (m_glImpl)
-        m_glImpl->handleSourceDestroyed(object);
+        return m_glImpl->parseLog();
 #endif
-    Q_UNUSED(object);
+    return m_impl->parseLog();
-}
-
-void QQuickShaderEffect::propertyChanged(int mappedId)
-{
-#ifndef QT_NO_OPENGL
-    if (m_glImpl)
-        m_glImpl->handlePropertyChanged(mappedId);
-#endif
-    Q_UNUSED(mappedId);
 }
 
 QT_END_NAMESPACE

src/quick/items/qquickshadereffect_p.h

@@ -57,6 +57,7 @@
 QT_BEGIN_NAMESPACE
 
 class QQuickOpenGLShaderEffect;
+class QQuickGenericShaderEffect;
 
 class Q_QUICK_PRIVATE_EXPORT QQuickShaderEffect : public QQuickItem
 {
@@ -109,6 +110,7 @@ public:
     Status status() const;
 
     bool isComponentComplete() const;
+    QString parseLog();
 
 Q_SIGNALS:
     void fragmentShaderChanged();
@@ -127,14 +129,11 @@ protected:
     void componentComplete() override;
     void itemChange(ItemChange change, const ItemChangeData &value) override;
 
-private Q_SLOTS:
-    void sourceDestroyed(QObject *object);
-    void propertyChanged(int mappedId);
-
 private:
 #ifndef QT_NO_OPENGL
     QQuickOpenGLShaderEffect *m_glImpl;
 #endif
+    QQuickGenericShaderEffect *m_impl;
 };
 
 QT_END_NAMESPACE

tests/auto/quick/qquickshadereffect/tst_qquickshadereffect.cpp

@@ -35,7 +35,7 @@
 #include <QtQuick/QQuickView>
 #include "../../shared/util.h"
 
-class TestShaderEffect : public QQuickOpenGLShaderEffect
+class TestShaderEffect : public QQuickShaderEffect
 {
     Q_OBJECT
     Q_PROPERTY(QVariant source READ dummyRead NOTIFY dummyChanged)