shell/platform/darwin/macos/framework/Source/FlutterMutatorView.mm - mirrors/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.

 #import "flutter/shell/platform/darwin/macos/framework/Source/FlutterMutatorView.h"
 #include "flutter/fml/logging.h"

 #include <QuartzCore/QuartzCore.h>
 #include <vector>

 @interface FlutterMutatorView () {
   /// Each of these views clips to a CGPathRef. These views, if present,
   /// are nested (first is child of FlutterMutatorView and last is parent of
   // _platformView).
   NSMutableArray* _pathClipViews;

   // View right above the platform view. Used to apply the final transform
   // (sans the translation) to the platform view.
   NSView* _platformViewContainer;

   NSView* _platformView;
 }

 @end

 /// View that clips that content to a specific CGPathRef.
 /// Clipping is done through a CAShapeLayer mask, which avoids the need to
 /// rasterize the mask.
 @interface FlutterPathClipView : NSView

 @end

 @implementation FlutterPathClipView

 - (instancetype)initWithFrame:(NSRect)frameRect {
   if (self = [super initWithFrame:frameRect]) {
     self.wantsLayer = YES;
   }
   return self;
 }

 - (BOOL)isFlipped {
   return YES;
 }

 /// Clip the view to the given path. Offset top left corner of platform view
 /// in global logical coordinates.
 - (void)maskToPath:(CGPathRef)path withOrigin:(CGPoint)origin {
   CAShapeLayer* maskLayer = self.layer.mask;
   if (maskLayer == nil) {
     maskLayer = [CAShapeLayer layer];
     self.layer.mask = maskLayer;
   }
   maskLayer.path = path;
   maskLayer.transform = CATransform3DMakeTranslation(-origin.x, -origin.y, 0);
 }

 @end

 namespace {
 CATransform3D ToCATransform3D(const FlutterTransformation& t) {
   CATransform3D transform = CATransform3DIdentity;
   transform.m11 = t.scaleX;
   transform.m21 = t.skewX;
   transform.m41 = t.transX;
   transform.m14 = t.pers0;
   transform.m12 = t.skewY;
   transform.m22 = t.scaleY;
   transform.m42 = t.transY;
   transform.m24 = t.pers1;
   return transform;
 }

 CGRect FromFlutterRect(const FlutterRect& rect) {
   return CGRectMake(rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top);
 }

 FlutterRect ToFlutterRect(const CGRect& rect) {
   return FlutterRect{
       .left = rect.origin.x,
       .top = rect.origin.y,
       .right = rect.origin.x + rect.size.width,
       .bottom = rect.origin.y + rect.size.height,

   };
 }

 /// Returns whether the point is inside ellipse with given radius (centered at 0, 0).
 bool PointInsideEllipse(const CGPoint& point, const FlutterSize& radius) {
   return (point.x * point.x) / (radius.width * radius.width) +
              (point.y * point.y) / (radius.height * radius.height) <
          1.0;
 }

 bool RoundRectCornerIntersects(const FlutterRoundedRect& roundRect, const FlutterRect& rect) {
   // Inner coordinate of the top left corner of the round rect.
   CGPoint inner_top_left =
       CGPointMake(roundRect.rect.left + roundRect.upper_left_corner_radius.width,
                   roundRect.rect.top + roundRect.upper_left_corner_radius.height);

   // Position of `rect` corner relative to inner_top_left.
   CGPoint relative_top_left =
       CGPointMake(rect.left - inner_top_left.x, rect.top - inner_top_left.y);

   // `relative_top_left` is in upper left quadrant.
   if (relative_top_left.x < 0 && relative_top_left.y < 0) {
     if (!PointInsideEllipse(relative_top_left, roundRect.upper_left_corner_radius)) {
       return true;
     }
   }

   // Inner coordinate of the top right corner of the round rect.
   CGPoint inner_top_right =
       CGPointMake(roundRect.rect.right - roundRect.upper_right_corner_radius.width,
                   roundRect.rect.top + roundRect.upper_right_corner_radius.height);

   // Positon of `rect` corner relative to inner_top_right.
   CGPoint relative_top_right =
       CGPointMake(rect.right - inner_top_right.x, rect.top - inner_top_right.y);

   // `relative_top_right` is in top right quadrant.
   if (relative_top_right.x > 0 && relative_top_right.y < 0) {
     if (!PointInsideEllipse(relative_top_right, roundRect.upper_right_corner_radius)) {
       return true;
     }
   }

   // Inner coordinate of the bottom left corner of the round rect.
   CGPoint inner_bottom_left =
       CGPointMake(roundRect.rect.left + roundRect.lower_left_corner_radius.width,
                   roundRect.rect.bottom - roundRect.lower_left_corner_radius.height);

   // Position of `rect` corner relative to inner_bottom_left.
   CGPoint relative_bottom_left =
       CGPointMake(rect.left - inner_bottom_left.x, rect.bottom - inner_bottom_left.y);

   // `relative_bottom_left` is in bottom left quadrant.
   if (relative_bottom_left.x < 0 && relative_bottom_left.y > 0) {
     if (!PointInsideEllipse(relative_bottom_left, roundRect.lower_left_corner_radius)) {
       return true;
     }
   }

   // Inner coordinate of the bottom right corner of the round rect.
   CGPoint inner_bottom_right =
       CGPointMake(roundRect.rect.right - roundRect.lower_right_corner_radius.width,
                   roundRect.rect.bottom - roundRect.lower_right_corner_radius.height);

   // Position of `rect` corner relative to inner_bottom_right.
   CGPoint relative_bottom_right =
       CGPointMake(rect.right - inner_bottom_right.x, rect.bottom - inner_bottom_right.y);

   // `relative_bottom_right` is in bottom right quadrant.
   if (relative_bottom_right.x > 0 && relative_bottom_right.y > 0) {
     if (!PointInsideEllipse(relative_bottom_right, roundRect.lower_right_corner_radius)) {
       return true;
     }
   }

   return false;
 }

 CGPathRef PathFromRoundedRect(const FlutterRoundedRect& roundedRect) {
   CGMutablePathRef path = CGPathCreateMutable();

   const auto& rect = roundedRect.rect;
   const auto& topLeft = roundedRect.upper_left_corner_radius;
   const auto& topRight = roundedRect.upper_right_corner_radius;
   const auto& bottomLeft = roundedRect.lower_left_corner_radius;
   const auto& bottomRight = roundedRect.lower_right_corner_radius;

   CGPathMoveToPoint(path, nullptr, rect.left + topLeft.width, rect.top);
   CGPathAddLineToPoint(path, nullptr, rect.right - topRight.width, rect.top);
   CGPathAddCurveToPoint(path, nullptr, rect.right, rect.top, rect.right, rect.top + topRight.height,
                         rect.right, rect.top + topRight.height);
   CGPathAddLineToPoint(path, nullptr, rect.right, rect.bottom - bottomRight.height);
   CGPathAddCurveToPoint(path, nullptr, rect.right, rect.bottom, rect.right - bottomRight.width,
                         rect.bottom, rect.right - bottomRight.width, rect.bottom);
   CGPathAddLineToPoint(path, nullptr, rect.left + bottomLeft.width, rect.bottom);
   CGPathAddCurveToPoint(path, nullptr, rect.left, rect.bottom, rect.left,
                         rect.bottom - bottomLeft.height, rect.left,
                         rect.bottom - bottomLeft.height);
   CGPathAddLineToPoint(path, nullptr, rect.left, rect.top + topLeft.height);
   CGPathAddCurveToPoint(path, nullptr, rect.left, rect.top, rect.left + topLeft.width, rect.top,
                         rect.left + topLeft.width, rect.top);
   CGPathCloseSubpath(path);
   return path;
 }
 }  // namespace

 @implementation FlutterMutatorView

 - (NSView*)platformView {
   return _platformView;
 }

 - (NSMutableArray*)pathClipViews {
   return _pathClipViews;
 }

 - (NSView*)platformViewContainer {
   return _platformViewContainer;
 }

 - (instancetype)initWithPlatformView:(NSView*)platformView {
   if (self = [super initWithFrame:NSZeroRect]) {
     _platformView = platformView;
     _pathClipViews = [NSMutableArray array];
     self.wantsLayer = YES;
   }
   return self;
 }

 - (NSView*)hitTest:(NSPoint)point {
   return nil;
 }

 - (BOOL)isFlipped {
   return YES;
 }

 /// Whenever possible view will be clipped using layer bounds.
 /// If clipping to path is needed, CAShapeLayer(s) will be used as mask.
 /// Clipping to round rect only clips to path if round corners are intersected.
 - (void)applyFlutterLayer:(const FlutterLayer*)layer {
   CGFloat scale = self.superview != nil ? self.superview.layer.contentsScale : 1.0;

   // Initial transform to compensate for scale factor. This is needed because all
   // cocoa coordinates are logical but Flutter will send the physical to logical
   // transform in mutations.
   CATransform3D transform = CATransform3DMakeScale(1.0 / scale, 1.0 / scale, 1);

   // Platform view transform after applying all transformation mutations.
   CATransform3D finalTransform = transform;
   for (size_t i = 0; i < layer->platform_view->mutations_count; ++i) {
     auto mutation = layer->platform_view->mutations[i];
     if (mutation->type == kFlutterPlatformViewMutationTypeTransformation) {
       finalTransform =
           CATransform3DConcat(ToCATransform3D(mutation->transformation), finalTransform);
     }
   }

   CGRect untransformedBoundingRect =
       CGRectMake(0, 0, layer->size.width / scale, layer->size.height / scale);

   CGRect finalBoundingRect = CGRectApplyAffineTransform(
       untransformedBoundingRect, CATransform3DGetAffineTransform(finalTransform));

   self.frame = finalBoundingRect;

   // Master clip in global logical coordinates. This is intersection of all clip rectangles
   // present in mutators.
   CGRect masterClip = finalBoundingRect;

   self.layer.opacity = 1.0;

   // Gathered pairs of rounded rect in local coordinates + appropriate transform.
   std::vector<std::pair<FlutterRoundedRect, CGAffineTransform>> roundedRects;

   for (size_t i = 0; i < layer->platform_view->mutations_count; ++i) {
     auto mutation = layer->platform_view->mutations[i];
     if (mutation->type == kFlutterPlatformViewMutationTypeTransformation) {
       transform = CATransform3DConcat(ToCATransform3D(mutation->transformation), transform);
     } else if (mutation->type == kFlutterPlatformViewMutationTypeClipRect) {
       CGRect rect = CGRectApplyAffineTransform(FromFlutterRect(mutation->clip_rect),
                                                CATransform3DGetAffineTransform(transform));
       masterClip = CGRectIntersection(rect, masterClip);
     } else if (mutation->type == kFlutterPlatformViewMutationTypeClipRoundedRect) {
       CGAffineTransform affineTransform = CATransform3DGetAffineTransform(transform);
       roundedRects.push_back(std::make_pair(mutation->clip_rounded_rect, affineTransform));
       CGRect rect = CGRectApplyAffineTransform(FromFlutterRect(mutation->clip_rounded_rect.rect),
                                                affineTransform);
       masterClip = CGRectIntersection(rect, masterClip);
     } else if (mutation->type == kFlutterPlatformViewMutationTypeOpacity) {
       self.layer.opacity *= mutation->opacity;
     }
   }

   if (CGRectIsNull(masterClip)) {
     self.hidden = YES;
     return;
   }

   self.hidden = NO;

   /// Paths in global logical coordinates that need to be clipped to.
   NSMutableArray* paths = [NSMutableArray array];

   for (const auto& r : roundedRects) {
     CGAffineTransform inverse = CGAffineTransformInvert(r.second);
     // Transform master clip to clip rect coordinates and check if this view intersects one of the
     // corners, which means we need to use path clipping.
     CGRect localMasterClip = CGRectApplyAffineTransform(masterClip, inverse);

     // Only clip to rounded rectangle path if the view intersects some of the round corners. If
     // not, clipping to masterClip is enough.
     if (RoundRectCornerIntersects(r.first, ToFlutterRect(localMasterClip))) {
       CGPathRef path = PathFromRoundedRect(r.first);
       CGPathRef transformedPath = CGPathCreateCopyByTransformingPath(path, &r.second);
       [paths addObject:(__bridge id)transformedPath];
       CGPathRelease(transformedPath);
       CGPathRelease(path);
     }
   }

   // Add / remove path clip views depending on the number of paths.

   while (_pathClipViews.count > paths.count) {
     NSView* view = _pathClipViews.lastObject;
     [view removeFromSuperview];
     [_pathClipViews removeLastObject];
   }

   NSView* lastView = self;

   for (size_t i = 0; i < paths.count; ++i) {
     FlutterPathClipView* pathClipView = nil;
     if (i < _pathClipViews.count) {
       pathClipView = _pathClipViews[i];
     } else {
       pathClipView = [[FlutterPathClipView alloc] initWithFrame:self.bounds];
       [_pathClipViews addObject:pathClipView];
       [lastView addSubview:pathClipView];
     }
     pathClipView.frame = self.bounds;
     [pathClipView maskToPath:(__bridge CGPathRef)[paths objectAtIndex:i]
                   withOrigin:finalBoundingRect.origin];
     lastView = pathClipView;
   }

   // Used to apply sublayer transform.
   if (_platformViewContainer == nil) {
     _platformViewContainer = [[NSView alloc] initWithFrame:self.bounds];
     _platformViewContainer.wantsLayer = YES;
   }

   [lastView addSubview:_platformViewContainer];
   _platformViewContainer.frame = self.bounds;

   [_platformViewContainer addSubview:_platformView];
   _platformView.frame = untransformedBoundingRect;

   // Transform for the platform view is finalTransform adjusted for bounding rect origin.
   _platformViewContainer.layer.sublayerTransform = CATransform3DTranslate(
       finalTransform, -finalBoundingRect.origin.x / finalTransform.m11 /* scaleX */,
       -finalBoundingRect.origin.y / finalTransform.m22 /* scaleY */, 0);

   // By default NSView clips children to frame. If masterClip is tighter than mutator view frame,
   // the frame is set to masterClip and child offset adjusted to compensate for the difference.
   if (!CGRectEqualToRect(masterClip, finalBoundingRect)) {
     FML_DCHECK(self.subviews.count == 1);
     auto subview = self.subviews.firstObject;
     FML_DCHECK(subview.frame.origin.x == 0 && subview.frame.origin.y == 0);
     subview.frame = CGRectMake(finalBoundingRect.origin.x - masterClip.origin.x,
                                finalBoundingRect.origin.y - masterClip.origin.y,
                                subview.frame.size.width, subview.frame.size.height);
     self.frame = masterClip;
   }
 }

 @end
	// 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.

	#import "flutter/shell/platform/darwin/macos/framework/Source/FlutterMutatorView.h"
	#include "flutter/fml/logging.h"

	#include <QuartzCore/QuartzCore.h>
	#include <vector>

	@interface FlutterMutatorView () {
	/// Each of these views clips to a CGPathRef. These views, if present,
	/// are nested (first is child of FlutterMutatorView and last is parent of
	// _platformView).
	NSMutableArray* _pathClipViews;

	// View right above the platform view. Used to apply the final transform
	// (sans the translation) to the platform view.
	NSView* _platformViewContainer;

	NSView* _platformView;
	}

	@end

	/// View that clips that content to a specific CGPathRef.
	/// Clipping is done through a CAShapeLayer mask, which avoids the need to
	/// rasterize the mask.
	@interface FlutterPathClipView : NSView

	@end

	@implementation FlutterPathClipView

	- (instancetype)initWithFrame:(NSRect)frameRect {
	if (self = [super initWithFrame:frameRect]) {
	self.wantsLayer = YES;
	}
	return self;
	}

	- (BOOL)isFlipped {
	return YES;
	}

	/// Clip the view to the given path. Offset top left corner of platform view
	/// in global logical coordinates.
	- (void)maskToPath:(CGPathRef)path withOrigin:(CGPoint)origin {
	CAShapeLayer* maskLayer = self.layer.mask;
	if (maskLayer == nil) {
	maskLayer = [CAShapeLayer layer];
	self.layer.mask = maskLayer;
	}
	maskLayer.path = path;
	maskLayer.transform = CATransform3DMakeTranslation(-origin.x, -origin.y, 0);
	}

	@end

	namespace {
	CATransform3D ToCATransform3D(const FlutterTransformation& t) {
	CATransform3D transform = CATransform3DIdentity;
	transform.m11 = t.scaleX;
	transform.m21 = t.skewX;
	transform.m41 = t.transX;
	transform.m14 = t.pers0;
	transform.m12 = t.skewY;
	transform.m22 = t.scaleY;
	transform.m42 = t.transY;
	transform.m24 = t.pers1;
	return transform;
	}

	CGRect FromFlutterRect(const FlutterRect& rect) {
	return CGRectMake(rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top);
	}

	FlutterRect ToFlutterRect(const CGRect& rect) {
	return FlutterRect{
	.left = rect.origin.x,
	.top = rect.origin.y,
	.right = rect.origin.x + rect.size.width,
	.bottom = rect.origin.y + rect.size.height,

	};
	}

	/// Returns whether the point is inside ellipse with given radius (centered at 0, 0).
	bool PointInsideEllipse(const CGPoint& point, const FlutterSize& radius) {
	return (point.x * point.x) / (radius.width * radius.width) +
	(point.y * point.y) / (radius.height * radius.height) <
	1.0;
	}

	bool RoundRectCornerIntersects(const FlutterRoundedRect& roundRect, const FlutterRect& rect) {
	// Inner coordinate of the top left corner of the round rect.
	CGPoint inner_top_left =
	CGPointMake(roundRect.rect.left + roundRect.upper_left_corner_radius.width,
	roundRect.rect.top + roundRect.upper_left_corner_radius.height);

	// Position of `rect` corner relative to inner_top_left.
	CGPoint relative_top_left =
	CGPointMake(rect.left - inner_top_left.x, rect.top - inner_top_left.y);

	// `relative_top_left` is in upper left quadrant.
	if (relative_top_left.x < 0 && relative_top_left.y < 0) {
	if (!PointInsideEllipse(relative_top_left, roundRect.upper_left_corner_radius)) {
	return true;
	}
	}

	// Inner coordinate of the top right corner of the round rect.
	CGPoint inner_top_right =
	CGPointMake(roundRect.rect.right - roundRect.upper_right_corner_radius.width,
	roundRect.rect.top + roundRect.upper_right_corner_radius.height);

	// Positon of `rect` corner relative to inner_top_right.
	CGPoint relative_top_right =
	CGPointMake(rect.right - inner_top_right.x, rect.top - inner_top_right.y);

	// `relative_top_right` is in top right quadrant.
	if (relative_top_right.x > 0 && relative_top_right.y < 0) {
	if (!PointInsideEllipse(relative_top_right, roundRect.upper_right_corner_radius)) {
	return true;
	}
	}

	// Inner coordinate of the bottom left corner of the round rect.
	CGPoint inner_bottom_left =
	CGPointMake(roundRect.rect.left + roundRect.lower_left_corner_radius.width,
	roundRect.rect.bottom - roundRect.lower_left_corner_radius.height);

	// Position of `rect` corner relative to inner_bottom_left.
	CGPoint relative_bottom_left =
	CGPointMake(rect.left - inner_bottom_left.x, rect.bottom - inner_bottom_left.y);

	// `relative_bottom_left` is in bottom left quadrant.
	if (relative_bottom_left.x < 0 && relative_bottom_left.y > 0) {
	if (!PointInsideEllipse(relative_bottom_left, roundRect.lower_left_corner_radius)) {
	return true;
	}
	}

	// Inner coordinate of the bottom right corner of the round rect.
	CGPoint inner_bottom_right =
	CGPointMake(roundRect.rect.right - roundRect.lower_right_corner_radius.width,
	roundRect.rect.bottom - roundRect.lower_right_corner_radius.height);

	// Position of `rect` corner relative to inner_bottom_right.
	CGPoint relative_bottom_right =
	CGPointMake(rect.right - inner_bottom_right.x, rect.bottom - inner_bottom_right.y);

	// `relative_bottom_right` is in bottom right quadrant.
	if (relative_bottom_right.x > 0 && relative_bottom_right.y > 0) {
	if (!PointInsideEllipse(relative_bottom_right, roundRect.lower_right_corner_radius)) {
	return true;
	}
	}

	return false;
	}

	CGPathRef PathFromRoundedRect(const FlutterRoundedRect& roundedRect) {
	CGMutablePathRef path = CGPathCreateMutable();

	const auto& rect = roundedRect.rect;
	const auto& topLeft = roundedRect.upper_left_corner_radius;
	const auto& topRight = roundedRect.upper_right_corner_radius;
	const auto& bottomLeft = roundedRect.lower_left_corner_radius;
	const auto& bottomRight = roundedRect.lower_right_corner_radius;

	CGPathMoveToPoint(path, nullptr, rect.left + topLeft.width, rect.top);
	CGPathAddLineToPoint(path, nullptr, rect.right - topRight.width, rect.top);
	CGPathAddCurveToPoint(path, nullptr, rect.right, rect.top, rect.right, rect.top + topRight.height,
	rect.right, rect.top + topRight.height);
	CGPathAddLineToPoint(path, nullptr, rect.right, rect.bottom - bottomRight.height);
	CGPathAddCurveToPoint(path, nullptr, rect.right, rect.bottom, rect.right - bottomRight.width,
	rect.bottom, rect.right - bottomRight.width, rect.bottom);
	CGPathAddLineToPoint(path, nullptr, rect.left + bottomLeft.width, rect.bottom);
	CGPathAddCurveToPoint(path, nullptr, rect.left, rect.bottom, rect.left,
	rect.bottom - bottomLeft.height, rect.left,
	rect.bottom - bottomLeft.height);
	CGPathAddLineToPoint(path, nullptr, rect.left, rect.top + topLeft.height);
	CGPathAddCurveToPoint(path, nullptr, rect.left, rect.top, rect.left + topLeft.width, rect.top,
	rect.left + topLeft.width, rect.top);
	CGPathCloseSubpath(path);
	return path;
	}
	} // namespace

	@implementation FlutterMutatorView

	- (NSView*)platformView {
	return _platformView;
	}

	- (NSMutableArray*)pathClipViews {
	return _pathClipViews;
	}

	- (NSView*)platformViewContainer {
	return _platformViewContainer;
	}

	- (instancetype)initWithPlatformView:(NSView*)platformView {
	if (self = [super initWithFrame:NSZeroRect]) {
	_platformView = platformView;
	_pathClipViews = [NSMutableArray array];
	self.wantsLayer = YES;
	}
	return self;
	}

	- (NSView*)hitTest:(NSPoint)point {
	return nil;
	}

	- (BOOL)isFlipped {
	return YES;
	}

	/// Whenever possible view will be clipped using layer bounds.
	/// If clipping to path is needed, CAShapeLayer(s) will be used as mask.
	/// Clipping to round rect only clips to path if round corners are intersected.
	- (void)applyFlutterLayer:(const FlutterLayer*)layer {
	CGFloat scale = self.superview != nil ? self.superview.layer.contentsScale : 1.0;

	// Initial transform to compensate for scale factor. This is needed because all
	// cocoa coordinates are logical but Flutter will send the physical to logical
	// transform in mutations.
	CATransform3D transform = CATransform3DMakeScale(1.0 / scale, 1.0 / scale, 1);

	// Platform view transform after applying all transformation mutations.
	CATransform3D finalTransform = transform;
	for (size_t i = 0; i < layer->platform_view->mutations_count; ++i) {
	auto mutation = layer->platform_view->mutations[i];
	if (mutation->type == kFlutterPlatformViewMutationTypeTransformation) {
	finalTransform =
	CATransform3DConcat(ToCATransform3D(mutation->transformation), finalTransform);
	}
	}

	CGRect untransformedBoundingRect =
	CGRectMake(0, 0, layer->size.width / scale, layer->size.height / scale);

	CGRect finalBoundingRect = CGRectApplyAffineTransform(
	untransformedBoundingRect, CATransform3DGetAffineTransform(finalTransform));

	self.frame = finalBoundingRect;

	// Master clip in global logical coordinates. This is intersection of all clip rectangles
	// present in mutators.
	CGRect masterClip = finalBoundingRect;

	self.layer.opacity = 1.0;

	// Gathered pairs of rounded rect in local coordinates + appropriate transform.
	std::vector<std::pair<FlutterRoundedRect, CGAffineTransform>> roundedRects;

	for (size_t i = 0; i < layer->platform_view->mutations_count; ++i) {
	auto mutation = layer->platform_view->mutations[i];
	if (mutation->type == kFlutterPlatformViewMutationTypeTransformation) {
	transform = CATransform3DConcat(ToCATransform3D(mutation->transformation), transform);
	} else if (mutation->type == kFlutterPlatformViewMutationTypeClipRect) {
	CGRect rect = CGRectApplyAffineTransform(FromFlutterRect(mutation->clip_rect),
	CATransform3DGetAffineTransform(transform));
	masterClip = CGRectIntersection(rect, masterClip);
	} else if (mutation->type == kFlutterPlatformViewMutationTypeClipRoundedRect) {
	CGAffineTransform affineTransform = CATransform3DGetAffineTransform(transform);
	roundedRects.push_back(std::make_pair(mutation->clip_rounded_rect, affineTransform));
	CGRect rect = CGRectApplyAffineTransform(FromFlutterRect(mutation->clip_rounded_rect.rect),
	affineTransform);
	masterClip = CGRectIntersection(rect, masterClip);
	} else if (mutation->type == kFlutterPlatformViewMutationTypeOpacity) {
	self.layer.opacity *= mutation->opacity;
	}
	}

	if (CGRectIsNull(masterClip)) {
	self.hidden = YES;
	return;
	}

	self.hidden = NO;

	/// Paths in global logical coordinates that need to be clipped to.
	NSMutableArray* paths = [NSMutableArray array];

	for (const auto& r : roundedRects) {
	CGAffineTransform inverse = CGAffineTransformInvert(r.second);
	// Transform master clip to clip rect coordinates and check if this view intersects one of the
	// corners, which means we need to use path clipping.
	CGRect localMasterClip = CGRectApplyAffineTransform(masterClip, inverse);

	// Only clip to rounded rectangle path if the view intersects some of the round corners. If
	// not, clipping to masterClip is enough.
	if (RoundRectCornerIntersects(r.first, ToFlutterRect(localMasterClip))) {
	CGPathRef path = PathFromRoundedRect(r.first);
	CGPathRef transformedPath = CGPathCreateCopyByTransformingPath(path, &r.second);
	[paths addObject:(__bridge id)transformedPath];
	CGPathRelease(transformedPath);
	CGPathRelease(path);
	}
	}

	// Add / remove path clip views depending on the number of paths.

	while (_pathClipViews.count > paths.count) {
	NSView* view = _pathClipViews.lastObject;
	[view removeFromSuperview];
	[_pathClipViews removeLastObject];
	}

	NSView* lastView = self;

	for (size_t i = 0; i < paths.count; ++i) {
	FlutterPathClipView* pathClipView = nil;
	if (i < _pathClipViews.count) {
	pathClipView = _pathClipViews[i];
	} else {
	pathClipView = [[FlutterPathClipView alloc] initWithFrame:self.bounds];
	[_pathClipViews addObject:pathClipView];
	[lastView addSubview:pathClipView];
	}
	pathClipView.frame = self.bounds;
	[pathClipView maskToPath:(__bridge CGPathRef)[paths objectAtIndex:i]
	withOrigin:finalBoundingRect.origin];
	lastView = pathClipView;
	}

	// Used to apply sublayer transform.
	if (_platformViewContainer == nil) {
	_platformViewContainer = [[NSView alloc] initWithFrame:self.bounds];
	_platformViewContainer.wantsLayer = YES;
	}

	[lastView addSubview:_platformViewContainer];
	_platformViewContainer.frame = self.bounds;

	[_platformViewContainer addSubview:_platformView];
	_platformView.frame = untransformedBoundingRect;

	// Transform for the platform view is finalTransform adjusted for bounding rect origin.
	_platformViewContainer.layer.sublayerTransform = CATransform3DTranslate(
	finalTransform, -finalBoundingRect.origin.x / finalTransform.m11 /* scaleX */,
	-finalBoundingRect.origin.y / finalTransform.m22 /* scaleY */, 0);

	// By default NSView clips children to frame. If masterClip is tighter than mutator view frame,
	// the frame is set to masterClip and child offset adjusted to compensate for the difference.
	if (!CGRectEqualToRect(masterClip, finalBoundingRect)) {
	FML_DCHECK(self.subviews.count == 1);
	auto subview = self.subviews.firstObject;
	FML_DCHECK(subview.frame.origin.x == 0 && subview.frame.origin.y == 0);
	subview.frame = CGRectMake(finalBoundingRect.origin.x - masterClip.origin.x,
	finalBoundingRect.origin.y - masterClip.origin.y,
	subview.frame.size.width, subview.frame.size.height);
	self.frame = masterClip;
	}
	}

	@end