lib/web_ui/lib/src/engine/compositor/layer.dart - external/github.com/flutter/engine - Git at Google

 // Copyright 2013 The Flutter Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 // @dart = 2.6
 part of engine;

 /// A layer to be composed into a scene.
 ///
 /// A layer is the lowest-level rendering primitive. It represents an atomic
 /// painting command.
 abstract class Layer implements ui.EngineLayer {
   /// The layer that contains us as a child.
   ContainerLayer parent;

   /// An estimated rectangle that this layer will draw into.
   ui.Rect paintBounds = ui.Rect.zero;

   /// Whether or not this layer actually needs to be painted in the scene.
   bool get needsPainting => !paintBounds.isEmpty;

   /// Pre-process this layer before painting.
   ///
   /// In this step, we compute the estimated [paintBounds] as well as
   /// apply heuristics to prepare the render cache for pictures that
   /// should be cached.
   void preroll(PrerollContext prerollContext, Matrix4 matrix);

   /// Paint this layer into the scene.
   void paint(PaintContext paintContext);
 }

 /// A context shared by all layers during the preroll pass.
 class PrerollContext {
   /// A raster cache. Used to register candidates for caching.
   final RasterCache rasterCache;

   /// A compositor for embedded HTML views.
   final HtmlViewEmbedder viewEmbedder;

   final MutatorsStack mutatorsStack = MutatorsStack();

   PrerollContext(this.rasterCache, this.viewEmbedder);
 }

 /// A context shared by all layers during the paint pass.
 class PaintContext {
   /// A multi-canvas that applies clips, transforms, and opacity
   /// operations to all canvases (root canvas and overlay canvases for the
   /// platform views).
   SkNWayCanvas internalNodesCanvas;

   /// The canvas for leaf nodes to paint to.
   SkCanvas leafNodesCanvas;

   /// A raster cache potentially containing pre-rendered pictures.
   final RasterCache rasterCache;

   /// A compositor for embedded HTML views.
   final HtmlViewEmbedder viewEmbedder;

   PaintContext(
     this.internalNodesCanvas,
     this.leafNodesCanvas,
     this.rasterCache,
     this.viewEmbedder,
   );
 }

 /// A layer that contains child layers.
 abstract class ContainerLayer extends Layer {
   final List<Layer> _layers = <Layer>[];

   /// Register [child] as a child of this layer.
   void add(Layer child) {
     child.parent = this;
     _layers.add(child);
   }

   @override
   void preroll(PrerollContext prerollContext, Matrix4 matrix) {
     paintBounds = prerollChildren(prerollContext, matrix);
   }

   /// Run [preroll] on all of the child layers.
   ///
   /// Returns a [Rect] that covers the paint bounds of all of the child layers.
   /// If all of the child layers have empty paint bounds, then the returned
   /// [Rect] is empty.
   ui.Rect prerollChildren(PrerollContext context, Matrix4 childMatrix) {
     ui.Rect childPaintBounds = ui.Rect.zero;
     for (Layer layer in _layers) {
       layer.preroll(context, childMatrix);
       if (childPaintBounds.isEmpty) {
         childPaintBounds = layer.paintBounds;
       } else if (!layer.paintBounds.isEmpty) {
         childPaintBounds = childPaintBounds.expandToInclude(layer.paintBounds);
       }
     }
     return childPaintBounds;
   }

   /// Calls [paint] on all child layers that need painting.
   void paintChildren(PaintContext context) {
     assert(needsPainting);

     for (Layer layer in _layers) {
       if (layer.needsPainting) {
         layer.paint(context);
       }
     }
   }
 }

 class BackdropFilterLayer extends ContainerLayer {
   final ui.ImageFilter _filter;

   BackdropFilterLayer(this._filter);

   @override
   void paint(PaintContext context) {
     context.internalNodesCanvas.saveLayerWithFilter(paintBounds, _filter);
     paintChildren(context);
     context.internalNodesCanvas.restore();
   }
 }

 /// A layer that clips its child layers by a given [Path].
 class ClipPathLayer extends ContainerLayer {
   /// The path used to clip child layers.
   final ui.Path _clipPath;
   final ui.Clip _clipBehavior;

   ClipPathLayer(this._clipPath, this._clipBehavior)
       : assert(_clipBehavior != ui.Clip.none);

   @override
   void preroll(PrerollContext context, Matrix4 matrix) {
     context.mutatorsStack.pushClipPath(_clipPath);
     final ui.Rect childPaintBounds = prerollChildren(context, matrix);
     final ui.Rect clipBounds = _clipPath.getBounds();
     if (childPaintBounds.overlaps(clipBounds)) {
       paintBounds = childPaintBounds.intersect(clipBounds);
     }
     context.mutatorsStack.pop();
   }

   @override
   void paint(PaintContext paintContext) {
     assert(needsPainting);

     paintContext.internalNodesCanvas.save();
     paintContext.internalNodesCanvas.clipPath(_clipPath, _clipBehavior != ui.Clip.hardEdge);

     if (_clipBehavior == ui.Clip.antiAliasWithSaveLayer) {
       paintContext.internalNodesCanvas.saveLayer(paintBounds, null);
     }
     paintChildren(paintContext);
     if (_clipBehavior == ui.Clip.antiAliasWithSaveLayer) {
       paintContext.internalNodesCanvas.restore();
     }
     paintContext.internalNodesCanvas.restore();
   }
 }

 /// A layer that clips its child layers by a given [Rect].
 class ClipRectLayer extends ContainerLayer {
   /// The rectangle used to clip child layers.
   final ui.Rect _clipRect;
   final ui.Clip _clipBehavior;

   ClipRectLayer(this._clipRect, this._clipBehavior)
       : assert(_clipBehavior != ui.Clip.none);

   @override
   void preroll(PrerollContext context, Matrix4 matrix) {
     context.mutatorsStack.pushClipRect(_clipRect);
     final ui.Rect childPaintBounds = prerollChildren(context, matrix);
     if (childPaintBounds.overlaps(_clipRect)) {
       paintBounds = childPaintBounds.intersect(_clipRect);
     }
     context.mutatorsStack.pop();
   }

   @override
   void paint(PaintContext paintContext) {
     assert(needsPainting);

     paintContext.internalNodesCanvas.save();
     paintContext.internalNodesCanvas.clipRect(
       _clipRect,
       ui.ClipOp.intersect,
       _clipBehavior != ui.Clip.hardEdge,
     );
     if (_clipBehavior == ui.Clip.antiAliasWithSaveLayer) {
       paintContext.internalNodesCanvas.saveLayer(_clipRect, null);
     }
     paintChildren(paintContext);
     if (_clipBehavior == ui.Clip.antiAliasWithSaveLayer) {
       paintContext.internalNodesCanvas.restore();
     }
     paintContext.internalNodesCanvas.restore();
   }
 }

 /// A layer that clips its child layers by a given [RRect].
 class ClipRRectLayer extends ContainerLayer {
   /// The rounded rectangle used to clip child layers.
   final ui.RRect _clipRRect;
   final ui.Clip _clipBehavior;

   ClipRRectLayer(this._clipRRect, this._clipBehavior)
       : assert(_clipBehavior != ui.Clip.none);

   @override
   void preroll(PrerollContext context, Matrix4 matrix) {
     context.mutatorsStack.pushClipRRect(_clipRRect);
     final ui.Rect childPaintBounds = prerollChildren(context, matrix);
     if (childPaintBounds.overlaps(_clipRRect.outerRect)) {
       paintBounds = childPaintBounds.intersect(_clipRRect.outerRect);
     }
     context.mutatorsStack.pop();
   }

   @override
   void paint(PaintContext paintContext) {
     assert(needsPainting);

     paintContext.internalNodesCanvas.save();
     paintContext.internalNodesCanvas
         .clipRRect(_clipRRect, _clipBehavior != ui.Clip.hardEdge);
     if (_clipBehavior == ui.Clip.antiAliasWithSaveLayer) {
       paintContext.internalNodesCanvas.saveLayer(paintBounds, null);
     }
     paintChildren(paintContext);
     if (_clipBehavior == ui.Clip.antiAliasWithSaveLayer) {
       paintContext.internalNodesCanvas.restore();
     }
     paintContext.internalNodesCanvas.restore();
   }
 }

 /// A layer that paints its children with the given opacity.
 class OpacityLayer extends ContainerLayer implements ui.OpacityEngineLayer {
   final int _alpha;
   final ui.Offset _offset;

   OpacityLayer(this._alpha, this._offset);

   @override
   void preroll(PrerollContext context, Matrix4 matrix) {
     final Matrix4 childMatrix = Matrix4.copy(matrix);
     childMatrix.translate(_offset.dx, _offset.dy);
     context.mutatorsStack
         .pushTransform(Matrix4.translationValues(_offset.dx, _offset.dy, 0.0));
     context.mutatorsStack.pushOpacity(_alpha);
     super.preroll(context, childMatrix);
     context.mutatorsStack.pop();
     context.mutatorsStack.pop();
     paintBounds = paintBounds.translate(_offset.dx, _offset.dy);
   }

   @override
   void paint(PaintContext paintContext) {
     assert(needsPainting);

     final ui.Paint paint = ui.Paint();
     paint.color = ui.Color.fromARGB(_alpha, 0, 0, 0);

     paintContext.internalNodesCanvas.save();
     paintContext.internalNodesCanvas.translate(_offset.dx, _offset.dy);

     final ui.Rect saveLayerBounds = paintBounds.shift(-_offset);

     paintContext.internalNodesCanvas.saveLayer(saveLayerBounds, paint);
     paintChildren(paintContext);
     // Restore twice: once for the translate and once for the saveLayer.
     paintContext.internalNodesCanvas.restore();
     paintContext.internalNodesCanvas.restore();
   }
 }

 /// A layer that transforms its child layers by the given transform matrix.
 class TransformLayer extends ContainerLayer
     implements ui.OffsetEngineLayer, ui.TransformEngineLayer {
   /// The matrix with which to transform the child layers.
   final Matrix4 _transform;

   TransformLayer(this._transform);

   @override
   void preroll(PrerollContext context, Matrix4 matrix) {
     final Matrix4 childMatrix = matrix * _transform;
     context.mutatorsStack.pushTransform(_transform);
     final ui.Rect childPaintBounds = prerollChildren(context, childMatrix);
     paintBounds = _transformRect(_transform, childPaintBounds);
     context.mutatorsStack.pop();
   }

   /// Applies the given matrix as a perspective transform to the given point.
   ///
   /// This function assumes the given point has a z-coordinate of 0.0. The
   /// z-coordinate of the result is ignored.
   static ui.Offset _transformPoint(Matrix4 transform, ui.Offset point) {
     final Vector3 position3 = Vector3(point.dx, point.dy, 0.0);
     final Vector3 transformed3 = transform.perspectiveTransform(position3);
     return ui.Offset(transformed3.x, transformed3.y);
   }

   /// Returns a rect that bounds the result of applying the given matrix as a
   /// perspective transform to the given rect.
   ///
   /// This function assumes the given rect is in the plane with z equals 0.0.
   /// The transformed rect is then projected back into the plane with z equals
   /// 0.0 before computing its bounding rect.
   static ui.Rect _transformRect(Matrix4 transform, ui.Rect rect) {
     final ui.Offset point1 = _transformPoint(transform, rect.topLeft);
     final ui.Offset point2 = _transformPoint(transform, rect.topRight);
     final ui.Offset point3 = _transformPoint(transform, rect.bottomLeft);
     final ui.Offset point4 = _transformPoint(transform, rect.bottomRight);
     return ui.Rect.fromLTRB(
         _min4(point1.dx, point2.dx, point3.dx, point4.dx),
         _min4(point1.dy, point2.dy, point3.dy, point4.dy),
         _max4(point1.dx, point2.dx, point3.dx, point4.dx),
         _max4(point1.dy, point2.dy, point3.dy, point4.dy));
   }

   static double _min4(double a, double b, double c, double d) {
     return math.min(a, math.min(b, math.min(c, d)));
   }

   static double _max4(double a, double b, double c, double d) {
     return math.max(a, math.max(b, math.max(c, d)));
   }

   @override
   void paint(PaintContext paintContext) {
     assert(needsPainting);

     paintContext.internalNodesCanvas.save();
     paintContext.internalNodesCanvas.transform(_transform.storage);
     paintChildren(paintContext);
     paintContext.internalNodesCanvas.restore();
   }
 }

 /// A layer that applies an [ui.ImageFilter] to its children.
 class ImageFilterLayer extends ContainerLayer implements ui.OpacityEngineLayer {
   ImageFilterLayer(this._filter);

   final ui.ImageFilter _filter;

   @override
   void paint(PaintContext paintContext) {
     assert(needsPainting);
     final ui.Paint paint = ui.Paint();
     paint.imageFilter = _filter;
     paintContext.internalNodesCanvas.saveLayer(paintBounds, paint);
     paintChildren(paintContext);
     paintContext.internalNodesCanvas.restore();
   }
 }

 /// A layer containing a [Picture].
 class PictureLayer extends Layer {
   /// The picture to paint into the canvas.
   final SkPicture picture;

   /// The offset at which to paint the picture.
   final ui.Offset offset;

   /// A hint to the compositor about whether this picture is complex.
   final bool isComplex;

   /// A hint to the compositor that this picture is likely to change.
   final bool willChange;

   PictureLayer(this.picture, this.offset, this.isComplex, this.willChange);

   @override
   void preroll(PrerollContext prerollContext, Matrix4 matrix) {
     paintBounds = picture.cullRect.shift(offset);
   }

   @override
   void paint(PaintContext paintContext) {
     assert(picture != null);
     assert(needsPainting);

     paintContext.leafNodesCanvas.save();
     paintContext.leafNodesCanvas.translate(offset.dx, offset.dy);

     paintContext.leafNodesCanvas.drawPicture(picture);
     paintContext.leafNodesCanvas.restore();
   }
 }

 /// A layer representing a physical shape.
 ///
 /// The shape clips its children to a given [Path], and casts a shadow based
 /// on the given elevation.
 class PhysicalShapeLayer extends ContainerLayer
     implements ui.PhysicalShapeEngineLayer {
   final double _elevation;
   final ui.Color _color;
   final ui.Color _shadowColor;
   final ui.Path _path;
   final ui.Clip _clipBehavior;

   PhysicalShapeLayer(
     this._elevation,
     this._color,
     this._shadowColor,
     this._path,
     this._clipBehavior,
   );

   @override
   void preroll(PrerollContext prerollContext, Matrix4 matrix) {
     prerollChildren(prerollContext, matrix);

     paintBounds = _path.getBounds();
     if (_elevation == 0.0) {
       // No need to extend the paint bounds if there is no shadow.
       return;
     } else {
       // Add some margin to the paint bounds to leave space for the shadow.
       // We fill this whole region and clip children to it so we don't need to
       // join the child paint bounds.
       // The offset is calculated as follows:

       //                   .---                           (kLightRadius)
       //                -------/                          (light)
       //                   |  /
       //                   | /
       //                   |/
       //                   |O
       //                  /|                              (kLightHeight)
       //                 / |
       //                /  |
       //               /   |
       //              /    |
       //             -------------                        (layer)
       //            /|     |
       //           / |     |                              (elevation)
       //        A /  |     |B
       // ------------------------------------------------ (canvas)
       //          ---                                     (extent of shadow)
       //
       // E = lt        }           t = (r + w/2)/h
       //                } =>
       // r + w/2 = ht  }           E = (l/h)(r + w/2)
       //
       // Where: E = extent of shadow
       //        l = elevation of layer
       //        r = radius of the light source
       //        w = width of the layer
       //        h = light height
       //        t = tangent of AOB, i.e., multiplier for elevation to extent
       final double devicePixelRatio = ui.window.devicePixelRatio;

       final double radius = kLightRadius * devicePixelRatio;
       // tangent for x
       double tx = (radius + paintBounds.width * 0.5) / kLightHeight;
       // tangent for y
       double ty = (radius + paintBounds.height * 0.5) / kLightHeight;

       paintBounds = ui.Rect.fromLTRB(
         paintBounds.left - tx,
         paintBounds.top - ty,
         paintBounds.right + tx,
         paintBounds.bottom + ty,
       );
     }
   }

   @override
   void paint(PaintContext paintContext) {
     assert(needsPainting);

     if (_elevation != 0) {
       drawShadow(paintContext.leafNodesCanvas, _path, _shadowColor, _elevation,
           _color.alpha != 0xff);
     }

     final ui.Paint paint = ui.Paint()..color = _color;
     if (_clipBehavior != ui.Clip.antiAliasWithSaveLayer) {
       paintContext.leafNodesCanvas.drawPath(_path, paint);
     }

     final int saveCount = paintContext.internalNodesCanvas.save();
     switch (_clipBehavior) {
       case ui.Clip.hardEdge:
         paintContext.internalNodesCanvas.clipPath(_path, false);
         break;
       case ui.Clip.antiAlias:
         paintContext.internalNodesCanvas.clipPath(_path, true);
         break;
       case ui.Clip.antiAliasWithSaveLayer:
         paintContext.internalNodesCanvas.clipPath(_path, true);
         paintContext.internalNodesCanvas.saveLayer(paintBounds, null);
         break;
       case ui.Clip.none:
         break;
     }

     if (_clipBehavior == ui.Clip.antiAliasWithSaveLayer) {
       // If we want to avoid the bleeding edge artifact
       // (https://github.com/flutter/flutter/issues/18057#issue-328003931)
       // using saveLayer, we have to call drawPaint instead of drawPath as
       // anti-aliased drawPath will always have such artifacts.
       paintContext.leafNodesCanvas.drawPaint(paint);
     }

     paintChildren(paintContext);

     paintContext.internalNodesCanvas.restoreToCount(saveCount);
   }

   /// Draws a shadow on the given [canvas] for the given [path].
   ///
   /// The blur of the shadow is decided by the [elevation], and the
   /// shadow is painted with the given [color].
   static void drawShadow(SkCanvas canvas, ui.Path path, ui.Color color,
       double elevation, bool transparentOccluder) {
     canvas.drawShadow(path, color, elevation, transparentOccluder);
   }
 }

 /// A layer which renders a platform view (an HTML element in this case).
 class PlatformViewLayer extends Layer {
   PlatformViewLayer(this.viewId, this.offset, this.width, this.height);

   final int viewId;
   final ui.Offset offset;
   final double width;
   final double height;

   @override
   void preroll(PrerollContext context, Matrix4 matrix) {
     paintBounds = ui.Rect.fromLTWH(offset.dx, offset.dy, width, height);
     context.viewEmbedder.prerollCompositeEmbeddedView(
       viewId,
       EmbeddedViewParams(
         offset,
         ui.Size(width, height),
         context.mutatorsStack,
       ),
     );
   }

   @override
   void paint(PaintContext context) {
     SkCanvas canvas = context.viewEmbedder.compositeEmbeddedView(viewId);
     context.leafNodesCanvas = canvas;
   }
 }
	// Copyright 2013 The Flutter Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	// @dart = 2.6
	part of engine;

	/// A layer to be composed into a scene.
	///
	/// A layer is the lowest-level rendering primitive. It represents an atomic
	/// painting command.
	abstract class Layer implements ui.EngineLayer {
	/// The layer that contains us as a child.
	ContainerLayer parent;

	/// An estimated rectangle that this layer will draw into.
	ui.Rect paintBounds = ui.Rect.zero;

	/// Whether or not this layer actually needs to be painted in the scene.
	bool get needsPainting => !paintBounds.isEmpty;

	/// Pre-process this layer before painting.
	///
	/// In this step, we compute the estimated [paintBounds] as well as
	/// apply heuristics to prepare the render cache for pictures that
	/// should be cached.
	void preroll(PrerollContext prerollContext, Matrix4 matrix);

	/// Paint this layer into the scene.
	void paint(PaintContext paintContext);
	}

	/// A context shared by all layers during the preroll pass.
	class PrerollContext {
	/// A raster cache. Used to register candidates for caching.
	final RasterCache rasterCache;

	/// A compositor for embedded HTML views.
	final HtmlViewEmbedder viewEmbedder;

	final MutatorsStack mutatorsStack = MutatorsStack();

	PrerollContext(this.rasterCache, this.viewEmbedder);
	}

	/// A context shared by all layers during the paint pass.
	class PaintContext {
	/// A multi-canvas that applies clips, transforms, and opacity
	/// operations to all canvases (root canvas and overlay canvases for the
	/// platform views).
	SkNWayCanvas internalNodesCanvas;

	/// The canvas for leaf nodes to paint to.
	SkCanvas leafNodesCanvas;

	/// A raster cache potentially containing pre-rendered pictures.
	final RasterCache rasterCache;

	/// A compositor for embedded HTML views.
	final HtmlViewEmbedder viewEmbedder;

	PaintContext(
	this.internalNodesCanvas,
	this.leafNodesCanvas,
	this.rasterCache,
	this.viewEmbedder,
	);
	}

	/// A layer that contains child layers.
	abstract class ContainerLayer extends Layer {
	final List<Layer> _layers = <Layer>[];

	/// Register [child] as a child of this layer.
	void add(Layer child) {
	child.parent = this;
	_layers.add(child);
	}

	@override
	void preroll(PrerollContext prerollContext, Matrix4 matrix) {
	paintBounds = prerollChildren(prerollContext, matrix);
	}

	/// Run [preroll] on all of the child layers.
	///
	/// Returns a [Rect] that covers the paint bounds of all of the child layers.
	/// If all of the child layers have empty paint bounds, then the returned
	/// [Rect] is empty.
	ui.Rect prerollChildren(PrerollContext context, Matrix4 childMatrix) {
	ui.Rect childPaintBounds = ui.Rect.zero;
	for (Layer layer in _layers) {
	layer.preroll(context, childMatrix);
	if (childPaintBounds.isEmpty) {
	childPaintBounds = layer.paintBounds;
	} else if (!layer.paintBounds.isEmpty) {
	childPaintBounds = childPaintBounds.expandToInclude(layer.paintBounds);
	}
	}
	return childPaintBounds;
	}

	/// Calls [paint] on all child layers that need painting.
	void paintChildren(PaintContext context) {
	assert(needsPainting);

	for (Layer layer in _layers) {
	if (layer.needsPainting) {
	layer.paint(context);
	}
	}
	}
	}

	class BackdropFilterLayer extends ContainerLayer {
	final ui.ImageFilter _filter;

	BackdropFilterLayer(this._filter);

	@override
	void paint(PaintContext context) {
	context.internalNodesCanvas.saveLayerWithFilter(paintBounds, _filter);
	paintChildren(context);
	context.internalNodesCanvas.restore();
	}
	}

	/// A layer that clips its child layers by a given [Path].
	class ClipPathLayer extends ContainerLayer {
	/// The path used to clip child layers.
	final ui.Path _clipPath;
	final ui.Clip _clipBehavior;

	ClipPathLayer(this._clipPath, this._clipBehavior)
	: assert(_clipBehavior != ui.Clip.none);

	@override
	void preroll(PrerollContext context, Matrix4 matrix) {
	context.mutatorsStack.pushClipPath(_clipPath);
	final ui.Rect childPaintBounds = prerollChildren(context, matrix);
	final ui.Rect clipBounds = _clipPath.getBounds();
	if (childPaintBounds.overlaps(clipBounds)) {
	paintBounds = childPaintBounds.intersect(clipBounds);
	}
	context.mutatorsStack.pop();
	}

	@override
	void paint(PaintContext paintContext) {
	assert(needsPainting);

	paintContext.internalNodesCanvas.save();
	paintContext.internalNodesCanvas.clipPath(_clipPath, _clipBehavior != ui.Clip.hardEdge);

	if (_clipBehavior == ui.Clip.antiAliasWithSaveLayer) {
	paintContext.internalNodesCanvas.saveLayer(paintBounds, null);
	}
	paintChildren(paintContext);
	if (_clipBehavior == ui.Clip.antiAliasWithSaveLayer) {
	paintContext.internalNodesCanvas.restore();
	}
	paintContext.internalNodesCanvas.restore();
	}
	}

	/// A layer that clips its child layers by a given [Rect].
	class ClipRectLayer extends ContainerLayer {
	/// The rectangle used to clip child layers.
	final ui.Rect _clipRect;
	final ui.Clip _clipBehavior;

	ClipRectLayer(this._clipRect, this._clipBehavior)
	: assert(_clipBehavior != ui.Clip.none);

	@override
	void preroll(PrerollContext context, Matrix4 matrix) {
	context.mutatorsStack.pushClipRect(_clipRect);
	final ui.Rect childPaintBounds = prerollChildren(context, matrix);
	if (childPaintBounds.overlaps(_clipRect)) {
	paintBounds = childPaintBounds.intersect(_clipRect);
	}
	context.mutatorsStack.pop();
	}

	@override
	void paint(PaintContext paintContext) {
	assert(needsPainting);

	paintContext.internalNodesCanvas.save();
	paintContext.internalNodesCanvas.clipRect(
	_clipRect,
	ui.ClipOp.intersect,
	_clipBehavior != ui.Clip.hardEdge,
	);
	if (_clipBehavior == ui.Clip.antiAliasWithSaveLayer) {
	paintContext.internalNodesCanvas.saveLayer(_clipRect, null);
	}
	paintChildren(paintContext);
	if (_clipBehavior == ui.Clip.antiAliasWithSaveLayer) {
	paintContext.internalNodesCanvas.restore();
	}
	paintContext.internalNodesCanvas.restore();
	}
	}

	/// A layer that clips its child layers by a given [RRect].
	class ClipRRectLayer extends ContainerLayer {
	/// The rounded rectangle used to clip child layers.
	final ui.RRect _clipRRect;
	final ui.Clip _clipBehavior;

	ClipRRectLayer(this._clipRRect, this._clipBehavior)
	: assert(_clipBehavior != ui.Clip.none);

	@override
	void preroll(PrerollContext context, Matrix4 matrix) {
	context.mutatorsStack.pushClipRRect(_clipRRect);
	final ui.Rect childPaintBounds = prerollChildren(context, matrix);
	if (childPaintBounds.overlaps(_clipRRect.outerRect)) {
	paintBounds = childPaintBounds.intersect(_clipRRect.outerRect);
	}
	context.mutatorsStack.pop();
	}

	@override
	void paint(PaintContext paintContext) {
	assert(needsPainting);

	paintContext.internalNodesCanvas.save();
	paintContext.internalNodesCanvas
	.clipRRect(_clipRRect, _clipBehavior != ui.Clip.hardEdge);
	if (_clipBehavior == ui.Clip.antiAliasWithSaveLayer) {
	paintContext.internalNodesCanvas.saveLayer(paintBounds, null);
	}
	paintChildren(paintContext);
	if (_clipBehavior == ui.Clip.antiAliasWithSaveLayer) {
	paintContext.internalNodesCanvas.restore();
	}
	paintContext.internalNodesCanvas.restore();
	}
	}

	/// A layer that paints its children with the given opacity.
	class OpacityLayer extends ContainerLayer implements ui.OpacityEngineLayer {
	final int _alpha;
	final ui.Offset _offset;

	OpacityLayer(this._alpha, this._offset);

	@override
	void preroll(PrerollContext context, Matrix4 matrix) {
	final Matrix4 childMatrix = Matrix4.copy(matrix);
	childMatrix.translate(_offset.dx, _offset.dy);
	context.mutatorsStack
	.pushTransform(Matrix4.translationValues(_offset.dx, _offset.dy, 0.0));
	context.mutatorsStack.pushOpacity(_alpha);
	super.preroll(context, childMatrix);
	context.mutatorsStack.pop();
	context.mutatorsStack.pop();
	paintBounds = paintBounds.translate(_offset.dx, _offset.dy);
	}

	@override
	void paint(PaintContext paintContext) {
	assert(needsPainting);

	final ui.Paint paint = ui.Paint();
	paint.color = ui.Color.fromARGB(_alpha, 0, 0, 0);

	paintContext.internalNodesCanvas.save();
	paintContext.internalNodesCanvas.translate(_offset.dx, _offset.dy);

	final ui.Rect saveLayerBounds = paintBounds.shift(-_offset);

	paintContext.internalNodesCanvas.saveLayer(saveLayerBounds, paint);
	paintChildren(paintContext);
	// Restore twice: once for the translate and once for the saveLayer.
	paintContext.internalNodesCanvas.restore();
	paintContext.internalNodesCanvas.restore();
	}
	}

	/// A layer that transforms its child layers by the given transform matrix.
	class TransformLayer extends ContainerLayer
	implements ui.OffsetEngineLayer, ui.TransformEngineLayer {
	/// The matrix with which to transform the child layers.
	final Matrix4 _transform;

	TransformLayer(this._transform);

	@override
	void preroll(PrerollContext context, Matrix4 matrix) {
	final Matrix4 childMatrix = matrix * _transform;
	context.mutatorsStack.pushTransform(_transform);
	final ui.Rect childPaintBounds = prerollChildren(context, childMatrix);
	paintBounds = _transformRect(_transform, childPaintBounds);
	context.mutatorsStack.pop();
	}

	/// Applies the given matrix as a perspective transform to the given point.
	///
	/// This function assumes the given point has a z-coordinate of 0.0. The
	/// z-coordinate of the result is ignored.
	static ui.Offset _transformPoint(Matrix4 transform, ui.Offset point) {
	final Vector3 position3 = Vector3(point.dx, point.dy, 0.0);
	final Vector3 transformed3 = transform.perspectiveTransform(position3);
	return ui.Offset(transformed3.x, transformed3.y);
	}

	/// Returns a rect that bounds the result of applying the given matrix as a
	/// perspective transform to the given rect.
	///
	/// This function assumes the given rect is in the plane with z equals 0.0.
	/// The transformed rect is then projected back into the plane with z equals
	/// 0.0 before computing its bounding rect.
	static ui.Rect _transformRect(Matrix4 transform, ui.Rect rect) {
	final ui.Offset point1 = _transformPoint(transform, rect.topLeft);
	final ui.Offset point2 = _transformPoint(transform, rect.topRight);
	final ui.Offset point3 = _transformPoint(transform, rect.bottomLeft);
	final ui.Offset point4 = _transformPoint(transform, rect.bottomRight);
	return ui.Rect.fromLTRB(
	_min4(point1.dx, point2.dx, point3.dx, point4.dx),
	_min4(point1.dy, point2.dy, point3.dy, point4.dy),
	_max4(point1.dx, point2.dx, point3.dx, point4.dx),
	_max4(point1.dy, point2.dy, point3.dy, point4.dy));
	}

	static double _min4(double a, double b, double c, double d) {
	return math.min(a, math.min(b, math.min(c, d)));
	}

	static double _max4(double a, double b, double c, double d) {
	return math.max(a, math.max(b, math.max(c, d)));
	}

	@override
	void paint(PaintContext paintContext) {
	assert(needsPainting);

	paintContext.internalNodesCanvas.save();
	paintContext.internalNodesCanvas.transform(_transform.storage);
	paintChildren(paintContext);
	paintContext.internalNodesCanvas.restore();
	}
	}

	/// A layer that applies an [ui.ImageFilter] to its children.
	class ImageFilterLayer extends ContainerLayer implements ui.OpacityEngineLayer {
	ImageFilterLayer(this._filter);

	final ui.ImageFilter _filter;

	@override
	void paint(PaintContext paintContext) {
	assert(needsPainting);
	final ui.Paint paint = ui.Paint();
	paint.imageFilter = _filter;
	paintContext.internalNodesCanvas.saveLayer(paintBounds, paint);
	paintChildren(paintContext);
	paintContext.internalNodesCanvas.restore();
	}
	}

	/// A layer containing a [Picture].
	class PictureLayer extends Layer {
	/// The picture to paint into the canvas.
	final SkPicture picture;

	/// The offset at which to paint the picture.
	final ui.Offset offset;

	/// A hint to the compositor about whether this picture is complex.
	final bool isComplex;

	/// A hint to the compositor that this picture is likely to change.
	final bool willChange;

	PictureLayer(this.picture, this.offset, this.isComplex, this.willChange);

	@override
	void preroll(PrerollContext prerollContext, Matrix4 matrix) {
	paintBounds = picture.cullRect.shift(offset);
	}

	@override
	void paint(PaintContext paintContext) {
	assert(picture != null);
	assert(needsPainting);

	paintContext.leafNodesCanvas.save();
	paintContext.leafNodesCanvas.translate(offset.dx, offset.dy);

	paintContext.leafNodesCanvas.drawPicture(picture);
	paintContext.leafNodesCanvas.restore();
	}
	}

	/// A layer representing a physical shape.
	///
	/// The shape clips its children to a given [Path], and casts a shadow based
	/// on the given elevation.
	class PhysicalShapeLayer extends ContainerLayer
	implements ui.PhysicalShapeEngineLayer {
	final double _elevation;
	final ui.Color _color;
	final ui.Color _shadowColor;
	final ui.Path _path;
	final ui.Clip _clipBehavior;

	PhysicalShapeLayer(
	this._elevation,
	this._color,
	this._shadowColor,
	this._path,
	this._clipBehavior,
	);

	@override
	void preroll(PrerollContext prerollContext, Matrix4 matrix) {
	prerollChildren(prerollContext, matrix);

	paintBounds = _path.getBounds();
	if (_elevation == 0.0) {
	// No need to extend the paint bounds if there is no shadow.
	return;
	} else {
	// Add some margin to the paint bounds to leave space for the shadow.
	// We fill this whole region and clip children to it so we don't need to
	// join the child paint bounds.
	// The offset is calculated as follows:

	// .--- (kLightRadius)
	// -------/ (light)
	// \| /
	// \| /
	// \|/
	// \|O
	// /\| (kLightHeight)
	// / \|
	// / \|
	// / \|
	// / \|
	// ------------- (layer)
	// /\| \|
	// / \| \| (elevation)
	// A / \| \|B
	// ------------------------------------------------ (canvas)
	// --- (extent of shadow)
	//
	// E = lt } t = (r + w/2)/h
	// } =>
	// r + w/2 = ht } E = (l/h)(r + w/2)
	//
	// Where: E = extent of shadow
	// l = elevation of layer
	// r = radius of the light source
	// w = width of the layer
	// h = light height
	// t = tangent of AOB, i.e., multiplier for elevation to extent
	final double devicePixelRatio = ui.window.devicePixelRatio;

	final double radius = kLightRadius * devicePixelRatio;
	// tangent for x
	double tx = (radius + paintBounds.width * 0.5) / kLightHeight;
	// tangent for y
	double ty = (radius + paintBounds.height * 0.5) / kLightHeight;

	paintBounds = ui.Rect.fromLTRB(
	paintBounds.left - tx,
	paintBounds.top - ty,
	paintBounds.right + tx,
	paintBounds.bottom + ty,
	);
	}
	}

	@override
	void paint(PaintContext paintContext) {
	assert(needsPainting);

	if (_elevation != 0) {
	drawShadow(paintContext.leafNodesCanvas, _path, _shadowColor, _elevation,
	_color.alpha != 0xff);
	}

	final ui.Paint paint = ui.Paint()..color = _color;
	if (_clipBehavior != ui.Clip.antiAliasWithSaveLayer) {
	paintContext.leafNodesCanvas.drawPath(_path, paint);
	}

	final int saveCount = paintContext.internalNodesCanvas.save();
	switch (_clipBehavior) {
	case ui.Clip.hardEdge:
	paintContext.internalNodesCanvas.clipPath(_path, false);
	break;
	case ui.Clip.antiAlias:
	paintContext.internalNodesCanvas.clipPath(_path, true);
	break;
	case ui.Clip.antiAliasWithSaveLayer:
	paintContext.internalNodesCanvas.clipPath(_path, true);
	paintContext.internalNodesCanvas.saveLayer(paintBounds, null);
	break;
	case ui.Clip.none:
	break;
	}

	if (_clipBehavior == ui.Clip.antiAliasWithSaveLayer) {
	// If we want to avoid the bleeding edge artifact
	// (https://github.com/flutter/flutter/issues/18057#issue-328003931)
	// using saveLayer, we have to call drawPaint instead of drawPath as
	// anti-aliased drawPath will always have such artifacts.
	paintContext.leafNodesCanvas.drawPaint(paint);
	}

	paintChildren(paintContext);

	paintContext.internalNodesCanvas.restoreToCount(saveCount);
	}

	/// Draws a shadow on the given [canvas] for the given [path].
	///
	/// The blur of the shadow is decided by the [elevation], and the
	/// shadow is painted with the given [color].
	static void drawShadow(SkCanvas canvas, ui.Path path, ui.Color color,
	double elevation, bool transparentOccluder) {
	canvas.drawShadow(path, color, elevation, transparentOccluder);
	}
	}

	/// A layer which renders a platform view (an HTML element in this case).
	class PlatformViewLayer extends Layer {
	PlatformViewLayer(this.viewId, this.offset, this.width, this.height);

	final int viewId;
	final ui.Offset offset;
	final double width;
	final double height;

	@override
	void preroll(PrerollContext context, Matrix4 matrix) {
	paintBounds = ui.Rect.fromLTWH(offset.dx, offset.dy, width, height);
	context.viewEmbedder.prerollCompositeEmbeddedView(
	viewId,
	EmbeddedViewParams(
	offset,
	ui.Size(width, height),
	context.mutatorsStack,
	),
	);
	}

	@override
	void paint(PaintContext context) {
	SkCanvas canvas = context.viewEmbedder.compositeEmbeddedView(viewId);
	context.leafNodesCanvas = canvas;
	}
	}