Merge lp:~loic.molinari/ubuntu-ui-toolkit/uitk-quad into lp:ubuntu-ui-toolkit/staging

[Loïc Molinari]

Added new nodes and item with fast and dynamic shadow rendering.

Added new nodes and item with fast and dynamic shadow rendering.

[lp:~loic.molinari/ubuntu-ui-toolkit/uitk-quad]

2130. By Loïc Molinari on 2016-10-04

Improved test.

2131. By Loïc Molinari on 2016-10-05

Renamed color to fillColor.

2132. By Loïc Molinari on 2016-10-05

Removed a bunch of useless casts.

2133. By Loïc Molinari on 2016-10-05

Removed useless RESTRICT define.

2134. By Loïc Molinari on 2016-10-05

Added aligned allocs support.

2135. By Loïc Molinari on 2016-10-06

Simplified texture factory code.

2136. By Loïc Molinari on 2016-10-09

Cleaned up texture factory.

2137. By Loïc Molinari on 2016-10-10

Clean up.

2138. By Loïc Molinari on 2016-10-14

Added inner shadow support.

2139. By Loïc Molinari on 2016-10-15

Moved fill corners to new resources arch.

2140. By Loïc Molinari on 2016-10-15

Moved drop shadow to new resources arch.

2141. By Loïc Molinari on 2016-10-16

Added fill corners shadow.

2142. By Loïc Molinari on 2016-10-17

Added initial border support.

2143. By Loïc Molinari on 2016-10-17

Fixed ZoomPan.qml.

2144. By Loïc Molinari on 2016-10-17

Cleaned up shaders.

2145. By Loïc Molinari on 2016-11-08

Made a nice Quad tweaker tool.

2146. By Loïc Molinari on 2016-11-10

Added border support to fill center nodes.

2147. By Loïc Molinari on 2016-11-10

Merged lp:ubuntu-ui-toolkit/staging.

2148. By Loïc Molinari on 2016-11-11

Added shadow border support fill corners node.

2149. By Loïc Molinari on 2016-11-11

Added border support fill corners node.

2150. By Loïc Molinari on 2016-11-11

Improved quad tdeak colors.

2151. By Loïc Molinari on 2016-11-11

Fixed Quad Tweak color picking system.

2152. By Loïc Molinari on 2016-11-13

Fixed and cleaned up mask texture creation when radius=0.

2153. By Loïc Molinari on 2016-11-13

Reverted to 0 default radius in quad tweak.

2154. By Loïc Molinari on 2016-11-15

Cleaned up shadow texture creation code.

2155. By Loïc Molinari on 2016-11-17

Shadow texture fixes.

2156. By Loïc Molinari on 2016-11-17

Fixed 0 radius and shadow size issues.

2157. By Loïc Molinari on 2016-11-18

Fixed drop shadow visiblity states.

2158. By Loïc Molinari on 2016-12-06

Replaced shadow blur with extended box filtering algorithm.

2159. By Loïc Molinari on 2016-12-06

Cleaned up alignment strategies.

[Emanuele Antonio Faraone (emanueleant03)]

review: Approve

Unmerged revisions

2159. By Loïc Molinari on 2016-12-06

Cleaned up alignment strategies.

2158. By Loïc Molinari on 2016-12-06

Replaced shadow blur with extended box filtering algorithm.

2157. By Loïc Molinari on 2016-11-18

Fixed drop shadow visiblity states.

2156. By Loïc Molinari on 2016-11-17

Fixed 0 radius and shadow size issues.

2155. By Loïc Molinari on 2016-11-17

Shadow texture fixes.

2154. By Loïc Molinari on 2016-11-15

Cleaned up shadow texture creation code.

2153. By Loïc Molinari on 2016-11-13

Reverted to 0 default radius in quad tweak.

2152. By Loïc Molinari on 2016-11-13

Fixed and cleaned up mask texture creation when radius=0.

2151. By Loïc Molinari on 2016-11-11

Fixed Quad Tweak color picking system.

2150. By Loïc Molinari on 2016-11-11

Improved quad tdeak colors.

=== modified file 'src/UbuntuToolkit/UbuntuToolkit.pro'
--- src/UbuntuToolkit/UbuntuToolkit.pro	2016-11-04 09:37:32 +0000
+++ src/UbuntuToolkit/UbuntuToolkit.pro	2016-12-14 07:25:05 +0000
@@ -45,13 +45,19 @@
     $$PWD/mousetouchadaptor_p.h \
     $$PWD/mousetouchadaptor_p_p.h \
     $$PWD/privates/appheaderbase_p.h \
-    $$PWD/privates/frame_p.h \
     $$PWD/privates/listitemdragarea_p.h \
     $$PWD/privates/listitemdraghandler_p.h \
     $$PWD/privates/listitemselection_p.h \
     $$PWD/privates/listviewextensions_p.h \
     $$PWD/privates/splitviewhandler_p.h \
     $$PWD/privates/threelabelsslot_p.h \
+    $$PWD/privates/ucshape_p.h \
+    $$PWD/privates/ucshapedropshadownodes_p.h \
+    $$PWD/privates/ucshapefillnodes_p.h \
+    $$PWD/privates/ucshapeframenodes_p.h \
+    $$PWD/privates/ucshaperesources_p.h \
+    $$PWD/privates/ucshapetexturefactory_p.h \
+    $$PWD/privates/ucshapeutils_p.h \
     $$PWD/privates/ucpagewrapper_p.h \
     $$PWD/privates/ucpagewrapper_p_p.h \
     $$PWD/privates/ucpagewrapperincubator_p.h \
@@ -155,7 +161,6 @@
     $$PWD/menugroup.cpp \
     $$PWD/mousetouchadaptor.cpp \
     $$PWD/privates/appheaderbase.cpp \
-    $$PWD/privates/frame.cpp \
     $$PWD/privates/listitemdragarea.cpp \
     $$PWD/privates/listitemdraghandler.cpp \
     $$PWD/privates/listitemexpansion.cpp \
@@ -163,6 +168,12 @@
     $$PWD/privates/listviewextensions.cpp \
     $$PWD/privates/splitviewhandler.cpp \
     $$PWD/privates/threelabelsslot_p.cpp \
+    $$PWD/privates/ucshape.cpp \
+    $$PWD/privates/ucshapedropshadownodes.cpp \
+    $$PWD/privates/ucshapefillnodes.cpp \
+    $$PWD/privates/ucshapeframenodes.cpp \
+    $$PWD/privates/ucshaperesources.cpp \
+    $$PWD/privates/ucshapetexturefactory.cpp \
     $$PWD/privates/ucpagewrapper.cpp \
     $$PWD/privates/ucpagewrapperincubator.cpp \
     $$PWD/privates/ucscrollbarutils.cpp \
@@ -231,13 +242,37 @@
     $$PWD/resources.qrc
 
 OTHER_FILES += \
+    $$PWD/privates/shaders/color.frag \
+    $$PWD/privates/shaders/color.vert \
+    $$PWD/privates/shaders/color_opaque.frag \
+    $$PWD/privates/shaders/colormask.frag \
+    $$PWD/privates/shaders/colormask.vert \
+    $$PWD/privates/shaders/colormask_opaque.frag \
+    $$PWD/privates/shaders/fillcenterborder.frag \
+    $$PWD/privates/shaders/fillcenterborder.vert \
+    $$PWD/privates/shaders/fillcenterborder_opaque.frag \
+    $$PWD/privates/shaders/fillcentershadow.frag \
+    $$PWD/privates/shaders/fillcentershadow.vert \
+    $$PWD/privates/shaders/fillcentershadow_opaque.frag \
+    $$PWD/privates/shaders/fillcentershadowborder.frag \
+    $$PWD/privates/shaders/fillcentershadowborder.vert \
+    $$PWD/privates/shaders/fillcentershadowborder_opaque.frag \
+    $$PWD/privates/shaders/fillcornersborder.frag \
+    $$PWD/privates/shaders/fillcornersborder.vert \
+    $$PWD/privates/shaders/fillcornersborder_opaque.frag \
+    $$PWD/privates/shaders/fillcornersshadow.frag \
+    $$PWD/privates/shaders/fillcornersshadow.vert \
+    $$PWD/privates/shaders/fillcornersshadow_opaque.frag \
+    $$PWD/privates/shaders/fillcornersshadowborder.frag \
+    $$PWD/privates/shaders/fillcornersshadowborder.vert \
+    $$PWD/privates/shaders/fillcornersshadowborder_opaque.frag \
+    $$PWD/privates/shaders/frame.frag \
+    $$PWD/privates/shaders/texture2.vert \
+    $$PWD/shaders/shape.frag \
     $$PWD/shaders/shape.vert \
-    $$PWD/shaders/shape.frag \
-    $$PWD/shaders/shape_no_dfdy.frag \
+    $$PWD/shaders/shape_mipmap.frag \
+    $$PWD/shaders/shapeoverlay.frag \
     $$PWD/shaders/shapeoverlay.vert \
-    $$PWD/shaders/shapeoverlay.frag \
-    $$PWD/shaders/shapeoverlay_no_dfdy.frag \
-    $$PWD/privates/shaders/frame.vert \
-    $$PWD/privates/shaders/frame.frag
+    $$PWD/shaders/shapeoverlay_mipmap.frag
 
 load(ubuntu_qt_module)

=== added file 'src/UbuntuToolkit/privates/shaders/color.frag'
--- src/UbuntuToolkit/privates/shaders/color.frag	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/shaders/color.frag	2016-12-14 07:25:05 +0000
@@ -0,0 +1,7 @@
+uniform lowp float opacity;
+varying lowp vec4 color;
+
+void main()
+{
+    gl_FragColor = vec4(opacity) * color;
+}

=== added file 'src/UbuntuToolkit/privates/shaders/color.vert'
--- src/UbuntuToolkit/privates/shaders/color.vert	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/shaders/color.vert	2016-12-14 07:25:05 +0000
@@ -0,0 +1,12 @@
+uniform highp mat4 matrix;
+
+attribute highp vec4 positionAttrib;
+attribute lowp vec4 colorAttrib;
+
+varying lowp vec4 color;
+
+void main()
+{
+    color = colorAttrib;
+    gl_Position = matrix * positionAttrib;
+}

=== added file 'src/UbuntuToolkit/privates/shaders/color_opaque.frag'
--- src/UbuntuToolkit/privates/shaders/color_opaque.frag	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/shaders/color_opaque.frag	2016-12-14 07:25:05 +0000
@@ -0,0 +1,6 @@
+varying lowp vec4 color;
+
+void main()
+{
+    gl_FragColor = color;
+}

=== added file 'src/UbuntuToolkit/privates/shaders/colormask.frag'
--- src/UbuntuToolkit/privates/shaders/colormask.frag	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/shaders/colormask.frag	2016-12-14 07:25:05 +0000
@@ -0,0 +1,10 @@
+uniform sampler2D maskTexture;
+uniform lowp float opacity;
+
+varying mediump vec2 maskCoord;
+varying lowp vec4 color;
+
+void main()
+{
+    gl_FragColor = color * vec4(texture2D(maskTexture, maskCoord).r * opacity);
+}

=== added file 'src/UbuntuToolkit/privates/shaders/colormask.vert'
--- src/UbuntuToolkit/privates/shaders/colormask.vert	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/shaders/colormask.vert	2016-12-14 07:25:05 +0000
@@ -0,0 +1,15 @@
+uniform highp mat4 matrix;
+
+attribute highp vec4 positionAttrib;
+attribute mediump vec2 maskCoordAttrib;
+attribute lowp vec4 colorAttrib;
+
+varying mediump vec2 maskCoord;
+varying lowp vec4 color;
+
+void main()
+{
+    maskCoord = maskCoordAttrib;
+    color = colorAttrib;
+    gl_Position = matrix * positionAttrib;
+}

=== added file 'src/UbuntuToolkit/privates/shaders/colormask_opaque.frag'
--- src/UbuntuToolkit/privates/shaders/colormask_opaque.frag	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/shaders/colormask_opaque.frag	2016-12-14 07:25:05 +0000
@@ -0,0 +1,9 @@
+uniform sampler2D maskTexture;
+
+varying mediump vec2 maskCoord;
+varying lowp vec4 color;
+
+void main()
+{
+    gl_FragColor = color * vec4(texture2D(maskTexture, maskCoord).r);
+}

=== added file 'src/UbuntuToolkit/privates/shaders/fillcenterborder.frag'
--- src/UbuntuToolkit/privates/shaders/fillcenterborder.frag	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/shaders/fillcenterborder.frag	2016-12-14 07:25:05 +0000
@@ -0,0 +1,14 @@
+uniform sampler2D borderTexture;
+uniform lowp float opacity;
+
+varying mediump vec2 borderCoord;
+varying lowp vec4 color;
+varying lowp vec4 borderColor;
+
+void main()
+{
+    lowp float borderCoverage = 1.0 - texture2D(borderTexture, borderCoord).r;
+    lowp vec4 border = borderColor * vec4(borderCoverage);
+    lowp vec4 blend = border + (vec4(1.0 - border.a) * color);
+    gl_FragColor = blend * vec4(opacity);
+}

=== added file 'src/UbuntuToolkit/privates/shaders/fillcenterborder.vert'
--- src/UbuntuToolkit/privates/shaders/fillcenterborder.vert	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/shaders/fillcenterborder.vert	2016-12-14 07:25:05 +0000
@@ -0,0 +1,18 @@
+uniform highp mat4 matrix;
+
+attribute highp vec4 positionAttrib;
+attribute mediump vec2 borderCoordAttrib;
+attribute lowp vec4 colorAttrib;
+attribute lowp vec4 borderColorAttrib;
+
+varying mediump vec2 borderCoord;
+varying lowp vec4 color;
+varying lowp vec4 borderColor;
+
+void main()
+{
+    borderCoord = borderCoordAttrib;
+    color = colorAttrib;
+    borderColor = borderColorAttrib;
+    gl_Position = matrix * positionAttrib;
+}

=== added file 'src/UbuntuToolkit/privates/shaders/fillcenterborder_opaque.frag'
--- src/UbuntuToolkit/privates/shaders/fillcenterborder_opaque.frag	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/shaders/fillcenterborder_opaque.frag	2016-12-14 07:25:05 +0000
@@ -0,0 +1,12 @@
+uniform sampler2D borderTexture;
+
+varying mediump vec2 borderCoord;
+varying lowp vec4 color;
+varying lowp vec4 borderColor;
+
+void main()
+{
+    lowp float borderCoverage = 1.0 - texture2D(borderTexture, borderCoord).r;
+    lowp vec4 border = borderColor * vec4(borderCoverage);
+    gl_FragColor = border + (vec4(1.0 - border.a) * color);
+}

=== added file 'src/UbuntuToolkit/privates/shaders/fillcentershadow.frag'
--- src/UbuntuToolkit/privates/shaders/fillcentershadow.frag	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/shaders/fillcentershadow.frag	2016-12-14 07:25:05 +0000
@@ -0,0 +1,16 @@
+uniform sampler2D shadowTexture;
+uniform lowp float opacity;
+
+varying mediump vec2 shadowCoord;
+varying mediump vec2 midShadowCoord;
+varying lowp vec4 color;
+varying lowp vec4 shadowColor;
+
+void main()
+{
+    mediump vec2 shadowTextureCoord = midShadowCoord - abs(shadowCoord - midShadowCoord);
+    lowp float shadowCoverage = 1.0 - texture2D(shadowTexture, shadowTextureCoord).r;
+    lowp vec4 shadow = shadowColor * vec4(shadowCoverage);
+    lowp vec4 blend = shadow + (vec4(1.0 - shadow.a) * color);
+    gl_FragColor = blend * vec4(opacity);
+}

=== added file 'src/UbuntuToolkit/privates/shaders/fillcentershadow.vert'
--- src/UbuntuToolkit/privates/shaders/fillcentershadow.vert	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/shaders/fillcentershadow.vert	2016-12-14 07:25:05 +0000
@@ -0,0 +1,21 @@
+uniform highp mat4 matrix;
+
+attribute highp vec4 positionAttrib;
+attribute mediump vec2 shadowCoordAttrib;
+attribute mediump vec2 midShadowCoordAttrib;
+attribute lowp vec4 colorAttrib;
+attribute lowp vec4 shadowColorAttrib;
+
+varying mediump vec2 shadowCoord;
+varying mediump vec2 midShadowCoord;
+varying lowp vec4 color;
+varying lowp vec4 shadowColor;
+
+void main()
+{
+    shadowCoord = shadowCoordAttrib;
+    midShadowCoord = midShadowCoordAttrib;
+    color = colorAttrib;
+    shadowColor = shadowColorAttrib;
+    gl_Position = matrix * positionAttrib;
+}

=== added file 'src/UbuntuToolkit/privates/shaders/fillcentershadow_opaque.frag'
--- src/UbuntuToolkit/privates/shaders/fillcentershadow_opaque.frag	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/shaders/fillcentershadow_opaque.frag	2016-12-14 07:25:05 +0000
@@ -0,0 +1,14 @@
+uniform sampler2D shadowTexture;
+
+varying mediump vec2 shadowCoord;
+varying mediump vec2 midShadowCoord;
+varying lowp vec4 color;
+varying lowp vec4 shadowColor;
+
+void main()
+{
+    mediump vec2 shadowTextureCoord = midShadowCoord - abs(shadowCoord - midShadowCoord);
+    lowp float shadowCoverage = 1.0 - texture2D(shadowTexture, shadowTextureCoord).r;
+    lowp vec4 shadow = shadowColor * vec4(shadowCoverage);
+    gl_FragColor = shadow + (vec4(1.0 - shadow.a) * color);
+}

=== added file 'src/UbuntuToolkit/privates/shaders/fillcentershadowborder.frag'
--- src/UbuntuToolkit/privates/shaders/fillcentershadowborder.frag	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/shaders/fillcentershadowborder.frag	2016-12-14 07:25:05 +0000
@@ -0,0 +1,22 @@
+uniform sampler2D shadowTexture;
+uniform sampler2D borderTexture;
+uniform lowp float opacity;
+
+varying mediump vec2 shadowCoord;
+varying mediump vec2 midShadowCoord;
+varying mediump vec2 borderCoord;
+varying lowp vec4 color;
+varying lowp vec4 shadowColor;
+varying lowp vec4 borderColor;
+
+void main()
+{
+    mediump vec2 shadowTextureCoord = midShadowCoord - abs(shadowCoord - midShadowCoord);
+    lowp float shadowCoverage = 1.0 - texture2D(shadowTexture, shadowTextureCoord).r;
+    lowp vec4 shadow = shadowColor * vec4(shadowCoverage);
+    lowp vec4 blend = shadow + (vec4(1.0 - shadow.a) * color);
+    lowp float borderCoverage = 1.0 - texture2D(borderTexture, borderCoord).r;
+    lowp vec4 border = borderColor * vec4(borderCoverage);
+    blend = border + (vec4(1.0 - border.a) * blend);
+    gl_FragColor = blend * vec4(opacity);
+}

=== added file 'src/UbuntuToolkit/privates/shaders/fillcentershadowborder.vert'
--- src/UbuntuToolkit/privates/shaders/fillcentershadowborder.vert	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/shaders/fillcentershadowborder.vert	2016-12-14 07:25:05 +0000
@@ -0,0 +1,27 @@
+uniform highp mat4 matrix;
+
+attribute highp vec4 positionAttrib;
+attribute mediump vec2 shadowCoordAttrib;
+attribute mediump vec2 midShadowCoordAttrib;
+attribute mediump vec2 borderCoordAttrib;
+attribute lowp vec4 colorAttrib;
+attribute lowp vec4 shadowColorAttrib;
+attribute lowp vec4 borderColorAttrib;
+
+varying mediump vec2 shadowCoord;
+varying mediump vec2 midShadowCoord;
+varying mediump vec2 borderCoord;
+varying lowp vec4 color;
+varying lowp vec4 shadowColor;
+varying lowp vec4 borderColor;
+
+void main()
+{
+    shadowCoord = shadowCoordAttrib;
+    midShadowCoord = midShadowCoordAttrib;
+    borderCoord = borderCoordAttrib;
+    color = colorAttrib;
+    shadowColor = shadowColorAttrib;
+    borderColor = borderColorAttrib;
+    gl_Position = matrix * positionAttrib;
+}

=== added file 'src/UbuntuToolkit/privates/shaders/fillcentershadowborder_opaque.frag'
--- src/UbuntuToolkit/privates/shaders/fillcentershadowborder_opaque.frag	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/shaders/fillcentershadowborder_opaque.frag	2016-12-14 07:25:05 +0000
@@ -0,0 +1,20 @@
+uniform sampler2D shadowTexture;
+uniform sampler2D borderTexture;
+
+varying mediump vec2 shadowCoord;
+varying mediump vec2 midShadowCoord;
+varying mediump vec2 borderCoord;
+varying lowp vec4 color;
+varying lowp vec4 shadowColor;
+varying lowp vec4 borderColor;
+
+void main()
+{
+    mediump vec2 shadowTextureCoord = midShadowCoord - abs(shadowCoord - midShadowCoord);
+    lowp float shadowCoverage = 1.0 - texture2D(shadowTexture, shadowTextureCoord).r;
+    lowp vec4 shadow = shadowColor * vec4(shadowCoverage);
+    lowp vec4 blend = shadow + (vec4(1.0 - shadow.a) * color);
+    lowp float borderCoverage = 1.0 - texture2D(borderTexture, borderCoord).r;
+    lowp vec4 border = borderColor * vec4(borderCoverage);
+    gl_FragColor = border + (vec4(1.0 - border.a) * blend);
+}

=== added file 'src/UbuntuToolkit/privates/shaders/fillcornersborder.frag'
--- src/UbuntuToolkit/privates/shaders/fillcornersborder.frag	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/shaders/fillcornersborder.frag	2016-12-14 07:25:05 +0000
@@ -0,0 +1,17 @@
+uniform sampler2D maskTexture;
+uniform sampler2D borderTexture;
+uniform lowp float opacity;
+
+varying mediump vec2 maskCoord;
+varying mediump vec2 borderCoord;
+varying lowp vec4 color;
+varying lowp vec4 borderColor;
+
+void main()
+{
+    lowp float borderCoverage = 1.0 - texture2D(borderTexture, borderCoord).r;
+    lowp vec4 border = borderColor * vec4(borderCoverage);
+    lowp vec4 blend = border + (vec4(1.0 - border.a) * color);
+    lowp float maskCoverage = texture2D(maskTexture, maskCoord).r;
+    gl_FragColor = blend * vec4(maskCoverage * opacity);
+}

=== added file 'src/UbuntuToolkit/privates/shaders/fillcornersborder.vert'
--- src/UbuntuToolkit/privates/shaders/fillcornersborder.vert	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/shaders/fillcornersborder.vert	2016-12-14 07:25:05 +0000
@@ -0,0 +1,21 @@
+uniform highp mat4 matrix;
+
+attribute highp vec4 positionAttrib;
+attribute mediump vec2 maskCoordAttrib;
+attribute mediump vec2 borderCoordAttrib;
+attribute lowp vec4 colorAttrib;
+attribute lowp vec4 borderColorAttrib;
+
+varying mediump vec2 maskCoord;
+varying mediump vec2 borderCoord;
+varying lowp vec4 color;
+varying lowp vec4 borderColor;
+
+void main()
+{
+    maskCoord = maskCoordAttrib;
+    borderCoord = borderCoordAttrib;
+    color = colorAttrib;
+    borderColor = borderColorAttrib;
+    gl_Position = matrix * positionAttrib;
+}

=== added file 'src/UbuntuToolkit/privates/shaders/fillcornersborder_opaque.frag'
--- src/UbuntuToolkit/privates/shaders/fillcornersborder_opaque.frag	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/shaders/fillcornersborder_opaque.frag	2016-12-14 07:25:05 +0000
@@ -0,0 +1,16 @@
+uniform sampler2D maskTexture;
+uniform sampler2D borderTexture;
+
+varying mediump vec2 maskCoord;
+varying mediump vec2 borderCoord;
+varying lowp vec4 color;
+varying lowp vec4 borderColor;
+
+void main()
+{
+    lowp float borderCoverage = 1.0 - texture2D(borderTexture, borderCoord).r;
+    lowp vec4 border = borderColor * vec4(borderCoverage);
+    lowp vec4 blend = border + (vec4(1.0 - border.a) * color);
+    lowp float maskCoverage = texture2D(maskTexture, maskCoord).r;
+    gl_FragColor = blend * vec4(maskCoverage);
+}

=== added file 'src/UbuntuToolkit/privates/shaders/fillcornersshadow.frag'
--- src/UbuntuToolkit/privates/shaders/fillcornersshadow.frag	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/shaders/fillcornersshadow.frag	2016-12-14 07:25:05 +0000
@@ -0,0 +1,18 @@
+uniform sampler2D shadowTexture;
+uniform lowp float opacity;
+
+varying mediump vec2 maskCoord;
+varying mediump vec2 shadowCoord;
+varying mediump vec2 midShadowCoord;
+varying lowp vec4 color;
+varying lowp vec4 shadowColor;
+
+void main()
+{
+    lowp float maskCoverage = texture2D(shadowTexture, maskCoord).a;
+    mediump vec2 shadowTextureCoord = midShadowCoord - abs(shadowCoord - midShadowCoord);
+    lowp float shadowCoverage = 1.0 - texture2D(shadowTexture, shadowTextureCoord).r;
+    lowp vec4 shadow = shadowColor * vec4(shadowCoverage);
+    lowp vec4 blend = shadow + (vec4(1.0 - shadow.a) * color);
+    gl_FragColor = blend * vec4(maskCoverage * opacity);
+}

=== added file 'src/UbuntuToolkit/privates/shaders/fillcornersshadow.vert'
--- src/UbuntuToolkit/privates/shaders/fillcornersshadow.vert	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/shaders/fillcornersshadow.vert	2016-12-14 07:25:05 +0000
@@ -0,0 +1,24 @@
+uniform highp mat4 matrix;
+
+attribute highp vec4 positionAttrib;
+attribute mediump vec2 maskCoordAttrib;
+attribute mediump vec2 shadowCoordAttrib;
+attribute mediump vec2 midShadowCoordAttrib;
+attribute lowp vec4 colorAttrib;
+attribute lowp vec4 shadowColorAttrib;
+
+varying mediump vec2 maskCoord;
+varying mediump vec2 shadowCoord;
+varying mediump vec2 midShadowCoord;
+varying lowp vec4 color;
+varying lowp vec4 shadowColor;
+
+void main()
+{
+    maskCoord = maskCoordAttrib;
+    shadowCoord = shadowCoordAttrib;
+    midShadowCoord = midShadowCoordAttrib;
+    color = colorAttrib;
+    shadowColor = shadowColorAttrib;
+    gl_Position = matrix * positionAttrib;
+}

=== added file 'src/UbuntuToolkit/privates/shaders/fillcornersshadow_opaque.frag'
--- src/UbuntuToolkit/privates/shaders/fillcornersshadow_opaque.frag	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/shaders/fillcornersshadow_opaque.frag	2016-12-14 07:25:05 +0000
@@ -0,0 +1,17 @@
+uniform sampler2D shadowTexture;
+
+varying mediump vec2 maskCoord;
+varying mediump vec2 shadowCoord;
+varying mediump vec2 midShadowCoord;
+varying lowp vec4 color;
+varying lowp vec4 shadowColor;
+
+void main()
+{
+    lowp float maskCoverage = texture2D(shadowTexture, maskCoord).a;
+    mediump vec2 shadowTextureCoord = midShadowCoord - abs(shadowCoord - midShadowCoord);
+    lowp float shadowCoverage = 1.0 - texture2D(shadowTexture, shadowTextureCoord).r;
+    lowp vec4 shadow = shadowColor * vec4(shadowCoverage);
+    lowp vec4 blend = shadow + (vec4(1.0 - shadow.a) * color);
+    gl_FragColor = blend * vec4(maskCoverage);
+}

=== added file 'src/UbuntuToolkit/privates/shaders/fillcornersshadowborder.frag'
--- src/UbuntuToolkit/privates/shaders/fillcornersshadowborder.frag	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/shaders/fillcornersshadowborder.frag	2016-12-14 07:25:05 +0000
@@ -0,0 +1,24 @@
+uniform sampler2D shadowTexture;
+uniform sampler2D borderTexture;
+uniform lowp float opacity;
+
+varying mediump vec2 maskCoord;
+varying mediump vec2 shadowCoord;
+varying mediump vec2 midShadowCoord;
+varying mediump vec2 borderCoord;
+varying lowp vec4 color;
+varying lowp vec4 shadowColor;
+varying lowp vec4 borderColor;
+
+void main()
+{
+    lowp float maskCoverage = texture2D(shadowTexture, maskCoord).a;
+    mediump vec2 shadowTextureCoord = midShadowCoord - abs(shadowCoord - midShadowCoord);
+    lowp float shadowCoverage = 1.0 - texture2D(shadowTexture, shadowTextureCoord).r;
+    lowp vec4 shadow = shadowColor * vec4(shadowCoverage);
+    lowp vec4 blend = shadow + (vec4(1.0 - shadow.a) * color);
+    lowp float borderCoverage = 1.0 - texture2D(borderTexture, borderCoord).r;
+    lowp vec4 border = borderColor * vec4(borderCoverage);
+    blend = border + (vec4(1.0 - border.a) * blend);
+    gl_FragColor = blend * vec4(maskCoverage * opacity);
+}

=== added file 'src/UbuntuToolkit/privates/shaders/fillcornersshadowborder.vert'
--- src/UbuntuToolkit/privates/shaders/fillcornersshadowborder.vert	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/shaders/fillcornersshadowborder.vert	2016-12-14 07:25:05 +0000
@@ -0,0 +1,30 @@
+uniform highp mat4 matrix;
+
+attribute highp vec4 positionAttrib;
+attribute mediump vec2 maskCoordAttrib;
+attribute mediump vec2 shadowCoordAttrib;
+attribute mediump vec2 midShadowCoordAttrib;
+attribute mediump vec2 borderCoordAttrib;
+attribute lowp vec4 colorAttrib;
+attribute lowp vec4 shadowColorAttrib;
+attribute lowp vec4 borderColorAttrib;
+
+varying mediump vec2 maskCoord;
+varying mediump vec2 shadowCoord;
+varying mediump vec2 midShadowCoord;
+varying mediump vec2 borderCoord;
+varying lowp vec4 color;
+varying lowp vec4 shadowColor;
+varying lowp vec4 borderColor;
+
+void main()
+{
+    maskCoord = maskCoordAttrib;
+    shadowCoord = shadowCoordAttrib;
+    midShadowCoord = midShadowCoordAttrib;
+    borderCoord = borderCoordAttrib;
+    color = colorAttrib;
+    shadowColor = shadowColorAttrib;
+    borderColor = borderColorAttrib;
+    gl_Position = matrix * positionAttrib;
+}

=== added file 'src/UbuntuToolkit/privates/shaders/fillcornersshadowborder_opaque.frag'
--- src/UbuntuToolkit/privates/shaders/fillcornersshadowborder_opaque.frag	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/shaders/fillcornersshadowborder_opaque.frag	2016-12-14 07:25:05 +0000
@@ -0,0 +1,23 @@
+uniform sampler2D shadowTexture;
+uniform sampler2D borderTexture;
+
+varying mediump vec2 maskCoord;
+varying mediump vec2 shadowCoord;
+varying mediump vec2 midShadowCoord;
+varying mediump vec2 borderCoord;
+varying lowp vec4 color;
+varying lowp vec4 shadowColor;
+varying lowp vec4 borderColor;
+
+void main()
+{
+    lowp float maskCoverage = texture2D(shadowTexture, maskCoord).a;
+    mediump vec2 shadowTextureCoord = midShadowCoord - abs(shadowCoord - midShadowCoord);
+    lowp float shadowCoverage = 1.0 - texture2D(shadowTexture, shadowTextureCoord).r;
+    lowp vec4 shadow = shadowColor * vec4(shadowCoverage);
+    lowp vec4 blend = shadow + (vec4(1.0 - shadow.a) * color);
+    lowp float borderCoverage = 1.0 - texture2D(borderTexture, borderCoord).r;
+    lowp vec4 border = borderColor * vec4(borderCoverage);
+    blend = border + (vec4(1.0 - border.a) * blend);
+    gl_FragColor = blend * vec4(maskCoverage);
+}

=== modified file 'src/UbuntuToolkit/privates/shaders/frame.frag'
--- src/UbuntuToolkit/privates/shaders/frame.frag	2016-01-21 11:46:11 +0000
+++ src/UbuntuToolkit/privates/shaders/frame.frag	2016-12-14 07:25:05 +0000
@@ -1,33 +1,15 @@
-/*
- * Copyright 2016 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 as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY 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/>.
- *
- * Author: Loïc Molinari <[e-mail]>
- */
-
-uniform sampler2D texture;
+uniform sampler2D texture[2];
 uniform lowp float opacity;
-varying mediump vec2 outerCoord;
-varying mediump vec2 innerCoord;
+
+varying mediump vec2 texCoord1;
+varying mediump vec2 texCoord2;
 varying lowp vec4 color;
 
-void main(void)
+void main()
 {
-    lowp float shapeOut = texture2D(texture, outerCoord).r;
-    lowp float shapeIn = texture2D(texture, innerCoord).r;
-    // Fused multiply-add friendly version of (shapeOut * (1.0 - shapeIn))
-    lowp float shape = (shapeOut * -shapeIn) + shapeOut;
-    // shape is squared to make thinner corners (particularly visible at stroke 1).
-    gl_FragColor = vec4(shape * shape * opacity) * color;
+    lowp float outerShape = texture2D(texture[0], texCoord1).r;
+    lowp float innerShape = texture2D(texture[1], texCoord2).r;
+    // Fused multiply-add friendly version of (outerShape * (1.0 - innerShape))
+    lowp float shape = (outerShape * -innerShape) + outerShape;
+    gl_FragColor = vec4(shape * opacity) * color;
 }

=== removed file 'src/UbuntuToolkit/privates/shaders/frame.vert'
--- src/UbuntuToolkit/privates/shaders/frame.vert	2016-01-21 11:46:11 +0000
+++ src/UbuntuToolkit/privates/shaders/frame.vert	1970-01-01 00:00:00 +0000
@@ -1,34 +0,0 @@
-/*
- * Copyright 2016 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 as published by
- * the Free Software Foundation; version 3.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY 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/>.
- *
- * Author: Loïc Molinari <[e-mail]>
- */
-
-uniform highp mat4 matrix;
-attribute highp vec4 positionAttrib;
-attribute mediump vec2 outerCoordAttrib;
-attribute mediump vec2 innerCoordAttrib;
-attribute lowp vec4 colorAttrib;
-varying mediump vec2 outerCoord;
-varying mediump vec2 innerCoord;
-varying lowp vec4 color;
-
-void main()
-{
-    outerCoord = outerCoordAttrib;
-    innerCoord = innerCoordAttrib;
-    color = colorAttrib;
-    gl_Position = matrix * positionAttrib;
-}

=== added file 'src/UbuntuToolkit/privates/shaders/texture2.vert'
--- src/UbuntuToolkit/privates/shaders/texture2.vert	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/shaders/texture2.vert	2016-12-14 07:25:05 +0000
@@ -0,0 +1,18 @@
+uniform highp mat4 matrix;
+
+attribute highp vec4 positionAttrib;
+attribute mediump vec2 texCoord1Attrib;
+attribute mediump vec2 texCoord2Attrib;
+attribute lowp vec4 colorAttrib;
+
+varying mediump vec2 texCoord1;
+varying mediump vec2 texCoord2;
+varying lowp vec4 color;
+
+void main()
+{
+    texCoord1 = texCoord1Attrib;
+    texCoord2 = texCoord2Attrib;
+    color = colorAttrib;
+    gl_Position = matrix * positionAttrib;
+}

=== added file 'src/UbuntuToolkit/privates/ucshape.cpp'
--- src/UbuntuToolkit/privates/ucshape.cpp	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/ucshape.cpp	2016-12-14 07:25:05 +0000
@@ -0,0 +1,434 @@
+/*
+ * Copyright 2016 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY 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/>.
+ *
+ * Author: Loïc Molinari <[e-mail]>
+ */
+
+// FIXME(loicm) Add a description of the techniques and terms used in the shape
+//     item and nodes.
+
+// TODO(loicm): Try using half-sized textures to speed up CPU-based shadow
+//     rendering, switching to bilinear texture sampling at runtime. Evaluate
+//     the trade-off between texture creation (faster generation allows higher
+//     max radius and shadow sizes) and rendering speed.
+
+// TODO(loicm): Outer shadow rendering should provide a clippedShape (or
+//     knockedOutShape) mode that knocks out the pixels of the shape area. This
+//     is often what we need and that would allow to optimise rendering by
+//     removing transparent pixels (that are still rasterised, shaded and
+//     blended by the GPU...) with a dedicated mesh.
+
+// TODO(loicm): Add support for negative distances.
+
+#include "ucshape_p.h"
+
+#include <math.h>
+
+#include "ucshapedropshadownodes_p.h"
+#include "ucshapefillnodes_p.h"
+
+UCShape::UCShape(QQuickItem* parent)
+    : QQuickItem(parent)
+    , m_fillColor(qRgba(0xe9, 0x54, 0x20, 0xff))  // Ubuntu orange.
+    , m_dropShadowColor(qRgba(0, 0, 0, 0xff))
+    , m_innerShadowColor(qRgba(0, 0, 0, 0xff))
+    , m_borderColor(qRgba(0xff, 0xff, 0xff, 0xff))
+    , m_radius(0)
+    , m_dropShadowSize(0)
+    , m_dropShadowDistance(0)
+    , m_dropShadowAngle(0)
+    , m_innerShadowSize(0)
+    , m_innerShadowDistance(0)
+    , m_innerShadowAngle(0)
+    , m_borderSize(0)
+    // the flags must be in sync with the default values above!
+    , m_flags(FillCenterVisible)
+    , m_shape(Squircle)
+{
+    setFlag(ItemHasContents);
+}
+
+UCShape::Shape UCShape::shape() const
+{
+    return static_cast<Shape>(m_shape);
+}
+
+void UCShape::setShape(Shape shape)
+{
+    const quint8 newShape = shape;
+    if (m_shape != newShape) {
+        m_shape = newShape;
+        update();
+        Q_EMIT shapeChanged();
+    }
+}
+
+qreal UCShape::radius() const
+{
+    return unquantizeFromU16(m_radius);
+}
+
+void UCShape::setRadius(qreal radius)
+{
+    const quint16 quantizedRadius = quantizeToU16(radius);
+    if (m_radius != quantizedRadius) {
+        if ((m_radius > 0) != (quantizedRadius > 0)) {
+            if (qAlpha(m_fillColor) > 0) {
+                if (quantizedRadius > 0) {
+                    m_flags |= FillCornersVisible | DirtyFillCornersVisibility;
+                } else {
+                    m_flags = (m_flags & ~FillCornersVisible) | DirtyFillCornersVisibility;
+                }
+            }
+        }
+        m_radius = quantizedRadius;
+        update();
+        Q_EMIT radiusChanged();
+    }
+}
+
+QColor UCShape::fillColor() const
+{
+    return QColor(qRed(m_fillColor), qGreen(m_fillColor), qBlue(m_fillColor), qAlpha(m_fillColor));
+}
+
+void UCShape::setFillColor(const QColor& color)
+{
+    const QRgb rgbColor = qRgba(color.red(), color.green(), color.blue(), color.alpha());
+    if (m_fillColor != rgbColor) {
+        if ((qAlpha(m_fillColor) > 0) != (qAlpha(rgbColor) > 0)) {
+            if (qAlpha(rgbColor) > 0) {
+                m_flags |= FillCenterVisible | DirtyFillCenterVisibility;
+                if (m_radius > 0) {
+                    m_flags |= FillCornersVisible | DirtyFillCornersVisibility;
+                }
+            } else {
+                m_flags &= ~FillCenterVisible;
+                m_flags |= DirtyFillCenterVisibility;
+                if (m_radius > 0) {
+                    m_flags &= ~FillCornersVisible;
+                    m_flags |= DirtyFillCornersVisibility;
+                }
+            }
+        }
+        m_fillColor = rgbColor;
+        update();
+        Q_EMIT fillColorChanged();
+    }
+}
+
+qreal UCShape::dropShadowSize() const
+{
+    return unquantizeFromU16(m_dropShadowSize);
+}
+
+void UCShape::setDropShadowSize(qreal size)
+{
+    const quint16 quantizedSize = quantizeToU16(size);
+    if (m_dropShadowSize != quantizedSize) {
+        if (((m_dropShadowSize > 0) != (quantizedSize > 0))
+            && ((m_dropShadowDistance == 0) && (qAlpha(m_dropShadowColor) > 0))) {
+            if (quantizedSize > 0) {
+                m_flags |= DropShadowVisible;
+            } else {
+                m_flags &= ~DropShadowVisible;
+            }
+            m_flags |= DirtyDropShadowVisibility;
+        }
+        m_dropShadowSize = quantizedSize;
+        update();
+        Q_EMIT dropShadowSizeChanged();
+    }
+}
+
+qreal UCShape::dropShadowDistance() const
+{
+    return unquantizeFromU16(m_dropShadowDistance);
+}
+
+void UCShape::setDropShadowDistance(qreal distance)
+{
+    const quint16 quantizedDistance = quantizeToU16(distance);
+    if (m_dropShadowDistance != quantizedDistance) {
+        if ((m_dropShadowDistance > 0) != (quantizedDistance > 0)
+            && ((m_dropShadowSize == 0) && (qAlpha(m_dropShadowColor) > 0))) {
+            if (quantizedDistance > 0) {
+                m_flags |= DropShadowVisible;
+            } else {
+                m_flags &= ~DropShadowVisible;
+            }
+            m_flags |= DirtyDropShadowVisibility;
+        }
+        m_dropShadowDistance = quantizedDistance;
+        update();
+        Q_EMIT dropShadowDistanceChanged();
+    }
+}
+
+qreal UCShape::dropShadowAngle() const
+{
+    return unquantizeFromU16(m_dropShadowAngle);
+}
+
+void UCShape::setDropShadowAngle(qreal angle)
+{
+    double clampedAngle = fmod(static_cast<double>(angle), 360.0);
+    if (clampedAngle < 0.0) {
+        clampedAngle += 360.0;
+    }
+    const quint16 quantizedAngle = quantizeToU16Clamped(clampedAngle);
+    if (m_dropShadowAngle != quantizedAngle) {
+        m_dropShadowAngle = quantizedAngle;
+        update();
+        Q_EMIT dropShadowAngleChanged();
+    }
+}
+
+QColor UCShape::dropShadowColor() const
+{
+    return QColor(
+        qRed(m_dropShadowColor), qGreen(m_dropShadowColor), qBlue(m_dropShadowColor),
+        qAlpha(m_dropShadowColor));
+}
+
+void UCShape::setDropShadowColor(const QColor& color)
+{
+    const QRgb rgbColor = qRgba(color.red(), color.green(), color.blue(), color.alpha());
+    if (m_dropShadowColor != rgbColor) {
+        if (((qAlpha(m_dropShadowColor) > 0) != (qAlpha(rgbColor) > 0))
+            && ((m_dropShadowDistance > 0) || (m_dropShadowSize > 0))) {
+            if (qAlpha(rgbColor) > 0) {
+                m_flags |= DropShadowVisible;
+            } else {
+                m_flags &= ~DropShadowVisible;
+            }
+            m_flags |= DirtyDropShadowVisibility;
+        }
+        m_dropShadowColor = rgbColor;
+        update();
+        Q_EMIT dropShadowColorChanged();
+    }
+}
+
+qreal UCShape::innerShadowSize() const
+{
+    return unquantizeFromU16(m_innerShadowSize);
+}
+
+void UCShape::setInnerShadowSize(qreal size)
+{
+    const quint16 quantizedSize = quantizeToU16(size);
+    if (m_innerShadowSize != quantizedSize) {
+        m_innerShadowSize = quantizedSize;
+        update();
+        Q_EMIT innerShadowSizeChanged();
+    }
+}
+
+qreal UCShape::innerShadowDistance() const
+{
+    return unquantizeFromU16(m_innerShadowDistance);
+}
+
+void UCShape::setInnerShadowDistance(qreal distance)
+{
+    const quint16 quantizedDistance = quantizeToU16(distance);
+    if (m_innerShadowDistance != quantizedDistance) {
+        m_innerShadowDistance = quantizedDistance;
+        update();
+        Q_EMIT innerShadowDistanceChanged();
+    }
+}
+
+qreal UCShape::innerShadowAngle() const
+{
+    return unquantizeFromU16(m_innerShadowAngle);
+}
+
+void UCShape::setInnerShadowAngle(qreal angle)
+{
+    double clampedAngle = fmod(static_cast<double>(angle), 360.0);
+    if (clampedAngle < 0.0) {
+        clampedAngle += 360.0;
+    }
+    const quint16 quantizedAngle = quantizeToU16Clamped(clampedAngle);
+    if (m_innerShadowAngle != quantizedAngle) {
+        m_innerShadowAngle = quantizedAngle;
+        update();
+        Q_EMIT innerShadowAngleChanged();
+    }
+}
+
+QColor UCShape::innerShadowColor() const
+{
+    return QColor(
+        qRed(m_innerShadowColor), qGreen(m_innerShadowColor), qBlue(m_innerShadowColor),
+        qAlpha(m_innerShadowColor));
+}
+
+void UCShape::setInnerShadowColor(const QColor& color)
+{
+    const QRgb rgbColor = qRgba(color.red(), color.green(), color.blue(), color.alpha());
+    if (m_innerShadowColor != rgbColor) {
+        m_innerShadowColor = rgbColor;
+        update();
+        Q_EMIT innerShadowColorChanged();
+    }
+}
+
+qreal UCShape::borderSize() const
+{
+    return unquantizeFromU16(m_borderSize);
+}
+
+void UCShape::setBorderSize(qreal size)
+{
+    const quint16 quantizedSize = quantizeToU16(size);
+    if (m_borderSize != quantizedSize) {
+        m_borderSize = quantizedSize;
+        update();
+        Q_EMIT borderSizeChanged();
+    }
+}
+
+QColor UCShape::borderColor() const
+{
+    return QColor(
+        qRed(m_borderColor), qGreen(m_borderColor), qBlue(m_borderColor), qAlpha(m_borderColor));
+}
+
+void UCShape::setBorderColor(const QColor& color)
+{
+    const QRgb rgbColor = qRgba(color.red(), color.green(), color.blue(), color.alpha());
+    if (m_borderColor != rgbColor) {
+        m_borderColor = rgbColor;
+        update();
+        Q_EMIT borderColorChanged();
+    }
+}
+
+class UCShapeNode : public QSGNode
+{
+public:
+    UCShapeNode() : QSGNode(), m_nodes{} { DLOG("creating UCShapeNode"); }
+    ~UCShapeNode() { DLOG("detroying UCShapeNode"); }
+
+    // Sorted by rendering order from back to front.
+    enum NodeType { DropShadow = 0, FillCenter, FillCorners, NodeTypeCount };
+
+    QSGNode* node(NodeType type, bool instantiate = true)
+    {
+        DASSERT(static_cast<quint32>(type) < NodeTypeCount);
+
+        if (m_nodes[type]) {
+            return m_nodes[type];
+        } else if (!instantiate) {
+            return Q_NULLPTR;
+        } else {
+            switch (type) {
+                case DropShadow: m_nodes[DropShadow] = new UCShapeDropShadowNode; break;
+                case FillCenter: m_nodes[FillCenter] = new UCShapeFillCenterNode; break;
+                case FillCorners: m_nodes[FillCorners] = new UCShapeFillCornersNode; break;
+                default: DNOT_REACHED(); return Q_NULLPTR;
+            }
+            for (int i = type + 1; i < NodeTypeCount; ++i) {
+                if (m_nodes[i]) {
+                    insertChildNodeBefore(m_nodes[type], m_nodes[i]);
+                    return m_nodes[type];
+                }
+            }
+            appendChildNode(m_nodes[type]);
+            return m_nodes[type];
+        }
+    }
+
+private:
+    QSGNode* m_nodes[NodeTypeCount];
+};
+
+QSGNode* UCShape::updatePaintNode(QSGNode* oldNode, UpdatePaintNodeData*)
+{
+    const QSizeF itemSize(width(), height());
+    if (itemSize.isEmpty()) {
+        delete oldNode;
+        return Q_NULLPTR;
+    }
+
+    UCShapeNode* shapeNode;
+    if (oldNode) {
+        shapeNode = static_cast<UCShapeNode*>(oldNode);
+    } else {
+        shapeNode = new UCShapeNode;
+        // Make sure the right visibility is set on the nodes.
+        m_flags |= DirtyFlags;
+    }
+
+    // The strategy here is to instantiate shape node's children only when
+    // required (for instance corner nodes are instantiated only when radius is
+    // greater than 0). Once instantiated a child node is freed only when the
+    // parent is freed (for instance corner nodes are not freed when radius goes
+    // back to 0). That allows to minimise the memory usage to what the user
+    // needs (properties like radius and shadow sizes are set to 0 by default on
+    // purpose), to avoid complexifying the code and to avoid costly memory
+    // allocations when animating for instance a color back and forth to
+    // transparent (which would require a node deletion).
+
+    // Drop shadow node.
+    const bool dropShadowVisible = static_cast<bool>(m_flags & DropShadowVisible);
+    if (dropShadowVisible) {
+        static_cast<UCShapeDropShadowNode*>(shapeNode->node(UCShapeNode::DropShadow))->update(
+            itemSize, static_cast<UCShapeType>(m_shape), unquantizeFromU16(m_radius),
+            unquantizeFromU16(m_dropShadowSize), unquantizeFromU16(m_dropShadowAngle),
+            unquantizeFromU16(m_dropShadowDistance), m_dropShadowColor);
+    }
+    if (m_flags & DirtyDropShadowVisibility) {
+        static_cast<UCShapeDropShadowNode*>(shapeNode->node(UCShapeNode::DropShadow))->setVisible(
+            dropShadowVisible);
+    }
+
+    // Fill center node.
+    const bool fillCenterVisible = static_cast<bool>(m_flags & FillCenterVisible);
+    if (fillCenterVisible) {
+        static_cast<UCShapeFillCenterNode*>(shapeNode->node(UCShapeNode::FillCenter))->update(
+            itemSize, static_cast<UCShapeType>(m_shape), unquantizeFromU16(m_radius), m_fillColor,
+            unquantizeFromU16(m_innerShadowSize), unquantizeFromU16(m_innerShadowAngle),
+            unquantizeFromU16(m_innerShadowDistance), m_innerShadowColor,
+            unquantizeFromU16(m_borderSize), m_borderColor);
+    }
+    if (m_flags & DirtyFillCenterVisibility) {
+        static_cast<UCShapeFillCenterNode*>(shapeNode->node(UCShapeNode::FillCenter))->setVisible(
+            fillCenterVisible);
+    }
+
+    // Fill corners node.
+    const bool fillCornersVisible = static_cast<bool>(m_flags & FillCornersVisible);
+    if (fillCornersVisible) {
+        static_cast<UCShapeFillCornersNode*>(shapeNode->node(UCShapeNode::FillCorners))->update(
+            itemSize, static_cast<UCShapeType>(m_shape), unquantizeFromU16(m_radius), m_fillColor,
+            unquantizeFromU16(m_innerShadowSize), unquantizeFromU16(m_innerShadowAngle),
+            unquantizeFromU16(m_innerShadowDistance), m_innerShadowColor,
+            unquantizeFromU16(m_borderSize), m_borderColor);
+    }
+    if (m_flags & DirtyFillCornersVisibility) {
+        UCShapeFillCornersNode* node = static_cast<UCShapeFillCornersNode*>(
+            shapeNode->node(UCShapeNode::FillCorners, false));
+        if (node) {
+            node->setVisible(fillCornersVisible);
+        }
+    }
+
+    m_flags &= ~DirtyFlags;
+    return shapeNode;
+}

=== added file 'src/UbuntuToolkit/privates/ucshape_p.h'
--- src/UbuntuToolkit/privates/ucshape_p.h	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/ucshape_p.h	2016-12-14 07:25:05 +0000
@@ -0,0 +1,162 @@
+/*
+ * Copyright 2016 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY 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/>.
+ *
+ * Author: Loïc Molinari <[e-mail]>
+ */
+
+#ifndef UCSHAPE_P_H
+#define UCSHAPE_P_H
+
+#include <QtQuick/QQuickItem>
+
+#include <UbuntuToolkit/private/ucshapetexturefactory_p.h>
+
+class UCShape : public QQuickItem
+{
+    Q_OBJECT
+    Q_ENUMS(Shape)
+
+    // Shape of the corner.
+    Q_PROPERTY(Shape shape READ shape WRITE setShape NOTIFY shapeChanged)
+
+    // Radius of the corners in pixels.
+    Q_PROPERTY(qreal radius READ radius WRITE setRadius NOTIFY radiusChanged)
+
+    // Fill color of the shape.
+    Q_PROPERTY(QColor fillColor READ fillColor WRITE setFillColor NOTIFY fillColorChanged)
+
+    // Size of the drop shadow in pixels.
+    Q_PROPERTY(qreal dropShadowSize READ dropShadowSize WRITE setDropShadowSize
+               NOTIFY dropShadowSizeChanged)
+
+    // Offset of the drop shadow in pixels.
+    Q_PROPERTY(qreal dropShadowDistance READ dropShadowDistance WRITE setDropShadowDistance
+               NOTIFY dropShadowDistanceChanged)
+
+    // Offset angle of the drop shadow in degrees. The virtual light points to
+    // the left by default and is rotated counter clockwise.
+    Q_PROPERTY(qreal dropShadowAngle READ dropShadowAngle WRITE setDropShadowAngle
+               NOTIFY dropShadowAngleChanged)
+
+    // Color of the drop shadow.
+    Q_PROPERTY(QColor dropShadowColor READ dropShadowColor WRITE setDropShadowColor
+               NOTIFY dropShadowColorChanged)
+
+    // Size of the inner shadow in pixels.
+    Q_PROPERTY(qreal innerShadowSize READ innerShadowSize WRITE setInnerShadowSize
+               NOTIFY innerShadowSizeChanged)
+
+    // Offset of the inner shadow in pixels.
+    Q_PROPERTY(qreal innerShadowDistance READ innerShadowDistance WRITE setInnerShadowDistance
+               NOTIFY innerShadowDistanceChanged)
+
+    // Offset angle of the inner shadow in degrees. The virtual light points to
+    // the left by default and is rotated counter clockwise.
+    Q_PROPERTY(qreal innerShadowAngle READ innerShadowAngle WRITE setInnerShadowAngle
+               NOTIFY innerShadowAngleChanged)
+
+    // Color of the inner shadow.
+    Q_PROPERTY(QColor innerShadowColor READ innerShadowColor WRITE setInnerShadowColor
+               NOTIFY innerShadowColorChanged)
+
+    // Size of the border in pixels.
+    Q_PROPERTY(qreal borderSize READ borderSize WRITE setBorderSize NOTIFY borderSizeChanged)
+
+    // Color of the border.
+    Q_PROPERTY(QColor borderColor READ borderColor WRITE setBorderColor NOTIFY borderColorChanged)
+
+public:
+    UCShape(QQuickItem* parent = 0);
+
+    enum Shape { Squircle = UCShapeType::Squircle, Circle = UCShapeType::Circle };
+
+    Shape shape() const;
+    void setShape(Shape shape);
+    qreal radius() const;
+    void setRadius(qreal radius);
+    QColor fillColor() const;
+    void setFillColor(const QColor& fillColor);
+    qreal dropShadowSize() const;
+    void setDropShadowSize(qreal size);
+    qreal dropShadowDistance() const;
+    void setDropShadowDistance(qreal distance);
+    qreal dropShadowAngle() const;
+    void setDropShadowAngle(qreal angle);
+    QColor dropShadowColor() const;
+    void setDropShadowColor(const QColor& color);
+    qreal innerShadowSize() const;
+    void setInnerShadowSize(qreal size);
+    qreal innerShadowDistance() const;
+    void setInnerShadowDistance(qreal distance);
+    qreal innerShadowAngle() const;
+    void setInnerShadowAngle(qreal angle);
+    QColor innerShadowColor() const;
+    void setInnerShadowColor(const QColor& color);
+    qreal borderSize() const;
+    void setBorderSize(qreal size);
+    QColor borderColor() const;
+    void setBorderColor(const QColor& color);
+
+Q_SIGNALS:
+    void shapeChanged();
+    void radiusChanged();
+    void fillColorChanged();
+    void dropShadowSizeChanged();
+    void dropShadowDistanceChanged();
+    void dropShadowAngleChanged();
+    void dropShadowColorChanged();
+    void innerShadowSizeChanged();
+    void innerShadowDistanceChanged();
+    void innerShadowAngleChanged();
+    void innerShadowColorChanged();
+    void borderSizeChanged();
+    void borderColorChanged();
+
+private:
+    QSGNode* updatePaintNode(QSGNode* oldNode, UpdatePaintNodeData* data) Q_DECL_OVERRIDE;
+
+    enum {
+        DropShadowVisible          = (1 << 0),
+        FillCenterVisible          = (1 << 1),
+        FillCornersVisible         = (1 << 2),
+        DirtyDropShadowVisibility  = (1 << 3),
+        DirtyFillCenterVisibility  = (1 << 4),
+        DirtyFillCornersVisibility = (1 << 5),
+        DirtyFlags =
+            DirtyDropShadowVisibility | DirtyFillCenterVisibility | DirtyFillCornersVisibility
+    };
+
+    QRgb m_fillColor;
+    QRgb m_dropShadowColor;
+    QRgb m_innerShadowColor;
+    QRgb m_borderColor;
+    quint16 m_radius;
+    quint16 m_dropShadowSize;
+    quint16 m_dropShadowDistance;
+    quint16 m_dropShadowAngle;
+    quint16 m_innerShadowSize;
+    quint16 m_innerShadowDistance;
+    quint16 m_innerShadowAngle;
+    quint16 m_borderSize;
+    quint16 m_flags;
+    quint8 m_shape : 1;
+    quint8 __padding : 7;
+
+    Q_DISABLE_COPY(UCShape)
+};
+
+QML_DECLARE_TYPE(UCShape)
+
+#endif  // UCSHAPE_P_H

=== added file 'src/UbuntuToolkit/privates/ucshapedropshadownodes.cpp'
--- src/UbuntuToolkit/privates/ucshapedropshadownodes.cpp	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/ucshapedropshadownodes.cpp	2016-12-14 07:25:05 +0000
@@ -0,0 +1,175 @@
+/*
+ * Copyright 2016 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY 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/>.
+ *
+ * Author: Loïc Molinari <[e-mail]>
+ */
+
+#include "ucshapedropshadownodes_p.h"
+
+#include <QtGui/QGuiApplication>
+#include <QtGui/QOpenGLFunctions>
+
+#include "ucshaperesources_p.h"
+
+// The geometry is made of 9 vertices indexed with a triangle strip mode.
+//     0 --- 1 --- 2
+//     |  /  |  /  |
+//     3 --- 4 --- 5
+//     |  /  |  /  |
+//     6 --- 7 --- 8
+const quint16 indices[] = {
+    0, 3, 1, 4, 2, 5,
+    5, 3,  // Degenerate triangle.
+    3, 6, 4, 7, 5, 8
+};
+const int indexCount = ARRAY_SIZE(indices);
+const int vertexCount = 9;
+
+UCShapeDropShadowNode::UCShapeDropShadowNode()
+    : QSGGeometryNode()
+    , m_resources(vertexCount, indexCount)
+    , m_radius(0)
+    , m_shadow(0)
+    , m_shape(UCShapeType::Squircle)
+    , m_flags(0)
+{
+    DLOG("creating UCShapeDropShadowNode");
+    setFlag(QSGNode::UsePreprocess, true);
+    setMaterial(m_resources.material());
+    m_resources.opaqueMaterial()->setFlag(QSGMaterial::Blending);
+    setOpaqueMaterial(m_resources.opaqueMaterial());
+    memcpy(m_resources.geometry()->indexData(), indices, indexCount * sizeof(quint16));
+    setGeometry(m_resources.geometry());
+    qsgnode_set_description(this, QLatin1String("shapedropshadow"));
+}
+
+UCShapeDropShadowNode::~UCShapeDropShadowNode()
+{
+    DLOG("detroying UCShapeDropShadowNode");
+}
+
+void UCShapeDropShadowNode::preprocess()
+{
+    if (m_flags & DirtyMask) {
+        static_cast<UCShapeColorMaskMaterial<false>*>(
+            m_resources.material())->updateShadowTexture(
+                static_cast<UCShapeType>(m_shape), m_radius, m_shadow);
+        static_cast<UCShapeColorMaskMaterial<true>*>(
+            m_resources.opaqueMaterial())->updateShadowTexture(
+                static_cast<UCShapeType>(m_shape), m_radius, m_shadow);
+    }
+    m_flags &= ~DirtyMask;
+}
+
+void UCShapeDropShadowNode::setVisible(bool visible)
+{
+    DLOG("UCShapeDropShadowNode::setVisible %d", visible);
+    if (static_cast<bool>(m_flags & Visible) != visible) {
+        m_flags = (m_flags & ~Visible) | (visible ? Visible : 0);
+        markDirty(DirtySubtreeBlocked);
+    }
+}
+
+void UCShapeDropShadowNode::update(
+    const QSizeF& itemSize, UCShapeType type, float radius, float shadowSize, float shadowAngle,
+    float shadowDistance, QRgb shadowColor)
+{
+    UCShapeColorMaskResources::Vertex* v =
+        reinterpret_cast<UCShapeColorMaskResources::Vertex*>(m_resources.geometry()->vertexData());
+    float s, c;
+    sincosf((shadowAngle + 180.0f) * -(M_PI / 180.0f), &s, &c);
+    const float offsetX = roundf(c * shadowDistance);
+    const float offsetY = roundf(s * shadowDistance);
+    const float dpr = qGuiApp->devicePixelRatio();
+    const float w = floorf(static_cast<float>(itemSize.width()));
+    const float h = floorf(static_cast<float>(itemSize.height()));
+    // Rounded down since renderShape() doesn't support sub-pixel rendering.
+    const float maxSize = floorf(qMin(w, h) * 0.5f);
+    const float clampedRadius = qMin(floorf(radius), maxSize);
+    const quint32 packedShadowColor = packColor(shadowColor);
+    const float clampedShadow = qMin(floorf(shadowSize), maxSize);
+    const float border = 1.0f;
+    const float textureSize = (2.0f * clampedShadow + 2.0f * border + clampedRadius) * dpr;
+    const float textureSizeRounded = roundUp(static_cast<int>(textureSize), textureRounding);
+    const float textureOffset = (textureSizeRounded - textureSize) / textureSizeRounded;
+    const float textureFactor = ((1.0f - textureOffset) * dpr) / textureSize;
+    const float midW = w * 0.5f;
+    const float midH = h * 0.5f;
+    const float midShadowS = (border + clampedShadow + midW) * textureFactor + textureOffset;
+    const float midShadowT = (border + clampedShadow + midH) * textureFactor + textureOffset;
+
+    v[0].x = -clampedShadow + offsetX;
+    v[0].y = -clampedShadow + offsetY;
+    v[0].maskS = border * textureFactor + textureOffset;
+    v[0].maskT = border * textureFactor + textureOffset;
+    v[0].color = packedShadowColor;
+    v[1].x = midW + offsetX;
+    v[1].y = -clampedShadow + offsetY;
+    v[1].maskS = midShadowS;
+    v[1].maskT = border * textureFactor + textureOffset;
+    v[1].color = packedShadowColor;
+    v[2].x = w + clampedShadow + offsetX;
+    v[2].y = -clampedShadow + offsetY;
+    v[2].maskS = border * textureFactor + textureOffset;
+    v[2].maskT = border * textureFactor + textureOffset;
+    v[2].color = packedShadowColor;
+    v[3].x = -clampedShadow + offsetX;
+    v[3].y = midH + offsetY;
+    v[3].maskS = border * textureFactor + textureOffset;
+    v[3].maskT = midShadowT;
+    v[3].color = packedShadowColor;
+    v[4].x = midW + offsetX;
+    v[4].y = midH + offsetY;
+    v[4].maskS = midShadowS;
+    v[4].maskT = midShadowT;
+    v[4].color = packedShadowColor;
+    v[5].x = w + clampedShadow + offsetX;
+    v[5].y = midH + offsetY;
+    v[5].maskS = border * textureFactor + textureOffset;
+    v[5].maskT = midShadowT;
+    v[5].color = packedShadowColor;
+    v[6].x = -clampedShadow + offsetX;
+    v[6].y = h + clampedShadow + offsetY;
+    v[6].maskS = border * textureFactor + textureOffset;
+    v[6].maskT = border * textureFactor + textureOffset;
+    v[6].color = packedShadowColor;
+    v[7].x = midW + offsetX;
+    v[7].y = h + clampedShadow + offsetY;
+    v[7].maskS = midShadowS;
+    v[7].maskT = border * textureFactor + textureOffset;
+    v[7].color = packedShadowColor;
+    v[8].x = w + clampedShadow + offsetX;
+    v[8].y = h + clampedShadow + offsetY;
+    v[8].maskS = border * textureFactor + textureOffset;
+    v[8].maskT = border * textureFactor + textureOffset;
+    v[8].color = packedShadowColor;
+    markDirty(QSGNode::DirtyGeometry);
+
+    // Update data for the preprocess() call.
+    const quint16 deviceShadow = static_cast<quint16>(clampedShadow * dpr);
+    if (m_shadow != deviceShadow) {
+        m_shadow = deviceShadow;
+        m_flags |= DirtyShadow;
+    }
+    const quint16 deviceRadius = static_cast<quint16>(clampedRadius * dpr);
+    if (m_radius != deviceRadius) {
+        m_radius = deviceRadius;
+        m_flags |= DirtyRadius;
+    }
+    if (m_shape != static_cast<quint8>(type)) {
+        m_shape = static_cast<quint8>(type);
+        m_flags |= DirtyShape;
+    }
+}

=== added file 'src/UbuntuToolkit/privates/ucshapedropshadownodes_p.h'
--- src/UbuntuToolkit/privates/ucshapedropshadownodes_p.h	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/ucshapedropshadownodes_p.h	2016-12-14 07:25:05 +0000
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2016 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY 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/>.
+ *
+ * Author: Loïc Molinari <[e-mail]>
+ */
+
+#ifndef UCSHAPEDROPSHADOWNODES_P_H
+#define UCSHAPEDROPSHADOWNODES_P_H
+
+#include <QtQuick/QSGNode>
+
+#include <UbuntuToolkit/private/ucshaperesources_p.h>
+
+class UCShapeDropShadowNode : public QSGGeometryNode
+{
+public:
+    UCShapeDropShadowNode();
+    ~UCShapeDropShadowNode();
+
+    void preprocess() Q_DECL_OVERRIDE;
+    bool isSubtreeBlocked() const Q_DECL_OVERRIDE { return !(m_flags & Visible); }
+
+    void setVisible(bool visible);
+    void update(
+        const QSizeF& itemSize, UCShapeType type, float radius, float shadowSize, float shadowAngle,
+        float shadowDistance, QRgb shadowColor);
+
+private:
+    enum {
+        DirtyRadius = (1 << 0),
+        DirtyShadow = (1 << 1),
+        DirtyShape  = (1 << 2),
+        DirtyMask   = (DirtyRadius | DirtyShadow | DirtyShape),
+        Visible     = (1 << 3),
+        Blending    = (1 << 4)
+    };
+
+    UCShapeColorMaskResources m_resources;
+    quint16 m_radius;
+    quint16 m_shadow;
+    quint8 m_shape;
+    quint8 m_flags;
+};
+
+#endif  // UCSHAPEDROPSHADOWNODES_P_H

=== added file 'src/UbuntuToolkit/privates/ucshapefillnodes.cpp'
--- src/UbuntuToolkit/privates/ucshapefillnodes.cpp	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/ucshapefillnodes.cpp	2016-12-14 07:25:05 +0000
@@ -0,0 +1,1431 @@
+/*
+ * Copyright 2016 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY 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/>.
+ *
+ * Author: Loïc Molinari <[e-mail]>
+ */
+
+// FIXME(loicm) The midShadow coords force a dependent texture read which is
+//     quite slow on some platforms. We should maybe add geometry to deal with
+//     the coords inversion. That would add complexity but improve perf.
+
+#include "ucshapefillnodes_p.h"
+
+#include <QtGui/QOpenGLFunctions>
+#include <QtGui/QGuiApplication>
+
+UCShapeFillCenterNode::UCShapeFillCenterNode()
+    : QSGGeometryNode()
+    , m_resources(Q_NULLPTR)
+    , m_radius(0)
+    , m_shadow(0)
+    , m_borderRadius(0)
+    , m_flags(0)
+    , m_shape(UCShapeType::Squircle)
+{
+    DLOG("creating UCShapeFillCenterNode");
+    qsgnode_set_description(this, QLatin1String("shapefillcenter"));
+}
+
+UCShapeFillCenterNode::~UCShapeFillCenterNode()
+{
+    DLOG("detroying UCShapeFillCenterNode");
+    delete m_resources;
+}
+
+void UCShapeFillCenterNode::preprocess()
+{
+    DASSERT(m_flags & Textured);
+
+    // FIXME(loicm) Could be made more consise (texture update methods in the resources?).
+
+    switch (m_flags & StyleMask) {
+    case (HasColor | HasShadow):
+        if (m_flags & (DirtyRadius | DirtyShadow | DirtyShape)) {
+            static_cast<UCShapeFillCenterShadowMaterial<false>*>(
+                m_resources->material())->updateShadowTexture(
+                    static_cast<UCShapeType>(m_shape), m_radius, m_shadow);
+            static_cast<UCShapeFillCenterShadowMaterial<true>*>(
+                m_resources->opaqueMaterial())->updateShadowTexture(
+                    static_cast<UCShapeType>(m_shape), m_radius, m_shadow);
+        }
+        break;
+
+    case (HasColor | HasBorder):
+        if (m_flags & (DirtyBorderRadius | DirtyShape)) {
+            static_cast<UCShapeFillCenterBorderMaterial<false>*>(
+                m_resources->material())->updateBorderTexture(
+                    static_cast<UCShapeType>(m_shape), m_borderRadius);
+            static_cast<UCShapeFillCenterBorderMaterial<true>*>(
+                m_resources->opaqueMaterial())->updateBorderTexture(
+                    static_cast<UCShapeType>(m_shape), m_borderRadius);
+        }
+        break;
+
+    case (HasColor | HasShadow | HasBorder):
+        if (m_flags & (DirtyRadius | DirtyShadow | DirtyShape)) {
+            static_cast<UCShapeFillCenterShadowBorderMaterial<false>*>(
+                m_resources->material())->updateShadowTexture(
+                    static_cast<UCShapeType>(m_shape), m_radius, m_shadow);
+            static_cast<UCShapeFillCenterShadowBorderMaterial<true>*>(
+                m_resources->opaqueMaterial())->updateShadowTexture(
+                    static_cast<UCShapeType>(m_shape), m_radius, m_shadow);
+        }
+        if (m_flags & (DirtyBorderRadius | DirtyShape)) {
+            static_cast<UCShapeFillCenterShadowBorderMaterial<false>*>(
+                m_resources->material())->updateBorderTexture(
+                    static_cast<UCShapeType>(m_shape), m_borderRadius);
+            static_cast<UCShapeFillCenterShadowBorderMaterial<true>*>(
+                m_resources->opaqueMaterial())->updateBorderTexture(
+                    static_cast<UCShapeType>(m_shape), m_borderRadius);
+        }
+        break;
+
+    default:
+        NOT_REACHED();
+    }
+
+    m_flags &= ~DirtyMask;
+}
+
+void UCShapeFillCenterNode::setVisible(bool visible)
+{
+    DLOG("UCShapeFillCenterNode::setVisible %d", visible);
+    if (static_cast<bool>(m_flags & Visible) != visible) {
+        m_flags = (m_flags & ~Visible) | (visible ? Visible : 0);
+        markDirty(DirtySubtreeBlocked);
+    }
+}
+
+void UCShapeFillCenterNode::update(
+    const QSizeF& itemSize, UCShapeType type, float radius, QRgb color, float shadowSize,
+    float shadowAngle, float shadowDistance, QRgb shadowColor, float borderSize, QRgb borderColor)
+{
+    // Without border, the geometry is made of 8 vertices indexed with a
+    // triangle strip mode. With border, the geometry is made of 13 vertices
+    // indexed with a triangle strip mode.
+    //
+    //      Without border:        With border:
+    //         0 ----- 1            0 - 1 - 2
+    //       /           \        /     |     \   ("-Werror=comment" GCC guard)
+    //     2               3    3       |       4
+    //     |               |    |       |       |
+    //     |               |    5 ----- 6 ----- 7
+    //     |               |    |       |       |
+    //     4               5    8       |       9
+    //       \           /        \     |     /
+    //         6 ----- 7            10 -11-12
+    const quint16 noBorderIndices[] = {
+        2, 4, 0, 6, 1, 7, 3, 5
+    };
+    const quint16 borderIndices[] = {
+        3, 5, 0, 6, 1, 7, 2, 4,
+        4, 8,  // Degenerate triangle.
+        8, 10, 5, 11, 6, 12, 7, 9
+    };
+    const int noBorderIndexCount = ARRAY_SIZE(noBorderIndices);
+    const int borderIndexCount = ARRAY_SIZE(borderIndices);
+    const int noBorderVertexCount = 8;
+    const int borderVertexCount = 13;
+
+    quint16 style = ((shadowSize <= 0.0f && shadowDistance <= 0.0f) || (qAlpha(shadowColor) == 0)) ?
+        HasColor : (HasColor | HasShadow);
+    if (borderSize >= 1.0f) {
+        style |= HasBorder;
+    }
+
+    // Create new material/geometry set if needed.
+    if (style != (m_flags & StyleMask)) {
+        delete m_resources;
+        switch (style) {
+        case HasColor:
+            m_resources = new UCShapeColorResources(noBorderVertexCount, noBorderIndexCount);
+            memcpy(m_resources->geometry()->indexData(), noBorderIndices,
+                   noBorderIndexCount * sizeof(quint16));
+            setFlag(QSGNode::UsePreprocess, false);
+            break;
+        case (HasColor | HasShadow):
+            m_resources = new UCShapeFillCenterShadowResources(
+                noBorderVertexCount, noBorderIndexCount);
+            memcpy(m_resources->geometry()->indexData(), noBorderIndices,
+                   noBorderIndexCount * sizeof(quint16));
+            setFlag(QSGNode::UsePreprocess, true);
+            break;
+        case (HasColor | HasBorder):
+            m_resources = new UCShapeFillCenterBorderResources(borderVertexCount, borderIndexCount);
+            memcpy(m_resources->geometry()->indexData(), borderIndices,
+                   borderIndexCount * sizeof(quint16));
+            setFlag(QSGNode::UsePreprocess, true);
+            break;
+        case (HasColor | HasShadow | HasBorder):
+            m_resources = new UCShapeFillCenterShadowBorderResources(
+                borderVertexCount, borderIndexCount);
+            memcpy(m_resources->geometry()->indexData(), borderIndices,
+                   borderIndexCount * sizeof(quint16));
+            setFlag(QSGNode::UsePreprocess, true);
+            break;
+        default:
+            NOT_REACHED();
+        }
+        setMaterial(m_resources->material());
+        setOpaqueMaterial(m_resources->opaqueMaterial());
+        setGeometry(m_resources->geometry());
+        m_flags = (m_flags & ~StyleMask) | style | DirtyMask;
+    }
+
+    const float dpr = qGuiApp->devicePixelRatio();
+    const float w = floorf(static_cast<float>(itemSize.width()));
+    const float h = floorf(static_cast<float>(itemSize.height()));
+    // Rounded down since Shadow doesn't support sub-pixel rendering.
+    const float maxSize = floorf(qMin(w, h) * 0.5f);
+    const float clampedRadius = qMin(floorf(radius), maxSize);
+    const quint32 packedColor = packColor(color);
+
+    // Update geometry depending on the style.
+    switch (style) {
+    case HasColor: {
+        UCShapeColorResources::Vertex* v =
+            reinterpret_cast<UCShapeColorResources::Vertex*>(m_resources->geometry()->vertexData());
+        v[0].x = clampedRadius;
+        v[0].y = 0.0f;
+        v[0].color = packedColor;
+        v[1].x = w - clampedRadius;
+        v[1].y = 0.0f;
+        v[1].color = packedColor;
+        v[2].x = 0.0f;
+        v[2].y = clampedRadius;
+        v[2].color = packedColor;
+        v[3].x = w;
+        v[3].y = clampedRadius;
+        v[3].color = packedColor;
+        v[4].x = 0.0f;
+        v[4].y = h - clampedRadius;
+        v[4].color = packedColor;
+        v[5].x = w;
+        v[5].y = h - clampedRadius;
+        v[5].color = packedColor;
+        v[6].x = clampedRadius;
+        v[6].y = h;
+        v[6].color = packedColor;
+        v[7].x = w - clampedRadius;
+        v[7].y = h;
+        v[7].color = packedColor;
+        markDirty(QSGNode::DirtyGeometry);
+        break;
+    }
+
+    case (HasColor | HasShadow): {
+        UCShapeFillCenterShadowResources::Vertex* v =
+            reinterpret_cast<UCShapeFillCenterShadowResources::Vertex*>(
+                m_resources->geometry()->vertexData());
+        float s, c;
+        sincosf(shadowAngle * -(M_PI / 180.0f), &s, &c);
+        const float offsetX = roundf(c * shadowDistance);
+        const float offsetY = roundf(s * shadowDistance);
+        const float clampedShadow = qMin(floorf(shadowSize), maxSize);
+        const float border = 1.0f;
+        const float textureSize = (2.0f * clampedShadow + 2.0f * border + clampedRadius) * dpr;
+        const float textureSizeRounded = roundUp(static_cast<int>(textureSize), textureRounding);
+        const float textureOffset = (textureSizeRounded - textureSize) / textureSizeRounded;
+        const float textureFactor = ((1.0f - textureOffset) * dpr) / textureSize;
+        const float midShadowS =
+            (border + clampedShadow + (w * 0.5f)) * textureFactor + textureOffset;
+        const float midShadowT =
+            (border + clampedShadow + (h * 0.5f)) * textureFactor + textureOffset;
+        const quint32 packedShadowColor = packColor(shadowColor);
+        v[0].x = clampedRadius;
+        v[0].y = 0.0f;
+        v[0].shadowS = (offsetX + border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[0].shadowT = (offsetY + border + clampedShadow) * textureFactor + textureOffset;
+        v[0].midShadowS = midShadowS;
+        v[0].midShadowT = midShadowT;
+        v[0].color = packedColor;
+        v[0].shadowColor = packedShadowColor;
+        v[1].x = w - clampedRadius;
+        v[1].y = 0.0f;
+        v[1].shadowS =
+            (offsetX + border + clampedShadow + (w - clampedRadius)) * textureFactor + textureOffset;
+        v[1].shadowT = (offsetY + border + clampedShadow) * textureFactor + textureOffset;
+        v[1].midShadowS = midShadowS;
+        v[1].midShadowT = midShadowT;
+        v[1].color = packedColor;
+        v[1].shadowColor = packedShadowColor;
+        v[2].x = 0.0f;
+        v[2].y = clampedRadius;
+        v[2].shadowS = (offsetX + border + clampedShadow) * textureFactor + textureOffset;
+        v[2].shadowT = (offsetY + border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[2].midShadowS = midShadowS;
+        v[2].midShadowT = midShadowT;
+        v[2].color = packedColor;
+        v[2].shadowColor = packedShadowColor;
+        v[3].x = w;
+        v[3].y = clampedRadius;
+        v[3].shadowS = (offsetX + border + clampedShadow + w) * textureFactor + textureOffset;
+        v[3].shadowT = (offsetY + border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[3].midShadowS = midShadowS;
+        v[3].midShadowT = midShadowT;
+        v[3].color = packedColor;
+        v[3].shadowColor = packedShadowColor;
+        v[4].x = 0.0f;
+        v[4].y = h - clampedRadius;
+        v[4].shadowS = (offsetX + border + clampedShadow) * textureFactor + textureOffset;
+        v[4].shadowT =
+            (offsetY + border + clampedShadow + (h - clampedRadius)) * textureFactor + textureOffset;
+        v[4].midShadowS = midShadowS;
+        v[4].midShadowT = midShadowT;
+        v[4].color = packedColor;
+        v[4].shadowColor = packedShadowColor;
+        v[5].x = w;
+        v[5].y = h - clampedRadius;
+        v[5].shadowS = (offsetX + border + clampedShadow + w) * textureFactor + textureOffset;
+        v[5].shadowT =
+            (offsetY + border + clampedShadow + (h - clampedRadius)) * textureFactor + textureOffset;
+        v[5].midShadowS = midShadowS;
+        v[5].midShadowT = midShadowT;
+        v[5].color = packedColor;
+        v[5].shadowColor = packedShadowColor;
+        v[6].x = clampedRadius;
+        v[6].y = h;
+        v[6].shadowS = (offsetX + border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[6].shadowT = (offsetY + border + clampedShadow + h) * textureFactor + textureOffset;
+        v[6].midShadowS = midShadowS;
+        v[6].midShadowT = midShadowT;
+        v[6].color = packedColor;
+        v[6].shadowColor = packedShadowColor;
+        v[7].x = w - clampedRadius;
+        v[7].y = h;
+        v[7].shadowS =
+            (offsetX + border + clampedShadow + (w - clampedRadius)) * textureFactor + textureOffset;
+        v[7].shadowT = (offsetY + border + clampedShadow + h) * textureFactor + textureOffset;
+        v[7].midShadowS = midShadowS;
+        v[7].midShadowT = midShadowT;
+        v[7].color = packedColor;
+        v[7].shadowColor = packedShadowColor;
+        markDirty(QSGNode::DirtyGeometry);
+
+        // Update data for the preprocess() call.
+        const quint16 deviceShadow = static_cast<quint16>(clampedShadow * dpr);
+        if (m_shadow != deviceShadow) {
+            m_shadow = deviceShadow;
+            m_flags |= DirtyShadow;
+        }
+        const quint16 deviceRadius = static_cast<quint16>(clampedRadius * dpr);
+        if (m_radius != deviceRadius) {
+            m_radius = deviceRadius;
+            m_flags |= DirtyRadius;
+        }
+        if (m_shape != static_cast<quint8>(type)) {
+            m_shape = static_cast<quint8>(type);
+            m_flags |= DirtyShape;
+        }
+        break;
+    }
+
+    case (HasColor | HasBorder): {
+        UCShapeFillCenterBorderResources::Vertex* v =
+            reinterpret_cast<UCShapeFillCenterBorderResources::Vertex*>(
+                m_resources->geometry()->vertexData());
+        const float midW = w * 0.5f;
+        const float midH = h * 0.5f;
+        const float clampedBorder = qMin(floorf(borderSize), maxSize);
+        const float clampedBorderRadius =
+            floorf(((maxSize - clampedBorder) / maxSize) * clampedRadius);
+        const float textureBorder = 1.0f;
+        const float borderTextureSize = (2.0f * textureBorder + clampedBorderRadius) * dpr;
+        const float borderTextureSizeRounded =
+            roundUp(static_cast<int>(borderTextureSize), textureRounding);
+        const float borderTextureOffset =
+            (borderTextureSizeRounded - borderTextureSize) / borderTextureSizeRounded;
+        const float borderTextureFactor = ((1.0f - borderTextureOffset) * dpr) / borderTextureSize;
+        const float borderOffset = -(clampedBorder - textureBorder);
+        const quint32 packedBorderColor = packColor(borderColor);
+        v[0].x = clampedRadius;
+        v[0].y = 0.0f;
+        v[0].borderS = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[0].borderT = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[0].color = packedColor;
+        v[0].borderColor = packedBorderColor;
+        v[1].x = midW;
+        v[1].y = 0.0f;
+        v[1].borderS = (midW + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[1].borderT = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[1].color = packedColor;
+        v[1].borderColor = packedBorderColor;
+        v[2].x = w - clampedRadius;
+        v[2].y = 0.0f;
+        v[2].borderS = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[2].borderT = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[2].color = packedColor;
+        v[2].borderColor = packedBorderColor;
+        v[3].x = 0.0f;
+        v[3].y = clampedRadius;
+        v[3].borderS = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[3].borderT = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[3].color = packedColor;
+        v[3].borderColor = packedBorderColor;
+        v[4].x = w;
+        v[4].y = clampedRadius;
+        v[4].borderS = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[4].borderT = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[4].color = packedColor;
+        v[4].borderColor = packedBorderColor;
+        v[5].x = 0.0f;
+        v[5].y = midH;
+        v[5].borderS = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[5].borderT = (midH + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[5].color = packedColor;
+        v[5].borderColor = packedBorderColor;
+        v[6].x = midW;
+        v[6].y = midH;
+        v[6].borderS = (midW + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[6].borderT = (midH + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[6].color = packedColor;
+        v[6].borderColor = packedBorderColor;
+        v[7].x = w;
+        v[7].y = midH;
+        v[7].borderS = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[7].borderT = (midH + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[7].color = packedColor;
+        v[7].borderColor = packedBorderColor;
+        v[8].x = 0.0f;
+        v[8].y = h - clampedRadius;
+        v[8].borderS = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[8].borderT = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[8].color = packedColor;
+        v[8].borderColor = packedBorderColor;
+        v[9].x = w;
+        v[9].y = h - clampedRadius;
+        v[9].borderS = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[9].borderT = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[9].color = packedColor;
+        v[9].borderColor = packedBorderColor;
+        v[10].x = clampedRadius;
+        v[10].y = h;
+        v[10].borderS = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[10].borderT = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[10].color = packedColor;
+        v[10].borderColor = packedBorderColor;
+        v[11].x = midW;
+        v[11].y = h;
+        v[11].borderS = (midW + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[11].borderT = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[11].color = packedColor;
+        v[11].borderColor = packedBorderColor;
+        v[12].x = w - clampedRadius;
+        v[12].y = h;
+        v[12].borderS = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[12].borderT = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[12].color = packedColor;
+        v[12].borderColor = packedBorderColor;
+        markDirty(QSGNode::DirtyGeometry);
+
+        // Update data for the preprocess() call.
+        const quint16 deviceRadius = static_cast<quint16>(clampedRadius * dpr);
+        if (m_radius != deviceRadius) {
+            m_radius = deviceRadius;
+            m_flags |= DirtyRadius;
+        }
+        const quint16 deviceBorderRadius = static_cast<quint16>(clampedBorderRadius * dpr);
+        if (m_borderRadius != deviceBorderRadius) {
+            m_borderRadius = deviceBorderRadius;
+            m_flags |= DirtyBorderRadius;
+        }
+        if (m_shape != static_cast<quint8>(type)) {
+            m_shape = static_cast<quint8>(type);
+            m_flags |= DirtyShape;
+        }
+        break;
+    }
+
+    case (HasColor | HasShadow | HasBorder): {
+        UCShapeFillCenterShadowBorderResources::Vertex* v =
+            reinterpret_cast<UCShapeFillCenterShadowBorderResources::Vertex*>(
+                m_resources->geometry()->vertexData());
+        float s, c;
+        sincosf(shadowAngle * -(M_PI / 180.0f), &s, &c);
+        const float offsetX = roundf(c * shadowDistance);
+        const float offsetY = roundf(s * shadowDistance);
+        const float clampedShadow = qMin(floorf(shadowSize), maxSize);
+        const float border = 1.0f;
+        const float textureSize = (2.0f * clampedShadow + 2.0f * border + clampedRadius) * dpr;
+        const float textureSizeRounded = roundUp(static_cast<int>(textureSize), textureRounding);
+        const float textureOffset = (textureSizeRounded - textureSize) / textureSizeRounded;
+        const float textureFactor = ((1.0f - textureOffset) * dpr) / textureSize;
+        const float midW = w * 0.5f;
+        const float midH = h * 0.5f;
+        const float midShadowS = (border + clampedShadow + midW) * textureFactor + textureOffset;
+        const float midShadowT = (border + clampedShadow + midH) * textureFactor + textureOffset;
+        const float clampedBorder = qMin(floorf(borderSize), maxSize);
+        const float clampedBorderRadius =
+            floorf(((maxSize - clampedBorder) / maxSize) * clampedRadius);
+        const float textureBorder = 1.0f;
+        const float borderTextureSize = (2.0f * textureBorder + clampedBorderRadius) * dpr;
+        const float borderTextureSizeRounded =
+            roundUp(static_cast<int>(borderTextureSize), textureRounding);
+        const float borderTextureOffset =
+            (borderTextureSizeRounded - borderTextureSize) / borderTextureSizeRounded;
+        const float borderTextureFactor = ((1.0f - borderTextureOffset) * dpr) / borderTextureSize;
+        const float borderOffset = -(clampedBorder - textureBorder);
+        const quint32 packedShadowColor = packColor(shadowColor);
+        const quint32 packedBorderColor = packColor(borderColor);
+        v[0].x = clampedRadius;
+        v[0].y = 0.0f;
+        v[0].shadowS = (offsetX + border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[0].shadowT = (offsetY + border + clampedShadow) * textureFactor + textureOffset;
+        v[0].midShadowS = midShadowS;
+        v[0].midShadowT = midShadowT;
+        v[0].borderS = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[0].borderT = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[0].color = packedColor;
+        v[0].shadowColor = packedShadowColor;
+        v[0].borderColor = packedBorderColor;
+        v[1].x = midW;
+        v[1].y = 0.0f;
+        v[1].shadowS = (offsetX + border + clampedShadow + midW) * textureFactor + textureOffset;
+        v[1].shadowT = (offsetY + border + clampedShadow) * textureFactor + textureOffset;
+        v[1].midShadowS = midShadowS;
+        v[1].midShadowT = midShadowT;
+        v[1].borderS = (midW + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[1].borderT = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[1].color = packedColor;
+        v[1].shadowColor = packedShadowColor;
+        v[1].borderColor = packedBorderColor;
+        v[2].x = w - clampedRadius;
+        v[2].y = 0.0f;
+        v[2].shadowS =
+            (offsetX + border + clampedShadow + (w - clampedRadius)) * textureFactor + textureOffset;
+        v[2].shadowT = (offsetY + border + clampedShadow) * textureFactor + textureOffset;
+        v[2].midShadowS = midShadowS;
+        v[2].midShadowT = midShadowT;
+        v[2].borderS = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[2].borderT = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[2].color = packedColor;
+        v[2].shadowColor = packedShadowColor;
+        v[2].borderColor = packedBorderColor;
+        v[3].x = 0.0f;
+        v[3].y = clampedRadius;
+        v[3].shadowS = (offsetX + border + clampedShadow) * textureFactor + textureOffset;
+        v[3].shadowT = (offsetY + border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[3].midShadowS = midShadowS;
+        v[3].midShadowT = midShadowT;
+        v[3].borderS = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[3].borderT = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[3].color = packedColor;
+        v[3].shadowColor = packedShadowColor;
+        v[3].borderColor = packedBorderColor;
+        v[4].x = w;
+        v[4].y = clampedRadius;
+        v[4].shadowS = (offsetX + border + clampedShadow + w) * textureFactor + textureOffset;
+        v[4].shadowT = (offsetY + border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[4].midShadowS = midShadowS;
+        v[4].midShadowT = midShadowT;
+        v[4].borderS = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[4].borderT = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[4].color = packedColor;
+        v[4].shadowColor = packedShadowColor;
+        v[4].borderColor = packedBorderColor;
+        v[5].x = 0.0f;
+        v[5].y = midH;
+        v[5].shadowS = (offsetX + border + clampedShadow) * textureFactor + textureOffset;
+        v[5].shadowT = (offsetY + border + clampedShadow + midH) * textureFactor + textureOffset;
+        v[5].midShadowS = midShadowS;
+        v[5].midShadowT = midShadowT;
+        v[5].borderS = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[5].borderT = (midH + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[5].color = packedColor;
+        v[5].shadowColor = packedShadowColor;
+        v[5].borderColor = packedBorderColor;
+        v[6].x = midW;
+        v[6].y = midH;
+        v[6].shadowS = (offsetX + border + clampedShadow + midW) * textureFactor + textureOffset;
+        v[6].shadowT = (offsetY + border + clampedShadow + midH) * textureFactor + textureOffset;
+        v[6].midShadowS = midShadowS;
+        v[6].midShadowT = midShadowT;
+        v[6].borderS = (midW + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[6].borderT = (midH + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[6].color = packedColor;
+        v[6].shadowColor = packedShadowColor;
+        v[6].borderColor = packedBorderColor;
+        v[7].x = w;
+        v[7].y = midH;
+        v[7].shadowS = (offsetX + border + clampedShadow + w) * textureFactor + textureOffset;
+        v[7].shadowT = (offsetY + border + clampedShadow + midH) * textureFactor + textureOffset;
+        v[7].midShadowS = midShadowS;
+        v[7].midShadowT = midShadowT;
+        v[7].borderS = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[7].borderT = (midH + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[7].color = packedColor;
+        v[7].shadowColor = packedShadowColor;
+        v[7].borderColor = packedBorderColor;
+        v[8].x = 0.0f;
+        v[8].y = h - clampedRadius;
+        v[8].shadowS = (offsetX + border + clampedShadow) * textureFactor + textureOffset;
+        v[8].shadowT =
+            (offsetY + border + clampedShadow + (h - clampedRadius)) * textureFactor + textureOffset;
+        v[8].midShadowS = midShadowS;
+        v[8].midShadowT = midShadowT;
+        v[8].borderS = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[8].borderT = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[8].color = packedColor;
+        v[8].shadowColor = packedShadowColor;
+        v[8].borderColor = packedBorderColor;
+        v[9].x = w;
+        v[9].y = h - clampedRadius;
+        v[9].shadowS = (offsetX + border + clampedShadow + w) * textureFactor + textureOffset;
+        v[9].shadowT =
+            (offsetY + border + clampedShadow + (h - clampedRadius)) * textureFactor + textureOffset;
+        v[9].midShadowS = midShadowS;
+        v[9].midShadowT = midShadowT;
+        v[9].borderS = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[9].borderT = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[9].color = packedColor;
+        v[9].shadowColor = packedShadowColor;
+        v[9].borderColor = packedBorderColor;
+        v[10].x = clampedRadius;
+        v[10].y = h;
+        v[10].shadowS = (offsetX + border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[10].shadowT = (offsetY + border + clampedShadow + h) * textureFactor + textureOffset;
+        v[10].midShadowS = midShadowS;
+        v[10].midShadowT = midShadowT;
+        v[10].borderS = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[10].borderT = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[10].color = packedColor;
+        v[10].shadowColor = packedShadowColor;
+        v[10].borderColor = packedBorderColor;
+        v[11].x = midW;
+        v[11].y = h;
+        v[11].shadowS = (offsetX + border + clampedShadow + midW) * textureFactor + textureOffset;
+        v[11].shadowT = (offsetY + border + clampedShadow + h) * textureFactor + textureOffset;
+        v[11].midShadowS = midShadowS;
+        v[11].midShadowT = midShadowT;
+        v[11].borderS = (midW + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[11].borderT = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[11].color = packedColor;
+        v[11].shadowColor = packedShadowColor;
+        v[11].borderColor = packedBorderColor;
+        v[12].x = w - clampedRadius;
+        v[12].y = h;
+        v[12].shadowS =
+            (offsetX + border + clampedShadow + (w - clampedRadius)) * textureFactor + textureOffset;
+        v[12].shadowT = (offsetY + border + clampedShadow + h) * textureFactor + textureOffset;
+        v[12].midShadowS = midShadowS;
+        v[12].midShadowT = midShadowT;
+        v[12].borderS = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[12].borderT = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[12].color = packedColor;
+        v[12].shadowColor = packedShadowColor;
+        v[12].borderColor = packedBorderColor;
+        markDirty(QSGNode::DirtyGeometry);
+
+        // Update data for the preprocess() call.
+        const quint16 deviceRadius = static_cast<quint16>(clampedRadius * dpr);
+        if (m_radius != deviceRadius) {
+            m_radius = deviceRadius;
+            m_flags |= DirtyRadius;
+        }
+        const quint16 deviceShadow = static_cast<quint16>(clampedShadow * dpr);
+        if (m_shadow != deviceShadow) {
+            m_shadow = deviceShadow;
+            m_flags |= DirtyShadow;
+        }
+        const quint16 deviceBorderRadius = static_cast<quint16>(clampedBorderRadius * dpr);
+        if (m_borderRadius != deviceBorderRadius) {
+            m_borderRadius = deviceBorderRadius;
+            m_flags |= DirtyBorderRadius;
+        }
+        if (m_shape != static_cast<quint8>(type)) {
+            m_shape = static_cast<quint8>(type);
+            m_flags |= DirtyShape;
+        }
+        break;
+    }
+
+    default:
+        DNOT_REACHED();
+    }
+
+    // Update the blending state of the opaque material (in QSG terms, an opaque
+    // material is the material automatically used when the opacity is 1, but
+    // even if the opacity is 1 we have to handle the case where the alpha of
+    // the specified color is less than 1).
+    const bool blending = qAlpha(color) < 255;
+    if (blending != static_cast<bool>(m_flags & Blending)) {
+        m_resources->opaqueMaterial()->setFlag(QSGMaterial::Blending, blending);
+        markDirty(QSGNode::DirtyMaterial);
+        m_flags = (m_flags & ~Blending) | (blending ? Blending : 0);
+    }
+}
+
+UCShapeFillCornersNode::UCShapeFillCornersNode()
+    : QSGGeometryNode()
+    , m_resources(Q_NULLPTR)
+    , m_radius(0)
+    , m_shadow(0)
+    , m_borderRadius(0)
+    , m_flags(0)
+    , m_shape(UCShapeType::Squircle)
+{
+    DLOG("creating UCShapeFillCornersNode");
+    setFlag(QSGNode::UsePreprocess, true);
+    qsgnode_set_description(this, QLatin1String("shapefillcorners"));
+}
+
+UCShapeFillCornersNode::~UCShapeFillCornersNode()
+{
+    DLOG("detroying UCShapeFillCornersNode");
+    delete m_resources;
+}
+
+void UCShapeFillCornersNode::preprocess()
+{
+    // FIXME(loicm) Could be made more consise (texture update methods in the resources?).
+
+    switch (m_flags & StyleMask) {
+    case (HasColor):
+        if (m_flags & (DirtyRadius | DirtyShape)) {
+            static_cast<UCShapeColorMaskMaterial<false>*>(
+                m_resources->material())->updateMaskTexture(
+                    static_cast<UCShapeType>(m_shape), m_radius);
+            static_cast<UCShapeColorMaskMaterial<true>*>(
+                m_resources->opaqueMaterial())->updateMaskTexture(
+                    static_cast<UCShapeType>(m_shape), m_radius);
+        }
+        break;
+
+    case (HasColor | HasShadow):
+        if (m_flags & (DirtyRadius | DirtyShadow | DirtyShape)) {
+            static_cast<UCShapeFillCornersShadowMaterial<false>*>(
+                m_resources->material())->updateShadowTexture(
+                    static_cast<UCShapeType>(m_shape), m_radius, m_shadow);
+            static_cast<UCShapeFillCornersShadowMaterial<true>*>(
+                m_resources->opaqueMaterial())->updateShadowTexture(
+                    static_cast<UCShapeType>(m_shape), m_radius, m_shadow);
+        }
+        break;
+
+    case (HasColor | HasBorder):
+        if (m_flags & (DirtyRadius | DirtyShape)) {
+            static_cast<UCShapeFillCornersBorderMaterial<false>*>(
+                m_resources->material())->updateMaskTexture(
+                    static_cast<UCShapeType>(m_shape), m_radius);
+            static_cast<UCShapeFillCornersBorderMaterial<true>*>(
+                m_resources->opaqueMaterial())->updateMaskTexture(
+                    static_cast<UCShapeType>(m_shape), m_radius);
+        }
+        if (m_flags & (DirtyBorderRadius | DirtyShape)) {
+            static_cast<UCShapeFillCornersBorderMaterial<false>*>(
+                m_resources->material())->updateBorderTexture(
+                    static_cast<UCShapeType>(m_shape), m_borderRadius);
+            static_cast<UCShapeFillCornersBorderMaterial<true>*>(
+                m_resources->opaqueMaterial())->updateBorderTexture(
+                    static_cast<UCShapeType>(m_shape), m_borderRadius);
+        }
+        break;
+
+    case (HasColor | HasShadow | HasBorder):
+        if (m_flags & (DirtyRadius | DirtyShadow | DirtyShape)) {
+            static_cast<UCShapeFillCornersShadowBorderMaterial<false>*>(
+                m_resources->material())->updateShadowTexture(
+                    static_cast<UCShapeType>(m_shape), m_radius, m_shadow);
+            static_cast<UCShapeFillCornersShadowBorderMaterial<true>*>(
+                m_resources->opaqueMaterial())->updateShadowTexture(
+                    static_cast<UCShapeType>(m_shape), m_radius, m_shadow);
+        }
+        if (m_flags & (DirtyBorderRadius | DirtyShape)) {
+            static_cast<UCShapeFillCornersShadowBorderMaterial<false>*>(
+                m_resources->material())->updateBorderTexture(
+                    static_cast<UCShapeType>(m_shape), m_borderRadius);
+            static_cast<UCShapeFillCornersShadowBorderMaterial<true>*>(
+                m_resources->opaqueMaterial())->updateBorderTexture(
+                    static_cast<UCShapeType>(m_shape), m_borderRadius);
+        }
+        break;
+
+    default:
+        NOT_REACHED();
+    }
+
+    m_flags &= ~DirtyMask;
+}
+
+void UCShapeFillCornersNode::setVisible(bool visible)
+{
+    DLOG("UCShapeFillCornersNode::setVisible %d", visible);
+    if (static_cast<bool>(m_flags & Visible) != visible) {
+        m_flags = (m_flags & ~Visible) | (visible ? Visible : 0);
+        markDirty(DirtySubtreeBlocked);
+    }
+}
+
+void UCShapeFillCornersNode::update(
+    const QSizeF& itemSize, UCShapeType type, float radius, QRgb color, float shadowSize,
+    float shadowAngle, float shadowDistance, QRgb shadowColor, float borderSize, QRgb borderColor)
+{
+    // The geometry is made of 12 vertices indexed with a triangles mode.
+    //     0 - 1    2 - 3
+    //     | /        \ |
+    //     4            5
+    //
+    //     6            7
+    //     | \        / |
+    //     8 - 9   10 - 11
+    const quint16 indices[] = { 1, 0, 4, 6, 8, 9, 10, 11, 7, 5, 3, 2 };
+    const int indexCount = ARRAY_SIZE(indices);
+    const int vertexCount = 12;
+
+    quint16 style = ((shadowSize <= 0.0f && shadowDistance <= 0.0f) || (qAlpha(shadowColor) == 0)) ?
+        HasColor : (HasColor | HasShadow);
+    if (borderSize >= 1.0f) {
+        style |= HasBorder;
+    }
+
+    // Create new material/geometry set if needed.
+    if (style != (m_flags & StyleMask)) {
+        delete m_resources;
+        switch (style) {
+        case HasColor:
+            m_resources = new UCShapeColorMaskResources(vertexCount, indexCount);
+            break;
+        case (HasColor | HasShadow):
+            m_resources = new UCShapeFillCornersShadowResources(vertexCount, indexCount);
+            break;
+        case (HasColor | HasBorder):
+            m_resources = new UCShapeFillCornersBorderResources(vertexCount, indexCount);
+            break;
+        case (HasColor | HasShadow | HasBorder):
+            m_resources = new UCShapeFillCornersShadowBorderResources(vertexCount, indexCount);
+            break;
+        default:
+            NOT_REACHED();
+        }
+        setMaterial(m_resources->material());
+        m_resources->opaqueMaterial()->setFlag(QSGMaterial::Blending);
+        setOpaqueMaterial(m_resources->opaqueMaterial());
+        memcpy(m_resources->geometry()->indexData(), indices, indexCount * sizeof(quint16));
+        setGeometry(m_resources->geometry());
+        m_flags = (m_flags & ~StyleMask) | style | DirtyMask;
+    }
+
+    const float dpr = qGuiApp->devicePixelRatio();
+    const float w = floorf(static_cast<float>(itemSize.width()));
+    const float h = floorf(static_cast<float>(itemSize.height()));
+    // Rounded down since Shadow doesn't support sub-pixel rendering.
+    const float maxSize = floorf(qMin(w, h) * 0.5f);
+    const float clampedRadius = qMin(floorf(radius), maxSize);
+    const quint32 packedColor = packColor(color);
+
+    // Update geometry depending on the style.
+    switch (style) {
+    case HasColor: {
+        UCShapeColorMaskResources::Vertex* v =
+            reinterpret_cast<UCShapeColorMaskResources::Vertex*>(
+                m_resources->geometry()->vertexData());
+        const float deviceRadius = clampedRadius * dpr;
+        const float border = 1.0f;
+        const float textureSize = deviceRadius + 2 * border;
+        const float textureSizeRounded = roundUp(static_cast<int>(textureSize), textureRounding);
+        const float textureStart = (textureSizeRounded - textureSize + border) / textureSizeRounded;
+        const float textureEnd = (textureSizeRounded - border) / textureSizeRounded;
+        v[0].x = 0.0f;
+        v[0].y = 0.0f;
+        v[0].maskS = textureStart;
+        v[0].maskT = textureStart;
+        v[0].color = packedColor;
+        v[1].x = clampedRadius;
+        v[1].y = 0.0f;
+        v[1].maskS = textureEnd;
+        v[1].maskT = textureStart;
+        v[1].color = packedColor;
+        v[2].x = w - clampedRadius;
+        v[2].y = 0.0f;
+        v[2].maskS = textureEnd;
+        v[2].maskT = textureStart;
+        v[2].color = packedColor;
+        v[3].x = w;
+        v[3].y = 0.0f;
+        v[3].maskS = textureStart;
+        v[3].maskT = textureStart;
+        v[3].color = packedColor;
+        v[4].x = 0.0f;
+        v[4].y = clampedRadius;
+        v[4].maskS = textureStart;
+        v[4].maskT = textureEnd;
+        v[4].color = packedColor;
+        v[5].x = w;
+        v[5].y = clampedRadius;
+        v[5].maskS = textureStart;
+        v[5].maskT = textureEnd;
+        v[5].color = packedColor;
+        v[6].x = 0.0f;
+        v[6].y = h - clampedRadius;
+        v[6].maskS = textureStart;
+        v[6].maskT = textureEnd;
+        v[6].color = packedColor;
+        v[7].x = w;
+        v[7].y = h - clampedRadius;
+        v[7].maskS = textureStart;
+        v[7].maskT = textureEnd;
+        v[7].color = packedColor;
+        v[8].x = 0.0f;
+        v[8].y = h;
+        v[8].maskS = textureStart;
+        v[8].maskT = textureStart;
+        v[8].color = packedColor;
+        v[9].x = clampedRadius;
+        v[9].y = h;
+        v[9].maskS = textureEnd;
+        v[9].maskT = textureStart;
+        v[9].color = packedColor;
+        v[10].x = w - clampedRadius;
+        v[10].y = h;
+        v[10].maskS = textureEnd;
+        v[10].maskT = textureStart;
+        v[10].color = packedColor;
+        v[11].x = w;
+        v[11].y = h;
+        v[11].maskS = textureStart;
+        v[11].maskT = textureStart;
+        v[11].color = packedColor;
+        markDirty(QSGNode::DirtyGeometry);
+
+        // Update data for the preprocess() call.
+        if (m_radius != static_cast<quint16>(deviceRadius)) {
+            m_radius = static_cast<quint16>(deviceRadius);
+            m_flags |= DirtyRadius;
+        }
+        if (m_shape != static_cast<quint8>(type)) {
+            m_shape = static_cast<quint8>(type);
+            m_flags |= DirtyShape;
+        }
+        break;
+    }
+
+    case (HasColor | HasShadow): {
+        UCShapeFillCornersShadowResources::Vertex* v =
+            reinterpret_cast<UCShapeFillCornersShadowResources::Vertex*>(
+                m_resources->geometry()->vertexData());
+        float s, c;
+        sincosf(shadowAngle * -(M_PI / 180.0f), &s, &c);
+        const float offsetX = roundf(c * shadowDistance);
+        const float offsetY = roundf(s * shadowDistance);
+        const float clampedShadow = qMin(floorf(shadowSize), maxSize);
+        const float border = 1.0f;
+        const float textureSize = (2.0f * clampedShadow + 2.0f * border + clampedRadius) * dpr;
+        const float textureSizeRounded = roundUp(static_cast<int>(textureSize), textureRounding);
+        const float textureOffset = (textureSizeRounded - textureSize) / textureSizeRounded;
+        const float textureFactor = ((1.0f - textureOffset) * dpr) / textureSize;
+        const float midShadowS = (border + clampedShadow + (w * 0.5f)) * textureFactor + textureOffset;
+        const float midShadowT = (border + clampedShadow + (h * 0.5f)) * textureFactor + textureOffset;
+        const quint32 packedShadowColor = packColor(shadowColor);
+        v[0].x = 0.0f;
+        v[0].y = 0.0f;
+        v[0].maskS = (border + clampedShadow) * textureFactor + textureOffset;
+        v[0].maskT = (border + clampedShadow) * textureFactor + textureOffset;
+        v[0].shadowS = (offsetX + border + clampedShadow) * textureFactor + textureOffset;
+        v[0].shadowT = (offsetY + border + clampedShadow) * textureFactor + textureOffset;
+        v[0].midShadowS = midShadowS;
+        v[0].midShadowT = midShadowT;
+        v[0].color = packedColor;
+        v[0].shadowColor = packedShadowColor;
+        v[1].x = clampedRadius;
+        v[1].y = 0.0f;
+        v[1].maskS = (border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[1].maskT = (border + clampedShadow) * textureFactor + textureOffset;
+        v[1].shadowS = (offsetX + border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[1].shadowT = (offsetY + border + clampedShadow) * textureFactor + textureOffset;
+        v[1].midShadowS = midShadowS;
+        v[1].midShadowT = midShadowT;
+        v[1].color = packedColor;
+        v[1].shadowColor = packedShadowColor;
+        v[2].x = w - clampedRadius;
+        v[2].y = 0.0f;
+        v[2].maskS = (border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[2].maskT = (border + clampedShadow) * textureFactor + textureOffset;
+        v[2].shadowS =
+            (offsetX + border + clampedShadow + (w - clampedRadius)) * textureFactor + textureOffset;
+        v[2].shadowT = (offsetY + border + clampedShadow) * textureFactor + textureOffset;
+        v[2].midShadowS = midShadowS;
+        v[2].midShadowT = midShadowT;
+        v[2].color = packedColor;
+        v[2].shadowColor = packedShadowColor;
+        v[3].x = w;
+        v[3].y = 0.0f;
+        v[3].maskS = (border + clampedShadow) * textureFactor + textureOffset;
+        v[3].maskT = (border + clampedShadow) * textureFactor + textureOffset;
+        v[3].shadowS = (offsetX + border + clampedShadow + w) * textureFactor + textureOffset;
+        v[3].shadowT = (offsetY + border + clampedShadow) * textureFactor + textureOffset;
+        v[3].midShadowS = midShadowS;
+        v[3].midShadowT = midShadowT;
+        v[3].color = packedColor;
+        v[3].shadowColor = packedShadowColor;
+        v[4].x = 0.0f;
+        v[4].y = clampedRadius;
+        v[4].maskS = (border + clampedShadow) * textureFactor + textureOffset;
+        v[4].maskT = (border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[4].shadowS = (offsetX + border + clampedShadow) * textureFactor + textureOffset;
+        v[4].shadowT = (offsetY + border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[4].midShadowS = midShadowS;
+        v[4].midShadowT = midShadowT;
+        v[4].color = packedColor;
+        v[4].shadowColor = packedShadowColor;
+        v[5].x = w;
+        v[5].y = clampedRadius;
+        v[5].maskS = (border + clampedShadow) * textureFactor + textureOffset;
+        v[5].maskT = (border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[5].shadowS = (offsetX + border + clampedShadow + w) * textureFactor + textureOffset;
+        v[5].shadowT = (offsetY + border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[5].midShadowS = midShadowS;
+        v[5].midShadowT = midShadowT;
+        v[5].color = packedColor;
+        v[5].shadowColor = packedShadowColor;
+        v[6].x = 0.0f;
+        v[6].y = h - clampedRadius;
+        v[6].maskS = (border + clampedShadow) * textureFactor + textureOffset;
+        v[6].maskT = (border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[6].shadowS = (offsetX + border + clampedShadow) * textureFactor + textureOffset;
+        v[6].shadowT =
+            (offsetY + border + clampedShadow + (h - clampedRadius)) * textureFactor + textureOffset;
+        v[6].midShadowS = midShadowS;
+        v[6].midShadowT = midShadowT;
+        v[6].color = packedColor;
+        v[6].shadowColor = packedShadowColor;
+        v[7].x = w;
+        v[7].y = h - clampedRadius;
+        v[7].maskS = (border + clampedShadow) * textureFactor + textureOffset;
+        v[7].maskT = (border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[7].shadowS = (offsetX + border + clampedShadow + w) * textureFactor + textureOffset;
+        v[7].shadowT =
+            (offsetY + border + clampedShadow + (h - clampedRadius)) * textureFactor + textureOffset;
+        v[7].midShadowS = midShadowS;
+        v[7].midShadowT = midShadowT;
+        v[7].color = packedColor;
+        v[7].shadowColor = packedShadowColor;
+        v[8].x = 0.0f;
+        v[8].y = h;
+        v[8].maskS = (border + clampedShadow) * textureFactor + textureOffset;
+        v[8].maskT = (border + clampedShadow) * textureFactor + textureOffset;
+        v[8].shadowS = (offsetX + border + clampedShadow) * textureFactor + textureOffset;
+        v[8].shadowT = (offsetY + border + clampedShadow + h) * textureFactor + textureOffset;
+        v[8].midShadowS = midShadowS;
+        v[8].midShadowT = midShadowT;
+        v[8].color = packedColor;
+        v[8].shadowColor = packedShadowColor;
+        v[9].x = clampedRadius;
+        v[9].y = h;
+        v[9].maskS = (border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[9].maskT = (border + clampedShadow) * textureFactor + textureOffset;
+        v[9].shadowS = (offsetX + border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[9].shadowT = (offsetY + border + clampedShadow + h) * textureFactor + textureOffset;
+        v[9].midShadowS = midShadowS;
+        v[9].midShadowT = midShadowT;
+        v[9].color = packedColor;
+        v[9].shadowColor = packedShadowColor;
+        v[10].x = w - clampedRadius;
+        v[10].y = h;
+        v[10].maskS = (border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[10].maskT = (border + clampedShadow) * textureFactor + textureOffset;
+        v[10].shadowS =
+            (offsetX + border + clampedShadow + (w - clampedRadius)) * textureFactor + textureOffset;
+        v[10].shadowT = (offsetY + border + clampedShadow + h) * textureFactor + textureOffset;
+        v[10].midShadowS = midShadowS;
+        v[10].midShadowT = midShadowT;
+        v[10].color = packedColor;
+        v[10].shadowColor = packedShadowColor;
+        v[11].x = w;
+        v[11].y = h;
+        v[11].maskS = (border + clampedShadow) * textureFactor + textureOffset;
+        v[11].maskT = (border + clampedShadow) * textureFactor + textureOffset;
+        v[11].shadowS = (offsetX + border + clampedShadow + w) * textureFactor + textureOffset;
+        v[11].shadowT = (offsetY + border + clampedShadow + h) * textureFactor + textureOffset;
+        v[11].midShadowS = midShadowS;
+        v[11].midShadowT = midShadowT;
+        v[11].color = packedColor;
+        v[11].shadowColor = packedShadowColor;
+        markDirty(QSGNode::DirtyGeometry);
+
+        // Update data for the preprocess() call.
+        const quint16 deviceShadow = static_cast<quint16>(clampedShadow * dpr);
+        if (m_shadow != deviceShadow) {
+            m_shadow = deviceShadow;
+            m_flags |= DirtyShadow;
+        }
+        const quint16 deviceRadius = static_cast<quint16>(clampedRadius * dpr);
+        if (m_radius != deviceRadius) {
+            m_radius = deviceRadius;
+            m_flags |= DirtyRadius;
+        }
+        if (m_shape != static_cast<quint8>(type)) {
+            m_shape = static_cast<quint8>(type);
+            m_flags |= DirtyShape;
+        }
+        break;
+    }
+
+    case (HasColor | HasBorder): {
+        UCShapeFillCornersBorderResources::Vertex* v =
+            reinterpret_cast<UCShapeFillCornersBorderResources::Vertex*>(
+                m_resources->geometry()->vertexData());
+        const float deviceRadius = clampedRadius * dpr;
+        const float maskBorder = 1.0f;
+        const float maskTextureSize = deviceRadius + 2.0f * maskBorder;
+        const float maskTextureSizeRounded =
+            roundUp(static_cast<int>(maskTextureSize), textureRounding);
+        const float maskTextureStart =
+            (maskTextureSizeRounded - maskTextureSize + maskBorder) / maskTextureSizeRounded;
+        const float maskTextureEnd = (maskTextureSizeRounded - maskBorder) / maskTextureSizeRounded;
+        const float clampedBorder = qMin(floorf(borderSize), maxSize);
+        const float clampedBorderRadius =
+            floorf(((maxSize - clampedBorder) / maxSize) * clampedRadius);
+        const float textureBorder = 1.0f;
+        const float borderTextureSize = (2.0f * textureBorder + clampedBorderRadius) * dpr;
+        const float borderTextureSizeRounded =
+            roundUp(static_cast<int>(borderTextureSize), textureRounding);
+        const float borderTextureOffset =
+            (borderTextureSizeRounded - borderTextureSize) / borderTextureSizeRounded;
+        const float borderTextureFactor = ((1.0f - borderTextureOffset) * dpr) / borderTextureSize;
+        const float borderOffset = -(clampedBorder - textureBorder);
+        const quint32 packedBorderColor = packColor(borderColor);
+        v[0].x = 0.0f;
+        v[0].y = 0.0f;
+        v[0].maskS = maskTextureStart;
+        v[0].maskT = maskTextureStart;
+        v[0].borderS = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[0].borderT = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[0].color = packedColor;
+        v[0].borderColor = packedBorderColor;
+        v[1].x = clampedRadius;
+        v[1].y = 0.0f;
+        v[1].maskS = maskTextureEnd;
+        v[1].maskT = maskTextureStart;
+        v[1].borderS = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[1].borderT = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[1].color = packedColor;
+        v[1].borderColor = packedBorderColor;
+        v[2].x = w - clampedRadius;
+        v[2].y = 0.0f;
+        v[2].maskS = maskTextureEnd;
+        v[2].maskT = maskTextureStart;
+        v[2].borderS = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[2].borderT = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[2].color = packedColor;
+        v[2].borderColor = packedBorderColor;
+        v[3].x = w;
+        v[3].y = 0.0f;
+        v[3].maskS = maskTextureStart;
+        v[3].maskT = maskTextureStart;
+        v[3].borderS = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[3].borderT = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[3].color = packedColor;
+        v[3].borderColor = packedBorderColor;
+        v[4].x = 0.0f;
+        v[4].y = clampedRadius;
+        v[4].maskS = maskTextureStart;
+        v[4].maskT = maskTextureEnd;
+        v[4].borderS = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[4].borderT = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[4].color = packedColor;
+        v[4].borderColor = packedBorderColor;
+        v[5].x = w;
+        v[5].y = clampedRadius;
+        v[5].maskS = maskTextureStart;
+        v[5].maskT = maskTextureEnd;
+        v[5].borderS = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[5].borderT = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[5].color = packedColor;
+        v[5].borderColor = packedBorderColor;
+        v[6].x = 0.0f;
+        v[6].y = h - clampedRadius;
+        v[6].maskS = maskTextureStart;
+        v[6].maskT = maskTextureEnd;
+        v[6].borderS = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[6].borderT = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[6].color = packedColor;
+        v[6].borderColor = packedBorderColor;
+        v[7].x = w;
+        v[7].y = h - clampedRadius;
+        v[7].maskS = maskTextureStart;
+        v[7].maskT = maskTextureEnd;
+        v[7].borderS = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[7].borderT = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[7].color = packedColor;
+        v[7].borderColor = packedBorderColor;
+        v[8].x = 0.0f;
+        v[8].y = h;
+        v[8].maskS = maskTextureStart;
+        v[8].maskT = maskTextureStart;
+        v[8].borderS = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[8].borderT = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[8].color = packedColor;
+        v[8].borderColor = packedBorderColor;
+        v[9].x = clampedRadius;
+        v[9].y = h;
+        v[9].maskS = maskTextureEnd;
+        v[9].maskT = maskTextureStart;
+        v[9].borderS = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[9].borderT = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[9].color = packedColor;
+        v[9].borderColor = packedBorderColor;
+        v[10].x = w - clampedRadius;
+        v[10].y = h;
+        v[10].maskS = maskTextureEnd;
+        v[10].maskT = maskTextureStart;
+        v[10].borderS = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[10].borderT = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[10].color = packedColor;
+        v[10].borderColor = packedBorderColor;
+        v[11].x = w;
+        v[11].y = h;
+        v[11].maskS = maskTextureStart;
+        v[11].maskT = maskTextureStart;
+        v[11].borderS = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[11].borderT = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[11].color = packedColor;
+        v[11].borderColor = packedBorderColor;
+        markDirty(QSGNode::DirtyGeometry);
+
+        // Update data for the preprocess() call.
+        if (m_radius != static_cast<quint16>(deviceRadius)) {
+            m_radius = static_cast<quint16>(deviceRadius);
+            m_flags |= DirtyRadius;
+        }
+        const quint16 deviceBorderRadius = static_cast<quint16>(clampedBorderRadius * dpr);
+        if (m_borderRadius != deviceBorderRadius) {
+            m_borderRadius = deviceBorderRadius;
+            m_flags |= DirtyBorderRadius;
+        }
+        if (m_shape != static_cast<quint8>(type)) {
+            m_shape = static_cast<quint8>(type);
+            m_flags |= DirtyShape;
+        }
+        break;
+    }
+
+    case (HasColor | HasShadow | HasBorder): {
+        UCShapeFillCornersShadowBorderResources::Vertex* v =
+            reinterpret_cast<UCShapeFillCornersShadowBorderResources::Vertex*>(
+                m_resources->geometry()->vertexData());
+        float s, c;
+        sincosf(shadowAngle * -(M_PI / 180.0f), &s, &c);
+        const float offsetX = roundf(c * shadowDistance);
+        const float offsetY = roundf(s * shadowDistance);
+        const float clampedShadow = qMin(floorf(shadowSize), maxSize);
+        const float border = 1.0f;
+        const float textureSize = (2.0f * clampedShadow + 2.0f * border + clampedRadius) * dpr;
+        const float textureSizeRounded = roundUp(static_cast<int>(textureSize), textureRounding);
+        const float textureOffset = (textureSizeRounded - textureSize) / textureSizeRounded;
+        const float textureFactor = ((1.0f - textureOffset) * dpr) / textureSize;
+        const float midShadowS = (border + clampedShadow + (w * 0.5f)) * textureFactor + textureOffset;
+        const float midShadowT = (border + clampedShadow + (h * 0.5f)) * textureFactor + textureOffset;
+        const float clampedBorder = qMin(floorf(borderSize), maxSize);
+        const float clampedBorderRadius =
+            floorf(((maxSize - clampedBorder) / maxSize) * clampedRadius);
+        const float textureBorder = 1.0f;
+        const float borderTextureSize = (2.0f * textureBorder + clampedBorderRadius) * dpr;
+        const float borderTextureSizeRounded =
+            roundUp(static_cast<int>(borderTextureSize), textureRounding);
+        const float borderTextureOffset =
+            (borderTextureSizeRounded - borderTextureSize) / borderTextureSizeRounded;
+        const float borderTextureFactor = ((1.0f - borderTextureOffset) * dpr) / borderTextureSize;
+        const float borderOffset = -(clampedBorder - textureBorder);
+        const quint32 packedShadowColor = packColor(shadowColor);
+        const quint32 packedBorderColor = packColor(borderColor);
+        v[0].x = 0.0f;
+        v[0].y = 0.0f;
+        v[0].maskS = (border + clampedShadow) * textureFactor + textureOffset;
+        v[0].maskT = (border + clampedShadow) * textureFactor + textureOffset;
+        v[0].shadowS = (offsetX + border + clampedShadow) * textureFactor + textureOffset;
+        v[0].shadowT = (offsetY + border + clampedShadow) * textureFactor + textureOffset;
+        v[0].midShadowS = midShadowS;
+        v[0].midShadowT = midShadowT;
+        v[0].borderS = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[0].borderT = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[0].color = packedColor;
+        v[0].shadowColor = packedShadowColor;
+        v[0].borderColor = packedBorderColor;
+        v[1].x = clampedRadius;
+        v[1].y = 0.0f;
+        v[1].maskS = (border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[1].maskT = (border + clampedShadow) * textureFactor + textureOffset;
+        v[1].shadowS = (offsetX + border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[1].shadowT = (offsetY + border + clampedShadow) * textureFactor + textureOffset;
+        v[1].midShadowS = midShadowS;
+        v[1].midShadowT = midShadowT;
+        v[1].borderS = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[1].borderT = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[1].color = packedColor;
+        v[1].shadowColor = packedShadowColor;
+        v[1].borderColor = packedBorderColor;
+        v[2].x = w - clampedRadius;
+        v[2].y = 0.0f;
+        v[2].maskS = (border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[2].maskT = (border + clampedShadow) * textureFactor + textureOffset;
+        v[2].shadowS =
+            (offsetX + border + clampedShadow + (w - clampedRadius)) * textureFactor + textureOffset;
+        v[2].shadowT = (offsetY + border + clampedShadow) * textureFactor + textureOffset;
+        v[2].midShadowS = midShadowS;
+        v[2].midShadowT = midShadowT;
+        v[2].borderS = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[2].borderT = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[2].color = packedColor;
+        v[2].shadowColor = packedShadowColor;
+        v[2].borderColor = packedBorderColor;
+        v[3].x = w;
+        v[3].y = 0.0f;
+        v[3].maskS = (border + clampedShadow) * textureFactor + textureOffset;
+        v[3].maskT = (border + clampedShadow) * textureFactor + textureOffset;
+        v[3].shadowS = (offsetX + border + clampedShadow + w) * textureFactor + textureOffset;
+        v[3].shadowT = (offsetY + border + clampedShadow) * textureFactor + textureOffset;
+        v[3].midShadowS = midShadowS;
+        v[3].midShadowT = midShadowT;
+        v[3].borderS = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[3].borderT = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[3].color = packedColor;
+        v[3].shadowColor = packedShadowColor;
+        v[3].borderColor = packedBorderColor;
+        v[4].x = 0.0f;
+        v[4].y = clampedRadius;
+        v[4].maskS = (border + clampedShadow) * textureFactor + textureOffset;
+        v[4].maskT = (border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[4].shadowS = (offsetX + border + clampedShadow) * textureFactor + textureOffset;
+        v[4].shadowT = (offsetY + border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[4].midShadowS = midShadowS;
+        v[4].midShadowT = midShadowT;
+        v[4].borderS = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[4].borderT = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[4].color = packedColor;
+        v[4].shadowColor = packedShadowColor;
+        v[4].borderColor = packedBorderColor;
+        v[5].x = w;
+        v[5].y = clampedRadius;
+        v[5].maskS = (border + clampedShadow) * textureFactor + textureOffset;
+        v[5].maskT = (border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[5].shadowS = (offsetX + border + clampedShadow + w) * textureFactor + textureOffset;
+        v[5].shadowT = (offsetY + border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[5].midShadowS = midShadowS;
+        v[5].midShadowT = midShadowT;
+        v[5].borderS = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[5].borderT = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[5].color = packedColor;
+        v[5].shadowColor = packedShadowColor;
+        v[5].borderColor = packedBorderColor;
+        v[6].x = 0.0f;
+        v[6].y = h - clampedRadius;
+        v[6].maskS = (border + clampedShadow) * textureFactor + textureOffset;
+        v[6].maskT = (border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[6].shadowS = (offsetX + border + clampedShadow) * textureFactor + textureOffset;
+        v[6].shadowT =
+            (offsetY + border + clampedShadow + (h - clampedRadius)) * textureFactor + textureOffset;
+        v[6].midShadowS = midShadowS;
+        v[6].midShadowT = midShadowT;
+        v[6].borderS = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[6].borderT = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[6].color = packedColor;
+        v[6].shadowColor = packedShadowColor;
+        v[6].borderColor = packedBorderColor;
+        v[7].x = w;
+        v[7].y = h - clampedRadius;
+        v[7].maskS = (border + clampedShadow) * textureFactor + textureOffset;
+        v[7].maskT = (border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[7].shadowS = (offsetX + border + clampedShadow + w) * textureFactor + textureOffset;
+        v[7].shadowT =
+            (offsetY + border + clampedShadow + (h - clampedRadius)) * textureFactor + textureOffset;
+        v[7].midShadowS = midShadowS;
+        v[7].midShadowT = midShadowT;
+        v[7].borderS = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[7].borderT = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[7].color = packedColor;
+        v[7].shadowColor = packedShadowColor;
+        v[7].borderColor = packedBorderColor;
+        v[8].x = 0.0f;
+        v[8].y = h;
+        v[8].maskS = (border + clampedShadow) * textureFactor + textureOffset;
+        v[8].maskT = (border + clampedShadow) * textureFactor + textureOffset;
+        v[8].shadowS = (offsetX + border + clampedShadow) * textureFactor + textureOffset;
+        v[8].shadowT = (offsetY + border + clampedShadow + h) * textureFactor + textureOffset;
+        v[8].midShadowS = midShadowS;
+        v[8].midShadowT = midShadowT;
+        v[8].borderS = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[8].borderT = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[8].color = packedColor;
+        v[8].shadowColor = packedShadowColor;
+        v[8].borderColor = packedBorderColor;
+        v[9].x = clampedRadius;
+        v[9].y = h;
+        v[9].maskS = (border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[9].maskT = (border + clampedShadow) * textureFactor + textureOffset;
+        v[9].shadowS = (offsetX + border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[9].shadowT = (offsetY + border + clampedShadow + h) * textureFactor + textureOffset;
+        v[9].midShadowS = midShadowS;
+        v[9].midShadowT = midShadowT;
+        v[9].borderS = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[9].borderT = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[9].color = packedColor;
+        v[9].shadowColor = packedShadowColor;
+        v[9].borderColor = packedBorderColor;
+        v[10].x = w - clampedRadius;
+        v[10].y = h;
+        v[10].maskS = (border + clampedShadow + clampedRadius) * textureFactor + textureOffset;
+        v[10].maskT = (border + clampedShadow) * textureFactor + textureOffset;
+        v[10].shadowS =
+            (offsetX + border + clampedShadow + (w - clampedRadius)) * textureFactor + textureOffset;
+        v[10].shadowT = (offsetY + border + clampedShadow + h) * textureFactor + textureOffset;
+        v[10].midShadowS = midShadowS;
+        v[10].midShadowT = midShadowT;
+        v[10].borderS = (clampedRadius + borderOffset) * borderTextureFactor + borderTextureOffset;
+        v[10].borderT = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[10].color = packedColor;
+        v[10].shadowColor = packedShadowColor;
+        v[10].borderColor = packedBorderColor;
+        v[11].x = w;
+        v[11].y = h;
+        v[11].maskS = (border + clampedShadow) * textureFactor + textureOffset;
+        v[11].maskT = (border + clampedShadow) * textureFactor + textureOffset;
+        v[11].shadowS = (offsetX + border + clampedShadow + w) * textureFactor + textureOffset;
+        v[11].shadowT = (offsetY + border + clampedShadow + h) * textureFactor + textureOffset;
+        v[11].midShadowS = midShadowS;
+        v[11].midShadowT = midShadowT;
+        v[11].borderS = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[11].borderT = borderOffset * borderTextureFactor + borderTextureOffset;
+        v[11].color = packedColor;
+        v[11].shadowColor = packedShadowColor;
+        v[11].borderColor = packedBorderColor;
+        markDirty(QSGNode::DirtyGeometry);
+
+        // Update data for the preprocess() call.
+        const quint16 deviceRadius = static_cast<quint16>(clampedRadius * dpr);
+        if (m_radius != deviceRadius) {
+            m_radius = deviceRadius;
+            m_flags |= DirtyRadius;
+        }
+        const quint16 deviceShadow = static_cast<quint16>(clampedShadow * dpr);
+        if (m_shadow != deviceShadow) {
+            m_shadow = deviceShadow;
+            m_flags |= DirtyShadow;
+        }
+        const quint16 deviceBorderRadius = static_cast<quint16>(clampedBorderRadius * dpr);
+        if (m_borderRadius != deviceBorderRadius) {
+            m_borderRadius = deviceBorderRadius;
+            m_flags |= DirtyBorderRadius;
+        }
+        if (m_shape != static_cast<quint8>(type)) {
+            m_shape = static_cast<quint8>(type);
+            m_flags |= DirtyShape;
+        }
+        break;
+    }
+
+    default:
+        DNOT_REACHED();
+    }
+}

=== added file 'src/UbuntuToolkit/privates/ucshapefillnodes_p.h'
--- src/UbuntuToolkit/privates/ucshapefillnodes_p.h	1970-01-01 00:00:00 +0000
+++ src/UbuntuToolkit/privates/ucshapefillnodes_p.h	2016-12-14 07:25:05 +0000
@@ -0,0 +1,999 @@
+/*
+ * Copyright 2016 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY 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/>.
+ *
+ * Author: Loïc Molinari <[e-mail]>
+ */
+
+#ifndef UCSHAPEFILLNODES_P_H
+#define UCSHAPEFILLNODES_P_H
+
+#include <QtQuick/QSGNode>
+
+#include <UbuntuToolkit/private/ucshapetexturefactory_p.h>
+#include <UbuntuToolkit/private/ucshaperesources_p.h>
+
+// ################################
+// # Fill center shadow materials #
+// ################################
+
+class UCShapeFillCenterShadowOpaqueShader : public QSGMaterialShader
+{
+public:
+    UCShapeFillCenterShadowOpaqueShader() {
+        setShaderSourceFile(QOpenGLShader::Vertex,
+                            QStringLiteral(":/uc/privates/shaders/fillcentershadow.vert"));
+        setShaderSourceFile(QOpenGLShader::Fragment,
+                            QStringLiteral(":/uc/privates/shaders/fillcentershadow_opaque.frag"));
+    }
+    char const* const* attributeNames() const Q_DECL_OVERRIDE {
+        static char const* const attributes[] = {
+            "positionAttrib", "shadowCoordAttrib", "midShadowCoordAttrib", "colorAttrib",
+            "shadowColorAttrib", 0
+        };
+        return attributes;
+    }
+    void initialize() Q_DECL_OVERRIDE {
+        QSGMaterialShader::initialize();
+        program()->bind();
+        program()->setUniformValue("shadowTexture", 0);
+        m_matrixId = program()->uniformLocation("matrix");
+    }
+    void updateState(
+        const RenderState& state, QSGMaterial* newEffect, QSGMaterial*) Q_DECL_OVERRIDE {
+        QOpenGLFunctions* funcs = QOpenGLContext::currentContext()->functions();
+        UCShapeTextureProvider* provider = dynamic_cast<UCShapeTextureProvider*>(newEffect);
+        funcs->glBindTexture(GL_TEXTURE_2D, provider->textureId());
+        if (state.isMatrixDirty()) {
+            program()->setUniformValue(m_matrixId, state.combinedMatrix());
+        }
+    }
+
+private:
+    int m_matrixId;
+};
+
+class UCShapeFillCenterShadowShader : public UCShapeFillCenterShadowOpaqueShader
+{
+public:
+    UCShapeFillCenterShadowShader() : UCShapeFillCenterShadowOpaqueShader() {
+        setShaderSourceFile(QOpenGLShader::Fragment,
+                            QStringLiteral(":/uc/privates/shaders/fillcentershadow.frag"));
+    }
+    void initialize() Q_DECL_OVERRIDE {
+        UCShapeFillCenterShadowOpaqueShader::initialize();
+        m_opacityId = program()->uniformLocation("opacity");
+    }
+    void updateState(
+        const RenderState& state, QSGMaterial* newEffect, QSGMaterial* oldEffect) Q_DECL_OVERRIDE {
+        UCShapeFillCenterShadowOpaqueShader::updateState(state, newEffect, oldEffect);
+        if (state.isOpacityDirty()) {
+            program()->setUniformValue(m_opacityId, state.opacity());
+        }
+    }
+
+private:
+    int m_opacityId;
+};
+
+template <bool opaque>
+class UCShapeFillCenterShadowMaterial : public QSGMaterial, public UCShapeTextureProvider
+{
+public:
+    UCShapeFillCenterShadowMaterial() : m_textureId(0) {
+        setFlag(Blending, !opaque);
+    }
+
+    QSGMaterialType* type() const Q_DECL_OVERRIDE {
+        static QSGMaterialType type[2];
+        return opaque ? &type[0] : &type[1];
+    }
+    QSGMaterialShader* createShader() const Q_DECL_OVERRIDE {
+        return opaque ? new UCShapeFillCenterShadowOpaqueShader : new UCShapeFillCenterShadowShader;
+    }
+    int compare(const QSGMaterial* other) const Q_DECL_OVERRIDE {
+        return reinterpret_cast<const UCShapeTextureProvider*>(other)->textureId() - m_textureId;
+    }
+
+    quint32 textureId(int) const Q_DECL_OVERRIDE {
+        return m_textureId;
+    }
+    void updateShadowTexture(UCShapeType type, quint16 radius, quint16 shadow) {
+        m_textureId = m_textureFactory.shadowTexture(0, type, radius, shadow);
+    }
+
+private:
+    UCShapeTextureFactory<1> m_textureFactory;
+    quint32 m_textureId;
+};
+
+class UCShapeFillCenterShadowResources : public UCShapeResources
+{
+public:
+    UCShapeFillCenterShadowResources(
+        int vertexCount, int indexCount, int indexType = GL_UNSIGNED_SHORT)
+        : m_geometry(attributeSet(), vertexCount, indexCount, indexType) {
+        m_geometry.setDrawingMode(GL_TRIANGLE_STRIP);
+        m_geometry.setIndexDataPattern(QSGGeometry::StaticPattern);
+        m_geometry.setVertexDataPattern(QSGGeometry::AlwaysUploadPattern);
+    }
+
+    QSGMaterial* material() Q_DECL_OVERRIDE { return &m_material; }
+    QSGMaterial* opaqueMaterial() Q_DECL_OVERRIDE { return &m_opaqueMaterial; }
+    QSGGeometry* geometry() Q_DECL_OVERRIDE { return &m_geometry; }
+
+    struct Vertex {
+        float x, y;
+        float shadowS, shadowT;
+        float midShadowS, midShadowT;
+        quint32 color;
+        quint32 shadowColor;
+    };
+
+private:
+    static const QSGGeometry::AttributeSet& attributeSet() {
+        static const QSGGeometry::Attribute attributes[] = {
+            QSGGeometry::Attribute::create(0, 2, GL_FLOAT, true),    // x, y
+            QSGGeometry::Attribute::create(1, 2, GL_FLOAT),          // shadowS, shadowT
+            QSGGeometry::Attribute::create(2, 2, GL_FLOAT),          // midShadowS, midShadowT
+            QSGGeometry::Attribute::create(3, 4, GL_UNSIGNED_BYTE),  // color
+            QSGGeometry::Attribute::create(4, 4, GL_UNSIGNED_BYTE)   // shadowColor
+        };
+        static const QSGGeometry::AttributeSet attributeSet = {
+            5, sizeof(Vertex), attributes
+        };
+        return attributeSet;
+    }
+
+    UCShapeFillCenterShadowMaterial<false> m_material;
+    UCShapeFillCenterShadowMaterial<true> m_opaqueMaterial;
+    QSGGeometry m_geometry;
+};
+
+// ################################
+// # Fill center border materials #
+// ################################
+
+class UCShapeFillCenterBorderOpaqueShader : public QSGMaterialShader
+{
+public:
+    UCShapeFillCenterBorderOpaqueShader() {
+        setShaderSourceFile(
+            QOpenGLShader::Vertex, QStringLiteral(":/uc/privates/shaders/fillcenterborder.vert"));
+        setShaderSourceFile(
+            QOpenGLShader::Fragment, QStringLiteral(
+                ":/uc/privates/shaders/fillcenterborder_opaque.frag"));
+    }
+    char const* const* attributeNames() const Q_DECL_OVERRIDE {
+        static char const* const attributes[] = {
+            "positionAttrib", "borderCoordAttrib", "colorAttrib", "borderColorAttrib", 0
+        };
+        return attributes;
+    }
+    void initialize() Q_DECL_OVERRIDE {
+        QSGMaterialShader::initialize();
+        program()->bind();
+        program()->setUniformValue("borderTexture", 0);
+        m_matrixId = program()->uniformLocation("matrix");
+    }
+    void updateState(
+        const RenderState& state, QSGMaterial* newEffect, QSGMaterial*) Q_DECL_OVERRIDE {
+        QOpenGLFunctions* funcs = QOpenGLContext::currentContext()->functions();
+        UCShapeTextureProvider* provider = dynamic_cast<UCShapeTextureProvider*>(newEffect);
+        funcs->glBindTexture(GL_TEXTURE_2D, provider->textureId());
+        if (state.isMatrixDirty()) {
+            program()->setUniformValue(m_matrixId, state.combinedMatrix());
+        }
+    }
+
+private:
+    int m_matrixId;
+};
+
+class UCShapeFillCenterBorderShader : public UCShapeFillCenterBorderOpaqueShader
+{
+public:
+    UCShapeFillCenterBorderShader() : UCShapeFillCenterBorderOpaqueShader() {
+        setShaderSourceFile(
+            QOpenGLShader::Fragment, QStringLiteral(":/uc/privates/shaders/fillcenterborder.frag"));
+    }
+    void initialize() Q_DECL_OVERRIDE {
+        UCShapeFillCenterBorderOpaqueShader::initialize();
+        m_opacityId = program()->uniformLocation("opacity");
+    }
+    void updateState(
+        const RenderState& state, QSGMaterial* newEffect, QSGMaterial* oldEffect) Q_DECL_OVERRIDE {
+        UCShapeFillCenterBorderOpaqueShader::updateState(state, newEffect, oldEffect);
+        if (state.isOpacityDirty()) {
+            program()->setUniformValue(m_opacityId, state.opacity());
+        }
+    }
+
+private:
+    int m_opacityId;
+};
+
+template <bool opaque>
+class UCShapeFillCenterBorderMaterial : public QSGMaterial, public UCShapeTextureProvider
+{
+public:
+    UCShapeFillCenterBorderMaterial() : m_textureId(0) {
+        setFlag(Blending, !opaque);
+    }
+
+    QSGMaterialType* type() const Q_DECL_OVERRIDE {
+        static QSGMaterialType type[2];
+        return opaque ? &type[0] : &type[1];
+    }
+    QSGMaterialShader* createShader() const Q_DECL_OVERRIDE {
+        return opaque ?
+            new UCShapeFillCenterBorderOpaqueShader : new UCShapeFillCenterBorderShader;
+    }
+    int compare(const QSGMaterial* other) const Q_DECL_OVERRIDE {
+        return reinterpret_cast<const UCShapeTextureProvider*>(other)->textureId() - m_textureId;
+    }
+
+    quint32 textureId(int) const Q_DECL_OVERRIDE {
+        return m_textureId;
+    }
+    void updateBorderTexture(UCShapeType type, quint16 radius) {
+        m_textureId = m_textureFactory.maskTexture(0, type, radius);
+    }
+
+private:
+    UCShapeTextureFactory<1> m_textureFactory;
+    quint32 m_textureId;
+};
+
+class UCShapeFillCenterBorderResources : public UCShapeResources
+{
+public:
+    UCShapeFillCenterBorderResources(
+        int vertexCount, int indexCount, int indexType = GL_UNSIGNED_SHORT)
+        : m_geometry(attributeSet(), vertexCount, indexCount, indexType) {
+        m_geometry.setDrawingMode(GL_TRIANGLE_STRIP);
+        m_geometry.setIndexDataPattern(QSGGeometry::StaticPattern);
+        m_geometry.setVertexDataPattern(QSGGeometry::AlwaysUploadPattern);
+    }
+
+    QSGMaterial* material() Q_DECL_OVERRIDE { return &m_material; }
+    QSGMaterial* opaqueMaterial() Q_DECL_OVERRIDE { return &m_opaqueMaterial; }
+    QSGGeometry* geometry() Q_DECL_OVERRIDE { return &m_geometry; }
+
+    struct Vertex {
+        float x, y;
+        float borderS, borderT;
+        quint32 color;
+        quint32 borderColor;
+    };
+
+private:
+    static const QSGGeometry::AttributeSet& attributeSet() {
+        static const QSGGeometry::Attribute attributes[] = {
+            QSGGeometry::Attribute::create(0, 2, GL_FLOAT, true),    // x, y
+            QSGGeometry::Attribute::create(1, 2, GL_FLOAT),          // borderS, borderT
+            QSGGeometry::Attribute::create(2, 4, GL_UNSIGNED_BYTE),  // color
+            QSGGeometry::Attribute::create(3, 4, GL_UNSIGNED_BYTE)   // borderColor
+        };
+        static const QSGGeometry::AttributeSet attributeSet = {
+            4, sizeof(Vertex), attributes
+        };
+        return attributeSet;
+    }
+
+    UCShapeFillCenterBorderMaterial<false> m_material;
+    UCShapeFillCenterBorderMaterial<true> m_opaqueMaterial;
+    QSGGeometry m_geometry;
+};
+
+// #######################################
+// # Fill center shadow border materials #
+// #######################################
+
+class UCShapeFillCenterShadowBorderOpaqueShader : public QSGMaterialShader
+{
+public:
+    UCShapeFillCenterShadowBorderOpaqueShader() {
+        setShaderSourceFile(
+            QOpenGLShader::Vertex, QStringLiteral(
+                ":/uc/privates/shaders/fillcentershadowborder.vert"));
+        setShaderSourceFile(
+            QOpenGLShader::Fragment, QStringLiteral(
+                ":/uc/privates/shaders/fillcentershadowborder_opaque.frag"));
+    }
+    char const* const* attributeNames() const Q_DECL_OVERRIDE {
+        static char const* const attributes[] = {
+            "positionAttrib", "shadowCoordAttrib", "midShadowCoordAttrib", "borderCoordAttrib",
+            "colorAttrib", "shadowColorAttrib", "borderColorAttrib", 0
+        };
+        return attributes;
+    }
+    void initialize() Q_DECL_OVERRIDE {
+        QSGMaterialShader::initialize();
+        program()->bind();
+        program()->setUniformValue("shadowTexture", 0);
+        program()->setUniformValue("borderTexture", 1);
+        m_matrixId = program()->uniformLocation("matrix");
+    }
+    void updateState(
+        const RenderState& state, QSGMaterial* newEffect, QSGMaterial*) Q_DECL_OVERRIDE {
+        QOpenGLFunctions* funcs = QOpenGLContext::currentContext()->functions();
+        UCShapeTextureProvider* provider = dynamic_cast<UCShapeTextureProvider*>(newEffect);
+        funcs->glActiveTexture(GL_TEXTURE1);
+        funcs->glBindTexture(GL_TEXTURE_2D, provider->textureId(1));
+        funcs->glActiveTexture(GL_TEXTURE0);
+        funcs->glBindTexture(GL_TEXTURE_2D, provider->textureId(0));
+        if (state.isMatrixDirty()) {
+            program()->setUniformValue(m_matrixId, state.combinedMatrix());
+        }
+    }
+
+private:
+    int m_matrixId;
+};
+
+class UCShapeFillCenterShadowBorderShader : public UCShapeFillCenterShadowBorderOpaqueShader
+{
+public:
+    UCShapeFillCenterShadowBorderShader() : UCShapeFillCenterShadowBorderOpaqueShader() {
+        setShaderSourceFile(
+            QOpenGLShader::Fragment, QStringLiteral(
+                ":/uc/privates/shaders/fillcentershadowborder.frag"));
+    }
+    void initialize() Q_DECL_OVERRIDE {
+        UCShapeFillCenterShadowBorderOpaqueShader::initialize();
+        m_opacityId = program()->uniformLocation("opacity");
+    }
+    void updateState(
+        const RenderState& state, QSGMaterial* newEffect, QSGMaterial* oldEffect) Q_DECL_OVERRIDE {
+        UCShapeFillCenterShadowBorderOpaqueShader::updateState(state, newEffect, oldEffect);
+        if (state.isOpacityDirty()) {
+            program()->setUniformValue(m_opacityId, state.opacity());
+        }
+    }
+
+private:
+    int m_opacityId;
+};
+
+template <bool opaque>
+class UCShapeFillCenterShadowBorderMaterial : public QSGMaterial, public UCShapeTextureProvider
+{
+public:
+    UCShapeFillCenterShadowBorderMaterial() : m_textureId{0, 0} {
+        setFlag(Blending, !opaque);
+    }
+
+    QSGMaterialType* type() const Q_DECL_OVERRIDE {
+        static QSGMaterialType type[2];
+        return opaque ? &type[0] : &type[1];
+    }
+    QSGMaterialShader* createShader() const Q_DECL_OVERRIDE {
+        return opaque ?
+            new UCShapeFillCenterShadowBorderOpaqueShader : new UCShapeFillCenterShadowBorderShader;
+    }
+    int compare(const QSGMaterial* other) const Q_DECL_OVERRIDE {
+        const UCShapeTextureProvider* provider =
+            reinterpret_cast<const UCShapeTextureProvider*>(other);
+        if (provider->textureId(0) == m_textureId[0]) {
+            return provider->textureId(1) - m_textureId[1];
+        } else {
+            return -1;
+        }
+    }
+
+    quint32 textureId(int index) const Q_DECL_OVERRIDE {
+        DASSERT(index <= 1);
+        return m_textureId[index];
+    }
+    void updateShadowTexture(UCShapeType type, quint16 radius, quint16 shadow) {
+        m_textureId[0] = m_textureFactory.shadowTexture(0, type, radius, shadow);
+    }
+    void updateBorderTexture(UCShapeType type, quint16 radius) {
+        m_textureId[1] = m_textureFactory.maskTexture(1, type, radius);
+    }
+
+private:
+    UCShapeTextureFactory<2> m_textureFactory;
+    quint32 m_textureId[2];
+};
+
+class UCShapeFillCenterShadowBorderResources : public UCShapeResources
+{
+public:
+    UCShapeFillCenterShadowBorderResources(
+        int vertexCount, int indexCount, int indexType = GL_UNSIGNED_SHORT)
+        : m_geometry(attributeSet(), vertexCount, indexCount, indexType) {
+        m_geometry.setDrawingMode(GL_TRIANGLE_STRIP);
+        m_geometry.setIndexDataPattern(QSGGeometry::StaticPattern);
+        m_geometry.setVertexDataPattern(QSGGeometry::AlwaysUploadPattern);
+    }
+
+    QSGMaterial* material() Q_DECL_OVERRIDE { return &m_material; }
+    QSGMaterial* opaqueMaterial() Q_DECL_OVERRIDE { return &m_opaqueMaterial; }
+    QSGGeometry* geometry() Q_DECL_OVERRIDE { return &m_geometry; }
+
+    struct Vertex {
+        float x, y;
+        float shadowS, shadowT;
+        float midShadowS, midShadowT;
+        float borderS, borderT;
+        quint32 color;
+        quint32 shadowColor;
+        quint32 borderColor;
+    };
+
+private:
+    static const QSGGeometry::AttributeSet& attributeSet() {
+        static const QSGGeometry::Attribute attributes[] = {
+            QSGGeometry::Attribute::create(0, 2, GL_FLOAT, true),    // x, y
+            QSGGeometry::Attribute::create(1, 2, GL_FLOAT),          // shadowS, shadowT
+            QSGGeometry::Attribute::create(2, 2, GL_FLOAT),          // midShadowS, midShadowT
+            QSGGeometry::Attribute::create(3, 2, GL_FLOAT),          // borderS, borderT
+            QSGGeometry::Attribute::create(4, 4, GL_UNSIGNED_BYTE),  // color
+            QSGGeometry::Attribute::create(5, 4, GL_UNSIGNED_BYTE),  // shadowColor
+            QSGGeometry::Attribute::create(6, 4, GL_UNSIGNED_BYTE)   // borderColor
+        };
+        static const QSGGeometry::AttributeSet attributeSet = {
+            7, sizeof(Vertex), attributes
+        };
+        return attributeSet;
+    }
+
+    UCShapeFillCenterShadowBorderMaterial<false> m_material;
+    UCShapeFillCenterShadowBorderMaterial<true> m_opaqueMaterial;
+    QSGGeometry m_geometry;
+};
+
+// ####################
+// # Fill center node #
+// ####################
+
+class UCShapeFillCenterNode : public QSGGeometryNode
+{
+public:
+    UCShapeFillCenterNode();
+    ~UCShapeFillCenterNode();
+
+    void preprocess() Q_DECL_OVERRIDE;
+    bool isSubtreeBlocked() const Q_DECL_OVERRIDE { return !(m_flags & Visible); }
+
+    void setVisible(bool visible);
+    void update(
+        const QSizeF& itemSize, UCShapeType type, float radius, QRgb color, float shadowSize,
+        float shadowAngle, float shadowDistance, QRgb shadowColor, float borderSize,
+        QRgb borderColor);
+
+private:
+    enum {
+        HasColor          = (1 << 0),
+        HasShadow         = (1 << 1),
+        HasBorder         = (1 << 2),
+        StyleMask         = (HasColor | HasShadow | HasBorder),
+        Textured          = (HasShadow | HasBorder),
+        DirtyRadius       = (1 << 3),
+        DirtyShadow       = (1 << 4),
+        DirtyShape        = (1 << 5),
+        DirtyBorderRadius = (1 << 6),
+        DirtyMask         = (DirtyRadius | DirtyShadow | DirtyShape | DirtyBorderRadius),
+        Visible           = (1 << 7),
+        Blending          = (1 << 8)
+    };
+
+    UCShapeResources* m_resources;
+    quint16 m_radius;
+    quint16 m_shadow;
+    quint16 m_borderRadius;
+    quint16 m_flags;
+    quint8 m_shape;
+};
+
+// #################################
+// # Fill corners shadow materials #
+// #################################
+
+class UCShapeFillCornersShadowOpaqueShader : public QSGMaterialShader
+{
+public:
+    UCShapeFillCornersShadowOpaqueShader() {
+        setShaderSourceFile(QOpenGLShader::Vertex,
+                            QStringLiteral(":/uc/privates/shaders/fillcornersshadow.vert"));
+        setShaderSourceFile(QOpenGLShader::Fragment,
+                            QStringLiteral(":/uc/privates/shaders/fillcornersshadow_opaque.frag"));
+    }
+    char const* const* attributeNames() const Q_DECL_OVERRIDE {
+        static char const* const attributes[] = {
+            "positionAttrib", "maskCoordAttrib", "shadowCoordAttrib", "midShadowCoordAttrib",
+            "colorAttrib", "shadowColorAttrib", 0
+        };
+        return attributes;
+    }
+    void initialize() Q_DECL_OVERRIDE {
+        QSGMaterialShader::initialize();
+        program()->bind();
+        program()->setUniformValue("shadowTexture", 0);
+        m_matrixId = program()->uniformLocation("matrix");
+    }
+    void updateState(
+        const RenderState& state, QSGMaterial* newEffect, QSGMaterial*) Q_DECL_OVERRIDE {
+        QOpenGLFunctions* funcs = QOpenGLContext::currentContext()->functions();
+        UCShapeTextureProvider* provider = dynamic_cast<UCShapeTextureProvider*>(newEffect);
+        funcs->glBindTexture(GL_TEXTURE_2D, provider->textureId());
+        if (state.isMatrixDirty()) {
+            program()->setUniformValue(m_matrixId, state.combinedMatrix());
+        }
+    }
+
+private:
+    int m_matrixId;
+};
+
+class UCShapeFillCornersShadowShader : public UCShapeFillCornersShadowOpaqueShader
+{
+public:
+    UCShapeFillCornersShadowShader() : UCShapeFillCornersShadowOpaqueShader() {
+        setShaderSourceFile(QOpenGLShader::Fragment,
+                            QStringLiteral(":/uc/privates/shaders/fillcornersshadow.frag"));
+    }
+    void initialize() Q_DECL_OVERRIDE {
+        UCShapeFillCornersShadowOpaqueShader::initialize();
+        m_opacityId = program()->uniformLocation("opacity");
+    }
+    void updateState(
+        const RenderState& state, QSGMaterial* newEffect, QSGMaterial* oldEffect) Q_DECL_OVERRIDE {
+        UCShapeFillCornersShadowOpaqueShader::updateState(state, newEffect, oldEffect);
+        if (state.isOpacityDirty()) {
+            program()->setUniformValue(m_opacityId, state.opacity());
+        }
+    }
+
+private:
+    int m_opacityId;
+};
+
+template <bool opaque>
+class UCShapeFillCornersShadowMaterial : public QSGMaterial, public UCShapeTextureProvider
+{
+public:
+    UCShapeFillCornersShadowMaterial() : m_textureId(0) {
+        setFlag(Blending, !opaque);
+    }
+
+    QSGMaterialType* type() const Q_DECL_OVERRIDE {
+        static QSGMaterialType type[2];
+        return opaque ? &type[0] : &type[1];
+    }
+    QSGMaterialShader* createShader() const Q_DECL_OVERRIDE {
+        return opaque ?
+            new UCShapeFillCornersShadowOpaqueShader : new UCShapeFillCornersShadowShader;
+    }
+    int compare(const QSGMaterial* other) const Q_DECL_OVERRIDE {
+        return reinterpret_cast<const UCShapeTextureProvider*>(other)->textureId() - m_textureId;
+    }
+
+    quint32 textureId(int) const Q_DECL_OVERRIDE {
+        return m_textureId;
+    }
+    void updateShadowTexture(UCShapeType type, quint16 radius, quint16 shadow) {
+        m_textureId = m_textureFactory.shadowTexture(0, type, radius, shadow);
+    }
+
+private:
+    UCShapeTextureFactory<1> m_textureFactory;
+    quint32 m_textureId;
+};
+
+class UCShapeFillCornersShadowResources : public UCShapeResources
+{
+public:
+    UCShapeFillCornersShadowResources(
+        int vertexCount, int indexCount, int indexType = GL_UNSIGNED_SHORT)
+        : m_geometry(attributeSet(), vertexCount, indexCount, indexType) {
+        m_geometry.setDrawingMode(GL_TRIANGLE_STRIP);
+        m_geometry.setIndexDataPattern(QSGGeometry::StaticPattern);
+        m_geometry.setVertexDataPattern(QSGGeometry::AlwaysUploadPattern);
+    }
+
+    QSGMaterial* material() Q_DECL_OVERRIDE { return &m_material; }
+    QSGMaterial* opaqueMaterial() Q_DECL_OVERRIDE { return &m_opaqueMaterial; }
+    QSGGeometry* geometry() Q_DECL_OVERRIDE { return &m_geometry; }
+
+    struct Vertex {
+        float x, y;
+        float maskS, maskT;
+        float shadowS, shadowT;
+        float midShadowS, midShadowT;
+        quint32 color;
+        quint32 shadowColor;
+    };
+
+private:
+    static const QSGGeometry::AttributeSet& attributeSet() {
+        static const QSGGeometry::Attribute attributes[] = {
+            QSGGeometry::Attribute::create(0, 2, GL_FLOAT, true),    // x, y
+            QSGGeometry::Attribute::create(1, 2, GL_FLOAT),          // maskS, maskT
+            QSGGeometry::Attribute::create(2, 2, GL_FLOAT),          // shadowS, shadowT
+            QSGGeometry::Attribute::create(3, 2, GL_FLOAT),          // midShadowS, midShadowT
+            QSGGeometry::Attribute::create(4, 4, GL_UNSIGNED_BYTE),  // color
+            QSGGeometry::Attribute::create(5, 4, GL_UNSIGNED_BYTE)   // shadowColor
+        };
+        static const QSGGeometry::AttributeSet attributeSet = {
+            6, sizeof(Vertex), attributes
+        };
+        return attributeSet;
+    }
+
+    UCShapeFillCornersShadowMaterial<false> m_material;
+    UCShapeFillCornersShadowMaterial<true> m_opaqueMaterial;
+    QSGGeometry m_geometry;
+};
+
+// #################################
+// # Fill corners border materials #
+// #################################
+
+class UCShapeFillCornersBorderOpaqueShader : public QSGMaterialShader
+{
+public:
+    UCShapeFillCornersBorderOpaqueShader() {
+        setShaderSourceFile(
+            QOpenGLShader::Vertex, QStringLiteral(":/uc/privates/shaders/fillcornersborder.vert"));
+        setShaderSourceFile(
+            QOpenGLShader::Fragment, QStringLiteral(
+                ":/uc/privates/shaders/fillcornersborder_opaque.frag"));
+    }
+    char const* const* attributeNames() const Q_DECL_OVERRIDE {
+        static char const* const attributes[] = {
+            "positionAttrib", "maskCoordAttrib", "borderCoordAttrib", "colorAttrib",
+            "borderColorAttrib", 0
+        };
+        return attributes;
+    }
+    void initialize() Q_DECL_OVERRIDE {
+        QSGMaterialShader::initialize();
+        program()->bind();
+        program()->setUniformValue("maskTexture", 0);
+        program()->setUniformValue("borderTexture", 1);
+        m_matrixId = program()->uniformLocation("matrix");
+    }
+    void updateState(
+        const RenderState& state, QSGMaterial* newEffect, QSGMaterial*) Q_DECL_OVERRIDE {
+        QOpenGLFunctions* funcs = QOpenGLContext::currentContext()->functions();
+        UCShapeTextureProvider* provider = dynamic_cast<UCShapeTextureProvider*>(newEffect);
+        funcs->glActiveTexture(GL_TEXTURE1);
+        funcs->glBindTexture(GL_TEXTURE_2D, provider->textureId(1));
+        funcs->glActiveTexture(GL_TEXTURE0);
+        funcs->glBindTexture(GL_TEXTURE_2D, provider->textureId(0));
+        if (state.isMatrixDirty()) {
+            program()->setUniformValue(m_matrixId, state.combinedMatrix());
+        }
+    }
+
+private:
+    int m_matrixId;
+};
+
+class UCShapeFillCornersBorderShader : public UCShapeFillCornersBorderOpaqueShader
+{
+public:
+    UCShapeFillCornersBorderShader() : UCShapeFillCornersBorderOpaqueShader() {
+        setShaderSourceFile(
+            QOpenGLShader::Fragment, QStringLiteral(
+                ":/uc/privates/shaders/fillcornersborder.frag"));
+    }
+    void initialize() Q_DECL_OVERRIDE {
+        UCShapeFillCornersBorderOpaqueShader::initialize();
+        m_opacityId = program()->uniformLocation("opacity");
+    }
+    void updateState(
+        const RenderState& state, QSGMaterial* newEffect, QSGMaterial* oldEffect) Q_DECL_OVERRIDE {
+        UCShapeFillCornersBorderOpaqueShader::updateState(state, newEffect, oldEffect);
+        if (state.isOpacityDirty()) {
+            program()->setUniformValue(m_opacityId, state.opacity());
+        }
+    }
+
+private:
+    int m_opacityId;
+};
+
+template <bool opaque>
+class UCShapeFillCornersBorderMaterial : public QSGMaterial, public UCShapeTextureProvider
+{
+public:
+    UCShapeFillCornersBorderMaterial() : m_textureId{0, 0} {
+        setFlag(Blending, !opaque);
+    }
+
+    QSGMaterialType* type() const Q_DECL_OVERRIDE {
+        static QSGMaterialType type[2];
+        return opaque ? &type[0] : &type[1];
+    }
+    QSGMaterialShader* createShader() const Q_DECL_OVERRIDE {
+        return opaque ?
+            new UCShapeFillCornersBorderOpaqueShader : new UCShapeFillCornersBorderShader;
+    }
+    int compare(const QSGMaterial* other) const Q_DECL_OVERRIDE {
+        const UCShapeTextureProvider* provider =
+            reinterpret_cast<const UCShapeTextureProvider*>(other);
+        if (provider->textureId(0) == m_textureId[0]) {
+            return provider->textureId(1) - m_textureId[1];
+        } else {
+            return -1;
+        }
+    }
+
+    quint32 textureId(int index) const Q_DECL_OVERRIDE {
+        DASSERT(index <= 1);
+        return m_textureId[index];
+    }
+    void updateMaskTexture(UCShapeType type, quint16 radius) {
+        m_textureId[0] = m_textureFactory.maskTexture(0, type, radius);
+    }
+    void updateBorderTexture(UCShapeType type, quint16 radius) {
+        m_textureId[1] = m_textureFactory.maskTexture(1, type, radius);
+    }
+
+private:
+    UCShapeTextureFactory<2> m_textureFactory;
+    quint32 m_textureId[2];
+};
+
+class UCShapeFillCornersBorderResources : public UCShapeResources
+{
+public:
+    UCShapeFillCornersBorderResources(
+        int vertexCount, int indexCount, int indexType = GL_UNSIGNED_SHORT)
+        : m_geometry(attributeSet(), vertexCount, indexCount, indexType) {
+        m_geometry.setDrawingMode(GL_TRIANGLE_STRIP);
+        m_geometry.setIndexDataPattern(QSGGeometry::StaticPattern);
+        m_geometry.setVertexDataPattern(QSGGeometry::AlwaysUploadPattern);
+    }
+
+    QSGMaterial* material() Q_DECL_OVERRIDE { return &m_material; }
+    QSGMaterial* opaqueMaterial() Q_DECL_OVERRIDE { return &m_opaqueMaterial; }
+    QSGGeometry* geometry() Q_DECL_OVERRIDE { return &m_geometry; }
+
+    struct Vertex {
+        float x, y;
+        float maskS, maskT;
+        float borderS, borderT;
+        quint32 color;
+        quint32 borderColor;
+    };
+
+private:
+    static const QSGGeometry::AttributeSet& attributeSet() {
+        static const QSGGeometry::Attribute attributes[] = {
+            QSGGeometry::Attribute::create(0, 2, GL_FLOAT, true),    // x, y
+            QSGGeometry::Attribute::create(1, 2, GL_FLOAT),          // maskS, maskT
+            QSGGeometry::Attribute::create(2, 2, GL_FLOAT),          // borderS, borderT
+            QSGGeometry::Attribute::create(3, 4, GL_UNSIGNED_BYTE),  // color
+            QSGGeometry::Attribute::create(4, 4, GL_UNSIGNED_BYTE)   // borderColor
+        };
+        static const QSGGeometry::AttributeSet attributeSet = {
+            5, sizeof(Vertex), attributes
+        };
+        return attributeSet;
+    }
+
+    UCShapeFillCornersBorderMaterial<false> m_material;
+    UCShapeFillCornersBorderMaterial<true> m_opaqueMaterial;
+    QSGGeometry m_geometry;
+};
+
+// ########################################
+// # Fill corners shadow border materials #
+// ########################################
+
+class UCShapeFillCornersShadowBorderOpaqueShader : public QSGMaterialShader
+{
+public:
+    UCShapeFillCornersShadowBorderOpaqueShader() {
+        setShaderSourceFile(
+            QOpenGLShader::Vertex, QStringLiteral(
+                ":/uc/privates/shaders/fillcornersshadowborder.vert"));
+        setShaderSourceFile(
+            QOpenGLShader::Fragment, QStringLiteral(
+                ":/uc/privates/shaders/fillcornersshadowborder_opaque.frag"));
+    }
+    char const* const* attributeNames() const Q_DECL_OVERRIDE {
+        static char const* const attributes[] = {
+            "positionAttrib", "maskCoordAttrib", "shadowCoordAttrib", "midShadowCoordAttrib",
+            "borderCoordAttrib", "colorAttrib", "shadowColorAttrib", "borderColorAttrib", 0
+        };
+        return attributes;
+    }
+    void initialize() Q_DECL_OVERRIDE {
+        QSGMaterialShader::initialize();
+        program()->bind();
+        program()->setUniformValue("shadowtexture", 0);
+        program()->setUniformValue("borderTexture", 1);
+        m_matrixId = program()->uniformLocation("matrix");
+    }
+    void updateState(
+        const RenderState& state, QSGMaterial* newEffect, QSGMaterial*) Q_DECL_OVERRIDE {
+        QOpenGLFunctions* funcs = QOpenGLContext::currentContext()->functions();
+        UCShapeTextureProvider* provider = dynamic_cast<UCShapeTextureProvider*>(newEffect);
+        funcs->glActiveTexture(GL_TEXTURE1);
+        funcs->glBindTexture(GL_TEXTURE_2D, provider->textureId(1));
+        funcs->glActiveTexture(GL_TEXTURE0);
+        funcs->glBindTexture(GL_TEXTURE_2D, provider->textureId(0));
+        if (state.isMatrixDirty()) {
+            program()->setUniformValue(m_matrixId, state.combinedMatrix());
+        }
+    }
+
+private:
+    int m_matrixId;
+};
+
+class UCShapeFillCornersShadowBorderShader : public UCShapeFillCornersShadowBorderOpaqueShader
+{
+public:
+    UCShapeFillCornersShadowBorderShader() : UCShapeFillCornersShadowBorderOpaqueShader() {
+        setShaderSourceFile(QOpenGLShader::Fragment,
+                            QStringLiteral(":/uc/privates/shaders/fillcornersshadowborder.frag"));
+    }
+    void initialize() Q_DECL_OVERRIDE {
+        UCShapeFillCornersShadowBorderOpaqueShader::initialize();
+        m_opacityId = program()->uniformLocation("opacity");
+    }
+    void updateState(
+        const RenderState& state, QSGMaterial* newEffect, QSGMaterial* oldEffect) Q_DECL_OVERRIDE {
+        UCShapeFillCornersShadowBorderOpaqueShader::updateState(state, newEffect, oldEffect);
+        if (state.isOpacityDirty()) {
+            program()->setUniformValue(m_opacityId, state.opacity());
+        }
+    }
+
+private:
+    int m_opacityId;
+};
+
+template <bool opaque>
+class UCShapeFillCornersShadowBorderMaterial : public QSGMaterial, public UCShapeTextureProvider
+{
+public:
+    UCShapeFillCornersShadowBorderMaterial() : m_textureId{0, 0} {
+        setFlag(Blending, !opaque);
+    }
+
+    QSGMaterialType* type() const Q_DECL_OVERRIDE {
+        static QSGMaterialType type[2];
+        return opaque ? &type[0] : &type[1];
+    }
+    QSGMaterialShader* createShader() const Q_DECL_OVERRIDE {
+        return opaque ?
+            new UCShapeFillCornersShadowBorderOpaqueShader :
+            new UCShapeFillCornersShadowBorderShader;
+    }
+    int compare(const QSGMaterial* other) const Q_DECL_OVERRIDE {
+        const UCShapeTextureProvider* provider =
+            reinterpret_cast<const UCShapeTextureProvider*>(other);
+        if (provider->textureId(0) == m_textureId[0]) {
+            return provider->textureId(1) - m_textureId[1];
+        } else {
+            return -1;
+        }
+    }
+
+    quint32 textureId(int index) const Q_DECL_OVERRIDE {
+        DASSERT(index <= 1);
+        return m_textureId[index];
+    }
+    void updateShadowTexture(UCShapeType type, quint16 radius, quint16 shadow) {
+        m_textureId[0] = m_textureFactory.shadowTexture(0, type, radius, shadow);
+    }
+    void updateBorderTexture(UCShapeType type, quint16 radius) {
+        m_textureId[1] = m_textureFactory.maskTexture(1, type, radius);
+    }
+
+private:
+    UCShapeTextureFactory<2> m_textureFactory;
+    quint32 m_textureId[2];
+};
+
+class UCShapeFillCornersShadowBorderResources : public UCShapeResources
+{
+public:
+    UCShapeFillCornersShadowBorderResources(
+        int vertexCount, int indexCount, int indexType = GL_UNSIGNED_SHORT)
+        : m_geometry(attributeSet(), vertexCount, indexCount, indexType) {
+        m_geometry.setDrawingMode(GL_TRIANGLE_STRIP);
+        m_geometry.setIndexDataPattern(QSGGeometry::StaticPattern);
+        m_geometry.setVertexDataPattern(QSGGeometry::AlwaysUploadPattern);
+    }
+
+    QSGMaterial* material() Q_DECL_OVERRIDE { return &m_material; }
+    QSGMaterial* opaqueMaterial() Q_DECL_OVERRIDE { return &m_opaqueMaterial; }
+    QSGGeometry* geometry() Q_DECL_OVERRIDE { return &m_geometry; }
+
+    struct Vertex {
+        float x, y;
+        float maskS, maskT;
+        float shadowS, shadowT;
+        float midShadowS, midShadowT;
+        float borderS, borderT;
+        quint32 color;
+        quint32 shadowColor;
+        quint32 borderColor;
+    };
+
+private:
+    static const QSGGeometry::AttributeSet& attributeSet() {
+        static const QSGGeometry::Attribute attributes[] = {
+            QSGGeometry::Attribute::create(0, 2, GL_FLOAT, true),    // x, y
+            QSGGeometry::Attribute::create(1, 2, GL_FLOAT),          // maskS, maskT
+            QSGGeometry::Attribute::create(2, 2, GL_FLOAT),          // shadowS, shadowT
+            QSGGeometry::Attribute::create(3, 2, GL_FLOAT),          // midShadowS, midShadowT
+            QSGGeometry::Attribute::create(4, 2, GL_FLOAT),          // borderS, borderT
+            QSGGeometry::Attribute::create(5, 4, GL_UNSIGNED_BYTE),  // color
+            QSGGeometry::Attribute::create(6, 4, GL_UNSIGNED_BYTE),  // shadowColor
+            QSGGeometry::Attribute::create(7, 4, GL_UNSIGNED_BYTE)   // borderColor
+        };
+        static const QSGGeometry::AttributeSet attributeSet = {
+            8, sizeof(Vertex), attributes
+        };
+        return attributeSet;
+    }
+
+    UCShapeFillCornersShadowBorderMaterial<false> m_material;
+    UCShapeFillCornersShadowBorderMaterial<true> m_opaqueMaterial;
+    QSGGeometry m_geometry;
+};
+
+// #####################
+// # Fill corners node #
+// #####################
+
+class UCShapeFillCornersNode : public QSGGeometryNode
+{
+public:
+    UCShapeFillCornersNode();
+    ~UCShapeFillCornersNode();
+
+    void preprocess() Q_DECL_OVERRIDE;
+    bool isSubtreeBlocked() const Q_DECL_OVERRIDE { return !(m_flags & Visible); }
+
+    void setVisible(bool visible);
+    void update(
+        const QSizeF& itemSize, UCShapeType type, float radius, QRgb color, float shadowSize,
+        float shadowAngle, float shadowDistance, QRgb shadowColor, float borderSize,
+        QRgb borderColor);
+
+private:
+    enum {
+        HasColor          = (1 << 0),
+        HasShadow         = (1 << 1),
+        HasBorder         = (1 << 2),
+        StyleMask         = (HasColor | HasShadow | HasBorder),
+        DirtyRadius       = (1 << 3),
+        DirtyShadow       = (1 << 4),
+        DirtyShape        = (1 << 5),
+        DirtyBorderRadius = (1 << 6),
+        DirtyMask         = (DirtyRadius | DirtyShadow | DirtyShape | DirtyBorderRadius),
+        Visible           = (1 << 7),
+        Blending          = (1 << 8)
+    };
+
+    UCShapeResources* m_resources;
+    quint16 m_radius;
+    quint16 m_shadow;
+    quint16 m_borderRadius;
+    quint16 m_flags;
+    quint8 m_shape;
+};
+
+#endif  // UCSHAPEFILLNODES_P_H

=== renamed file 'src/UbuntuToolkit/privates/frame.cpp' => 'src/UbuntuToolkit/privates/ucshapeframenodes.cpp'
--- src/UbuntuToolkit/privates/frame.cpp	2016-09-09 17:49:07 +0000
+++ src/UbuntuToolkit/privates/ucshapeframenodes.cpp	2016-12-14 07:25:05 +0000
@@ -16,68 +16,191 @@
  * Author: Loïc Molinari <[e-mail]>
  */
 
-#include "privates/frame_p.h"
+#include "ucshapeframenodes_p.h"
 
-#include <QtGui/QOpenGLContext>
+#include <QtGui/QGuiApplication>
 #include <QtGui/QOpenGLFunctions>
 
-#include "privates/textures_p.h"
-
-UT_NAMESPACE_BEGIN
-
-const QRgb defaultColor = qRgba(255, 255, 255, 255);
-const float defaultThickness = 20.0f;
-const float defaultRadius = 50.0f;
-
-// --- Shader ---
-
-class FrameShader : public QSGMaterialShader
+UCShapeFrameEdgesNode::UCShapeFrameEdgesNode()
+    : QSGGeometryNode()
+    , m_resources(16, 22, GL_UNSIGNED_SHORT)
+    , m_visible(0)
+    , m_blending(0)
+{
+    DLOG("creating UCShapeFrameEdgesNode");
+
+    setMaterial(m_resources.material());
+    setOpaqueMaterial(m_resources.opaqueMaterial());
+
+    // The geometry is made of 16 vertices indexed with a triangle strip mode.
+    //        0 ----- 1
+    //         2 --- 3
+    //     4             5
+    //     | 6         7 |
+    //     | |         | |
+    //     | 8         9 |
+    //    10             11
+    //        12 --- 13
+    //       14 ----- 15
+    const quint16 indices[] = {
+        0, 2, 1, 3,
+        3, 4,  // Degenerate triangle.
+        4, 10, 6, 8,
+        8, 7,  // Degenerate triangle.
+        7, 9, 5, 11,
+        11, 12,  // Degenerate triangle.
+        12, 14, 13, 15
+    };
+    memcpy(m_resources.geometry()->indexData(), indices, 22 * sizeof(quint16));
+    setGeometry(m_resources.geometry());
+
+    qsgnode_set_description(this, QLatin1String("shapeframeedges"));
+}
+
+UCShapeFrameEdgesNode::~UCShapeFrameEdgesNode()
+{
+    DLOG("detroying UCShapeFrameEdgesNode");
+}
+
+void UCShapeFrameEdgesNode::setVisible(bool visible)
+{
+    DLOG("UCShapeFrameEdgesNode::setVisible %d", visible);
+    if (m_visible != visible) {
+        m_visible = visible;
+        markDirty(DirtySubtreeBlocked);
+    }
+}
+
+void UCShapeFrameEdgesNode::update(
+    const QSizeF& itemSize, float radius, float thickness, float space, QRgb color)
+{
+    Q_UNUSED(space);
+    // FIXME(loicm) Add space support.
+
+    UCShapeColorResources::Vertex* v =
+        reinterpret_cast<UCShapeColorResources::Vertex*>(m_resources.geometry()->vertexData());
+    const float w = static_cast<float>(itemSize.width());
+    const float h = static_cast<float>(itemSize.height());
+    // FIXME(loicm) Rounded down since renderShape() doesn't support sub-pixel rendering.
+    const float maxSize = floorf(qMin(w, h) * 0.5f);
+    const float clampedThickness = qMin(floorf(thickness), maxSize);
+    const float outerRadius = qMin(floorf(radius), maxSize);
+    // FIXME(loicm) Rounded down since renderShape() doesn't support sub-pixel rendering.
+    const float innerRadius = floorf(outerRadius * ((maxSize - clampedThickness) / maxSize));
+    const quint32 packedColor = packColor(color);
+
+    v[0].x = outerRadius;
+    v[0].y = 0.0f;
+    v[0].color = packedColor;
+    v[1].x = w - outerRadius;
+    v[1].y = 0.0f;
+    v[1].color = packedColor;
+    v[2].x = clampedThickness + innerRadius;
+    v[2].y = clampedThickness;
+    v[2].color = packedColor;
+    v[3].x = w - clampedThickness - innerRadius;
+    v[3].y = clampedThickness;
+    v[3].color = packedColor;
+    v[4].x = 0.0f;
+    v[4].y = outerRadius;
+    v[4].color = packedColor;
+    v[5].x = w;
+    v[5].y = outerRadius;
+    v[5].color = packedColor;
+    v[6].x = clampedThickness;
+    v[6].y = clampedThickness + innerRadius;
+    v[6].color = packedColor;
+    v[7].x = w - clampedThickness;
+    v[7].y = clampedThickness + innerRadius;
+    v[7].color = packedColor;
+    v[8].x = clampedThickness;
+    v[8].y = h - clampedThickness - innerRadius;
+    v[8].color = packedColor;
+    v[9].x = w - clampedThickness;
+    v[9].y = h - clampedThickness - innerRadius;
+    v[9].color = packedColor;
+    v[10].x = 0.0f;
+    v[10].y = h - outerRadius;
+    v[10].color = packedColor;
+    v[11].x = w;
+    v[11].y = h - outerRadius;
+    v[11].color = packedColor;
+    v[12].x = clampedThickness + innerRadius;
+    v[12].y = h - clampedThickness;
+    v[12].color = packedColor;
+    v[13].x = w - clampedThickness - innerRadius;
+    v[13].y = h - clampedThickness;
+    v[13].color = packedColor;
+    v[14].x = outerRadius;
+    v[14].y = h;
+    v[14].color = packedColor;
+    v[15].x = w - outerRadius;
+    v[15].y = h;
+    v[15].color = packedColor;
+    markDirty(QSGNode::DirtyGeometry);
+
+    // Update the blending state of the opaque material (in QSG terms, an opaque
+    // material is the material automatically used when the opacity is 1, but
+    // even if the opacity is 1 we have to handle the case where the alpha of
+    // the specified color is less than 1).
+    const bool blending = qAlpha(color) < 255;
+    if (blending != static_cast<bool>(m_blending)) {
+        m_resources.opaqueMaterial()->setFlag(QSGMaterial::Blending, blending);
+        markDirty(QSGNode::DirtyMaterial);
+    }
+}
+
+class UCShapeFrameCornersShader : public QSGMaterialShader
 {
 public:
-    FrameShader();
-    char const* const* attributeNames() const override;
-    void initialize() override;
+    UCShapeFrameCornersShader();
+    char const* const* attributeNames() const Q_DECL_OVERRIDE;
+    void initialize() Q_DECL_OVERRIDE;
     void updateState(
-        const RenderState& state, QSGMaterial* newEffect, QSGMaterial* oldEffect) override;
+        const RenderState& state, QSGMaterial* newEffect, QSGMaterial* oldEffect) Q_DECL_OVERRIDE;
 
 private:
     int m_matrixId;
     int m_opacityId;
 };
 
-FrameShader::FrameShader()
+UCShapeFrameCornersShader::UCShapeFrameCornersShader()
 {
-    setShaderSourceFile(
-        QOpenGLShader::Vertex, QStringLiteral(":/uc/privates/shaders/frame.vert"));
-    setShaderSourceFile(
-        QOpenGLShader::Fragment, QStringLiteral(":/uc/privates/shaders/frame.frag"));
+    setShaderSourceFile(QOpenGLShader::Vertex,
+                        QStringLiteral(":/uc/privates/shaders/texture2.vert"));
+    setShaderSourceFile(QOpenGLShader::Fragment,
+                        QStringLiteral(":/uc/privates/shaders/frame.frag"));
 }
 
-char const* const* FrameShader::attributeNames() const
+char const* const* UCShapeFrameCornersShader::attributeNames() const
 {
     static char const* const attributes[] = {
-        "positionAttrib", "outerCoordAttrib", "innerCoordAttrib", "colorAttrib", 0
+        "positionAttrib", "texCoord1Attrib", "texCoord2Attrib", "colorAttrib", 0
     };
     return attributes;
 }
 
-void FrameShader::initialize()
+void UCShapeFrameCornersShader::initialize()
 {
     QSGMaterialShader::initialize();
     program()->bind();
-    program()->setUniformValue("texture", 0);
+    const GLint values[2] = { 0, 1 };
+    program()->setUniformValueArray("texture", values, 2);
     m_matrixId = program()->uniformLocation("matrix");
     m_opacityId = program()->uniformLocation("opacity");
 }
 
-void FrameShader::updateState(
+void UCShapeFrameCornersShader::updateState(
     const RenderState& state, QSGMaterial* newEffect, QSGMaterial* oldEffect)
 {
     Q_UNUSED(oldEffect);
 
     QOpenGLFunctions* funcs = QOpenGLContext::currentContext()->functions();
-    funcs->glBindTexture(
-        GL_TEXTURE_2D, static_cast<UCFrameMaterial*>(newEffect)->textureId());
+    UCShapeFrameCornersMaterial* material = static_cast<UCShapeFrameCornersMaterial*>(newEffect);
+    funcs->glActiveTexture(GL_TEXTURE1);
+    funcs->glBindTexture(GL_TEXTURE_2D, material->innerTextureId());
+    funcs->glActiveTexture(GL_TEXTURE0);
+    funcs->glBindTexture(GL_TEXTURE_2D, material->outerTextureId());
 
     if (state.isMatrixDirty()) {
         program()->setUniformValue(m_matrixId, state.combinedMatrix());
@@ -87,136 +210,87 @@
     }
 }
 
-// --- Material ---
-
-const int maxTextures = 16;
-static struct { QOpenGLContext* openglContext; quint32 textureId; } textures[maxTextures];
-
-// Gets the textures' slot used by the given context, or -1 if not stored.
-static int getTexturesIndex(const QOpenGLContext* openglContext)
-{
-    int index = 0;
-    while (textures[index].openglContext != openglContext) {
-        index++;
-        if (index == maxTextures) {
-            return -1;
-        }
-    }
-    return index;
-}
-
-// Gets an empty textures' slot.
-static int getEmptyTexturesIndex()
-{
-    int index = 0;
-    while (textures[index].openglContext) {
-        index++;
-        if (index == maxTextures) {
-            // Don't bother with a dynamic array, let's just set a high enough
-            // maxTextures and increase the static array size if ever needed.
-            qFatal("reached maximum number of OpenGL contexts supported per item.");
-        }
-    }
-    return index;
-}
-
-UCFrameMaterial::UCFrameMaterial()
+UCShapeFrameCornersMaterial::UCShapeFrameCornersMaterial()
 {
     setFlag(Blending, true);
-
-    // Get the texture stored per context and shared by all materials of the same type.
-    QOpenGLContext* openglContext = QOpenGLContext::currentContext();
-    int index = getTexturesIndex(openglContext);
-    if (index < 0) {
-        QOpenGLFunctions* funcs = openglContext->functions();
-        index = getEmptyTexturesIndex();
-        textures[index].openglContext = openglContext;
-        funcs->glGenTextures(1, &textures[index].textureId);
-        funcs->glBindTexture(GL_TEXTURE_2D, textures[index].textureId);
-        funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-        funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-        // FIXME(loicm) GL_LINEAR_MIPMAP_[NEAREST,LINEAR] perf/quality tradeoff.
-        funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
-        funcs->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
-        // Set the highest mipmap level in order to avoid clamp to edge issues
-        // with inner corners starting from mipmap level 5 (OpenGL ES 2 doesn't
-        // support GL_TEXTURE_MAX_LOD).
-        funcs->glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_LOD, 4.0f);
-        for (int i = 0; i < shapeMipmapCount; i++) {
-            funcs->glTexImage2D(GL_TEXTURE_2D, i, GL_LUMINANCE, shapeMipmapBaseSize >> i,
-                                shapeMipmapBaseSize >> i, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE,
-                                &shapeMipmapData[shapeMipmapOffsets[i]]);
-        }
-        QObject::connect(
-            openglContext, &QOpenGLContext::aboutToBeDestroyed, [index] {
-                QOpenGLFunctions* funcs = textures[index].openglContext->functions();
-                funcs->glDeleteTextures(1, &textures[index].textureId);
-                textures[index].openglContext = NULL;
-            });
-    }
-    m_textureId = textures[index].textureId;
 }
 
-QSGMaterialType* UCFrameMaterial::type() const
+QSGMaterialType* UCShapeFrameCornersMaterial::type() const
 {
     static QSGMaterialType type;
     return &type;
 }
 
-QSGMaterialShader* UCFrameMaterial::createShader() const
-{
-    return new FrameShader;
-}
-
-int UCFrameMaterial::compare(const QSGMaterial* other) const
-{
-    Q_UNUSED(other);
-    return 0;
-}
-
-// --- Node ---
-
-UCFrameNode::UCFrameNode()
+QSGMaterialShader* UCShapeFrameCornersMaterial::createShader() const
+{
+    return new UCShapeFrameCornersShader;
+}
+
+int UCShapeFrameCornersMaterial::compare(const QSGMaterial* other) const
+{
+    const UCShapeFrameCornersMaterial* otherFrameCornersMaterial =
+        static_cast<const UCShapeFrameCornersMaterial*>(other);
+    if (otherFrameCornersMaterial->outerTextureId() != m_textureId[0]) {
+        return -1;
+    }
+    return otherFrameCornersMaterial->innerTextureId() - m_textureId[1];
+}
+
+void UCShapeFrameCornersMaterial::updateTexture(int index, UCShapeType type, quint16 radius)
+{
+    DASSERT(index >= 0 && index < 2);
+    //DASSERT(radius >= 0);
+    m_textureId[index] = m_textureFactory.maskTexture(index, type, radius);
+}
+
+UCShapeFrameCornersNode::UCShapeFrameCornersNode()
     : QSGGeometryNode()
     , m_material()
-    , m_geometry(attributeSet(), 20, 34, GL_UNSIGNED_SHORT)
+    , m_geometry(attributeSet(), 20, 26, GL_UNSIGNED_SHORT)
+    , m_radius{0, 0}
+    , m_newRadius{0, 0}
+    , m_type(0)
+    , m_newType(0)
+    , m_visible(0)
 {
-    memcpy(m_geometry.indexData(), indices(), 34 * sizeof(unsigned short));
+    DLOG("creating UCShapeFrameCornersNode");
+    setFlag(QSGNode::UsePreprocess);
+    memcpy(m_geometry.indexData(), indices(), 26 * sizeof(quint16));
     m_geometry.setDrawingMode(GL_TRIANGLE_STRIP);
     m_geometry.setIndexDataPattern(QSGGeometry::StaticPattern);
     m_geometry.setVertexDataPattern(QSGGeometry::AlwaysUploadPattern);
     setMaterial(&m_material);
     setGeometry(&m_geometry);
-    qsgnode_set_description(this, QLatin1String("frame"));
+    qsgnode_set_description(this, QLatin1String("shapeframecorners"));
 }
 
 // static
-const unsigned short* UCFrameNode::indices()
+const quint16* UCShapeFrameCornersNode::indices()
 {
     // The geometry is made of 20 vertices indexed with a triangle strip mode.
-    //     0 -1 ----- 2- 3
-    //     |   4 --- 5   |
-    //     6  /       \  9
-    //     | 7         8 |
-    //     | |         | |
-    //     | 11       12 |
-    //    10  \       /  13
-    //     |   14---15   |
-    //    16 -17 --- 18- 19
-    static const unsigned short indices[] = {
-        6, 7, 0, 4, 1, 5, 2,
-        2, 2,  // Degenerate triangle.
-        2, 5, 3, 8, 9, 12, 13,
-        13, 13,  // Degenerate triangle.
-        13, 12, 19, 15, 18, 14, 17,
-        17, 17,  // Degenerate triangle.
-        17, 14, 16, 11, 10, 7, 6
+    //     0 -1       2- 3
+    //     |   4     5   |
+    //     6  /       \  7
+    //       8         9
+    //
+    //       10       11
+    //    12  \       /  13
+    //     |   14   15   |
+    //    16 -17     18- 19
+    static const quint16 indices[] = {
+        0, 6, 1, 8, 4,
+        4, 5,  // Degenerate triangle.
+        5, 9, 2, 7, 3,
+        3, 16,  // Degenerate triangle.
+        16, 12, 17, 10, 14,
+        14, 15,  // Degenerate triangle.
+        15, 11, 18, 13, 19
     };
     return indices;
 }
 
 // static
-const QSGGeometry::AttributeSet& UCFrameNode::attributeSet()
+const QSGGeometry::AttributeSet& UCShapeFrameCornersNode::attributeSet()
 {
     static const QSGGeometry::Attribute attributes[] = {
         QSGGeometry::Attribute::create(0, 2, GL_FLOAT, true),
@@ -230,246 +304,238 @@
     return attributeSet;
 }
 
-// Pack a color in a premultiplied 32-bit ABGR value.
-static quint32 packColor(QRgb color)
-{
-    const quint32 a = qAlpha(color);
-    const quint32 b = ((qBlue(color) * a) + 0xff) >> 8;
-    const quint32 g = ((qGreen(color) * a) + 0xff) >> 8;
-    const quint32 r = ((qRed(color) * a) + 0xff) >> 8;
-    return (a << 24) | ((b & 0xff) << 16) | ((g & 0xff) << 8) | (r & 0xff);
-}
-
-void UCFrameNode::updateGeometry(
-    const QSizeF& itemSize, float thickness, float radius, QRgb color)
-{
-    UCFrameNode::Vertex* v = reinterpret_cast<UCFrameNode::Vertex*>(m_geometry.vertexData());
+void UCShapeFrameCornersNode::preprocess()
+{
+    const bool hasNewType = m_newType != m_type;
+    for (int i = 0; i < 2; i++) {
+        if (hasNewType || m_newRadius[i] != m_radius[i]) {
+            m_material.updateTexture(i, static_cast<UCShapeType>(m_newType), m_newRadius[i]);
+            m_radius[i] = m_newRadius[i];
+        }
+    }
+    if (hasNewType) {
+        m_type = m_newType;
+    }
+}
+
+void UCShapeFrameCornersNode::setVisible(bool visible)
+{
+    DLOG("UCShapeFrameCornersNode::setVisible %d", visible);
+    if (m_visible != visible) {
+        m_visible = visible;
+        markDirty(DirtySubtreeBlocked);
+    }
+}
+
+void UCShapeFrameCornersNode::update(
+    const QSizeF& itemSize, UCShapeType type, float radius, float thickness, float space,
+    QRgb color)
+{
+    Q_UNUSED(space);
+    // FIXME(loicm) Add space support.
+
+    // FIXME(loicm) Temp hack to hide the broken rendering of corners which
+    //     slightly appears when the thickness is less than 1.
+    if (thickness < 1.0f) {
+        radius = 0.0f;
+    }
+
+    UCShapeFrameCornersNode::Vertex* v =
+        reinterpret_cast<UCShapeFrameCornersNode::Vertex*>(m_geometry.vertexData());
+    const float devicePixelRatio = qGuiApp->devicePixelRatio();
     const float w = static_cast<float>(itemSize.width());
     const float h = static_cast<float>(itemSize.height());
-    const float maxSize = qMin(w, h) * 0.5f;
-    const float clampedThickness = qMin(thickness, maxSize);
-    const float radiusOut = qBound(0.01f, radius, maxSize);
-    const float radiusIn = radiusOut * ((maxSize - clampedThickness) / maxSize);
-    const float outerCoord1 =
-        (((1.0f - shapeOffset) / radiusOut) * (clampedThickness + radiusIn)) + shapeOffset;
-    const float outerCoord2 =
-        (((1.0f - shapeOffset) / radiusOut) * clampedThickness) + shapeOffset;
-    const float innerCoord1 =
-        (((1.0f - shapeOffset) / radiusIn) * -clampedThickness) + shapeOffset;
-    const float innerCoord2 =
-        (((1.0f - shapeOffset) / radiusIn) * (radiusOut - clampedThickness)) + shapeOffset;
+    // FIXME(loicm) Rounded down since renderShape() doesn't support sub-pixel rendering.
+    const float maxSize = floorf(qMin(w, h) * 0.5f);
+    const float clampedThickness = qMin(floorf(thickness), maxSize);
+    const float deviceThickness = clampedThickness * devicePixelRatio;
+    const float border = 1.0f;
+    const float outerRadius = qMin(floorf(radius), maxSize);
+    const float deviceOuterRadius = outerRadius * devicePixelRatio;
+    // FIXME(loicm) Rounded down since renderShape() doesn't support sub-pixel rendering.
+    const float outerRadiusRounded =
+        roundUp(static_cast<int>(deviceOuterRadius + 2 * border), textureRounding);
+    const float innerRadius = floorf(outerRadius * ((maxSize - clampedThickness) / maxSize));
+    const float deviceInnerRadius = innerRadius * devicePixelRatio;
+    const float innerRadiusRounded =
+        roundUp(static_cast<int>(deviceInnerRadius + 2 * border), textureRounding);
+
+    const float outerRadiusOffset = outerRadiusRounded - deviceOuterRadius - border;
+    const float outerTextureFactor = 1.0f / outerRadiusRounded;
+    const float outerS0 = outerTextureFactor * outerRadiusOffset;
+    const float outerS1 = outerTextureFactor * (outerRadiusOffset + deviceOuterRadius);
+    const float outerS2 = outerTextureFactor * (outerRadiusOffset + deviceThickness);
+    const float outerS3 =
+        outerTextureFactor * (outerRadiusOffset + deviceThickness + deviceInnerRadius);
+
+    const float innerRadiusOffset = innerRadiusRounded - deviceInnerRadius - border;
+    const float innerTextureFactor = 1.0f / innerRadiusRounded;
+    const float innerS0 = innerTextureFactor * innerRadiusOffset;
+    const float innerS1 = innerTextureFactor * (innerRadiusOffset + deviceInnerRadius);
+    const float innerS2 = innerTextureFactor * (innerRadiusOffset - deviceThickness);
+    const float innerS3 =
+        innerTextureFactor * (innerRadiusOffset - deviceThickness + deviceOuterRadius);
+
     const quint32 packedColor = packColor(color);
 
-    // 1st row.
     v[0].x = 0.0f;
     v[0].y = 0.0f;
-    v[0].s1 = shapeOffset;
-    v[0].t1 = shapeOffset;
-    v[0].s2 = innerCoord1;
-    v[0].t2 = innerCoord1;
+    v[0].outerS = outerS0;
+    v[0].outerT = outerS0;
+    v[0].innerS = innerS2;
+    v[0].innerT = innerS2;
     v[0].color = packedColor;
-    v[1].x = radiusOut;
+    v[1].x = outerRadius;
     v[1].y = 0.0f;
-    v[1].s1 = 1.0f;
-    v[1].t1 = shapeOffset;
-    v[1].s2 = innerCoord2;
-    v[1].t2 = innerCoord1;
+    v[1].outerS = outerS1;
+    v[1].outerT = outerS0;
+    v[1].innerS = innerS3;
+    v[1].innerT = innerS2;
     v[1].color = packedColor;
-    v[2].x = w - radiusOut;
+    v[2].x = w - outerRadius;
     v[2].y = 0.0f;
-    v[2].s1 = 1.0f;
-    v[2].t1 = shapeOffset;
-    v[2].s2 = innerCoord2;
-    v[2].t2 = innerCoord1;
+    v[2].outerS = outerS1;
+    v[2].outerT = outerS0;
+    v[2].innerS = innerS3;
+    v[2].innerT = innerS2;
     v[2].color = packedColor;
     v[3].x = w;
     v[3].y = 0.0f;
-    v[3].s1 = shapeOffset;
-    v[3].t1 = shapeOffset;
-    v[3].s2 = innerCoord1;
-    v[3].t2 = innerCoord1;
+    v[3].outerS = outerS0;
+    v[3].outerT = outerS0;
+    v[3].innerS = innerS2;
+    v[3].innerT = innerS2;
     v[3].color = packedColor;
 
-    // 2nd row.
-    v[4].x = clampedThickness + radiusIn;
+    v[4].x = clampedThickness + innerRadius;
     v[4].y = clampedThickness;
-    v[4].s1 = outerCoord1;
-    v[4].t1 = outerCoord2;
-    v[4].s2 = 1.0f;
-    v[4].t2 = shapeOffset;
+    v[4].outerS = outerS3;
+    v[4].outerT = outerS2;
+    v[4].innerS = innerS1;
+    v[4].innerT = innerS0;
     v[4].color = packedColor;
-    v[5].x = w - (clampedThickness + radiusIn);
+    v[5].x = w - (clampedThickness + innerRadius);
     v[5].y = clampedThickness;
-    v[5].s1 = outerCoord1;
-    v[5].t1 = outerCoord2;
-    v[5].s2 = 1.0f;
-    v[5].t2 = shapeOffset;
+    v[5].outerS = outerS3;
+    v[5].outerT = outerS2;
+    v[5].innerS = innerS1;
+    v[5].innerT = innerS0;
     v[5].color = packedColor;
 
-    // 3rd row.
     v[6].x = 0.0f;
-    v[6].y = radiusOut;
-    v[6].s1 = shapeOffset;
-    v[6].t1 = 1.0f;
-    v[6].s2 = innerCoord1;
-    v[6].t2 = innerCoord2;
+    v[6].y = outerRadius;
+    v[6].outerS = outerS0;
+    v[6].outerT = outerS1;
+    v[6].innerS = innerS2;
+    v[6].innerT = innerS3;
     v[6].color = packedColor;
-    v[7].x = clampedThickness;
-    v[7].y = clampedThickness + radiusIn;
-    v[7].s1 = outerCoord2;
-    v[7].t1 = outerCoord1;
-    v[7].s2 = shapeOffset;
-    v[7].t2 = 1.0f;
+    v[7].x = w;
+    v[7].y = outerRadius;
+    v[7].outerS = outerS0;
+    v[7].outerT = outerS1;
+    v[7].innerS = innerS2;
+    v[7].innerT = innerS3;
     v[7].color = packedColor;
-    v[8].x = w - clampedThickness;
-    v[8].y = clampedThickness + radiusIn;
-    v[8].s1 = outerCoord2;
-    v[8].t1 = outerCoord1;
-    v[8].s2 = shapeOffset;
-    v[8].t2 = 1.0f;
+
+    v[8].x = clampedThickness;
+    v[8].y = clampedThickness + innerRadius;
+    v[8].outerS = outerS2;
+    v[8].outerT = outerS3;
+    v[8].innerS = innerS0;
+    v[8].innerT = innerS1;
     v[8].color = packedColor;
-    v[9].x = w;
-    v[9].y = radiusOut;
-    v[9].s1 = shapeOffset;
-    v[9].t1 = 1.0f;
-    v[9].s2 = innerCoord1;
-    v[9].t2 = innerCoord2;
+    v[9].x = w - clampedThickness;
+    v[9].y = clampedThickness + innerRadius;
+    v[9].outerS = outerS2;
+    v[9].outerT = outerS3;
+    v[9].innerS = innerS0;
+    v[9].innerT = innerS1;
     v[9].color = packedColor;
 
-    // 4th row.
-    v[10].x = 0.0f;
-    v[10].y = h - radiusOut;
-    v[10].s1 = shapeOffset;
-    v[10].t1 = 1.0f;
-    v[10].s2 = innerCoord1;
-    v[10].t2 = innerCoord2;
+    v[10].x = clampedThickness;
+    v[10].y = h - (clampedThickness + innerRadius);
+    v[10].outerS = outerS2;
+    v[10].outerT = outerS3;
+    v[10].innerS = innerS0;
+    v[10].innerT = innerS1;
     v[10].color = packedColor;
-    v[11].x = clampedThickness;
-    v[11].y = h - (clampedThickness + radiusIn);
-    v[11].s1 = outerCoord2;
-    v[11].t1 = outerCoord1;
-    v[11].s2 = shapeOffset;
-    v[11].t2 = 1.0f;
+    v[11].x = w - clampedThickness;
+    v[11].y = h - (clampedThickness + innerRadius);
+    v[11].outerS = outerS2;
+    v[11].outerT = outerS3;
+    v[11].innerS = innerS0;
+    v[11].innerT = innerS1;
     v[11].color = packedColor;
-    v[12].x = w - clampedThickness;
-    v[12].y = h - (clampedThickness + radiusIn);
-    v[12].s1 = outerCoord2;
-    v[12].t1 = outerCoord1;
-    v[12].s2 = shapeOffset;
-    v[12].t2 = 1.0f;
+
+    v[12].x = 0.0f;
+    v[12].y = h - outerRadius;
+    v[12].outerS = outerS0;
+    v[12].outerT = outerS1;
+    v[12].innerS = innerS2;
+    v[12].innerT = innerS3;
     v[12].color = packedColor;
     v[13].x = w;
-    v[13].y = h - radiusOut;
-    v[13].s1 = shapeOffset;
-    v[13].t1 = 1.0f;
-    v[13].s2 = innerCoord1;
-    v[13].t2 = innerCoord2;
+    v[13].y = h - outerRadius;
+    v[13].outerS = outerS0;
+    v[13].outerT = outerS1;
+    v[13].innerS = innerS2;
+    v[13].innerT = innerS3;
     v[13].color = packedColor;
 
-    // 5th row.
-    v[14].x = clampedThickness + radiusIn;
+    v[14].x = clampedThickness + innerRadius;
     v[14].y = h - clampedThickness;
-    v[14].s1 = outerCoord1;
-    v[14].t1 = outerCoord2;
-    v[14].s2 = 1.0f;
-    v[14].t2 = shapeOffset;
+    v[14].outerS = outerS3;
+    v[14].outerT = outerS2;
+    v[14].innerS = innerS1;
+    v[14].innerT = innerS0;
     v[14].color = packedColor;
-    v[15].x = w - (clampedThickness + radiusIn);
+    v[15].x = w - (clampedThickness + innerRadius);
     v[15].y = h - clampedThickness;
-    v[15].s1 = outerCoord1;
-    v[15].t1 = outerCoord2;
-    v[15].s2 = 1.0f;
-    v[15].t2 = shapeOffset;
+    v[15].outerS = outerS3;
+    v[15].outerT = outerS2;
+    v[15].innerS = innerS1;
+    v[15].innerT = innerS0;
     v[15].color = packedColor;
 
-    // 6th row.
     v[16].x = 0.0f;
     v[16].y = h;
-    v[16].s1 = shapeOffset;
-    v[16].t1 = shapeOffset;
-    v[16].s2 = innerCoord1;
-    v[16].t2 = innerCoord1;
+    v[16].outerS = outerS0;
+    v[16].outerT = outerS0;
+    v[16].innerS = innerS2;
+    v[16].innerT = innerS2;
     v[16].color = packedColor;
-    v[17].x = radiusOut;
+    v[17].x = outerRadius;
     v[17].y = h;
-    v[17].s1 = 1.0f;
-    v[17].t1 = shapeOffset;
-    v[17].s2 = innerCoord2;
-    v[17].t2 = innerCoord1;
+    v[17].outerS = outerS1;
+    v[17].outerT = outerS0;
+    v[17].innerS = innerS3;
+    v[17].innerT = innerS2;
     v[17].color = packedColor;
-    v[18].x = w - radiusOut;
+    v[18].x = w - outerRadius;
     v[18].y = h;
-    v[18].s1 = 1.0f;
-    v[18].t1 = shapeOffset;
-    v[18].s2 = innerCoord2;
-    v[18].t2 = innerCoord1;
+    v[18].outerS = outerS1;
+    v[18].outerT = outerS0;
+    v[18].innerS = innerS3;
+    v[18].innerT = innerS2;
     v[18].color = packedColor;
     v[19].x = w;
     v[19].y = h;
-    v[19].s1 = shapeOffset;
-    v[19].t1 = shapeOffset;
-    v[19].s2 = innerCoord1;
-    v[19].t2 = innerCoord1;
+    v[19].outerS = outerS0;
+    v[19].outerT = outerS0;
+    v[19].innerS = innerS2;
+    v[19].innerT = innerS2;
     v[19].color = packedColor;
 
     markDirty(QSGNode::DirtyGeometry);
-}
-
-// --- Item ---
-
-UCFrame::UCFrame(QQuickItem* parent)
-    : QQuickItem(parent)
-    , m_color(defaultColor)
-    , m_thickness(defaultThickness)
-    , m_radius(defaultRadius)
-{
-    setFlag(ItemHasContents);
-}
-
-void UCFrame::setThickness(qreal thickness)
-{
-    thickness = qMax(0.0f, static_cast<float>(thickness));
-    if (m_thickness != thickness) {
-        m_thickness = thickness;
-        update();
-        Q_EMIT thicknessChanged();
-    }
-}
-
-void UCFrame::setRadius(qreal radius)
-{
-    radius = qMax(0.0f, static_cast<float>(radius));
-    if (m_radius != radius) {
-        m_radius = radius;
-        update();
-        Q_EMIT radiusChanged();
-    }
-}
-
-void UCFrame::setColor(const QColor& color)
-{
-    const QRgb rgbColor = qRgba(color.red(), color.green(), color.blue(), color.alpha());
-    if (m_color != rgbColor) {
-        m_color = rgbColor;
-        update();
-        Q_EMIT colorChanged();
-    }
-}
-
-QSGNode* UCFrame::updatePaintNode(QSGNode* oldNode, UpdatePaintNodeData* data)
-{
-    Q_UNUSED(data);
-
-    const QSizeF itemSize(width(), height());
-    if (itemSize.isEmpty() || m_thickness <= 0.0f) {
-        delete oldNode;
-        return NULL;
-    }
-
-    UCFrameNode* node = oldNode ? static_cast<UCFrameNode*>(oldNode) : new UCFrameNode();
-    node->updateGeometry(itemSize, m_thickness, m_radius, m_color);
-
-    return node;
-}
-
-UT_NAMESPACE_END
+
+    // Update data for the preprocess() call.
+    if (m_radius[0] != static_cast<quint16>(deviceOuterRadius)) {
+        m_newRadius[0] = static_cast<quint16>(deviceOuterRadius);
+    }
+    if (m_radius[1] != static_cast<quint16>(deviceInnerRadius)) {
+        m_newRadius[1] = static_cast<quint16>(deviceInnerRadius);
+    }
+    if (m_type != static_cast<quint8>(type)) {
+        m_newType = static_cast<quint8>(type);
+    }
+}

=== renamed file 'src/UbuntuToolkit/privates/frame_p.h' => 'src/UbuntuToolkit/privates/ucshapeframenodes_p.h'
--- src/UbuntuToolkit/privates/frame_p.h	2016-09-09 17:49:07 +0000
+++ src/UbuntuToolkit/privates/ucshapeframenodes_p.h	2016-12-14 07:25:05 +0000
@@ -16,90 +16,79 @@
  * Author: Loïc Molinari <[e-mail]>
  */
 
-#ifndef FRAME_P_H
-#define FRAME_P_H
+#ifndef UCSHAPEFRAMENODES_P_H
+#define UCSHAPEFRAMENODES_P_H
 
 #include <QtQuick/QQuickItem>
-#include <QtQuick/QSGMaterial>
 #include <QtQuick/QSGNode>
 
-#include <UbuntuToolkit/ubuntutoolkitglobal.h>
-
-UT_NAMESPACE_BEGIN
-
-class UCFrameMaterial : public QSGMaterial
-{
-public:
-    UCFrameMaterial();
-    QSGMaterialType* type() const override;
-    QSGMaterialShader* createShader() const override;
-    int compare(const QSGMaterial* other) const override;
-
-    quint32 textureId() const { return m_textureId; }
-
-private:
-    quint32 m_textureId;
-};
-
-class UCFrameNode : public QSGGeometryNode
-{
-public:
-  struct Vertex { float x, y, s1, t1, s2, t2; quint32 color; };
-
-    static const unsigned short* indices();
+#include <UbuntuToolkit/private/ucshapetexturefactory_p.h>
+#include <UbuntuToolkit/private/ucshaperesources_p.h>
+
+class UCShapeFrameEdgesNode : public QSGGeometryNode
+{
+public:
+    UCShapeFrameEdgesNode();
+    ~UCShapeFrameEdgesNode();
+
+    bool isSubtreeBlocked() const Q_DECL_OVERRIDE { return m_visible == 0; }
+
+    void setVisible(bool visible);
+    void update(const QSizeF& itemSize, float radius, float thickness, float space, QRgb color);
+
+private:
+    UCShapeColorResources m_resources;
+    quint8 m_visible : 1;
+    quint8 m_blending : 1;
+    quint8 __padding : 6;
+};
+
+class UCShapeFrameCornersMaterial : public QSGMaterial
+{
+public:
+    UCShapeFrameCornersMaterial();
+    QSGMaterialType* type() const Q_DECL_OVERRIDE;
+    QSGMaterialShader* createShader() const Q_DECL_OVERRIDE;
+    int compare(const QSGMaterial* other) const Q_DECL_OVERRIDE;
+
+    quint32 outerTextureId() const { return m_textureId[0]; }
+    quint32 innerTextureId() const { return m_textureId[1]; }
+    void updateTexture(int index, UCShapeType type, quint16 radius);
+
+private:
+    UCShapeTextureFactory<2> m_textureFactory;
+    quint32 m_textureId[2];
+};
+
+class UCShapeFrameCornersNode : public QSGGeometryNode
+{
+public:
+    struct Vertex { float x, y, outerS, outerT, innerS, innerT; quint32 color; };
+
+    static const quint16* indices();
     static const QSGGeometry::AttributeSet& attributeSet();
 
-    UCFrameNode();
-    void updateGeometry(const QSizeF& itemSize, float thickness, float radius, QRgb color);
+    UCShapeFrameCornersNode();
+    ~UCShapeFrameCornersNode() { DLOG("detroying UCShapeFrameCornersNode"); }
+
+    void preprocess() Q_DECL_OVERRIDE;
+    bool isSubtreeBlocked() const Q_DECL_OVERRIDE { return m_visible == 0; }
+
+    void setVisible(bool visible);
+    void update(
+        const QSizeF& itemSize, UCShapeType type, float radius, float thickness, float space,
+        QRgb color);
 
 private:
-    UCFrameMaterial m_material;
+    UCShapeFrameCornersMaterial m_material;
     QSGGeometry m_geometry;
-};
-
-// Renders the frame (border) of a shape.
-class UBUNTUTOOLKIT_EXPORT UCFrame : public QQuickItem
-{
-    Q_OBJECT
-
-    // Thickness of the frame in pixels.
-    Q_PROPERTY(qreal thickness READ thickness WRITE setThickness NOTIFY thicknessChanged)
-
-    // Radius of the shape in pixels. A rectangle frame could be obtained using
-    // a radius of 0 but it's recommended to use a Ractangle with a border for
-    // that as it is a bit more efficient in term of rendering speed (reason is
-    // we don't bother to specify a dedicated mesh and shader when radius is 0).
-    Q_PROPERTY(qreal radius READ radius WRITE setRadius NOTIFY radiusChanged)
-
-    // Color of the frame. Translucent colors are supported too.
-    Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
-
-public:
-    UCFrame(QQuickItem* parent = 0);
-
-    qreal thickness() const { return m_thickness; }
-    void setThickness(qreal thickness);
-    qreal radius() const { return m_radius; }
-    void setRadius(qreal radius);
-    QColor color() const {