Merge pull request #6576 from AvaloniaUI/feature/1279-combining-geometries

Add GeometryGroup and CombinedGeometry
Conflicts:
	src/Avalonia.Visuals/ApiCompatBaseline.txt

src/Avalonia.Headless/HeadlessPlatformRenderInterface.cs

@@ -47,6 +47,8 @@ namespace Avalonia.Headless
         }
 
         public IStreamGeometryImpl CreateStreamGeometry() => new HeadlessStreamingGeometryStub();
+        public IGeometryImpl CreateGeometryGroup(FillRule fillRule, IReadOnlyList<Geometry> children) => throw new NotImplementedException();
+        public IGeometryImpl CreateCombinedGeometry(GeometryCombineMode combineMode, Geometry g1, Geometry g2) => throw new NotImplementedException();
 
         public IRenderTarget CreateRenderTarget(IEnumerable<object> surfaces) => new HeadlessRenderTarget();
 

src/Avalonia.Visuals/ApiCompatBaseline.txt

@@ -6,8 +6,13 @@ InterfacesShouldHaveSameMembers : Interface member 'public System.Double Avaloni
 InterfacesShouldHaveSameMembers : Interface member 'public System.Boolean Avalonia.Platform.IGeometryImpl.TryGetPointAndTangentAtDistance(System.Double, Avalonia.Point, Avalonia.Point)' is present in the implementation but not in the contract.
 InterfacesShouldHaveSameMembers : Interface member 'public System.Boolean Avalonia.Platform.IGeometryImpl.TryGetPointAtDistance(System.Double, Avalonia.Point)' is present in the implementation but not in the contract.
 InterfacesShouldHaveSameMembers : Interface member 'public System.Boolean Avalonia.Platform.IGeometryImpl.TryGetSegment(System.Double, System.Double, System.Boolean, Avalonia.Platform.IGeometryImpl)' is present in the implementation but not in the contract.
+InterfacesShouldHaveSameMembers : Interface member 'public Avalonia.Platform.IGeometryImpl Avalonia.Platform.IPlatformRenderInterface.CreateCombinedGeometry(Avalonia.Media.GeometryCombineMode, Avalonia.Media.Geometry, Avalonia.Media.Geometry)' is present in the implementation but not in the contract.
+InterfacesShouldHaveSameMembers : Interface member 'public Avalonia.Platform.IGeometryImpl Avalonia.Platform.IPlatformRenderInterface.CreateGeometryGroup(Avalonia.Media.FillRule, System.Collections.Generic.IReadOnlyList<Avalonia.Media.Geometry>)' is present in the implementation but not in the contract.
+InterfacesShouldHaveSameMembers : Interface member 'public Avalonia.Platform.IGlyphRunImpl Avalonia.Platform.IPlatformRenderInterface.CreateGlyphRun(Avalonia.Media.GlyphRun)' is present in the implementation but not in the contract.
+InterfacesShouldHaveSameMembers : Interface member 'public Avalonia.Platform.IGlyphRunImpl Avalonia.Platform.IPlatformRenderInterface.CreateGlyphRun(Avalonia.Media.GlyphRun, System.Double)' is present in the contract but not in the implementation.
+MembersMustExist : Member 'public Avalonia.Platform.IGlyphRunImpl Avalonia.Platform.IPlatformRenderInterface.CreateGlyphRun(Avalonia.Media.GlyphRun, System.Double)' does not exist in the implementation but it does exist in the contract.
 InterfacesShouldHaveSameMembers : Interface member 'public Avalonia.Platform.IWriteableBitmapImpl Avalonia.Platform.IPlatformRenderInterface.LoadWriteableBitmap(System.IO.Stream)' is present in the implementation but not in the contract.
 InterfacesShouldHaveSameMembers : Interface member 'public Avalonia.Platform.IWriteableBitmapImpl Avalonia.Platform.IPlatformRenderInterface.LoadWriteableBitmap(System.String)' is present in the implementation but not in the contract.
 InterfacesShouldHaveSameMembers : Interface member 'public Avalonia.Platform.IWriteableBitmapImpl Avalonia.Platform.IPlatformRenderInterface.LoadWriteableBitmapToHeight(System.IO.Stream, System.Int32, Avalonia.Visuals.Media.Imaging.BitmapInterpolationMode)' is present in the implementation but not in the contract.
 InterfacesShouldHaveSameMembers : Interface member 'public Avalonia.Platform.IWriteableBitmapImpl Avalonia.Platform.IPlatformRenderInterface.LoadWriteableBitmapToWidth(System.IO.Stream, System.Int32, Avalonia.Visuals.Media.Imaging.BitmapInterpolationMode)' is present in the implementation but not in the contract.
-Total Issues: 11
+Total Issues: 17

src/Avalonia.Visuals/Media/CombinedGeometry.cs

@@ -0,0 +1,170 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Avalonia.Platform;
+
+#nullable enable
+
+namespace Avalonia.Media
+{
+    public enum GeometryCombineMode
+    {
+        /// <summary>
+        /// The two regions are combined by taking the union of both. The resulting geometry is
+        /// geometry A + geometry B.
+        /// </summary>
+        Union,
+
+        /// <summary>
+        /// The two regions are combined by taking their intersection. The new area consists of the
+        /// overlapping region between the two geometries.
+        /// </summary>
+        Intersect,
+
+        /// <summary>
+        /// The two regions are combined by taking the area that exists in the first region but not
+        /// the second and the area that exists in the second region but not the first. The new
+        /// region consists of (A-B) + (B-A), where A and B are geometries.
+        /// </summary>
+        Xor,
+
+        /// <summary>
+        /// The second region is excluded from the first. Given two geometries, A and B, the area of
+        /// geometry B is removed from the area of geometry A, producing a region that is A-B.
+        /// </summary>
+        Exclude,
+    }
+
+    /// <summary>
+    /// Represents a 2-D geometric shape defined by the combination of two Geometry objects.
+    /// </summary>
+    public class CombinedGeometry : Geometry
+    {
+        /// <summary>
+        /// Defines the <see cref="Geometry1"/> property.
+        /// </summary>
+        public static readonly StyledProperty<Geometry?> Geometry1Property =
+            AvaloniaProperty.Register<CombinedGeometry, Geometry?>(nameof(Geometry1));
+
+        /// <summary>
+        /// Defines the <see cref="Geometry2"/> property.
+        /// </summary>
+        public static readonly StyledProperty<Geometry?> Geometry2Property =
+            AvaloniaProperty.Register<CombinedGeometry, Geometry?>(nameof(Geometry2));
+        /// <summary>
+        /// Defines the <see cref="GeometryCombineMode"/> property.
+        /// </summary>
+        public static readonly StyledProperty<GeometryCombineMode> GeometryCombineModeProperty =
+            AvaloniaProperty.Register<CombinedGeometry, GeometryCombineMode>(nameof(GeometryCombineMode));
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CombinedGeometry"/> class.
+        /// </summary>
+        public CombinedGeometry()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CombinedGeometry"/> class with the
+        /// specified <see cref="Geometry"/> objects.
+        /// </summary>
+        /// <param name="geometry1">The first geometry to combine.</param>
+        /// <param name="geometry2">The second geometry to combine.</param>
+        public CombinedGeometry(Geometry geometry1, Geometry geometry2)
+        {
+            Geometry1 = geometry1;
+            Geometry2 = geometry2;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CombinedGeometry"/> class with the
+        /// specified <see cref="Geometry"/> objects and <see cref="GeometryCombineMode"/>.
+        /// </summary>
+        /// <param name="combineMode">The method by which geometry1 and geometry2 are combined.</param>
+        /// <param name="geometry1">The first geometry to combine.</param>
+        /// <param name="geometry2">The second geometry to combine.</param>
+        public CombinedGeometry(GeometryCombineMode combineMode, Geometry? geometry1, Geometry? geometry2)
+        {
+            Geometry1 = geometry1;
+            Geometry2 = geometry2;
+            GeometryCombineMode = combineMode;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CombinedGeometry"/> class with the
+        /// specified <see cref="Geometry"/> objects, <see cref="GeometryCombineMode"/> and
+        /// <see cref="Transform"/>.
+        /// </summary>
+        /// <param name="combineMode">The method by which geometry1 and geometry2 are combined.</param>
+        /// <param name="geometry1">The first geometry to combine.</param>
+        /// <param name="geometry2">The second geometry to combine.</param>
+        /// <param name="transform">The transform applied to the geometry.</param>
+        public CombinedGeometry(
+            GeometryCombineMode combineMode,
+            Geometry? geometry1,
+            Geometry? geometry2,
+            Transform? transform)
+        {
+            Geometry1 = geometry1;
+            Geometry2 = geometry2;
+            GeometryCombineMode = combineMode;
+            Transform = transform;
+        }
+
+        /// <summary>
+        /// Gets or sets the first <see cref="Geometry"/> object of this
+        /// <see cref="CombinedGeometry"/> object.
+        /// </summary>
+        public Geometry? Geometry1
+        {
+            get => GetValue(Geometry1Property);
+            set => SetValue(Geometry1Property, value);
+        }
+
+        /// <summary>
+        /// Gets or sets the second <see cref="Geometry"/> object of this
+        /// <see cref="CombinedGeometry"/> object.
+        /// </summary>
+        public Geometry? Geometry2
+        {
+            get => GetValue(Geometry2Property);
+            set => SetValue(Geometry2Property, value);
+        }
+
+        /// <summary>
+        /// Gets or sets the method by which the two geometries (specified by the
+        /// <see cref="Geometry1"/> and <see cref="Geometry2"/> properties) are combined. The
+        /// default value is <see cref="GeometryCombineMode.Union"/>.
+        /// </summary>
+        public GeometryCombineMode GeometryCombineMode
+        {
+            get => GetValue(GeometryCombineModeProperty);
+            set => SetValue(GeometryCombineModeProperty, value);
+        }
+
+        public override Geometry Clone()
+        {
+            return new CombinedGeometry(GeometryCombineMode, Geometry1, Geometry2, Transform);
+        }
+
+        protected override IGeometryImpl? CreateDefiningGeometry()
+        {
+            var g1 = Geometry1;
+            var g2 = Geometry2;
+
+            if (g1 is object && g2 is object)
+            {
+                var factory = AvaloniaLocator.Current.GetService<IPlatformRenderInterface>();
+                return factory.CreateCombinedGeometry(GeometryCombineMode, g1, g2);
+            }
+            else if (GeometryCombineMode == GeometryCombineMode.Intersect)
+                return null;
+            else if (g1 is object)
+                return g1.PlatformImpl;
+            else if (g2 is object)
+                return g2.PlatformImpl;
+            else
+                return null;
+        }
+    }
+}

src/Avalonia.Visuals/Media/GeometryCollection.cs

@@ -0,0 +1,37 @@
+using System.Collections;
+using System.Collections.Generic;
+using Avalonia.Animation;
+
+#nullable enable
+
+namespace Avalonia.Media
+{
+    public class GeometryCollection : Animatable, IList<Geometry>, IReadOnlyList<Geometry>
+    {
+        private List<Geometry> _inner;
+
+        public GeometryCollection() => _inner = new List<Geometry>();
+        public GeometryCollection(IEnumerable<Geometry> collection) => _inner = new List<Geometry>(collection);
+        public GeometryCollection(int capacity) => _inner = new List<Geometry>(capacity);
+
+        public Geometry this[int index] 
+        { 
+            get => _inner[index];
+            set => _inner[index] = value; 
+        }
+
+        public int Count => _inner.Count;
+        public bool IsReadOnly => false;
+
+        public void Add(Geometry item) => _inner.Add(item);
+        public void Clear() => _inner.Clear();
+        public bool Contains(Geometry item) => _inner.Contains(item);
+        public void CopyTo(Geometry[] array, int arrayIndex) => _inner.CopyTo(array, arrayIndex);
+        public IEnumerator<Geometry> GetEnumerator() => _inner.GetEnumerator();
+        public int IndexOf(Geometry item) => _inner.IndexOf(item);
+        public void Insert(int index, Geometry item) => _inner.Insert(index, item);
+        public bool Remove(Geometry item) => _inner.Remove(item);
+        public void RemoveAt(int index) => _inner.RemoveAt(index);
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+    }
+}

src/Avalonia.Visuals/Media/GeometryGroup.cs

@@ -0,0 +1,80 @@
+using System.Collections.Generic;
+using System.Linq;
+using Avalonia.Metadata;
+using Avalonia.Platform;
+
+#nullable enable
+
+namespace Avalonia.Media
+{
+    /// <summary>
+    /// Represents a composite geometry, composed of other <see cref="Geometry"/> objects.
+    /// </summary>
+    public class GeometryGroup : Geometry
+    {
+        public static readonly DirectProperty<GeometryGroup, GeometryCollection?> ChildrenProperty =
+            AvaloniaProperty.RegisterDirect<GeometryGroup, GeometryCollection?> (
+                nameof(Children),
+                o => o.Children,
+                (o, v) => o.Children = v);
+
+        public static readonly StyledProperty<FillRule> FillRuleProperty =
+            AvaloniaProperty.Register<GeometryGroup, FillRule>(nameof(FillRule));
+
+        private GeometryCollection? _children;
+        private bool _childrenSet;
+
+        /// <summary>
+        /// Gets or sets the collection that contains the child geometries.
+        /// </summary>
+        [Content]
+        public GeometryCollection? Children
+        {
+            get => _children ??= (!_childrenSet ? new GeometryCollection() : null);
+            set
+            {
+                SetAndRaise(ChildrenProperty, ref _children, value);
+                _childrenSet = true;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets how the intersecting areas of the objects contained in this
+        /// <see cref="GeometryGroup"/> are combined. The default is <see cref="FillRule.EvenOdd"/>.
+        /// </summary>
+        public FillRule FillRule
+        {
+            get => GetValue(FillRuleProperty);
+            set => SetValue(FillRuleProperty, value);
+        }
+
+        public override Geometry Clone()
+        {
+            var result = new GeometryGroup { FillRule = FillRule, Transform = Transform };
+            if (_children?.Count > 0)
+                result.Children = new GeometryCollection(_children);
+            return result;
+        }
+
+        protected override IGeometryImpl? CreateDefiningGeometry()
+        {
+            if (_children?.Count > 0)
+            {
+                var factory = AvaloniaLocator.Current.GetService<IPlatformRenderInterface>();
+                return factory.CreateGeometryGroup(FillRule, _children);
+            }
+
+            return null;
+        }
+
+        protected override void OnPropertyChanged<T>(AvaloniaPropertyChangedEventArgs<T> change)
+        {
+            base.OnPropertyChanged(change);
+
+            if (change.Property == ChildrenProperty || change.Property == FillRuleProperty)
+            {
+                InvalidateGeometry();
+            }
+        }
+    }
+}

src/Avalonia.Visuals/Media/RotateTransform.cs

@@ -14,6 +14,18 @@ namespace Avalonia.Media
         public static readonly StyledProperty<double> AngleProperty =
             AvaloniaProperty.Register<RotateTransform, double>(nameof(Angle));
 
+        /// <summary>
+        /// Defines the <see cref="CenterX"/> property.
+        /// </summary>
+        public static readonly StyledProperty<double> CenterXProperty =
+            AvaloniaProperty.Register<RotateTransform, double>(nameof(CenterX));
+
+        /// <summary>
+        /// Defines the <see cref="CenterY"/> property.
+        /// </summary>
+        public static readonly StyledProperty<double> CenterYProperty =
+            AvaloniaProperty.Register<RotateTransform, double>(nameof(CenterY));
+
         /// <summary>
         /// Initializes a new instance of the <see cref="RotateTransform"/> class.
         /// </summary>
@@ -32,18 +44,52 @@ namespace Avalonia.Media
             Angle = angle;
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RotateTransform"/> class.
+        /// </summary>
+        /// <param name="angle">The angle, in degrees.</param>
+        /// <param name="centerX">The x-coordinate of the center point for the rotation.</param>
+        /// <param name="centerY">The y-coordinate of the center point for the rotation.</param>
+        public RotateTransform(double angle, double centerX, double centerY)
+            : this()
+        {
+            Angle = angle;
+            CenterX = centerX;
+            CenterY = centerY;
+        }
+
         /// <summary>
         /// Gets or sets the angle of rotation, in degrees.
         /// </summary>
         public double Angle
         {
-            get { return GetValue(AngleProperty); }
+            get => GetValue(AngleProperty);
-            set { SetValue(AngleProperty, value); }
+            set => SetValue(AngleProperty, value);
+        }
+
+        /// <summary>
+        /// Gets or sets the x-coordinate of the rotation center point. The default is 0.
+        /// </summary>
+        public double CenterX
+        {
+            get => GetValue(CenterXProperty);
+            set => SetValue(CenterXProperty, value);
+        }
+
+        /// <summary>
+        /// Gets or sets the y-coordinate of the rotation center point. The default is 0.
+        /// </summary>
+        public double CenterY
+        {
+            get => GetValue(CenterYProperty);
+            set => SetValue(CenterYProperty, value);
         }
 
         /// <summary>
         /// Gets the transform's <see cref="Matrix"/>.
         /// </summary>
-        public override Matrix Value => Matrix.CreateRotation(Matrix.ToRadians(Angle));
+        public override Matrix Value => Matrix.CreateTranslation(-CenterX, -CenterY) *
+            Matrix.CreateRotation(Matrix.ToRadians(Angle)) *
+            Matrix.CreateTranslation(CenterX, CenterY);
     }
 }

src/Avalonia.Visuals/Platform/IPlatformRenderInterface.cs

@@ -59,6 +59,23 @@ namespace Avalonia.Platform
         /// <returns>An <see cref="IStreamGeometryImpl"/>.</returns>
         IStreamGeometryImpl CreateStreamGeometry();
 
+        /// <summary>
+        /// Creates a geometry group implementation.
+        /// </summary>
+        /// <param name="fillRule">The fill rule.</param>
+        /// <param name="children">The geometries to group.</param>
+        /// <returns>A combined geometry.</returns>
+        IGeometryImpl CreateGeometryGroup(FillRule fillRule, IReadOnlyList<Geometry> children);
+
+        /// <summary>
+        /// Creates a geometry group implementation.
+        /// </summary>
+        /// <param name="combineMode">The combine mode</param>
+        /// <param name="g1">The first geometry.</param>
+        /// <param name="g2">The second geometry.</param>
+        /// <returns>A combined geometry.</returns>
+        IGeometryImpl CreateCombinedGeometry(GeometryCombineMode combineMode, Geometry g1, Geometry g2);
+
         /// <summary>
         /// Creates a renderer.
         /// </summary>

src/Skia/Avalonia.Skia/CombinedGeometryImpl.cs

@@ -0,0 +1,35 @@
+using System.Collections.Generic;
+using Avalonia.Media;
+using SkiaSharp;
+
+#nullable enable
+
+namespace Avalonia.Skia
+{
+    /// <summary>
+    /// A Skia implementation of a <see cref="Avalonia.Media.GeometryGroup"/>.
+    /// </summary>
+    internal class CombinedGeometryImpl : GeometryImpl
+    {
+        public CombinedGeometryImpl(GeometryCombineMode combineMode, Geometry g1, Geometry g2)
+        {
+            var path1 = ((GeometryImpl)g1.PlatformImpl).EffectivePath;
+            var path2 = ((GeometryImpl)g2.PlatformImpl).EffectivePath;
+            var op = combineMode switch
+            {
+                GeometryCombineMode.Intersect => SKPathOp.Intersect,
+                GeometryCombineMode.Xor => SKPathOp.Xor,
+                GeometryCombineMode.Exclude => SKPathOp.Difference,
+                _ => SKPathOp.Union,
+            };
+
+            var path = path1.Op(path2, op);
+
+            EffectivePath = path;
+            Bounds = path.Bounds.ToAvaloniaRect();
+        }
+
+        public override Rect Bounds { get; }
+        public override SKPath EffectivePath { get; }
+    }
+}

src/Skia/Avalonia.Skia/GeometryGroupImpl.cs

@@ -0,0 +1,36 @@
+using System.Collections.Generic;
+using Avalonia.Media;
+using SkiaSharp;
+
+#nullable enable
+
+namespace Avalonia.Skia
+{
+    /// <summary>
+    /// A Skia implementation of a <see cref="Avalonia.Media.GeometryGroup"/>.
+    /// </summary>
+    internal class GeometryGroupImpl : GeometryImpl
+    {
+        public GeometryGroupImpl(FillRule fillRule, IReadOnlyList<Geometry> children)
+        {
+            var path = new SKPath
+            {
+                FillType = fillRule == FillRule.NonZero ? SKPathFillType.Winding : SKPathFillType.EvenOdd,
+            };
+
+            var count = children.Count;
+            
+            for (var i = 0; i < count; ++i)
+            {
+                if (children[i]?.PlatformImpl is GeometryImpl child)
+                    path.AddPath(child.EffectivePath);
+            }
+
+            EffectivePath = path;
+            Bounds = path.Bounds.ToAvaloniaRect();
+        }
+
+        public override Rect Bounds { get; }
+        public override SKPath EffectivePath { get; }
+    }
+}

src/Skia/Avalonia.Skia/PlatformRenderInterface.cs

@@ -62,6 +62,16 @@ namespace Avalonia.Skia
             return new StreamGeometryImpl();
         }
 
+        public IGeometryImpl CreateGeometryGroup(FillRule fillRule, IReadOnlyList<Geometry> children)
+        {
+            return new GeometryGroupImpl(fillRule, children);
+        }
+
+        public IGeometryImpl CreateCombinedGeometry(GeometryCombineMode combineMode, Geometry g1, Geometry g2)
+        {
+            return new CombinedGeometryImpl(combineMode, g1, g2);
+        }
+
         /// <inheritdoc />
         public IBitmapImpl LoadBitmap(string fileName)
         {

src/Windows/Avalonia.Direct2D1/Direct2D1Platform.cs

@@ -175,6 +175,8 @@ namespace Avalonia.Direct2D1
         public IGeometryImpl CreateLineGeometry(Point p1, Point p2) => new LineGeometryImpl(p1, p2);
         public IGeometryImpl CreateRectangleGeometry(Rect rect) => new RectangleGeometryImpl(rect);
         public IStreamGeometryImpl CreateStreamGeometry() => new StreamGeometryImpl();
+        public IGeometryImpl CreateGeometryGroup(FillRule fillRule, IReadOnlyList<Geometry> children) => new GeometryGroupImpl(fillRule, children);
+        public IGeometryImpl CreateCombinedGeometry(GeometryCombineMode combineMode, Geometry g1, Geometry g2) => new CombinedGeometryImpl(combineMode, g1, g2);
 
         /// <inheritdoc />
         public IBitmapImpl LoadBitmap(string fileName)

src/Windows/Avalonia.Direct2D1/Media/CombinedGeometryImpl.cs

@@ -0,0 +1,36 @@
+using SharpDX.Direct2D1;
+using AM = Avalonia.Media;
+
+namespace Avalonia.Direct2D1.Media
+{
+    /// <summary>
+    /// A Direct2D implementation of a <see cref="Avalonia.Media.CombinedGeometry"/>.
+    /// </summary>
+    internal class CombinedGeometryImpl : GeometryImpl
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StreamGeometryImpl"/> class.
+        /// </summary>
+        public CombinedGeometryImpl(
+            AM.GeometryCombineMode combineMode,
+            AM.Geometry geometry1,
+            AM.Geometry geometry2)
+            : base(CreateGeometry(combineMode, geometry1, geometry2))
+        {
+        }
+
+        private static Geometry CreateGeometry(
+            AM.GeometryCombineMode combineMode,
+            AM.Geometry geometry1,
+            AM.Geometry geometry2)
+        {
+            var g1 = ((GeometryImpl)geometry1.PlatformImpl).Geometry;
+            var g2 = ((GeometryImpl)geometry2.PlatformImpl).Geometry;
+            var dest = new PathGeometry(Direct2D1Platform.Direct2D1Factory);
+            using var sink = dest.Open();
+            g1.Combine(g2, (CombineMode)combineMode, sink);
+            sink.Close();
+            return dest;
+        }
+    }
+}

src/Windows/Avalonia.Direct2D1/Media/GeometryGroupImpl.cs

@@ -0,0 +1,33 @@
+using System.Collections.Generic;
+using SharpDX.Direct2D1;
+using AM = Avalonia.Media;
+
+namespace Avalonia.Direct2D1.Media
+{
+    /// <summary>
+    /// A Direct2D implementation of a <see cref="Avalonia.Media.GeometryGroup"/>.
+    /// </summary>
+    internal class GeometryGroupImpl : GeometryImpl
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StreamGeometryImpl"/> class.
+        /// </summary>
+        public GeometryGroupImpl(AM.FillRule fillRule, IReadOnlyList<AM.Geometry> geometry)
+            : base(CreateGeometry(fillRule, geometry))
+        {
+        }
+
+        private static Geometry CreateGeometry(AM.FillRule fillRule, IReadOnlyList<AM.Geometry> children)
+        {
+            var count = children.Count;
+            var c = new Geometry[count];
+
+            for (var i = 0; i < count; ++i)
+            {
+                c[i] = ((GeometryImpl)children[i].PlatformImpl).Geometry;
+            }
+
+            return new GeometryGroup(Direct2D1Platform.Direct2D1Factory, (FillMode)fillRule, c);
+        }
+    }
+}

tests/Avalonia.Benchmarks/NullRenderingPlatform.cs

@@ -36,6 +36,16 @@ namespace Avalonia.Benchmarks
             return new MockStreamGeometryImpl();
         }
 
+        public IGeometryImpl CreateGeometryGroup(FillRule fillRule, IReadOnlyList<Geometry> children)
+        {
+            throw new NotImplementedException();
+        }
+
+        public IGeometryImpl CreateCombinedGeometry(GeometryCombineMode combineMode, Geometry g1, Geometry g2)
+        {
+            throw new NotImplementedException();
+        }
+
         public IRenderTarget CreateRenderTarget(IEnumerable<object> surfaces)
         {
             throw new NotImplementedException();

tests/Avalonia.RenderTests/Media/CombinedGeometryTests.cs

@@ -0,0 +1,89 @@
+using System.Threading.Tasks;
+using Avalonia.Controls;
+using Avalonia.Controls.Shapes;
+using Avalonia.Media;
+using Xunit;
+
+#if AVALONIA_SKIA
+namespace Avalonia.Skia.RenderTests
+#else
+namespace Avalonia.Direct2D1.RenderTests.Media
+#endif
+{
+    public class CombinedGeometryTests : TestBase
+    {
+        public CombinedGeometryTests()
+            : base(@"Media\CombinedGeometry")
+        {
+        }
+
+        [Theory]
+        [InlineData(Avalonia.Media.GeometryCombineMode.Union)]
+        [InlineData(Avalonia.Media.GeometryCombineMode.Intersect)]
+        [InlineData(Avalonia.Media.GeometryCombineMode.Xor)]
+        [InlineData(Avalonia.Media.GeometryCombineMode.Exclude)]
+        public async Task GeometryCombineMode(GeometryCombineMode mode)
+        {
+            var target = new Border
+            {
+                Width = 200,
+                Height = 200,
+                Background = Brushes.White,
+                Child = new Path
+                {
+                    Data = new CombinedGeometry
+                    {
+                        GeometryCombineMode = mode,
+                        Geometry1 = new RectangleGeometry(new Rect(25, 25, 100, 100)),
+                        Geometry2 = new EllipseGeometry
+                        {
+                            Center = new Point(125, 125),
+                            RadiusX = 50,
+                            RadiusY = 50,
+                        }
+                    },
+                    Fill = Brushes.Blue,
+                    Stroke = Brushes.Red,
+                    StrokeThickness = 1,
+                }
+            };
+
+            var testName = $"{nameof(GeometryCombineMode)}_{mode}";
+            await RenderToFile(target, testName);
+            CompareImages(testName);
+        }
+
+        [Fact]
+        public async Task Geometry1_Transform()
+        {
+            var target = new Border
+            {
+                Width = 200,
+                Height = 200,
+                Background = Brushes.White,
+                Child = new Path
+                {
+                    Data = new CombinedGeometry
+                    {
+                        Geometry1 = new RectangleGeometry(new Rect(25, 25, 100, 100))
+                        {
+                            Transform = new RotateTransform(45, 75, 75)
+                        },
+                        Geometry2 = new EllipseGeometry
+                        {
+                            Center = new Point(125, 125),
+                            RadiusX = 50,
+                            RadiusY = 50,
+                        }
+                    },
+                    Fill = Brushes.Blue,
+                    Stroke = Brushes.Red,
+                    StrokeThickness = 1,
+                }
+            };
+
+            await RenderToFile(target);
+            CompareImages();
+        }
+    }
+}

tests/Avalonia.RenderTests/Media/GeometryGroupTests.cs

@@ -0,0 +1,95 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Avalonia.Controls;
+using Avalonia.Controls.Shapes;
+using Avalonia.Media;
+using Avalonia.Media.Imaging;
+using Xunit;
+
+#if AVALONIA_SKIA
+namespace Avalonia.Skia.RenderTests
+#else
+namespace Avalonia.Direct2D1.RenderTests.Media
+#endif
+{
+    public class GeometryGroupTests : TestBase
+    {
+        public GeometryGroupTests()
+            : base(@"Media\GeometryGroup")
+        {
+        }
+
+        [Theory]
+        [InlineData(FillRule.EvenOdd)]
+        [InlineData(FillRule.NonZero)]
+        public async Task FillRule_Stroke(FillRule fillRule)
+        {
+            var target = new Border
+            {
+                Width = 200,
+                Height = 200,
+                Background = Brushes.White,
+                Child = new Path
+                {
+                    Data = new GeometryGroup
+                    {
+                        FillRule = fillRule,
+                        Children =
+                        {
+                            new RectangleGeometry(new Rect(25, 25, 100, 100)),
+                            new EllipseGeometry
+                            {
+                                Center = new Point(125, 125),
+                                RadiusX = 50,
+                                RadiusY = 50,
+                            },
+                        }
+                    },
+                    Fill = Brushes.Blue,
+                    Stroke = Brushes.Red,
+                    StrokeThickness = 1,
+                }
+            };
+
+            var testName = $"{nameof(FillRule_Stroke)}_{fillRule}";
+            await RenderToFile(target, testName);
+            CompareImages(testName);
+        }
+
+        [Fact]
+        public async Task Child_Transform()
+        {
+            var target = new Border
+            {
+                Width = 200,
+                Height = 200,
+                Background = Brushes.White,
+                Child = new Path
+                {
+                    Data = new GeometryGroup
+                    {
+                        Children =
+                        {
+                            new RectangleGeometry(new Rect(25, 25, 100, 100))
+                            {
+                                Transform = new RotateTransform(45, 75, 75)
+                            },
+                            new EllipseGeometry
+                            {
+                                Center = new Point(125, 125),
+                                RadiusX = 50,
+                                RadiusY = 50,
+                            },
+                        }
+                    },
+                    Fill = Brushes.Blue,
+                    Stroke = Brushes.Red,
+                    StrokeThickness = 1,
+                }
+            };
+
+            await RenderToFile(target);
+            CompareImages();
+        }
+    }
+}

tests/Avalonia.UnitTests/MockPlatformRenderInterface.cs

@@ -52,6 +52,16 @@ namespace Avalonia.UnitTests
             return new MockStreamGeometryImpl();
         }
 
+        public IGeometryImpl CreateGeometryGroup(FillRule fillRule, IReadOnlyList<Geometry> children)
+        {
+            return Mock.Of<IGeometryImpl>();
+        }
+
+        public IGeometryImpl CreateCombinedGeometry(GeometryCombineMode combineMode, Geometry g1, Geometry g2)
+        {
+            return Mock.Of<IGeometryImpl>();
+        }
+
         public IWriteableBitmapImpl CreateWriteableBitmap(
             PixelSize size,
             Vector dpi,

tests/Avalonia.Visuals.UnitTests/Media/GeometryGroupTests.cs

@@ -0,0 +1,26 @@
+using Avalonia.Media;
+using Xunit;
+
+namespace Avalonia.Visuals.UnitTests.Media
+{
+    public class GeometryGroupTests
+    {
+        [Fact]
+        public void Children_Should_Have_Initial_Collection()
+        {
+            var target = new GeometryGroup();
+
+            Assert.NotNull(target.Children);
+        }
+
+        [Fact]
+        public void Children_Can_Be_Set_To_Null()
+        {
+            var target = new GeometryGroup();
+
+            target.Children = null;
+
+            Assert.Null(target.Children);
+        }
+    }
+}

tests/Avalonia.Visuals.UnitTests/VisualTree/MockRenderInterface.cs

@@ -37,6 +37,16 @@ namespace Avalonia.Visuals.UnitTests.VisualTree
             return new MockStreamGeometry();
         }
 
+        public IGeometryImpl CreateGeometryGroup(FillRule fillRule, IReadOnlyList<Geometry> children)
+        {
+            throw new NotImplementedException();
+        }
+
+        public IGeometryImpl CreateCombinedGeometry(GeometryCombineMode combineMode, Geometry g1, Geometry g2)
+        {
+            throw new NotImplementedException();
+        }
+
         public IBitmapImpl LoadBitmap(Stream stream)
         {
             throw new NotImplementedException();