add backdrop image filter.

Runtime/rendering/layer.cs

             properties.add(new DiagnosticsProperty<Offset>("offset", this.offset));
         }
     }
+    
+    public class BackdropFilterLayer : ContainerLayer {
+        public BackdropFilterLayer(ImageFilter filter = null) {
+            D.assert(filter != null);
+            this._filter = filter;
+        }
+
+        ImageFilter _filter;
+
+        public ImageFilter filter {
+            get { return this._filter; }
+            set {
+                if (value != this._filter) {
+                    this._filter = value;
+                    this.markNeedsAddToScene();
+                }
+            }
+        }
+
+        internal override flow.Layer addToScene(SceneBuilder builder, Offset layerOffset = null) {
+            builder.pushBackdropFilter(this.filter);
+            this.addChildrenToScene(builder, layerOffset);
+            builder.pop();
+            return null;
+        }
+    }
 
     public class LayerLink {
         public LeaderLayer leader {

Runtime/rendering/proxy_box.cs

         }
     }
 
+    public class RenderBackdropFilter : RenderProxyBox {
+        public RenderBackdropFilter(
+            RenderBox child = null,
+            ImageFilter filter = null
+        ) : base(child) {
+            D.assert(filter != null);
+            this._filter = filter;
+        }
+
+        ImageFilter _filter;
+
+        public ImageFilter filter {
+            get { return this._filter; }
+            set {
+                D.assert(value != null);
+                if (this._filter == value) {
+                    return;
+                }
+
+                this.markNeedsPaint();
+            }
+        }
+
+        protected override bool alwaysNeedsCompositing {
+            get { return this.child != null; }
+        }
+
+        public override void paint(PaintingContext context, Offset offset) {
+            if (this.child != null) {
+                D.assert(this.needsCompositing);
+                context.pushLayer(new BackdropFilterLayer(this.filter), base.paint, offset);
+            }
+        }
+    }
 
     public abstract class CustomClipper<T> {
         public CustomClipper(Listenable reclip = null) {

Runtime/ui/compositing.cs

             return layer;
         }
 
+        public Layer pushBackdropFilter(ImageFilter filter) {
+            var layer = new BackdropFilterLayer();
+            layer.filter = filter;
+            this._pushLayer(layer);
+            return layer;
+        }
+
+        
         public void addRetained(Layer layer) {
             if (this._currentLayer == null) {
                 return;

Runtime/ui/painting/canvas_impl.cs

                 layerPaint = paint,
             };
 
-            parentLayer.layers.Add(layer);
+            parentLayer.addLayer(layer);
+
+            if (paint.backdrop != null) {
+                if (paint.backdrop is _BlurImageFilter) {
+                    var filter = (_BlurImageFilter) paint.backdrop;
+                    if (!(filter.sigmaX == 0 && filter.sigmaY == 0)) {
+                        var points = new[] {bounds.topLeft, bounds.bottomLeft, bounds.bottomRight, bounds.topRight};
+                        state.matrix.mapPoints(points);
+
+                        var parentBounds = parentLayer.layerBounds;
+                        for (int i = 0; i < 4; i++) {
+                            points[i] = new Offset(
+                                (points[i].dx - parentBounds.left) / parentBounds.width,
+                                (points[i].dy - parentBounds.top) / parentBounds.height
+                            );
+                        }
+
+                        var mesh = ImageMeshGenerator.imageMesh(
+                            null,
+                            points[0], points[1], points[2], points[3],
+                            bounds);
+                        var renderDraw = CanvasShader.texRT(layer, layer.layerPaint, mesh, parentLayer);
+                        layer.draws.Add(renderDraw);
+
+                        var blurLayer = this._createBlurLayer(layer, filter.sigmaX, filter.sigmaY, layer);
+                        var blurMesh = ImageMeshGenerator.imageMesh(null, Rect.one, bounds);
+                        layer.draws.Add(CanvasShader.texRT(layer, paint, blurMesh, blurLayer));
+                    }
+                } else if (paint.backdrop is _MatrixImageFilter) {
+                    var filter = (_MatrixImageFilter) paint.backdrop;
+                    if (!filter.transform.isIdentity()) {
+                        layer.filterMode = filter.filterMode;
+                    
+                        var points = new[] {bounds.topLeft, bounds.bottomLeft, bounds.bottomRight, bounds.topRight};
+                        state.matrix.mapPoints(points);
+
+                        var parentBounds = parentLayer.layerBounds;
+                        for (int i = 0; i < 4; i++) {
+                            points[i] = new Offset(
+                                (points[i].dx - parentBounds.left) / parentBounds.width,
+                                (points[i].dy - parentBounds.top) / parentBounds.height
+                            );
+                        }
+
+                        var matrix = Matrix3.makeTrans(-bounds.left, -bounds.top);
+                        matrix.postConcat(filter.transform);
+                        matrix.postTranslate(bounds.left, bounds.top);
+                        
+                        var mesh = ImageMeshGenerator.imageMesh(
+                            matrix,
+                            points[0], points[1], points[2], points[3],
+                            bounds);
+                        var renderDraw = CanvasShader.texRT(layer, layer.layerPaint, mesh, parentLayer);
+                        layer.draws.Add(renderDraw);
+                    }
+                }
+            }
         }
         
         void _restore() {
                 return;
             }
 
-            layer.draws.Add(new RenderScissor {
+            layer.draws.Add(new CmdScissor {
                 deviceScissor = scissor,
             });
             layer.lastScissor = scissor;
                 filterMode = FilterMode.Bilinear,
             };
 
-            parentLayer.layers.Add(maskLayer);
+            parentLayer.addLayer(maskLayer);
             this._layers.Add(maskLayer);
             this._currentLayer = maskLayer;
 
             return maskLayer;
         }
 
-        RenderLayer _createBlurLayer(RenderLayer maskLayer, float sigma, RenderLayer parentLayer) {
-            sigma = BlurUtils.adjustSigma(sigma, out var scaleFactor, out var radius);
+        RenderLayer _createBlurLayer(RenderLayer maskLayer, float sigmaX, float sigmaY, RenderLayer parentLayer) {
+            sigmaX = BlurUtils.adjustSigma(sigmaX, out var scaleFactorX, out var radiusX);
+            sigmaY = BlurUtils.adjustSigma(sigmaY, out var scaleFactorY, out var radiusY);
-            var textureWidth = Mathf.CeilToInt((float) maskLayer.width / scaleFactor);
+            var textureWidth = Mathf.CeilToInt((float) maskLayer.width / scaleFactorX);
-            var textureHeight = Mathf.CeilToInt((float) maskLayer.height / scaleFactor);
+            var textureHeight = Mathf.CeilToInt((float) maskLayer.height / scaleFactorY);
             if (textureHeight < 1) {
                 textureHeight = 1;
             }
                 filterMode = FilterMode.Bilinear,
             };
 
-            parentLayer.layers.Add(blurXLayer);
+            parentLayer.addLayer(blurXLayer);
 
             var blurYLayer = new RenderLayer {
                 rtID = Shader.PropertyToID("_rtID_" + this._layers.Count + "_" + parentLayer.layers.Count),
                 filterMode = FilterMode.Bilinear,
             };
 
-            parentLayer.layers.Add(blurYLayer);
+            parentLayer.addLayer(blurYLayer);
-            var kernel = BlurUtils.get1DGaussianKernel(sigma, radius);
+            var kernelX = BlurUtils.get1DGaussianKernel(sigmaX, radiusX);
+            var kernelY = BlurUtils.get1DGaussianKernel(sigmaY, radiusY);
-                radius, new Vector2(1f / textureWidth, 0), kernel));
+                radiusX, new Vector2(1f / textureWidth, 0), kernelX));
-                radius, new Vector2(0, -1f / textureHeight), kernel));
+                radiusY, new Vector2(0, -1f / textureHeight), kernelY));
 
             return blurYLayer;
         }
 
             var maskLayer = this._createMaskLayer(layer, maskBounds, drawAction, paint);
 
-            var blurLayer = this._createBlurLayer(maskLayer, sigma, layer);
+            var blurLayer = this._createBlurLayer(maskLayer, sigma, sigma, layer);
 
             var blurMesh = ImageMeshGenerator.imageMesh(null, Rect.one, maskBounds);
             if (!this._applyClip(blurMesh.bounds)) {
         }
         
          void _drawLayer(RenderLayer layer, CommandBuffer cmdBuf) {
-            foreach (var subLayer in layer.layers) {
-                var desc = new RenderTextureDescriptor(
-                    subLayer.width, subLayer.height,
-                    RenderTextureFormat.Default, 24) {
-                    useMipMap = false,
-                    autoGenerateMips = false,
-                };
+             if (layer.rtID == 0) {
+                 cmdBuf.SetRenderTarget(this._renderTexture,
+                     RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store);
+                 cmdBuf.ClearRenderTarget(true, true, UnityEngine.Color.clear);
+             }
+             else {
+                 cmdBuf.SetRenderTarget(layer.rtID,
+                     RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store);
+                 cmdBuf.ClearRenderTarget(true, true, UnityEngine.Color.clear);
+             }
+
+             foreach (var cmdObj in layer.draws) {
+                switch (cmdObj) {
+                    case CmdLayer cmd:
+                        var subLayer = cmd.layer;
+                        var desc = new RenderTextureDescriptor(
+                            subLayer.width, subLayer.height,
+                            RenderTextureFormat.Default, 24) {
+                            useMipMap = false,
+                            autoGenerateMips = false,
+                        };
-                if (QualitySettings.antiAliasing != 0) {
-                    desc.msaaSamples = QualitySettings.antiAliasing;
-                }
+                        if (QualitySettings.antiAliasing != 0) {
+                            desc.msaaSamples = QualitySettings.antiAliasing;
+                        }
-                cmdBuf.GetTemporaryRT(subLayer.rtID, desc, subLayer.filterMode);
-                this._drawLayer(subLayer, cmdBuf);
-            }
-
-            if (layer.rtID == 0) {
-                cmdBuf.SetRenderTarget(this._renderTexture,
-                    RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store);
-                cmdBuf.ClearRenderTarget(true, true, UnityEngine.Color.clear);
-            }
-            else {
-                cmdBuf.SetRenderTarget(layer.rtID,
-                    RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store);
-                cmdBuf.ClearRenderTarget(true, true, UnityEngine.Color.clear);
-            }
+                        cmdBuf.GetTemporaryRT(subLayer.rtID, desc, subLayer.filterMode);
+                        this._drawLayer(subLayer, cmdBuf);
+                        
+                        if (layer.rtID == 0) {
+                            cmdBuf.SetRenderTarget(this._renderTexture,
+                                RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store);
+                        }
+                        else {
+                            cmdBuf.SetRenderTarget(layer.rtID,
+                                RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store);
+                        }
-            foreach (var cmdObj in layer.draws) {
-                switch (cmdObj) {
-                    case RenderDraw cmd:
+                        break;
+                    case CmdDraw cmd:
-                            cmdBuf.SetGlobalTexture(RenderDraw.texId, cmd.layer.rtID);
+                            if (cmd.layer.rtID == 0) {
+                                cmdBuf.SetGlobalTexture(CmdDraw.texId, this._renderTexture);
+                            } else {
+                                cmdBuf.SetGlobalTexture(CmdDraw.texId, cmd.layer.rtID);
+                            }
                         }
 
                         D.assert(cmd.meshObj == null);
                         if (mesh == null) {
                             continue;
                         }
-  
                         
                         D.assert(mesh.vertices.Count > 0);  
                         cmd.meshObj.SetVertices(mesh.vertices);
                         if (mesh.matrix == null) {
-                            cmd.properties.SetFloatArray(RenderDraw.matId, RenderDraw.idMat3.fMat);
+                            cmd.properties.SetFloatArray(CmdDraw.matId, CmdDraw.idMat3.fMat);
-                            cmd.properties.SetFloatArray(RenderDraw.matId, mesh.matrix.fMat);
+                            cmd.properties.SetFloatArray(CmdDraw.matId, mesh.matrix.fMat);
-                        cmdBuf.DrawMesh(cmd.meshObj, RenderDraw.idMat, cmd.material, 0, cmd.pass, cmd.properties);
+                        cmdBuf.DrawMesh(cmd.meshObj, CmdDraw.idMat, cmd.material, 0, cmd.pass, cmd.properties);
-                            cmdBuf.SetGlobalTexture(RenderDraw.texId, BuiltinRenderTextureType.None);
+                            cmdBuf.SetGlobalTexture(CmdDraw.texId, BuiltinRenderTextureType.None);
-                    case RenderScissor cmd:
+                    case CmdScissor cmd:
                         if (cmd.deviceScissor == null) {
                             cmdBuf.DisableScissorRect();
                         } else {
         void _clearLayer(RenderLayer layer) {
             foreach (var cmdObj in layer.draws) {
                 switch (cmdObj) {
-                    case RenderDraw cmd:
+                    case CmdDraw cmd:
                         if (cmd.meshObjCreated) {
                             this._meshPool.returnMesh(cmd.meshObj);
                             cmd.meshObj = null;
             public uint lastClipGenId;
             public Rect lastClipBounds;
             public Rect lastScissor;
-            public bool ignoreClip;
+            public bool ignoreClip = true;
 
             Vector4? _viewport;
 
                 this.currentState = new State();
                 this.states.Add(this.currentState);
             }
+
+            public void addLayer(RenderLayer layer) {
+                this.layers.Add(layer);
+                this.draws.Add(new CmdLayer {layer = layer});
+            }
         }
 
         internal class State {
             }
         }
         
-        internal class RenderDraw {
+        
+        internal class CmdLayer {
+            public RenderLayer layer;
+        }
+        
+        internal class CmdDraw {
             public MeshMesh mesh;
             public TextBlobMesh textMesh;
             public int pass;
             public static readonly int matId = Shader.PropertyToID("_mat");
         }
 
-        internal class RenderScissor {
+        internal class CmdScissor {
             public Rect deviceScissor;
         }
     }
             10, 11, 14, 11, 15, 14,
         };
 
+        public static MeshMesh imageMesh(Matrix3 matrix,
+            Offset srcTL, Offset srcBL, Offset srcBR, Offset srcTR,
+            Rect dst) {
+            var vertices = new List<Vector3>(4);
+            var uv = new List<Vector2>(4);
+
+            vertices.Add(new Vector2(dst.left, dst.top));
+            uv.Add(new Vector2(srcTL.dx, 1.0f - srcTL.dy));
+            vertices.Add(new Vector2(dst.left, dst.bottom));
+            uv.Add(new Vector2(srcBL.dx, 1.0f - srcBL.dy));
+            vertices.Add(new Vector2(dst.right, dst.bottom));
+            uv.Add(new Vector2(srcBR.dx, 1.0f - srcBR.dy));
+            vertices.Add(new Vector2(dst.right, dst.top));
+            uv.Add(new Vector2(srcTR.dx, 1.0f - srcTR.dy));
+
+            return new MeshMesh(matrix, vertices, _imageTriangles, uv);
+        }
+        
         public static MeshMesh imageMesh(Matrix3 matrix, Rect src, Rect dst) {
             var vertices = new List<Vector3>(4);
             var uv = new List<Vector2>(4);

Runtime/ui/painting/canvas_shader.cs

             }
         }
 
-        public static PictureFlusher.RenderDraw convexFill(PictureFlusher.RenderLayer layer, Paint paint,
+        public static PictureFlusher.CmdDraw convexFill(PictureFlusher.RenderLayer layer, Paint paint,
-            return new PictureFlusher.RenderDraw {
+            return new PictureFlusher.CmdDraw {
                 mesh = mesh,
                 pass = pass,
                 material = mat,
 
-        public static PictureFlusher.RenderDraw fill0(PictureFlusher.RenderLayer layer, MeshMesh mesh) {
+        public static PictureFlusher.CmdDraw fill0(PictureFlusher.RenderLayer layer, MeshMesh mesh) {
             Vector4 viewport = layer.viewport;
             var mat = _fill0Mat.getMaterial(layer.ignoreClip);
 
 
-            return new PictureFlusher.RenderDraw {
+            return new PictureFlusher.CmdDraw {
                 mesh = mesh,
                 pass = pass,
                 material = mat,
 
-        public static PictureFlusher.RenderDraw fill1(PictureFlusher.RenderLayer layer, Paint paint,
+        public static PictureFlusher.CmdDraw fill1(PictureFlusher.RenderLayer layer, Paint paint,
-            return new PictureFlusher.RenderDraw {
+            return new PictureFlusher.CmdDraw {
                 mesh = mesh.boundsMesh,
                 pass = pass,
                 material = mat,
 
-        public static PictureFlusher.RenderDraw stroke0(PictureFlusher.RenderLayer layer, Paint paint,
+        public static PictureFlusher.CmdDraw stroke0(PictureFlusher.RenderLayer layer, Paint paint,
-            return new PictureFlusher.RenderDraw {
+            return new PictureFlusher.CmdDraw {
                 mesh = mesh,
                 pass = pass,
                 material = mat,
 
-        public static PictureFlusher.RenderDraw stroke1(PictureFlusher.RenderLayer layer, MeshMesh mesh) {
+        public static PictureFlusher.CmdDraw stroke1(PictureFlusher.RenderLayer layer, MeshMesh mesh) {
             Vector4 viewport = layer.viewport;
             var mat = _stroke1Mat;
 
 
-            return new PictureFlusher.RenderDraw {
+            return new PictureFlusher.CmdDraw {
                 mesh = mesh,
                 pass = pass,
                 material = mat,
 
-        public static PictureFlusher.RenderDraw stencilClear(
+        public static PictureFlusher.CmdDraw stencilClear(
             PictureFlusher.RenderLayer layer, MeshMesh mesh) {
             Vector4 viewport = layer.viewport;
             var mat = _stencilMat;
             props.SetVector("_viewport", viewport);
 
-            return new PictureFlusher.RenderDraw {
+            return new PictureFlusher.CmdDraw {
                 mesh = mesh,
                 pass = pass,
                 material = mat,
 
-        public static PictureFlusher.RenderDraw stencil0(PictureFlusher.RenderLayer layer, MeshMesh mesh) {
+        public static PictureFlusher.CmdDraw stencil0(PictureFlusher.RenderLayer layer, MeshMesh mesh) {
             Vector4 viewport = layer.viewport;
             var mat = _stencilMat;
 
 
-            return new PictureFlusher.RenderDraw {
+            return new PictureFlusher.CmdDraw {
                 mesh = mesh,
                 pass = pass,
                 material = mat,
 
-        public static PictureFlusher.RenderDraw stencil1(PictureFlusher.RenderLayer layer, MeshMesh mesh) {
+        public static PictureFlusher.CmdDraw stencil1(PictureFlusher.RenderLayer layer, MeshMesh mesh) {
             Vector4 viewport = layer.viewport;
             var mat = _stencilMat;
 
 
-            return new PictureFlusher.RenderDraw {
+            return new PictureFlusher.CmdDraw {
                 mesh = mesh,
                 pass = pass,
                 material = mat,
 
-        public static PictureFlusher.RenderDraw tex(PictureFlusher.RenderLayer layer, Paint paint,
+        public static PictureFlusher.CmdDraw tex(PictureFlusher.RenderLayer layer, Paint paint,
             MeshMesh mesh, Image image) {
             var mat = _texMat.getMaterial(paint.blendMode, layer.ignoreClip);
             _getShaderPassAndProps(layer, paint, mesh, 1.0f, out var pass, out var props);
             props.SetInt("_texMode", image.texture is RenderTexture ? 1 : 0); // pre alpha if RT else post alpha
 
-            return new PictureFlusher.RenderDraw {
+            return new PictureFlusher.CmdDraw {
                 mesh = mesh,
                 pass = pass,
                 material = mat,
         }
 
-        public static PictureFlusher.RenderDraw texRT(PictureFlusher.RenderLayer layer, Paint paint,
+        public static PictureFlusher.CmdDraw texRT(PictureFlusher.RenderLayer layer, Paint paint,
-            return new PictureFlusher.RenderDraw {
+            return new PictureFlusher.CmdDraw {
                 mesh = mesh,
                 pass = pass,
                 material = mat,
         }
 
-        public static PictureFlusher.RenderDraw texAlpha(PictureFlusher.RenderLayer layer, Paint paint,
+        public static PictureFlusher.CmdDraw texAlpha(PictureFlusher.RenderLayer layer, Paint paint,
-        public static PictureFlusher.RenderDraw texAlpha(PictureFlusher.RenderLayer layer, Paint paint,
+        public static PictureFlusher.CmdDraw texAlpha(PictureFlusher.RenderLayer layer, Paint paint,
-        public static PictureFlusher.RenderDraw texAlpha(PictureFlusher.RenderLayer layer, Paint paint,
+        public static PictureFlusher.CmdDraw texAlpha(PictureFlusher.RenderLayer layer, Paint paint,
             MeshMesh mesh, TextBlobMesh textMesh, Texture tex) {
             
             var mat = _texMat.getMaterial(paint.blendMode, layer.ignoreClip);
             props.SetInt("_texMode", 2); // alpha only
 
-            return new PictureFlusher.RenderDraw {
+            return new PictureFlusher.CmdDraw {
                 mesh = mesh,
                 textMesh = textMesh,
                 pass = pass,
         }
 
-        public static PictureFlusher.RenderDraw maskFilter(PictureFlusher.RenderLayer layer, MeshMesh mesh,
+        public static PictureFlusher.CmdDraw maskFilter(PictureFlusher.RenderLayer layer, MeshMesh mesh,
             PictureFlusher.RenderLayer renderLayer, float radius, Vector2 imgInc, float[] kernel) {
             Vector4 viewport = layer.viewport;
             var mat = _filterMat;
             props.SetVector("_mf_imgInc", imgInc);
             props.SetFloatArray("_mf_kernel", kernel);
 
-            return new PictureFlusher.RenderDraw {
+            return new PictureFlusher.CmdDraw {
                 mesh = mesh,
                 pass = pass,
                 material = mat,

Runtime/ui/painting/painting.cs

 
         public MaskFilter maskFilter = null;
 
+        public ImageFilter backdrop = null;
+
         public PaintShader shader = null;
 
         public bool invertColors = false;
             this.filterMode = paint.filterMode;
             this.colorFilter = paint.colorFilter;
             this.maskFilter = paint.maskFilter;
+            this.backdrop = paint.backdrop;
             this.shader = paint.shader;
             this.invertColors = paint.invertColors;
         }

Runtime/widgets/basic.cs

         }
     }
 
+    public class BackdropFilter : SingleChildRenderObjectWidget {
+        public BackdropFilter(
+            Key key = null,
+            ImageFilter filter = null,
+            Widget child = null)
+            : base(key, child) {
+            D.assert(filter != null);
+            this.filter = filter;
+        }
+
+        public readonly ImageFilter filter;
+
+        public override RenderObject createRenderObject(BuildContext context) {
+            return new RenderBackdropFilter(filter: this.filter);
+        }
+
+        public override void updateRenderObject(BuildContext context, RenderObject renderObject) {
+            ((RenderBackdropFilter) renderObject).filter = this.filter;
+        }
+    }
+
     public class Opacity : SingleChildRenderObjectWidget {
         public Opacity(float opacity, Key key = null, Widget child = null) : base(key, child) {
             this.opacity = opacity;

Tests/Editor/CanvasAndLayers.cs

         void saveLayer() {
             var pictureRecorder = new PictureRecorder();
             var canvas = new RecorderCanvas(pictureRecorder);
+            var paint1 = new Paint {
+                color = new Color(0xFFFFFFFF),
+            };
+            var path1 = new Path();
+            path1.moveTo(0, 0);
+            path1.lineTo(0, 90);
+            path1.lineTo(90, 90);
+            path1.lineTo(90, 0);
+            path1.close();
+            canvas.drawPath(path1, paint1);
+
+            
-            path.moveTo(10, 10);
-            path.lineTo(10, 110);
-            path.lineTo(90, 110);
-            path.lineTo(110, 10);
+            path.moveTo(20, 20);
+            path.lineTo(20, 70);
+            path.lineTo(70, 70);
+            path.lineTo(70, 20);
-            paint = new Paint {
+            var paint2 = new Paint {
-            var rect = Unity.UIWidgets.ui.Rect.fromLTWH(10, 150, 100, 100);
-            var rrect = RRect.fromRectAndCorners(rect, 0, 4, 8, 16);
-            var rect1 = Unity.UIWidgets.ui.Rect.fromLTWH(18, 152, 88, 92);
-            var rrect1 = RRect.fromRectAndCorners(rect1, 0, 4, 8, 16);
-            canvas.drawDRRect(rrect, rrect1, paint);
-
-            canvas.rotate(-45 * Mathf.PI / 180.0f, new Offset(150, 150));
+            var path2 = new Path();
+            path2.moveTo(30, 30);
+            path2.lineTo(30, 60);
+            path2.lineTo(60, 60);
+            path2.lineTo(60, 30);
+            path2.close();
-//            paint = new Paint {
-//                color = new Color(0xFF00FFFF),
-//                blurSigma = 3,
-//            };
-//            canvas.drawRectShadow(
-//                Rect.fromLTWH(150, 150, 110, 120),
-//                paint);
+            canvas.drawPath(path2, paint2);
-            Debug.Log("picture.paintBounds: " + picture.paintBounds);
-            editorCanvas.saveLayer(picture.paintBounds, new Paint {color = new Color(0x7FFFFFFF)});
+            editorCanvas.saveLayer(
+                picture.paintBounds, new Paint {
+                    color = new Color(0xFFFFFFFF),
+                });
-            editorCanvas.translate(150, 0);
-            editorCanvas.saveLayer(picture.paintBounds, new Paint {color = new Color(0xFFFFFFFF)});
-            editorCanvas.drawPicture(picture);
+            editorCanvas.saveLayer(Unity.UIWidgets.ui.Rect.fromLTWH(45, 45, 90, 90), new Paint {
+                color = new Color(0xFFFFFFFF),
+                backdrop = ImageFilter.blur(3f, 3f)
+            });
             editorCanvas.restore();
 
             editorCanvas.flush();

Tests/Editor/Widgets.cs

                 child: new Container(
                     color: CLColors.background3,
                     child: new Transform(
-                        transform: Matrix3.makeRotate(Mathf.PI/180 * 5, px, py),
+                        transform: Matrix3.makeRotate(Mathf.PI / 180 * 5, px, py),
                         child:
                         new Column(
                             children: new List<Widget> {
                     )
                 )
             );
-            return container;
+
+            var stack = new Stack(
+                children: new List<Widget> {
+                    container,
+                    new Positioned(
+                        top: 50,
+                        right: 50,
+                        child: new BackdropFilter(
+                            filter: ImageFilter.blur(10, 10),
+                            child: new Container(
+                                width: 300, height: 300,
+                                decoration: new BoxDecoration(
+                                    color: Colors.transparent
+                                )
+                            )
+                        )
+                    )
+                }
+            );
+
+            return stack;
         }
     }
 

Runtime/flow/backdrop_filter_layer.cs

+using Unity.UIWidgets.foundation;
+using Unity.UIWidgets.ui;
+
+namespace Unity.UIWidgets.flow {
+    public class BackdropFilterLayer : ContainerLayer {
+        ImageFilter _filter;
+
+        public ImageFilter filter {
+            set { this._filter = value; }
+        }
+
+        public override void paint(PaintContext context) {
+            D.assert(this.needsPainting);
+
+            var canvas = context.canvas;
+            canvas.saveLayer(this.paintBounds, new Paint {backdrop = this._filter});
+
+            try {
+                this.paintChildren(context);
+            } finally {
+                canvas.restore();
+            }
+        }
+    }
+}

Runtime/flow/backdrop_filter_layer.cs.meta

+fileFormatVersion: 2
+guid: 13a0ce179081f4b35b10fac26f568cc8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: