[Windows] Fix performance issue using Shadows

src/Controls/samples/Controls.Sample/Pages/Core/ShadowGalleries/ShadowBenchmark.cs

@@ -0,0 +1,117 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.Maui.Controls;
+using Microsoft.Maui.Graphics;
+
+namespace Maui.Controls.Sample.Pages
+{
+	public class ShadowBenchmark : ContentPage
+	{
+		event Action timerUpdateEvent;
+
+		public ShadowBenchmark()
+		{
+			Title = "Shadow Benchmark";
+
+			double fps = 60;
+
+			var timer = Dispatcher.CreateTimer();
+			timer.Interval = TimeSpan.FromSeconds(1 / fps);
+			double time = 0;
+			DateTime currentTickDateTime = DateTime.Now;
+			double deltaTime = 0;
+
+			timer.Tick += delegate 
+			{
+				deltaTime = (DateTime.Now - currentTickDateTime).TotalSeconds;
+				currentTickDateTime = DateTime.Now;
+				time += deltaTime;
+				timerUpdateEvent?.Invoke();
+			};
+
+			timer.Start();
+
+			AbsoluteLayout rootAbs = new AbsoluteLayout();
+			Content = rootAbs;
+
+			Label fpsLabel = new Label
+			{
+				BackgroundColor = Colors.Black,
+				TextColor = Colors.White
+			};
+
+			AbsoluteLayout abs = new AbsoluteLayout();
+			rootAbs.Add(abs);
+			rootAbs.Add(fpsLabel);
+
+			VerticalStackLayout vert = new VerticalStackLayout();
+			vert.BackgroundColor = Colors.LightGray;
+			abs.Add(vert);
+
+			AbsoluteLayout abs2 = new AbsoluteLayout();
+			vert.Add(abs2);
+
+			int numBorders = 3;
+			List<Border> borders = new List<Border>();
+
+			for (int i = 0; i < numBorders; i++)
+			{
+				Border border = new Border
+				{
+					HeightRequest = 200,
+					WidthRequest = 500,
+					BackgroundColor = Colors.DimGray
+				};
+				abs2.Add(border);
+				borders.Add(border);
+				border.Shadow = new Shadow() { Brush = new SolidColorBrush(Colors.Black), Offset = new Point(5, 5), Radius = 5 };
+			}
+
+			Border borderBot = new Border
+			{
+				HeightRequest = 200,
+				WidthRequest = 50,
+				BackgroundColor = Colors.DarkGray
+			};
+			vert.Add(borderBot);
+
+			timerUpdateEvent += delegate 
+			{
+				double sinVal = (Math.Sin(time) + 1) * 0.5;
+				double height = 20 + sinVal * 800;
+				for (int i = 0; i < borders.Count; i++)
+				{
+					borders[i].HeightRequest = height;
+				}
+			};
+
+			SizeChanged += delegate 
+			{
+				if (Width > 0)
+				{
+					abs.WidthRequest = Width;
+					abs.HeightRequest = Height;
+					vert.WidthRequest = Width;
+
+					for (int i = 0; i < borders.Count; i++)
+					{
+						borders[i].WidthRequest = Width;
+						borders[i].TranslationX = Width * i;
+					}
+				}
+			};
+
+			DateTime lastUpdateDateTime = DateTime.Now;
+			abs2.SizeChanged += delegate 
+			{
+				if (lastUpdateDateTime != DateTime.Now)
+				{
+					string fps = "FPS " + 1 / (DateTime.Now - lastUpdateDateTime).TotalSeconds;
+					fpsLabel.Text = fps;
+
+					lastUpdateDateTime = DateTime.Now;
+				}
+			};
+		}
+	}
+}

src/Controls/samples/Controls.Sample/Pages/Core/ShadowGalleries/ShadowMaskPage.xaml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<views:BasePage
+    xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+    xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+    x:Class="Maui.Controls.Sample.Pages.ShadowMaskPage"
+    xmlns:views="clr-namespace:Maui.Controls.Sample.Pages.Base"
+    Title="Shadow Mask - Shadows respect control shape">
+    <VerticalStackLayout  
+        Padding="12">
+        <Button
+            HorizontalOptions="Center"
+            Text="Shadow"
+            CornerRadius="60"
+            HeightRequest="120"
+            WidthRequest="120">
+            <Button.Shadow>
+                <Shadow
+                   Brush="Black"
+                   Opacity="1"
+                   Radius="10"
+                   Offset="0, 0" />
+            </Button.Shadow>
+        </Button>
+    </VerticalStackLayout>
+</views:BasePage>

src/Controls/samples/Controls.Sample/Pages/Core/ShadowGalleries/ShadowMaskPage.xaml.cs

@@ -0,0 +1,10 @@
+namespace Maui.Controls.Sample.Pages
+{
+	public partial class ShadowMaskPage
+	{
+		public ShadowMaskPage()
+		{
+			InitializeComponent();
+		}
+	}
+}

src/Controls/samples/Controls.Sample/Pages/Core/ShadowGalleries/ShadowPage.cs

@@ -24,7 +24,11 @@ public ShadowPage()
 						GalleryBuilder.NavButton("Shadow Playground", () =>
 							new ShadowPlaygroundPage(), Navigation),
 						GalleryBuilder.NavButton("Invalidate Shadow Host", () =>
-							new InvalidateShadowHostPage(), Navigation),
+							new InvalidateShadowHostPage(), Navigation),	
+						GalleryBuilder.NavButton("Shadow Mask", () =>
+							new ShadowMaskPage(), Navigation),
+						GalleryBuilder.NavButton("Shadow Benchmark", () =>
+							new ShadowBenchmark(), Navigation),
 					}
 				}
 			};

src/Controls/tests/TestCases.HostApp/Issues/Issue18172.cs

@@ -0,0 +1,126 @@
+using Microsoft.Maui.Controls.Shapes;
+
+namespace Maui.Controls.Sample.Issues
+{
+	[Issue(IssueTracker.Github, 18172, "Shadows not drawing/updating correctly in Windows & cover entire screen", PlatformAffected.UWP)]
+	public class Issue18172 : TestContentPage
+	{
+		protected override void Init()
+		{
+			Title = "Issue 18172";
+
+			BackgroundColor = Colors.LightPink;
+
+			ScreenSizeMonitor.Instance.setContentPage(this);
+
+			VerticalStackLayout verticalStackLayout = new VerticalStackLayout();
+			Content = verticalStackLayout;
+
+			AbsoluteLayout absoluteLayout = new AbsoluteLayout();
+			verticalStackLayout.Add(absoluteLayout);
+			absoluteLayout.Add(TopObjectWithShadow.Instance);
+		}
+	}
+
+	public class TopObjectWithShadow : AbsoluteLayout
+	{
+		public static TopObjectWithShadow Instance { get { return lazy.Value; } }
+		static readonly Lazy<TopObjectWithShadow> lazy = new Lazy<TopObjectWithShadow>(() => new TopObjectWithShadow());
+
+		public TopSubComponent topMenuFrameComponent;
+
+		private TopObjectWithShadow()
+		{
+			IgnoreSafeArea = true;
+			topMenuFrameComponent = new TopSubComponent();
+			Add(topMenuFrameComponent);
+			topMenuFrameComponent.Shadow = new Shadow() { Offset = new Point(0, 5), Radius = 5 };
+			ScreenSizeMonitor.Instance.ScreenSizeChanged += OnScreenSizeChanged;
+		}
+
+		void OnScreenSizeChanged()
+		{
+			if (topMenuFrameComponent != null)
+			{
+				WidthRequest = ScreenSizeMonitor.Instance.screenWidth;
+				HeightRequest = ScreenSizeMonitor.Instance.screenHeight;
+
+				topMenuFrameComponent.resizeFunction();
+			}
+		}
+	}
+
+	public class TopSubComponent : AbsoluteLayout
+	{
+		readonly Border _frameBorder;
+		readonly double _frameBaseHeight = 68;
+
+		public TopSubComponent()
+		{
+			_frameBorder = new Border
+			{
+				AutomationId = "BorderControl"
+			};
+
+			Add(_frameBorder);
+			IgnoreSafeArea = true;
+			_frameBorder.HeightRequest = _frameBaseHeight;
+			_frameBorder.BackgroundColor = Colors.White;
+			_frameBorder.Margin = new Thickness(0, 20, 0, 0);
+			_frameBorder.StrokeShape = new RoundRectangle() { CornerRadius = new CornerRadius(30, 30, 30, 30) };
+			_frameBorder.StrokeThickness = 0;
+		}
+		public void resizeFunction()
+		{
+			WidthRequest = ScreenSizeMonitor.Instance.screenWidth;
+			HeightRequest = ScreenSizeMonitor.Instance.screenHeight;
+			_frameBorder.WidthRequest = ScreenSizeMonitor.Instance.screenWidth;
+			_frameBorder.HeightRequest = _frameBaseHeight;
+		}
+	}
+	public class ScreenSizeMonitor
+	{
+		public ContentPage pageToMonitor;
+
+		private static readonly Lazy<ScreenSizeMonitor> lazy = new Lazy<ScreenSizeMonitor>(() => new ScreenSizeMonitor());
+		public static ScreenSizeMonitor Instance { get { return lazy.Value; } }
+
+		public double screenWidth = 0;
+		public double screenHeight = 0;
+		public event Action ScreenSizeChanged = null;
+
+		public void setContentPage(ContentPage contentPageToMonitor)
+		{
+			pageToMonitor = contentPageToMonitor;
+			StartScreenMonitor();
+		}
+
+		void StartScreenMonitor()
+		{
+			UpdateFunction();
+
+			pageToMonitor.SizeChanged += delegate
+			{
+				UpdateFunction();
+			};
+		}
+
+		void UpdateFunction()
+		{
+			if (pageToMonitor.Width > 0 && pageToMonitor.Height > 0)
+			{
+				screenWidth = pageToMonitor.Width;
+				screenHeight = pageToMonitor.Height;
+
+				invokeScreenSizeChanged();
+			}
+		}
+		public void invokeScreenSizeChanged()
+		{
+			MainThread.BeginInvokeOnMainThread(() =>
+			{
+				ScreenSizeChanged?.Invoke();
+			});
+		}
+	}
+}

src/Controls/tests/TestCases.Shared.Tests/Tests/Issues/Issue18172.cs

@@ -0,0 +1,26 @@
+#if WINDOWS // Issue only happens on Windows
+using NUnit.Framework;
+using UITest.Appium;
+using UITest.Core;
+
+namespace Microsoft.Maui.TestCases.Tests.Issues
+{
+	class Issue18172 : _IssuesUITest
+	{
+		public Issue18172(TestDevice device)
+			: base(device)
+		{ }
+
+		public override string Issue => "Shadows not drawing/updating correctly in Windows & cover entire screen";
+
+		[Test]
+		[Category(UITestCategories.GraphicsView)]
+		public async Task Issue18172Test()
+		{
+			await Task.Delay(500);
+
+			VerifyScreenshot();
+		}
+	}
+}
+#endif

src/Core/src/Platform/Windows/ShadowExtensions.cs

@@ -13,7 +13,6 @@
 using Windows.Foundation;
 using Windows.Graphics.Imaging;
 
-
 namespace Microsoft.Maui.Platform
 {
 	internal static class ShadowExtensions
@@ -24,28 +23,33 @@ public static async Task<CompositionBrush> GetAlphaMaskAsync(this UIElement elem
 
 			try
 			{
-				//For some reason, using  TextBlock and getting the AlphaMask
-				//generates a shadow with a size more smaller than the control size. 
-				if (element is TextBlock textElement)
+				var visual = ElementCompositionPreview.GetElementVisual(element);
+				bool isClipped = visual.Clip is not null;
+
+				if (!isClipped && element is TextBlock textElement)
 				{
 					return textElement.GetAlphaMask();
 				}
-				if (element is Image image)
+				if (!isClipped && element is Image image)
 				{
 					return image.GetAlphaMask();
 				}
-				if (element is Shape shape)
+				if (!isClipped && element is Shape shape)
 				{
 					return shape.GetAlphaMask();
 				}
+				if (!isClipped && element is ContentPanel contentPanel)
+				{
+					var borderPath = contentPanel.BorderPath;
+					return borderPath?.GetAlphaMask();
+				}
 				else if (element is FrameworkElement frameworkElement)
 				{
 					var height = (int)frameworkElement.ActualHeight;
 					var width = (int)frameworkElement.ActualWidth;
 
 					if (height > 0 && width > 0)
 					{
-						var visual = ElementCompositionPreview.GetElementVisual(element);
 						var elementVisual = visual.Compositor.CreateSpriteVisual();
 						elementVisual.Size = element.RenderSize.ToVector2();
 						var bitmap = new RenderTargetBitmap();