Merge lp:~loic.molinari/qtmir/qtmir-custom-mirsurfacenode into lp:qtmir

[Loïc Molinari]

Switched to a custom mir surface node.

MirSurfaceNode is a Qt scene graph node that renders a texture with a given filtering. It can be compared to the image node provided by QtQuick (although simpler) with the addition of a more efficient antialiasing technique that keeps the same quality.

QtQuick provides 2 different antialiasing techniques. The first one is called multisampling and is proposed by the underlying hardware. It can be enabled at window creation time by defining a number of samples on the QSurfaceFormat associated to the created QtQuick scene (window). The efficiency of that technique is highly dependent on the hardware and often not adapted. The second technique is called vertex antialiasing, when the antialiasing property is set to true on a QtQuick item, QtQuick switches to that technique which adds 4 new vertices with additional attributes and lets the vertex shader accurately set their position and opacity fall-off. The drawback of this technique is that it forces the whole node to be rendered in the translucent pass of the renderer even though the whole content of the node is opaque, another drawback is that it oten prevents batching.

The antialiasing technique provided by this node prevents both issues by creating 2 geometry nodes, a FillNode that is made to fill the content and an EdgeNode that is made to render the antialiased edge. The edge node uses exactly the same vertex-based algorithm than the default QtQuick nodes.

This technique is perfectly adapted to the rendering of the Spread, where there is quite a lot of overdraw, by bringing back the ability for GPUs to use early-Z cull optimisations.

This is a first step and the performance boost implied by that change can't be noticed directly since the surface nodes are currently always backing ARGB surfaces. This QtMir branch (lp:~unity-team/qtubuntu/requested-surface-format-fix) will fix that.

Switched to a custom mir surface node.

MirSurfaceNode is a Qt scene graph node that renders a texture with a given filtering. It can be compared to the image node provided by QtQuick (although simpler) with the addition of a more efficient antialiasing technique that keeps the same quality.

QtQuick provides 2 different antialiasing techniques. The first one is called multisampling and is proposed by the underlying hardware. It can be enabled at window creation time by defining a number of samples on the QSurfaceFormat associated to the created QtQuick scene (window). The efficiency of that technique is highly dependent on the hardware and often not adapted. The second technique is called vertex antialiasing, when the antialiasing property is set to true on a QtQuick item, QtQuick switches to that technique which adds 4 new vertices with additional attributes and lets the vertex shader accurately set their position and opacity fall-off. The drawback of this technique is that it forces the whole node to be rendered in the translucent pass of the renderer even though the whole content of the node is opaque, another drawback is that it oten prevents batching.

The antialiasing technique provided by this node prevents both issues by creating 2 geometry nodes, a FillNode that is made to fill the content and an EdgeNode that is made to render the antialiased edge. The edge node uses exactly the same vertex-based algorithm than the default QtQuick nodes.

This technique is perfectly adapted to the rendering of the Spread, where there is quite a lot of overdraw, by bringing back the ability for GPUs to use early-Z cull optimisations.

This is a first step and the performance boost implied by that change can't be noticed directly since the surface nodes are currently always backing ARGB surfaces. This QtMir branch (lp:~unity-team/qtubuntu/requested-surface-format-fix) will fix that.

[lp:~loic.molinari/qtmir/qtmir-custom-mirsurfacenode]

386. By Loïc Molinari on 2015-10-19

Converted comment to 80 chars line wrap as expected by Qt coding guidelines.

Unmerged revisions

386. By Loïc Molinari on 2015-10-19

Converted comment to 80 chars line wrap as expected by Qt coding guidelines.

385. By Loïc Molinari on 2015-10-19

Switched to a custom MirSurfaceNode.

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-09-17 20:17:17 +0000
+++ CMakeLists.txt	2015-10-19 10:47:33 +0000
@@ -16,8 +16,9 @@
 # add custom cmake modules
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules)
 
-# Instruct CMake to run moc automatically when needed.
+# Instruct CMake to run moc and rcc automatically when needed.
 set(CMAKE_AUTOMOC ON)
+set(CMAKE_AUTORCC ON)
 
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99 -Wall -Wextra -Werror")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Wall -fno-strict-aliasing -Werror -Wextra")

=== modified file 'src/modules/Unity/Application/CMakeLists.txt'
--- src/modules/Unity/Application/CMakeLists.txt	2015-09-17 16:17:17 +0000
+++ src/modules/Unity/Application/CMakeLists.txt	2015-10-19 10:47:33 +0000
@@ -36,6 +36,7 @@
     ubuntukeyboardinfo.cpp
     mirsurface.cpp
     mirsurfaceinterface.h
+    mirsurfacenode.cpp
     mirsurfaceitem.cpp
     mirbuffersgtexture.cpp
     proc_info.cpp
@@ -59,6 +60,7 @@
 
 add_library(unityapplicationplugin SHARED
     ${QMLMIRPLUGIN_SRC}
+    resources.qrc
 )
 
 target_link_libraries(

=== modified file 'src/modules/Unity/Application/mirsurfaceitem.cpp'
--- src/modules/Unity/Application/mirsurfaceitem.cpp	2015-09-28 14:24:48 +0000
+++ src/modules/Unity/Application/mirsurfaceitem.cpp	2015-10-19 10:47:33 +0000
@@ -17,6 +17,7 @@
 // local
 #include "application.h"
 #include "session.h"
+#include "mirsurfacenode.h"
 #include "mirsurfaceitem.h"
 #include "logging.h"
 #include "ubuntukeyboardinfo.h"
@@ -31,7 +32,6 @@
 #include <QQmlEngine>
 #include <QQuickWindow>
 #include <QScreen>
-#include <private/qsgdefaultimagenode_p.h>
 #include <QTimer>
 #include <QSGTextureProvider>
 
@@ -89,6 +89,7 @@
     , m_surfaceHeight(0)
     , m_orientationAngle(nullptr)
     , m_consumesInput(false)
+    , m_flags(0)
 {
     qCDebug(QTMIR_SURFACES) << "MirSurfaceItem::MirSurfaceItem";
 
@@ -104,6 +105,7 @@
     connect(&m_updateMirSurfaceSizeTimer, &QTimer::timeout, this, &MirSurfaceItem::updateMirSurfaceSize);
 
     connect(this, &QQuickItem::activeFocusChanged, this, &MirSurfaceItem::updateMirSurfaceFocus);
+    connect(this, &QQuickItem::smoothChanged, this, &MirSurfaceItem::onSmoothChanged);
 }
 
 MirSurfaceItem::~MirSurfaceItem()
@@ -173,6 +175,15 @@
     return m_surface && m_surface->live();
 }
 
+void MirSurfaceItem::itemChange(ItemChange change, const ItemChangeData &data)
+{
+    if (change == ItemAntialiasingHasChanged) {
+        m_flags |= DirtyAntialiasing;
+        update();
+    }
+    QQuickItem::itemChange(change, data);
+}
+
 // Called from the rendering (scene graph) thread
 QSGTextureProvider *MirSurfaceItem::textureProvider() const
 {
@@ -229,34 +240,40 @@
 
     m_textureProvider->smooth = smooth();
 
-    QSGDefaultImageNode *node = static_cast<QSGDefaultImageNode*>(oldNode);
-    if (!node) {
-        node = new QSGDefaultImageNode;
-        node->setTexture(m_textureProvider->texture());
-
-        node->setMipmapFiltering(QSGTexture::None);
-        node->setHorizontalWrapMode(QSGTexture::ClampToEdge);
-        node->setVerticalWrapMode(QSGTexture::ClampToEdge);
-        node->setSubSourceRect(QRectF(0, 0, 1, 1));
+    MirSurfaceNode *node;
+    if (oldNode) {
+        node = static_cast<MirSurfaceNode*>(oldNode);
+        if (m_flags & DirtyFiltering) {
+            node->setFiltering(smooth() ? QSGTexture::Linear : QSGTexture::Nearest);
+        }
+        if (m_flags & DirtyAntialiasing) {
+            node->setAntialiasing(antialiasing());
+        }
+        // FIXME(loicm) This code was here before the switch to a dedicated node
+        // and it is maintained as it is to prevent potential issues, but I'm
+        // not sure if it really makes sense to explicitly mark the material as
+        // dirty since the texture id stays the same and the node will be
+        // rendered after this update pass anyway. Commenting it out seems not
+        // to change anything, so that would need to be investigated IMO.
+        if (!m_lastFrameNumberRendered
+            || (*m_lastFrameNumberRendered != m_surface->currentFrameNumber())) {
+            node->updateMaterial();
+        }
     } else {
-        if (!m_lastFrameNumberRendered  || (*m_lastFrameNumberRendered != m_surface->currentFrameNumber())) {
-            node->markDirty(QSGNode::DirtyMaterial);
-        }
+        node = new MirSurfaceNode(
+            m_textureProvider->texture(),
+            smooth() ? QSGTexture::Linear : QSGTexture::Nearest, antialiasing());
     }
 
-    node->setTargetRect(QRectF(0, 0, width(), height()));
-    node->setInnerTargetRect(QRectF(0, 0, width(), height()));
-
-    node->setFiltering(smooth() ? QSGTexture::Linear : QSGTexture::Nearest);
-    node->setAntialiasing(antialiasing());
-
-    node->update();
+    node->updateGeometry(width(), height());
 
     if (!m_lastFrameNumberRendered) {
         m_lastFrameNumberRendered = new unsigned int;
     }
     *m_lastFrameNumberRendered = m_surface->currentFrameNumber();
 
+    m_flags = 0;
+
     return node;
 }
 
@@ -676,6 +693,13 @@
     setImplicitSize(size.width(), size.height());
 }
 
+void MirSurfaceItem::onSmoothChanged(bool smooth)
+{
+    Q_UNUSED(smooth);
+    m_flags |= DirtyFiltering;
+    update();
+}
+
 int MirSurfaceItem::surfaceHeight() const
 {
     return m_surfaceHeight;

=== modified file 'src/modules/Unity/Application/mirsurfaceitem.h'
--- src/modules/Unity/Application/mirsurfaceitem.h	2015-09-18 20:11:50 +0000
+++ src/modules/Unity/Application/mirsurfaceitem.h	2015-10-19 10:47:33 +0000
@@ -103,6 +103,8 @@
 
     void touchEvent(QTouchEvent *event) override;
 
+    void itemChange(ItemChange change, const ItemChangeData &data);
+
     QSGNode *updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *);
 
     void releaseResources() override;
@@ -115,7 +117,14 @@
 
     void onActualSurfaceSizeChanged(const QSize &size);
 
+    void onSmoothChanged(bool smooth);
+
 private:
+    enum {
+        DirtyFiltering    = (1 << 0),
+        DirtyAntialiasing = (1 << 1)
+    };
+
     void ensureTextureProvider();
 
     bool hasTouchInsideUbuntuKeyboard(const QList<QTouchEvent::TouchPoint> &touchPoints);
@@ -163,6 +172,8 @@
     Mir::OrientationAngle *m_orientationAngle;
 
     bool m_consumesInput;
+
+    quint8 m_flags;
 };
 
 } // namespace qtmir

=== added file 'src/modules/Unity/Application/mirsurfacenode.cpp'
--- src/modules/Unity/Application/mirsurfacenode.cpp	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/mirsurfacenode.cpp	2015-10-19 10:47:33 +0000
@@ -0,0 +1,736 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "mirsurfacenode.h"
+#include <QtQuick/QSGMaterial>
+
+// --- Vertex layouts ---
+
+struct Vertex {
+    float position[2];
+    float textureCoordinate[2];
+};
+
+struct OffsetVertex {
+    float position[2];
+    float textureCoordinate[2];
+    float positionOffset[2];
+    float textureCoordinateOffset[2];
+};
+
+// --- Shader classes ---
+
+class OpaqueFillShader : public QSGMaterialShader
+{
+public:
+    OpaqueFillShader();
+    virtual char const *const *attributeNames() const;
+    virtual void initialize();
+    virtual void updateState(
+        const RenderState &state, QSGMaterial *newEffect, QSGMaterial *oldEffect);
+
+private:
+    int m_matrixId;
+};
+
+class FillShader : public OpaqueFillShader
+{
+public:
+    FillShader();
+    virtual void initialize();
+    virtual void updateState(
+        const RenderState &state, QSGMaterial *newEffect, QSGMaterial *oldEffect);
+
+private:
+    int m_opacityId;
+};
+
+class OffsetOpaqueFillShader : public OpaqueFillShader
+{
+public:
+    OffsetOpaqueFillShader();
+    virtual char const *const *attributeNames() const;
+    virtual void initialize();
+    virtual void updateState(
+        const RenderState &state, QSGMaterial *newEffect, QSGMaterial *oldEffect);
+
+private:
+    int m_pixelSizeId;
+};
+
+class OffsetFillShader : public FillShader
+{
+public:
+    OffsetFillShader();
+    virtual char const *const *attributeNames() const;
+    virtual void initialize();
+    virtual void updateState(
+        const RenderState &state, QSGMaterial *newEffect, QSGMaterial *oldEffect);
+
+private:
+    int m_pixelSizeId;
+};
+
+class EdgeShader : public OffsetFillShader
+{
+public:
+    EdgeShader();
+};
+
+// --- Material classes ---
+
+class OpaqueFillMaterial : public QSGMaterial
+{
+public:
+    OpaqueFillMaterial(QSGTexture *texture, QSGTexture::Filtering filtering);
+    virtual QSGMaterialType *type() const;
+    virtual QSGMaterialShader *createShader() const;
+    virtual int compare(const QSGMaterial *other) const;
+
+    QSGTexture *texture() const { return m_texture; }
+    QSGTexture::Filtering filtering() const { return m_filtering; }
+    void setFiltering(QSGTexture::Filtering filtering) { m_filtering = filtering; }
+
+private:
+    QSGTexture *m_texture;
+    QSGTexture::Filtering m_filtering;
+};
+
+class FillMaterial : public OpaqueFillMaterial
+{
+public:
+    FillMaterial(QSGTexture *texture, QSGTexture::Filtering filtering);
+    virtual QSGMaterialType *type() const;
+    virtual QSGMaterialShader *createShader() const;
+};
+
+class OffsetOpaqueFillMaterial : public OpaqueFillMaterial
+{
+public:
+    OffsetOpaqueFillMaterial(QSGTexture *texture, QSGTexture::Filtering filtering);
+    virtual QSGMaterialType *type() const;
+    virtual QSGMaterialShader *createShader() const;
+};
+
+class OffsetFillMaterial : public FillMaterial
+{
+public:
+    OffsetFillMaterial(QSGTexture *texture, QSGTexture::Filtering filtering);
+    virtual QSGMaterialType *type() const;
+    virtual QSGMaterialShader *createShader() const;
+};
+
+class EdgeMaterial : public OpaqueFillMaterial
+{
+public:
+    EdgeMaterial(QSGTexture *texture, QSGTexture::Filtering filtering);
+    virtual QSGMaterialType *type() const;
+    virtual QSGMaterialShader *createShader() const;
+};
+
+// --- Node classes ---
+
+class FillNode : public QSGGeometryNode
+{
+public:
+    FillNode(QSGTexture *texture, QSGTexture::Filtering filtering, bool offset);
+
+    void setOffset(bool offset);
+    void setFiltering(QSGTexture::Filtering filtering);
+    void updateGeometry(float width, float height);
+
+private:
+    static const unsigned short *indices();
+    static const QSGGeometry::AttributeSet &attributeSet();
+    static const QSGGeometry::AttributeSet &offsetAttributeSet();
+
+    enum { Offset = (1 << 0) };
+
+    OpaqueFillMaterial m_opaqueMaterial;
+    FillMaterial m_material;
+    OffsetOpaqueFillMaterial m_offsetOpaqueMaterial;
+    OffsetFillMaterial m_offsetMaterial;
+    QSGGeometry m_geometry;
+    QSGGeometry m_offsetGeometry;
+    quint8 m_flags;
+};
+
+class EdgeNode : public QSGGeometryNode
+{
+public:
+    EdgeNode(QSGTexture *texture, QSGTexture::Filtering filtering, bool visible);
+    virtual bool isSubtreeBlocked() const { return !!(m_flags & Visible); }
+
+    void setVisible(bool visible);
+    void setFiltering(QSGTexture::Filtering filtering);
+    void updateGeometry(float width, float height);
+
+private:
+    static const unsigned short *indices();
+    static const QSGGeometry::AttributeSet &attributeSet();
+
+    enum { Visible = (1 << 0) };
+
+    EdgeMaterial m_material;
+    QSGGeometry m_geometry;
+    quint8 m_flags;
+};
+
+// --- Opaque fill shader ---
+
+OpaqueFillShader::OpaqueFillShader()
+{
+    setShaderSourceFile(QOpenGLShader::Vertex, QStringLiteral(":/shaders/fill.vert"));
+    setShaderSourceFile(QOpenGLShader::Fragment, QStringLiteral(":/shaders/opaquefill.frag"));
+}
+
+char const *const *OpaqueFillShader::attributeNames() const
+{
+    static char const *const attributes[] = {
+        "positionAttrib", "textureCoordAttrib", 0
+    };
+    return attributes;
+}
+
+void OpaqueFillShader::initialize()
+{
+    QSGMaterialShader::initialize();
+    program()->bind();
+    program()->setUniformValue("texture", 0);
+    m_matrixId = program()->uniformLocation("matrix");
+}
+
+void OpaqueFillShader::updateState(
+    const RenderState &state, QSGMaterial *newEffect, QSGMaterial *oldEffect)
+{
+    Q_UNUSED(oldEffect);
+
+    // Bind and update texturing states. Note that (as mentioned in the scene
+    // graph doc and as it is also expected in the standard texture materials)
+    // getting a NULL texture pointer here is the result of a buggy node
+    // implementation.
+    OpaqueFillMaterial *material = static_cast<OpaqueFillMaterial*>(newEffect);
+    QSGTexture *texture = material->texture();
+    Q_ASSERT_X(texture, "updateState", "NULL texture pointer, node must be fixed");
+    texture->setFiltering(material->filtering());
+    texture->bind();
+
+    if (state.isMatrixDirty()) {
+        program()->setUniformValue(m_matrixId, state.combinedMatrix());
+    }
+}
+
+// --- Fill shader ---
+
+FillShader::FillShader()
+    : OpaqueFillShader()
+{
+    setShaderSourceFile(QOpenGLShader::Fragment, QStringLiteral(":/shaders/fill.frag"));
+}
+
+void FillShader::initialize()
+{
+    OpaqueFillShader::initialize();
+    m_opacityId = program()->uniformLocation("opacity");
+}
+
+void FillShader::updateState(
+    const RenderState &state, QSGMaterial *newEffect, QSGMaterial *oldEffect)
+{
+    OpaqueFillShader::updateState(state, newEffect, oldEffect);
+    if (state.isOpacityDirty()) {
+        program()->setUniformValue(m_opacityId, state.opacity());
+    }
+}
+
+// --- Offset opaque fill shader ---
+
+OffsetOpaqueFillShader::OffsetOpaqueFillShader()
+    : OpaqueFillShader()
+{
+    setShaderSourceFile(QOpenGLShader::Vertex, QStringLiteral(":/shaders/offsetfill.vert"));
+}
+
+char const *const *OffsetOpaqueFillShader::attributeNames() const
+{
+    static char const *const attributes[] = {
+        "positionAttrib", "textureCoordAttrib", "positionOffsetAttrib", "textureCoordOffsetAttrib",
+        0
+    };
+    return attributes;
+}
+
+void OffsetOpaqueFillShader::initialize()
+{
+    OpaqueFillShader::initialize();
+    m_pixelSizeId = program()->uniformLocation("pixelSize");
+}
+
+void OffsetOpaqueFillShader::updateState(
+    const RenderState &state, QSGMaterial *newEffect, QSGMaterial *oldEffect)
+{
+    OpaqueFillShader::updateState(state, newEffect, oldEffect);
+    if (!oldEffect) {
+        // Set the pixel size only once since the viewport is constant.
+        const QRect rect = state.viewportRect();
+        program()->setUniformValue(m_pixelSizeId, 2.0f / rect.width(), 2.0f / rect.height());
+    }
+}
+
+// --- Offset fill shader ---
+
+OffsetFillShader::OffsetFillShader()
+    : FillShader()
+{
+    setShaderSourceFile(QOpenGLShader::Vertex, QStringLiteral(":/shaders/offsetfill.vert"));
+}
+
+char const *const *OffsetFillShader::attributeNames() const
+{
+    static char const *const attributes[] = {
+        "positionAttrib", "textureCoordAttrib", "positionOffsetAttrib", "textureCoordOffsetAttrib",
+        0
+    };
+    return attributes;
+}
+
+void OffsetFillShader::initialize()
+{
+    FillShader::initialize();
+    m_pixelSizeId = program()->uniformLocation("pixelSize");
+}
+
+void OffsetFillShader::updateState(
+    const RenderState &state, QSGMaterial *newEffect, QSGMaterial *oldEffect)
+{
+    FillShader::updateState(state, newEffect, oldEffect);
+    if (!oldEffect) {
+        // Set the pixel size only once since the viewport is constant.
+        const QRect rect = state.viewportRect();
+        program()->setUniformValue(m_pixelSizeId, 2.0f / rect.width(), 2.0f / rect.height());
+    }
+}
+
+// --- Edge shader ---
+
+EdgeShader::EdgeShader()
+    : OffsetFillShader()
+{
+    setShaderSourceFile(QOpenGLShader::Vertex, QStringLiteral(":/shaders/edge.vert"));
+    setShaderSourceFile(QOpenGLShader::Fragment, QStringLiteral(":/shaders/edge.frag"));
+}
+
+// --- Opaque fill material ---
+
+OpaqueFillMaterial::OpaqueFillMaterial(QSGTexture *texture, QSGTexture::Filtering filtering)
+    : m_texture(texture)
+    , m_filtering(filtering)
+{
+    Q_ASSERT(texture);
+
+    // It might seem a bit counterintuitive to set the blending flag in an
+    // opaque material so here's a quick explanation. A geometry node can have a
+    // standard and an opaque material, the latter one being used by the
+    // renderer when the accumulated opacity on a node is 1. The point is to
+    // simplify the shader used in that particular case. That said, an opaque
+    // material can still render translucent fragments coming, for instance,
+    // from an RGBA texture. In that case blending must be enabled and this is
+    // exactly what happens here.
+    setFlag(Blending, texture->hasAlphaChannel());
+}
+
+QSGMaterialType *OpaqueFillMaterial::type() const
+{
+    static QSGMaterialType type;
+    return &type;
+}
+
+QSGMaterialShader *OpaqueFillMaterial::createShader() const
+{
+    return new OpaqueFillShader;
+}
+
+int OpaqueFillMaterial::compare(const QSGMaterial *other) const
+{
+    const OpaqueFillMaterial *otherMaterial = static_cast<const OpaqueFillMaterial*>(other);
+    if (const int diff = m_texture->textureId() - otherMaterial->texture()->textureId()) {
+        return diff;
+    }
+    return static_cast<int>(m_filtering) - static_cast<int>(otherMaterial->filtering());
+}
+
+// --- Fill material ---
+
+FillMaterial::FillMaterial(QSGTexture *texture, QSGTexture::Filtering filtering)
+    : OpaqueFillMaterial(texture, filtering)
+{
+}
+
+QSGMaterialType *FillMaterial::type() const
+{
+    static QSGMaterialType type;
+    return &type;
+}
+
+QSGMaterialShader *FillMaterial::createShader() const
+{
+    return new FillShader;
+}
+
+/// --- Offset opaque fill material ---
+
+OffsetOpaqueFillMaterial::OffsetOpaqueFillMaterial(
+    QSGTexture *texture, QSGTexture::Filtering filtering)
+    : OpaqueFillMaterial(texture, filtering)
+{
+    setFlag(RequiresFullMatrixExceptTranslate, true);
+}
+
+QSGMaterialType *OffsetOpaqueFillMaterial::type() const
+{
+    static QSGMaterialType type;
+    return &type;
+}
+
+QSGMaterialShader *OffsetOpaqueFillMaterial::createShader() const
+{
+    return new OffsetOpaqueFillShader;
+}
+
+/// --- Offset fill material ---
+
+OffsetFillMaterial::OffsetFillMaterial(QSGTexture *texture, QSGTexture::Filtering filtering)
+    : FillMaterial(texture, filtering)
+{
+    setFlag(RequiresFullMatrixExceptTranslate, true);
+}
+
+QSGMaterialType *OffsetFillMaterial::type() const
+{
+    static QSGMaterialType type;
+    return &type;
+}
+
+QSGMaterialShader *OffsetFillMaterial::createShader() const
+{
+    return new OffsetFillShader;
+}
+
+// --- Edge material ---
+
+EdgeMaterial::EdgeMaterial(QSGTexture *texture, QSGTexture::Filtering filtering)
+    : OpaqueFillMaterial(texture, filtering)
+{
+    setFlag(Blending | RequiresFullMatrixExceptTranslate, true);
+}
+
+QSGMaterialType *EdgeMaterial::type() const
+{
+    static QSGMaterialType type;
+    return &type;
+}
+
+QSGMaterialShader *EdgeMaterial::createShader() const
+{
+    return new EdgeShader;
+}
+
+// --- Fill node ---
+
+FillNode::FillNode(QSGTexture *texture, QSGTexture::Filtering filtering, bool offset)
+    : QSGGeometryNode()
+    , m_opaqueMaterial(texture, filtering)
+    , m_material(texture, filtering)
+    , m_offsetOpaqueMaterial(texture, filtering)
+    , m_offsetMaterial(texture, filtering)
+    , m_geometry(attributeSet(), 4, 4, GL_UNSIGNED_SHORT)
+    , m_offsetGeometry(offsetAttributeSet(), 4, 4, GL_UNSIGNED_SHORT)
+    , m_flags(0)
+{
+    Q_ASSERT(texture);
+
+    memcpy(m_geometry.indexData(), indices(), 4 * sizeof(unsigned short));
+    m_geometry.setIndexDataPattern(QSGGeometry::StaticPattern);
+    memcpy(m_offsetGeometry.indexData(), indices(), 4 * sizeof(unsigned short));
+    m_offsetGeometry.setIndexDataPattern(QSGGeometry::StaticPattern);
+    setOffset(offset);
+
+    qsgnode_set_description(this, QLatin1String("mirsurfacefill"));
+}
+
+// static
+const unsigned short *FillNode::indices()
+{
+    // Triangle strip layout:
+    // 0 - 1
+    // | / |
+    // 2 - 3
+    static const unsigned short indices[] = { 0, 2, 1, 3 };
+    return indices;
+}
+
+// static
+const QSGGeometry::AttributeSet &FillNode::attributeSet()
+{
+    static const QSGGeometry::Attribute attributes[] = {
+        QSGGeometry::Attribute::create(0, 2, GL_FLOAT, true),
+        QSGGeometry::Attribute::create(1, 2, GL_FLOAT),
+    };
+    static const QSGGeometry::AttributeSet attributeSet = {
+        2, sizeof(Vertex), attributes
+    };
+    return attributeSet;
+}
+
+// static
+const QSGGeometry::AttributeSet &FillNode::offsetAttributeSet()
+{
+    static const QSGGeometry::Attribute attributes[] = {
+        QSGGeometry::Attribute::create(0, 2, GL_FLOAT, true),
+        QSGGeometry::Attribute::create(1, 2, GL_FLOAT),
+        QSGGeometry::Attribute::create(2, 2, GL_FLOAT),
+        QSGGeometry::Attribute::create(3, 2, GL_FLOAT)
+    };
+    static const QSGGeometry::AttributeSet attributeSet = {
+        4, sizeof(OffsetVertex), attributes
+    };
+    return attributeSet;
+}
+
+void FillNode::setOffset(bool offset)
+{
+    if (!offset) {
+        setGeometry(&m_geometry);
+        setOpaqueMaterial(&m_opaqueMaterial);
+        setMaterial(&m_material);
+        m_flags &= ~Offset;
+    } else {
+        setGeometry(&m_offsetGeometry);
+        setOpaqueMaterial(&m_offsetOpaqueMaterial);
+        setMaterial(&m_offsetMaterial);
+        m_flags |= Offset;
+    }
+}
+
+void FillNode::setFiltering(QSGTexture::Filtering filtering)
+{
+    m_opaqueMaterial.setFiltering(filtering);
+    m_material.setFiltering(filtering);
+    m_offsetOpaqueMaterial.setFiltering(filtering);
+    m_offsetMaterial.setFiltering(filtering);
+    markDirty(DirtyMaterial);
+}
+
+void FillNode::updateGeometry(float width, float height)
+{
+    if (!(m_flags & Offset)) {
+        Vertex *v = reinterpret_cast<Vertex*>(m_geometry.vertexData());
+        v[0].position[0] = 0.0f;
+        v[0].position[1] = 0.0f;
+        v[0].textureCoordinate[0] = 0.0f;
+        v[0].textureCoordinate[1] = 0.0f;
+        v[1].position[0] = width;
+        v[1].position[1] = 0.0f;
+        v[1].textureCoordinate[0] = 1.0f;
+        v[1].textureCoordinate[1] = 0.0f;
+        v[2].position[0] = 0.0f;
+        v[2].position[1] = height;
+        v[2].textureCoordinate[0] = 0.0f;
+        v[2].textureCoordinate[1] = 1.0f;
+        v[3].position[0] = width;
+        v[3].position[1] = height;
+        v[3].textureCoordinate[0] = 1.0f;
+        v[3].textureCoordinate[1] = 1.0f;
+    } else {
+        OffsetVertex *v = reinterpret_cast<OffsetVertex*>(m_offsetGeometry.vertexData());
+        const float delta = qMin(width, height) * 0.5f;
+        const float sx = 1.0f / width;
+        const float sy = 1.0f / height;
+        v[0].position[0] = 0.0f;
+        v[0].position[1] = 0.0f;
+        v[0].textureCoordinate[0] = 0.0f;
+        v[0].textureCoordinate[1] = 0.0f;
+        v[0].positionOffset[0] = delta;
+        v[0].positionOffset[1] = delta;
+        v[0].textureCoordinateOffset[0] = delta * sx;
+        v[0].textureCoordinateOffset[1] = delta * sy;
+        v[1].position[0] = width;
+        v[1].position[1] = 0.0f;
+        v[1].textureCoordinate[0] = 1.0f;
+        v[1].textureCoordinate[1] = 0.0f;
+        v[1].positionOffset[0] = -delta;
+        v[1].positionOffset[1] = delta;
+        v[1].textureCoordinateOffset[0] = -delta * sx;
+        v[1].textureCoordinateOffset[1] = delta * sy;
+        v[2].position[0] = 0.0f;
+        v[2].position[1] = height;
+        v[2].textureCoordinate[0] = 0.0f;
+        v[2].textureCoordinate[1] = 1.0f;
+        v[2].positionOffset[0] = delta;
+        v[2].positionOffset[1] = -delta;
+        v[2].textureCoordinateOffset[0] = delta * sx;
+        v[2].textureCoordinateOffset[1] = -delta * sy;
+        v[3].position[0] = width;
+        v[3].position[1] = height;
+        v[3].textureCoordinate[0] = 1.0f;
+        v[3].textureCoordinate[1] = 1.0f;
+        v[3].positionOffset[0] = -delta;
+        v[3].positionOffset[1] = -delta;
+        v[3].textureCoordinateOffset[0] = -delta * sx;
+        v[3].textureCoordinateOffset[1] = -delta * sy;
+    }
+
+    markDirty(DirtyGeometry);
+}
+
+// --- Edge node ---
+
+EdgeNode::EdgeNode(QSGTexture *texture, QSGTexture::Filtering filtering, bool visible)
+    : QSGGeometryNode()
+    , m_material(texture, filtering)
+    , m_geometry(attributeSet(), 8, 10, GL_UNSIGNED_SHORT)
+    , m_flags(0)
+{
+    Q_ASSERT(texture);
+
+    memcpy(m_geometry.indexData(), indices(), 10 * sizeof(unsigned short));
+    m_geometry.setIndexDataPattern(QSGGeometry::StaticPattern);
+    setGeometry(&m_geometry);
+    setMaterial(&m_material);
+    setVisible(visible);
+
+    qsgnode_set_description(this, QLatin1String("mirsurfaceedge"));
+}
+
+// static
+const unsigned short* EdgeNode::indices()
+{
+    // Triangle strip layout:
+    // 0 ----- 1
+    // | 4 - 5 |
+    // | |   | |
+    // | 6 - 7 |
+    // 2 ----- 3
+    static const unsigned short indices[] = { 0, 4, 1, 5, 3, 7, 2, 6, 0, 4 };
+    return indices;
+}
+
+// static
+const QSGGeometry::AttributeSet& EdgeNode::attributeSet()
+{
+    static const QSGGeometry::Attribute attributes[] = {
+        QSGGeometry::Attribute::create(0, 2, GL_FLOAT, true),
+        QSGGeometry::Attribute::create(1, 2, GL_FLOAT),
+        QSGGeometry::Attribute::create(2, 2, GL_FLOAT),
+        QSGGeometry::Attribute::create(3, 2, GL_FLOAT)
+    };
+    static const QSGGeometry::AttributeSet attributeSet = {
+        4, sizeof(OffsetVertex), attributes
+    };
+    return attributeSet;
+}
+
+void EdgeNode::setVisible(bool visible)
+{
+    if (!(m_flags & Visible) != visible) {
+        m_flags ^= Visible;
+        markDirty(DirtySubtreeBlocked);
+    }
+}
+
+void EdgeNode::setFiltering(QSGTexture::Filtering filtering)
+{
+    m_material.setFiltering(filtering);
+    markDirty(DirtyMaterial);
+}
+
+void EdgeNode::updateGeometry(float width, float height)
+{
+    OffsetVertex *v = reinterpret_cast<OffsetVertex*>(m_geometry.vertexData());
+    const float delta = qMin(width, height) * 0.5f;
+    const float sx = 1.0f / width;
+    const float sy = 1.0f / height;
+    for (int i = 0, d = -1; i <= 4; i += 4, d += 2) {
+        v[i+0].position[0] = 0.0f;
+        v[i+0].position[1] = 0.0f;
+        v[i+0].textureCoordinate[0] = 0.0f;
+        v[i+0].textureCoordinate[1] = 0.0f;
+        v[i+0].positionOffset[0] = delta * d;
+        v[i+0].positionOffset[1] = delta * d;
+        v[i+0].textureCoordinateOffset[0] = d < 0 ? 0.0f : delta * d * sx;
+        v[i+0].textureCoordinateOffset[1] = d < 0 ? 0.0f : delta * d * sy;
+        v[i+1].position[0] = width;
+        v[i+1].position[1] = 0.0f;
+        v[i+1].textureCoordinate[0] = 1.0f;
+        v[i+1].textureCoordinate[1] = 0.0f;
+        v[i+1].positionOffset[0] = -delta * d;
+        v[i+1].positionOffset[1] = delta * d;
+        v[i+1].textureCoordinateOffset[0] = d < 0 ? 0.0f : -delta * d * sx;
+        v[i+1].textureCoordinateOffset[1] = d < 0 ? 0.0f : delta * d * sy;
+        v[i+2].position[0] = 0.0f;
+        v[i+2].position[1] = height;
+        v[i+2].textureCoordinate[0] = 0.0f;
+        v[i+2].textureCoordinate[1] = 1.0f;
+        v[i+2].positionOffset[0] = delta * d;
+        v[i+2].positionOffset[1] = -delta * d;
+        v[i+2].textureCoordinateOffset[0] = d < 0 ? 0.0f : delta * d * sx;
+        v[i+2].textureCoordinateOffset[1] = d < 0 ? 0.0f : -delta * d * sy;
+        v[i+3].position[0] = width;
+        v[i+3].position[1] = height;
+        v[i+3].textureCoordinate[0] = 1.0f;
+        v[i+3].textureCoordinate[1] = 1.0f;
+        v[i+3].positionOffset[0] = -delta * d;
+        v[i+3].positionOffset[1] = -delta * d;
+        v[i+3].textureCoordinateOffset[0] = d < 0 ? 0.0f : -delta * d * sx;
+        v[i+3].textureCoordinateOffset[1] = d < 0 ? 0.0f : -delta * d * sy;
+    }
+
+    markDirty(DirtyGeometry);
+}
+
+// --- MirSurface node ---
+
+MirSurfaceNode::MirSurfaceNode(
+    QSGTexture *texture, QSGTexture::Filtering filtering, bool antialiasing)
+{
+    Q_ASSERT(texture);
+    appendChildNode(new FillNode(texture, filtering, antialiasing));
+    appendChildNode(new EdgeNode(texture, filtering, antialiasing));
+}
+
+void MirSurfaceNode::setAntialiasing(bool antialiasing)
+{
+    static_cast<FillNode*>(firstChild())->setOffset(antialiasing);
+    static_cast<EdgeNode*>(lastChild())->setVisible(antialiasing);
+}
+
+void MirSurfaceNode::setFiltering(QSGTexture::Filtering filtering)
+{
+    static_cast<FillNode*>(firstChild())->setFiltering(filtering);
+    static_cast<EdgeNode*>(lastChild())->setFiltering(filtering);
+}
+
+void MirSurfaceNode::updateGeometry(float width, float height)
+{
+    static_cast<FillNode*>(firstChild())->updateGeometry(width, height);
+    static_cast<EdgeNode*>(lastChild())->updateGeometry(width, height);
+}
+
+void MirSurfaceNode::updateMaterial()
+{
+    firstChild()->markDirty(QSGNode::DirtyMaterial);
+    lastChild()->markDirty(QSGNode::DirtyMaterial);
+}

=== added file 'src/modules/Unity/Application/mirsurfacenode.h'
--- src/modules/Unity/Application/mirsurfacenode.h	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/mirsurfacenode.h	2015-10-19 10:47:33 +0000
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <QtQuick/QSGNode>
+#include <QtQuick/QSGTexture>
+
+// MirSurfaceNode is a Qt scene graph node that renders a texture with a given
+// filtering. It can be compared to the image node provided by QtQuick (although
+// simpler) with the addition of a more efficient antialiasing technique that
+// keeps the same quality.
+//
+// QtQuick provides 2 different antialiasing techniques. The first one is called
+// multisampling and is proposed by the underlying hardware. It can be enabled
+// at window creation time by defining a number of samples on the QSurfaceFormat
+// associated to the created QtQuick scene (window). The efficiency of that
+// technique is highly dependent on the hardware and often not adapted. The
+// second technique is called vertex antialiasing, when the antialiasing
+// property is set to true on a QtQuick item, QtQuick switches to that technique
+// which adds 4 new vertices with additional attributes and lets the vertex
+// shader accurately set their position and opacity fall-off. The drawback of
+// this technique is that it forces the whole node to be rendered in the
+// translucent pass of the renderer even though the whole content of the node is
+// opaque, another drawback is that it oten prevents batching.
+//
+// The antialiasing technique provided by this node prevents both issues by
+// creating 2 geometry nodes, a FillNode that is made to fill the content and an
+// EdgeNode that is made to render the antialiased edge. The edge node uses
+// exactly the same vertex-based algorithm than the default QtQuick nodes.
+//
+// This technique is perfectly adapted to the rendering of the Spread, where
+// there is quite a lot of overdraw, by bringing back the ability for GPUs to
+// use early-Z cull optimisations.
+class MirSurfaceNode : public QSGNode
+{
+public:
+    MirSurfaceNode(QSGTexture *texture, QSGTexture::Filtering filtering, bool antialiasing);
+
+    void setFiltering(QSGTexture::Filtering filtering);
+    void setAntialiasing(bool antialiasing);
+    void updateGeometry(float width, float height);
+    void updateMaterial();
+};

=== added file 'src/modules/Unity/Application/resources.qrc'
--- src/modules/Unity/Application/resources.qrc	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/resources.qrc	2015-10-19 10:47:33 +0000
@@ -0,0 +1,10 @@
+<!DOCTYPE RCC><RCC version="1.0">
+  <qresource>
+    <file>shaders/fill.vert</file>
+    <file>shaders/fill.frag</file>
+    <file>shaders/opaquefill.frag</file>
+    <file>shaders/offsetfill.vert</file>
+    <file>shaders/edge.vert</file>
+    <file>shaders/edge.frag</file>
+  </qresource>
+</RCC>

=== added directory 'src/modules/Unity/Application/shaders'
=== added file 'src/modules/Unity/Application/shaders/edge.frag'
--- src/modules/Unity/Application/shaders/edge.frag	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/shaders/edge.frag	2015-10-19 10:47:33 +0000
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+uniform sampler2D texture;
+varying mediump vec2 textureCoord;
+varying lowp float vertexOpacity;
+
+void main(void)
+{
+    gl_FragColor = texture2D(texture, textureCoord) * vec4(vertexOpacity);
+}

=== added file 'src/modules/Unity/Application/shaders/edge.vert'
--- src/modules/Unity/Application/shaders/edge.vert	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/shaders/edge.vert	2015-10-19 10:47:33 +0000
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// Uses the vertex antialiasing code from QtQuick.
+
+uniform highp mat4 matrix;
+uniform lowp float opacity;
+uniform highp vec2 pixelSize;
+attribute highp vec4 positionAttrib;
+attribute mediump vec2 textureCoordAttrib;
+attribute highp vec2 positionOffsetAttrib;
+attribute highp vec2 textureCoordOffsetAttrib;
+varying mediump vec2 textureCoord;
+varying lowp float vertexOpacity;
+
+void main()
+{
+    textureCoord = textureCoordAttrib;
+    highp vec4 pos = matrix * positionAttrib;
+    gl_Position = pos;
+
+    if (positionOffsetAttrib.x != 0.0) {
+        highp vec4 delta = matrix[0] * positionOffsetAttrib.x;
+        highp vec2 dir = delta.xy * pos.w - pos.xy * delta.w;
+        highp vec2 ndir = 0.5 * pixelSize * normalize(dir / pixelSize);
+        dir -= ndir * delta.w * pos.w;
+        highp float numerator = dot(dir, ndir * pos.w * pos.w);
+        highp float scale = 0.0;
+        if (numerator < 0.0) {
+            scale = 1.0;
+        } else {
+            scale = min(1.0, numerator / dot(dir, dir));
+        }
+        gl_Position += scale * delta;
+        textureCoord.x += scale * textureCoordOffsetAttrib.x;
+    }
+
+    if (positionOffsetAttrib.y != 0.0) {
+        highp vec4 delta = matrix[1] * positionOffsetAttrib.y;
+        highp vec2 dir = delta.xy * pos.w - pos.xy * delta.w;
+        highp vec2 ndir = 0.5 * pixelSize * normalize(dir / pixelSize);
+        dir -= ndir * delta.w * pos.w;
+        highp float numerator = dot(dir, ndir * pos.w * pos.w);
+        highp float scale = 0.0;
+        if (numerator < 0.0) {
+            scale = 1.0;
+        } else {
+            scale = min(1.0, numerator / dot(dir, dir));
+        }
+        gl_Position += scale * delta;
+        textureCoord.y += scale * textureCoordOffsetAttrib.y;
+    }
+
+    bool onEdge = any(notEqual(positionOffsetAttrib, vec2(0.0)));
+    bool outerEdge = all(equal(textureCoordOffsetAttrib, vec2(0.0)));
+    if (onEdge && outerEdge) {
+        vertexOpacity = 0.0;
+    } else {
+        vertexOpacity = opacity;
+    }
+}

=== added file 'src/modules/Unity/Application/shaders/fill.frag'
--- src/modules/Unity/Application/shaders/fill.frag	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/shaders/fill.frag	2015-10-19 10:47:33 +0000
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+uniform sampler2D texture;
+uniform lowp float opacity;
+varying mediump vec2 textureCoord;
+
+void main(void)
+{
+    gl_FragColor = texture2D(texture, textureCoord) * vec4(opacity);
+}

=== added file 'src/modules/Unity/Application/shaders/fill.vert'
--- src/modules/Unity/Application/shaders/fill.vert	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/shaders/fill.vert	2015-10-19 10:47:33 +0000
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+uniform highp mat4 matrix;
+attribute highp vec4 positionAttrib;
+attribute mediump vec2 textureCoordAttrib;
+varying mediump vec2 textureCoord;
+
+void main()
+{
+    textureCoord = textureCoordAttrib;
+    gl_Position = matrix * positionAttrib;
+}

=== added file 'src/modules/Unity/Application/shaders/offsetfill.vert'
--- src/modules/Unity/Application/shaders/offsetfill.vert	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/shaders/offsetfill.vert	2015-10-19 10:47:33 +0000
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// Uses the vertex antialiasing code from QtQuick.
+
+uniform highp mat4 matrix;
+uniform highp vec2 pixelSize;
+attribute highp vec4 positionAttrib;
+attribute mediump vec2 textureCoordAttrib;
+attribute highp vec2 positionOffsetAttrib;
+attribute highp vec2 textureCoordOffsetAttrib;
+varying mediump vec2 textureCoord;
+
+void main()
+{
+    textureCoord = textureCoordAttrib;
+    highp vec4 pos = matrix * positionAttrib;
+    gl_Position = pos;
+
+    if (positionOffsetAttrib.x != 0.0) {
+        highp vec4 delta = matrix[0] * positionOffsetAttrib.x;
+        highp vec2 dir = delta.xy * pos.w - pos.xy * delta.w;
+        highp vec2 ndir = 0.5 * pixelSize * normalize(dir / pixelSize);
+        dir -= ndir * delta.w * pos.w;
+        highp float numerator = dot(dir, ndir * pos.w * pos.w);
+        highp float scale = 0.0;
+        if (numerator < 0.0) {
+            scale = 1.0;
+        } else {
+            scale = min(1.0, numerator / dot(dir, dir));
+        }
+        gl_Position += scale * delta;
+        textureCoord.x += scale * textureCoordOffsetAttrib.x;
+    }
+
+    if (positionOffsetAttrib.y != 0.0) {
+        highp vec4 delta = matrix[1] * positionOffsetAttrib.y;
+        highp vec2 dir = delta.xy * pos.w - pos.xy * delta.w;
+        highp vec2 ndir = 0.5 * pixelSize * normalize(dir / pixelSize);
+        dir -= ndir * delta.w * pos.w;
+        highp float numerator = dot(dir, ndir * pos.w * pos.w);
+        highp float scale = 0.0;
+        if (numerator < 0.0) {
+            scale = 1.0;
+        } else {
+            scale = min(1.0, numerator / dot(dir, dir));
+        }
+        gl_Position += scale * delta;
+        textureCoord.y += scale * textureCoordOffsetAttrib.y;
+    }
+}

=== added file 'src/modules/Unity/Application/shaders/opaquefill.frag'
--- src/modules/Unity/Application/shaders/opaquefill.frag	1970-01-01 00:00:00 +0000
+++ src/modules/Unity/Application/shaders/opaquefill.frag	2015-10-19 10:47:33 +0000
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2015 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+uniform sampler2D texture;
+varying mediump vec2 textureCoord;
+
+void main(void)
+{
+  gl_FragColor = texture2D(texture, textureCoord);
+}