Prefix GL-specific shader effect code

Rename the C++ sources and classes. The QML type name remains the same.

No changes in functionality.

The shader effect, node, material (and uniform animator and particles and
bits and pieces here and there...) are highly interconnected and do not
follow the usual design practices for Quick and the scenegraph and the
adaptation layer. Therefore while we aim for keeping full compatibility
for GL apps, other backends will likely get a different ShaderEffect item
implementation.

The C++ class QQuickShaderEffect itself is currently a dummy with an
unchanged API. It is not in use for now but forms the basis for the
implementation for other backends. This will be covered in future commits.

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

1 files changed, 34 insertions, 781 deletions

diff --git a/src/quick/items/qquickshadereffect.cpp b/src/quick/items/qquickshadereffect.cpp
index a2c2ebb380..e604e80d96 100644
--- a/src/quick/items/qquickshadereffect.cpp
+++ b/src/quick/items/qquickshadereffect.cpp
@@ -38,493 +38,9 @@
 ****************************************************************************/
 
 #include <private/qquickshadereffect_p.h>
-#include <private/qquickshadereffectnode_p.h>
-
-#include <QtQuick/qsgmaterial.h>
-#include <QtQuick/private/qsgshadersourcebuilder_p.h>
-#include "qquickitem_p.h"
-
-#include <QtQuick/private/qsgcontext_p.h>
-#include <QtQuick/qsgtextureprovider.h>
-#include "qquickwindow.h"
-
-#include "qquickimage_p.h"
-#include "qquickshadereffectsource_p.h"
-#include "qquickshadereffectmesh_p.h"
-
-#include <QtCore/qsignalmapper.h>
 
 QT_BEGIN_NAMESPACE
 
-namespace {
-
-    enum VariableQualifier {
-        AttributeQualifier,
-        UniformQualifier
-    };
-
-    inline bool qt_isalpha(char c)
-    {
-        char ch = c | 0x20;
-        return (ch >= 'a' && ch <= 'z') || c == '_';
-    }
-
-    inline bool qt_isalnum(char c)
-    {
-        return qt_isalpha(c) || (c >= '0' && c <= '9');
-    }
-
-    inline bool qt_isspace(char c)
-    {
-        return c == ' ' || (c >= 0x09 && c <= 0x0d);
-    }
-
-    // Returns -1 if not found, returns index to first character after the name if found.
-    int qt_search_for_variable(const char *s, int length, int index, VariableQualifier &decl,
-                               int &typeIndex, int &typeLength,
-                               int &nameIndex, int &nameLength,
-                               QQuickShaderEffectCommon::Key::ShaderType shaderType)
-    {
-        enum Identifier {
-            QualifierIdentifier, // Base state
-            PrecisionIdentifier,
-            TypeIdentifier,
-            NameIdentifier
-        };
-        Identifier expected = QualifierIdentifier;
-        bool compilerDirectiveExpected = index == 0;
-
-        while (index < length) {
-            // Skip whitespace.
-            while (qt_isspace(s[index])) {
-                compilerDirectiveExpected |= s[index] == '\n';
-                ++index;
-            }
-
-            if (qt_isalpha(s[index])) {
-                // Read identifier.
-                int idIndex = index;
-                ++index;
-                while (qt_isalnum(s[index]))
-                    ++index;
-                int idLength = index - idIndex;
-
-                const int attrLen = sizeof("attribute") - 1;
-                const int inLen = sizeof("in") - 1;
-                const int uniLen = sizeof("uniform") - 1;
-                const int loLen = sizeof("lowp") - 1;
-                const int medLen = sizeof("mediump") - 1;
-                const int hiLen = sizeof("highp") - 1;
-
-                switch (expected) {
-                case QualifierIdentifier:
-                    if (idLength == attrLen && qstrncmp("attribute", s + idIndex, attrLen) == 0) {
-                        decl = AttributeQualifier;
-                        expected = PrecisionIdentifier;
-                    } else if (shaderType == QQuickShaderEffectCommon::Key::VertexShader
-                               && idLength == inLen && qstrncmp("in", s + idIndex, inLen) == 0) {
-                        decl = AttributeQualifier;
-                        expected = PrecisionIdentifier;
-                    } else if (idLength == uniLen && qstrncmp("uniform", s + idIndex, uniLen) == 0) {
-                        decl = UniformQualifier;
-                        expected = PrecisionIdentifier;
-                    }
-                    break;
-                case PrecisionIdentifier:
-                    if ((idLength == loLen && qstrncmp("lowp", s + idIndex, loLen) == 0)
-                            || (idLength == medLen && qstrncmp("mediump", s + idIndex, medLen) == 0)
-                            || (idLength == hiLen && qstrncmp("highp", s + idIndex, hiLen) == 0))
-                    {
-                        expected = TypeIdentifier;
-                        break;
-                    }
-                    // Fall through.
-                case TypeIdentifier:
-                    typeIndex = idIndex;
-                    typeLength = idLength;
-                    expected = NameIdentifier;
-                    break;
-                case NameIdentifier:
-                    nameIndex = idIndex;
-                    nameLength = idLength;
-                    return index; // Attribute or uniform declaration found. Return result.
-                default:
-                    break;
-                }
-            } else if (s[index] == '#' && compilerDirectiveExpected) {
-                // Skip compiler directives.
-                ++index;
-                while (index < length && (s[index] != '\n' || s[index - 1] == '\\'))
-                    ++index;
-            } else if (s[index] == '/' && s[index + 1] == '/') {
-                // Skip comments.
-                index += 2;
-                while (index < length && s[index] != '\n')
-                    ++index;
-            } else if (s[index] == '/' && s[index + 1] == '*') {
-                // Skip comments.
-                index += 2;
-                while (index < length && (s[index] != '*' || s[index + 1] != '/'))
-                    ++index;
-                if (index < length)
-                    index += 2; // Skip star-slash.
-            } else {
-                expected = QualifierIdentifier;
-                ++index;
-            }
-            compilerDirectiveExpected = false;
-        }
-        return -1;
-    }
-}
-
-
-
-QQuickShaderEffectCommon::~QQuickShaderEffectCommon()
-{
-    for (int shaderType = 0; shaderType < Key::ShaderTypeCount; ++shaderType)
-        qDeleteAll(signalMappers[shaderType]);
-}
-
-void QQuickShaderEffectCommon::disconnectPropertySignals(QQuickItem *item, Key::ShaderType shaderType)
-{
-    for (int i = 0; i < uniformData[shaderType].size(); ++i) {
-        if (signalMappers[shaderType].at(i) == 0)
-            continue;
-        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)));
-        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*)));
-            }
-        }
-    }
-}
-
-void QQuickShaderEffectCommon::connectPropertySignals(QQuickItem *item, Key::ShaderType shaderType)
-{
-    for (int i = 0; i < uniformData[shaderType].size(); ++i) {
-        if (signalMappers[shaderType].at(i) == 0)
-            continue;
-        const UniformData &d = uniformData[shaderType].at(i);
-        int pi = item->metaObject()->indexOfProperty(d.name.constData());
-        if (pi >= 0) {
-            QMetaProperty mp = item->metaObject()->property(pi);
-            if (!mp.hasNotifySignal())
-                qWarning("QQuickShaderEffect: property '%s' does not have notification method!", d.name.constData());
-            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)));
-        } else {
-            // If the source is set via a dynamic property, like the layer is, then we need this
-            // check to disable the warning.
-            if (!item->property(d.name.constData()).isValid())
-                qWarning("QQuickShaderEffect: '%s' does not have a matching property!", d.name.constData());
-        }
-
-        if (d.specialType == UniformData::Sampler) {
-            QQuickItem *source = qobject_cast<QQuickItem *>(qvariant_cast<QObject *>(d.value));
-            if (source) {
-                if (item->window())
-                    QQuickItemPrivate::get(source)->refWindow(item->window());
-                QObject::connect(source, SIGNAL(destroyed(QObject*)), item, SLOT(sourceDestroyed(QObject*)));
-            }
-        }
-    }
-}
-
-void QQuickShaderEffectCommon::updateParseLog(bool ignoreAttributes)
-{
-    parseLog.clear();
-    if (!ignoreAttributes) {
-        if (!attributes.contains(qtPositionAttributeName())) {
-            parseLog += QLatin1String("Warning: Missing reference to \'");
-            parseLog += QLatin1String(qtPositionAttributeName());
-            parseLog += QLatin1String("\'.\n");
-        }
-        if (!attributes.contains(qtTexCoordAttributeName())) {
-            parseLog += QLatin1String("Warning: Missing reference to \'");
-            parseLog += QLatin1String(qtTexCoordAttributeName());
-            parseLog += QLatin1String("\'.\n");
-        }
-    }
-    bool respectsMatrix = false;
-    bool respectsOpacity = false;
-    for (int i = 0; i < uniformData[Key::VertexShader].size(); ++i)
-        respectsMatrix |= uniformData[Key::VertexShader].at(i).specialType == UniformData::Matrix;
-    for (int shaderType = 0; shaderType < Key::ShaderTypeCount; ++shaderType) {
-        for (int i = 0; i < uniformData[shaderType].size(); ++i)
-            respectsOpacity |= uniformData[shaderType].at(i).specialType == UniformData::Opacity;
-    }
-    if (!respectsMatrix)
-        parseLog += QLatin1String("Warning: Vertex shader is missing reference to \'qt_Matrix\'.\n");
-    if (!respectsOpacity)
-        parseLog += QLatin1String("Warning: Shaders are missing reference to \'qt_Opacity\'.\n");
-}
-
-void QQuickShaderEffectCommon::lookThroughShaderCode(QQuickItem *item, Key::ShaderType shaderType, const QByteArray &code)
-{
-    int index = 0;
-    int typeIndex = -1;
-    int typeLength = 0;
-    int nameIndex = -1;
-    int nameLength = 0;
-    const char *s = code.constData();
-    VariableQualifier decl = AttributeQualifier;
-    while ((index = qt_search_for_variable(s, code.size(), index, decl, typeIndex, typeLength,
-                                           nameIndex, nameLength, shaderType)) != -1)
-    {
-        if (decl == AttributeQualifier) {
-            if (shaderType == Key::VertexShader)
-                attributes.append(QByteArray(s + nameIndex, nameLength));
-        } else {
-            Q_ASSERT(decl == UniformQualifier);
-
-            const int sampLen = sizeof("sampler2D") - 1;
-            const int opLen = sizeof("qt_Opacity") - 1;
-            const int matLen = sizeof("qt_Matrix") - 1;
-            const int srLen = sizeof("qt_SubRect_") - 1;
-
-            UniformData d;
-            QSignalMapper *mapper = 0;
-            d.name = QByteArray(s + nameIndex, nameLength);
-            if (nameLength == opLen && qstrncmp("qt_Opacity", s + nameIndex, opLen) == 0) {
-                d.specialType = UniformData::Opacity;
-            } else if (nameLength == matLen && qstrncmp("qt_Matrix", s + nameIndex, matLen) == 0) {
-                d.specialType = UniformData::Matrix;
-            } else if (nameLength > srLen && qstrncmp("qt_SubRect_", s + nameIndex, srLen) == 0) {
-                d.specialType = UniformData::SubRect;
-            } else {
-                mapper = new QSignalMapper;
-                mapper->setMapping(item, uniformData[shaderType].size() | (shaderType << 16));
-                d.value = item->property(d.name.constData());
-                bool sampler = typeLength == sampLen && qstrncmp("sampler2D", s + typeIndex, sampLen) == 0;
-                d.specialType = sampler ? UniformData::Sampler : UniformData::None;
-            }
-            uniformData[shaderType].append(d);
-            signalMappers[shaderType].append(mapper);
-        }
-    }
-}
-
-void QQuickShaderEffectCommon::updateShader(QQuickItem *item, Key::ShaderType shaderType)
-{
-    disconnectPropertySignals(item, shaderType);
-    qDeleteAll(signalMappers[shaderType]);
-    uniformData[shaderType].clear();
-    signalMappers[shaderType].clear();
-    if (shaderType == Key::VertexShader)
-        attributes.clear();
-
-    const QByteArray &code = source.sourceCode[shaderType];
-    if (code.isEmpty()) {
-        // Optimize for default code.
-        if (shaderType == Key::VertexShader) {
-            attributes.append(QByteArray(qtPositionAttributeName()));
-            attributes.append(QByteArray(qtTexCoordAttributeName()));
-            UniformData d;
-            d.name = "qt_Matrix";
-            d.specialType = UniformData::Matrix;
-            uniformData[Key::VertexShader].append(d);
-            signalMappers[Key::VertexShader].append(0);
-        } else if (shaderType == Key::FragmentShader) {
-            UniformData d;
-            d.name = "qt_Opacity";
-            d.specialType = UniformData::Opacity;
-            uniformData[Key::FragmentShader].append(d);
-            signalMappers[Key::FragmentShader].append(0);
-            QSignalMapper *mapper = new QSignalMapper;
-            mapper->setMapping(item, 1 | (Key::FragmentShader << 16));
-            const char *sourceName = "source";
-            d.name = sourceName;
-            d.value = item->property(sourceName);
-            d.specialType = UniformData::Sampler;
-            uniformData[Key::FragmentShader].append(d);
-            signalMappers[Key::FragmentShader].append(mapper);
-        }
-    } else {
-        lookThroughShaderCode(item, shaderType, code);
-    }
-
-    connectPropertySignals(item, shaderType);
-}
-
-void QQuickShaderEffectCommon::updateMaterial(QQuickShaderEffectNode *node,
-                                              QQuickShaderEffectMaterial *material,
-                                              bool updateUniforms, bool updateUniformValues,
-                                              bool updateTextureProviders)
-{
-    if (updateUniforms) {
-        for (int i = 0; i < material->textureProviders.size(); ++i) {
-            QSGTextureProvider *t = material->textureProviders.at(i);
-            if (t) {
-                QObject::disconnect(t, SIGNAL(textureChanged()), node, SLOT(markDirtyTexture()));
-                QObject::disconnect(t, SIGNAL(destroyed(QObject*)), node, SLOT(textureProviderDestroyed(QObject*)));
-            }
-        }
-
-        // First make room in the textureProviders array. Set to proper value further down.
-        int textureProviderCount = 0;
-        for (int shaderType = 0; shaderType < Key::ShaderTypeCount; ++shaderType) {
-            for (int i = 0; i < uniformData[shaderType].size(); ++i) {
-                if (uniformData[shaderType].at(i).specialType == UniformData::Sampler)
-                    ++textureProviderCount;
-            }
-            material->uniforms[shaderType] = uniformData[shaderType];
-        }
-        material->textureProviders.fill(0, textureProviderCount);
-        updateUniformValues = false;
-        updateTextureProviders = true;
-    }
-
-    if (updateUniformValues) {
-        for (int shaderType = 0; shaderType < Key::ShaderTypeCount; ++shaderType) {
-            Q_ASSERT(uniformData[shaderType].size() == material->uniforms[shaderType].size());
-            for (int i = 0; i < uniformData[shaderType].size(); ++i)
-                material->uniforms[shaderType][i].value = uniformData[shaderType].at(i).value;
-        }
-    }
-
-    if (updateTextureProviders) {
-        int index = 0;
-        for (int shaderType = 0; shaderType < Key::ShaderTypeCount; ++shaderType) {
-            for (int i = 0; i < uniformData[shaderType].size(); ++i) {
-                const UniformData &d = uniformData[shaderType].at(i);
-                if (d.specialType != UniformData::Sampler)
-                    continue;
-                QSGTextureProvider *oldProvider = material->textureProviders.at(index);
-                QSGTextureProvider *newProvider = 0;
-                QQuickItem *source = qobject_cast<QQuickItem *>(qvariant_cast<QObject *>(d.value));
-                if (source && source->isTextureProvider())
-                    newProvider = source->textureProvider();
-                if (newProvider != oldProvider) {
-                    if (oldProvider) {
-                        QObject::disconnect(oldProvider, SIGNAL(textureChanged()), node, SLOT(markDirtyTexture()));
-                        QObject::disconnect(oldProvider, SIGNAL(destroyed(QObject*)), node, SLOT(textureProviderDestroyed(QObject*)));
-                    }
-                    if (newProvider) {
-                        Q_ASSERT_X(newProvider->thread() == QThread::currentThread(),
-                                   "QQuickShaderEffect::updatePaintNode",
-                                   "Texture provider must belong to the rendering thread");
-                        QObject::connect(newProvider, SIGNAL(textureChanged()), node, SLOT(markDirtyTexture()));
-                        QObject::connect(newProvider, SIGNAL(destroyed(QObject*)), node, SLOT(textureProviderDestroyed(QObject*)));
-                    } else {
-                        const char *typeName = source ? source->metaObject()->className() : d.value.typeName();
-                        qWarning("ShaderEffect: Property '%s' is not assigned a valid texture provider (%s).",
-                                 d.name.constData(), typeName);
-                    }
-                    material->textureProviders[index] = newProvider;
-                }
-                ++index;
-            }
-        }
-        Q_ASSERT(index == material->textureProviders.size());
-    }
-}
-
-void QQuickShaderEffectCommon::updateWindow(QQuickWindow *window)
-{
-    // See comment in QQuickShaderEffectCommon::propertyChanged().
-    if (window) {
-        for (int shaderType = 0; shaderType < Key::ShaderTypeCount; ++shaderType) {
-            for (int i = 0; i < uniformData[shaderType].size(); ++i) {
-                const UniformData &d = uniformData[shaderType].at(i);
-                if (d.specialType == UniformData::Sampler) {
-                    QQuickItem *source = qobject_cast<QQuickItem *>(qvariant_cast<QObject *>(d.value));
-                    if (source)
-                        QQuickItemPrivate::get(source)->refWindow(window);
-                }
-            }
-        }
-    } else {
-        for (int shaderType = 0; shaderType < Key::ShaderTypeCount; ++shaderType) {
-            for (int i = 0; i < uniformData[shaderType].size(); ++i) {
-                const UniformData &d = uniformData[shaderType].at(i);
-                if (d.specialType == UniformData::Sampler) {
-                    QQuickItem *source = qobject_cast<QQuickItem *>(qvariant_cast<QObject *>(d.value));
-                    if (source)
-                        QQuickItemPrivate::get(source)->derefWindow();
-                }
-            }
-        }
-    }
-}
-
-void QQuickShaderEffectCommon::sourceDestroyed(QObject *object)
-{
-    for (int shaderType = 0; shaderType < Key::ShaderTypeCount; ++shaderType) {
-        for (int i = 0; i < uniformData[shaderType].size(); ++i) {
-            UniformData &d = uniformData[shaderType][i];
-            if (d.specialType == UniformData::Sampler && d.value.canConvert<QObject *>()) {
-                if (qvariant_cast<QObject *>(d.value) == object)
-                    d.value = QVariant();
-            }
-        }
-    }
-}
-
-static bool qquick_uniqueInUniformData(QQuickItem *source, const QVector<QQuickShaderEffectMaterial::UniformData> *uniformData, int typeToSkip, int indexToSkip)
-{
-    for (int s=0; s<QQuickShaderEffectMaterialKey::ShaderTypeCount; ++s) {
-        for (int i=0; i<uniformData[s].size(); ++i) {
-            if (s == typeToSkip && i == indexToSkip)
-                continue;
-            const QQuickShaderEffectMaterial::UniformData &d = uniformData[s][i];
-            if (d.specialType == QQuickShaderEffectMaterial::UniformData::Sampler && qvariant_cast<QObject *>(d.value) == source)
-                return false;
-        }
-    }
-    return true;
-}
-
-void QQuickShaderEffectCommon::propertyChanged(QQuickItem *item, int mappedId,
-                                               bool *textureProviderChanged)
-{
-    Key::ShaderType shaderType = Key::ShaderType(mappedId >> 16);
-    int index = mappedId & 0xffff;
-    UniformData &d = uniformData[shaderType][index];
-    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() will disconnect all matching connections. If the same
-            // source has been attached to two separate samplers, then changing one of them
-            // 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*)));
-        }
-
-        d.value = item->property(d.name.constData());
-
-        source = qobject_cast<QQuickItem *>(qvariant_cast<QObject *>(d.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 (item->window())
-                QQuickItemPrivate::get(source)->refWindow(item->window());
-            QObject::connect(source, SIGNAL(destroyed(QObject*)), item, SLOT(sourceDestroyed(QObject*)));
-        }
-        if (textureProviderChanged)
-            *textureProviderChanged = true;
-    } else {
-        d.value = item->property(d.name.constData());
-        if (textureProviderChanged)
-            *textureProviderChanged = false;
-    }
-}
-
-
 /*!
     \qmltype ShaderEffect
     \instantiates QQuickShaderEffect
@@ -675,30 +191,10 @@ void QQuickShaderEffectCommon::propertyChanged(QQuickItem *item, int mappedId,
 
 QQuickShaderEffect::QQuickShaderEffect(QQuickItem *parent)
     : QQuickItem(parent)
-    , m_meshResolution(1, 1)
-    , m_mesh(0)
-    , m_cullMode(NoCulling)
-    , m_status(Uncompiled)
-    , m_blending(true)
-    , m_dirtyUniforms(true)
-    , m_dirtyUniformValues(true)
-    , m_dirtyTextureProviders(true)
-    , m_dirtyProgram(true)
-    , m_dirtyParseLog(true)
-    , m_dirtyMesh(true)
-    , m_dirtyGeometry(true)
-    , m_customVertexShader(false)
-    , m_supportsAtlasTextures(false)
 {
     setFlag(QQuickItem::ItemHasContents);
 }
 
-QQuickShaderEffect::~QQuickShaderEffect()
-{
-    for (int shaderType = 0; shaderType < Key::ShaderTypeCount; ++shaderType)
-        m_common.disconnectPropertySignals(this, Key::ShaderType(shaderType));
-}
-
 /*!
     \qmlproperty string QtQuick::ShaderEffect::fragmentShader
 
@@ -708,23 +204,14 @@ QQuickShaderEffect::~QQuickShaderEffect()
     sampler2D named "source".
 */
 
-void QQuickShaderEffect::setFragmentShader(const QByteArray &code)
+QByteArray QQuickShaderEffect::fragmentShader() const
 {
-    if (m_common.source.sourceCode[Key::FragmentShader].constData() == code.constData())
-        return;
-    m_common.source.sourceCode[Key::FragmentShader] = code;
-    m_dirtyProgram = true;
-    m_dirtyParseLog = true;
-
-    if (isComponentComplete())
-        m_common.updateShader(this, Key::FragmentShader);
+    return QByteArray();
+}
 
-    update();
-    if (m_status != Uncompiled) {
-        m_status = Uncompiled;
-        emit statusChanged();
-    }
-    emit fragmentShaderChanged();
+void QQuickShaderEffect::setFragmentShader(const QByteArray &code)
+{
+    Q_UNUSED(code);
 }
 
 /*!
@@ -735,24 +222,14 @@ void QQuickShaderEffect::setFragmentShader(const QByteArray &code)
     shader as "varying highp vec2 qt_TexCoord0".
 */
 
-void QQuickShaderEffect::setVertexShader(const QByteArray &code)
+QByteArray QQuickShaderEffect::vertexShader() const
 {
-    if (m_common.source.sourceCode[Key::VertexShader].constData() == code.constData())
-        return;
-    m_common.source.sourceCode[Key::VertexShader] = code;
-    m_dirtyProgram = true;
-    m_dirtyParseLog = true;
-    m_customVertexShader = true;
-
-    if (isComponentComplete())
-        m_common.updateShader(this, Key::VertexShader);
+    return QByteArray();
+}
 
-    update();
-    if (m_status != Uncompiled) {
-        m_status = Uncompiled;
-        emit statusChanged();
-    }
-    emit vertexShaderChanged();
+void QQuickShaderEffect::setVertexShader(const QByteArray &code)
+{
+    Q_UNUSED(code);
 }
 
 /*!
@@ -764,15 +241,14 @@ void QQuickShaderEffect::setVertexShader(const QByteArray &code)
     property to false when blending is not needed. The default value is true.
 */
 
-void QQuickShaderEffect::setBlending(bool enable)
+bool QQuickShaderEffect::blending() const
 {
-    if (blending() == enable)
-        return;
-
-    m_blending = enable;
-    update();
+    return true;
+}
 
-    emit blendingChanged();
+void QQuickShaderEffect::setBlending(bool enable)
+{
+    Q_UNUSED(enable);
 }
 
 /*!
@@ -790,44 +266,12 @@ void QQuickShaderEffect::setBlending(bool enable)
 
 QVariant QQuickShaderEffect::mesh() const
 {
-    return m_mesh ? qVariantFromValue(static_cast<QObject *>(m_mesh))
-                  : qVariantFromValue(m_meshResolution);
+    return QVariant();
 }
 
 void QQuickShaderEffect::setMesh(const QVariant &mesh)
 {
-    QQuickShaderEffectMesh *newMesh = qobject_cast<QQuickShaderEffectMesh *>(qvariant_cast<QObject *>(mesh));
-    if (newMesh && newMesh == m_mesh)
-        return;
-    if (m_mesh)
-        disconnect(m_mesh, SIGNAL(geometryChanged()), this, 0);
-    m_mesh = newMesh;
-    if (m_mesh) {
-        connect(m_mesh, SIGNAL(geometryChanged()), this, SLOT(updateGeometry()));
-    } 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 size or object deriving from QQuickShaderEffectMesh.");
-        }
-        m_defaultMesh.setResolution(m_meshResolution);
-    }
-
-    m_dirtyMesh = true;
-    m_dirtyParseLog = true;
-    update();
-    emit meshChanged();
+    Q_UNUSED(mesh);
 }
 
 /*!
@@ -844,13 +288,14 @@ void QQuickShaderEffect::setMesh(const QVariant &mesh)
     The default is NoCulling.
 */
 
+QQuickShaderEffect::CullMode QQuickShaderEffect::cullMode() const
+{
+    return NoCulling;
+}
+
 void QQuickShaderEffect::setCullMode(CullMode face)
 {
-    if (face == m_cullMode)
-        return;
-    m_cullMode = face;
-    update();
-    emit cullModeChanged();
+    Q_UNUSED(face);
 }
 
 /*!
@@ -874,41 +319,14 @@ void QQuickShaderEffect::setCullMode(CullMode face)
     \since QtQuick 2.4
 */
 
-void QQuickShaderEffect::setSupportsAtlasTextures(bool supports)
-{
-    if (supports == m_supportsAtlasTextures)
-        return;
-    m_supportsAtlasTextures = supports;
-    updateGeometry();
-    emit supportsAtlasTexturesChanged();
-}
-
-QString QQuickShaderEffect::parseLog()
+bool QQuickShaderEffect::supportsAtlasTextures() const
 {
-    if (m_dirtyParseLog) {
-        m_common.updateParseLog(m_mesh != 0);
-        m_dirtyParseLog = false;
-    }
-    return m_common.parseLog;
+    return false;
 }
 
-bool QQuickShaderEffect::event(QEvent *event)
+void QQuickShaderEffect::setSupportsAtlasTextures(bool supports)
 {
-    if (event->type() == QEvent::DynamicPropertyChange) {
-        QDynamicPropertyChangeEvent *e = static_cast<QDynamicPropertyChangeEvent *>(event);
-        for (int shaderType = 0; shaderType < Key::ShaderTypeCount; ++shaderType) {
-            for (int i = 0; i < m_common.uniformData[shaderType].size(); ++i) {
-                if (m_common.uniformData[shaderType].at(i).name == e->propertyName()) {
-                    bool textureProviderChanged;
-                    m_common.propertyChanged(this, (shaderType << 16) | i, &textureProviderChanged);
-                    m_dirtyTextureProviders |= textureProviderChanged;
-                    m_dirtyUniformValues = true;
-                    update();
-                }
-            }
-        }
-    }
-    return QQuickItem::event(event);
+    Q_UNUSED(supports);
 }
 
 /*!
@@ -939,179 +357,14 @@ bool QQuickShaderEffect::event(QEvent *event)
     \sa status
 */
 
-void QQuickShaderEffect::updateGeometry()
-{
-    m_dirtyGeometry = true;
-    update();
-}
-
-void QQuickShaderEffect::updateGeometryIfAtlased()
-{
-    if (m_supportsAtlasTextures)
-        updateGeometry();
-}
-
-void QQuickShaderEffect::updateLogAndStatus(const QString &log, int status)
-{
-    m_log = parseLog() + log;
-    m_status = Status(status);
-    emit logChanged();
-    emit statusChanged();
-}
-
-void QQuickShaderEffect::sourceDestroyed(QObject *object)
-{
-    m_common.sourceDestroyed(object);
-}
-
-
-void QQuickShaderEffect::propertyChanged(int mappedId)
-{
-    bool textureProviderChanged;
-    m_common.propertyChanged(this, mappedId, &textureProviderChanged);
-    m_dirtyTextureProviders |= textureProviderChanged;
-    m_dirtyUniformValues = true;
-    update();
-}
-
-void QQuickShaderEffect::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry)
-{
-    m_dirtyGeometry = true;
-    QQuickItem::geometryChanged(newGeometry, oldGeometry);
-}
-
-QSGNode *QQuickShaderEffect::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *)
-{
-    QQuickShaderEffectNode *node = static_cast<QQuickShaderEffectNode *>(oldNode);
-
-    // In the case of zero-size or a bad vertex shader, don't try to create a node...
-    if (m_common.attributes.isEmpty() || width() <= 0 || height() <= 0) {
-        if (node)
-            delete node;
-        return 0;
-    }
-
-    if (!node) {
-        node = new QQuickShaderEffectNode;
-        node->setMaterial(new QQuickShaderEffectMaterial(node));
-        node->setFlag(QSGNode::OwnsMaterial, true);
-        m_dirtyProgram = true;
-        m_dirtyUniforms = true;
-        m_dirtyGeometry = true;
-        connect(node, SIGNAL(logAndStatusChanged(QString,int)), this, SLOT(updateLogAndStatus(QString,int)));
-        connect(node, &QQuickShaderEffectNode::dirtyTexture,
-                this, &QQuickShaderEffect::updateGeometryIfAtlased);
-    }
-
-    QQuickShaderEffectMaterial *material = static_cast<QQuickShaderEffectMaterial *>(node->material());
-
-    // Update blending
-    if (bool(material->flags() & QSGMaterial::Blending) != m_blending) {
-        material->setFlag(QSGMaterial::Blending, m_blending);
-        node->markDirty(QSGNode::DirtyMaterial);
-    }
-
-    if (int(material->cullMode) != int(m_cullMode)) {
-        material->cullMode = QQuickShaderEffectMaterial::CullMode(m_cullMode);
-        node->markDirty(QSGNode::DirtyMaterial);
-    }
-
-    if (m_dirtyProgram) {
-        Key s = m_common.source;
-        QSGShaderSourceBuilder builder;
-        if (s.sourceCode[Key::FragmentShader].isEmpty()) {
-            builder.appendSourceFile(QStringLiteral(":/qt-project.org/items/shaders/shadereffect.frag"));
-            s.sourceCode[Key::FragmentShader] = builder.source();
-            builder.clear();
-        }
-        if (s.sourceCode[Key::VertexShader].isEmpty()) {
-            builder.appendSourceFile(QStringLiteral(":/qt-project.org/items/shaders/shadereffect.vert"));
-            s.sourceCode[Key::VertexShader] = builder.source();
-        }
-        s.className = metaObject()->className();
-
-        material->setProgramSource(s);
-        material->attributes = m_common.attributes;
-        node->markDirty(QSGNode::DirtyMaterial);
-        m_dirtyProgram = false;
-        m_dirtyUniforms = true;
-    }
-
-    if (m_dirtyUniforms || m_dirtyUniformValues || m_dirtyTextureProviders) {
-        m_common.updateMaterial(node, material, m_dirtyUniforms, m_dirtyUniformValues,
-                                m_dirtyTextureProviders);
-        node->markDirty(QSGNode::DirtyMaterial);
-        m_dirtyUniforms = m_dirtyUniformValues = m_dirtyTextureProviders = false;
-    }
-
-    QRectF srcRect(0, 0, 1, 1);
-    bool geometryUsesTextureSubRect = false;
-    if (m_supportsAtlasTextures && material->textureProviders.size() == 1) {
-        QSGTextureProvider *provider = material->textureProviders.at(0);
-        if (provider->texture()) {
-            srcRect = provider->texture()->normalizedTextureSubRect();
-            geometryUsesTextureSubRect = true;
-        }
-    }
-
-    if (bool(material->flags() & QSGMaterial::RequiresFullMatrix) != m_customVertexShader) {
-        material->setFlag(QSGMaterial::RequiresFullMatrix, m_customVertexShader);
-        node->markDirty(QSGNode::DirtyMaterial);
-    }
-
-    if (material->geometryUsesTextureSubRect != geometryUsesTextureSubRect) {
-        material->geometryUsesTextureSubRect = geometryUsesTextureSubRect;
-        node->markDirty(QSGNode::DirtyMaterial);
-    }
-
-    if (m_dirtyMesh) {
-        node->setGeometry(0);
-        m_dirtyMesh = false;
-        m_dirtyGeometry = true;
-    }
-
-    if (m_dirtyGeometry) {
-        node->setFlag(QSGNode::OwnsGeometry, false);
-        QSGGeometry *geometry = node->geometry();
-        QRectF rect(0, 0, width(), height());
-        QQuickShaderEffectMesh *mesh = m_mesh ? m_mesh : &m_defaultMesh;
-
-        geometry = mesh->updateGeometry(geometry, m_common.attributes, srcRect, rect);
-        if (!geometry) {
-            QString log = mesh->log();
-            if (!log.isNull()) {
-                m_log = parseLog();
-                m_log += QLatin1String("*** Mesh ***\n");
-                m_log += log;
-                m_status = Error;
-                emit logChanged();
-                emit statusChanged();
-            }
-            delete node;
-            return 0;
-        }
-
-        node->setGeometry(geometry);
-        node->setFlag(QSGNode::OwnsGeometry, true);
-
-        m_dirtyGeometry = false;
-    }
-
-    return node;
-}
-
-void QQuickShaderEffect::componentComplete()
+QString QQuickShaderEffect::log() const
 {
-    m_common.updateShader(this, Key::VertexShader);
-    m_common.updateShader(this, Key::FragmentShader);
-    QQuickItem::componentComplete();
+    return QString();
 }
 
-void QQuickShaderEffect::itemChange(ItemChange change, const ItemChangeData &value)
+QQuickShaderEffect::Status QQuickShaderEffect::status() const
 {
-    if (change == QQuickItem::ItemSceneChange)
-        m_common.updateWindow(value.window);
-    QQuickItem::itemChange(change, value);
+    return Uncompiled;
 }
 
 QT_END_NAMESPACE