Draft: Add SKSLEffect.

build/SkiaSharp.props

@@ -5,8 +5,8 @@
     <PackageReference Condition="'$(IncludeWasmSkia)' == 'true'" Include="SkiaSharp.NativeAssets.WebAssembly" Version="2.88.9" />
   </ItemGroup>
   <ItemGroup Condition="'$(AvsIncludeSkiaSharp3)' == 'true'">
-    <PackageReference Include="SkiaSharp" Version="3.118.0-preview.1.2" />
-    <PackageReference Condition="'$(IncludeLinuxSkia)' == 'true'" Include="SkiaSharp.NativeAssets.Linux" Version="3.118.0-preview.1.2" />
-    <PackageReference Condition="'$(IncludeWasmSkia)' == 'true'" Include="SkiaSharp.NativeAssets.WebAssembly" Version="3.118.0-preview.1.2" />
+    <PackageReference Include="SkiaSharp" Version="3.118.0" />
+    <PackageReference Condition="'$(IncludeLinuxSkia)' == 'true'" Include="SkiaSharp.NativeAssets.Linux" Version="3.118.0" />
+    <PackageReference Condition="'$(IncludeWasmSkia)' == 'true'" Include="SkiaSharp.NativeAssets.WebAssembly" Version="3.118.0" />
   </ItemGroup>
 </Project>

samples/ControlCatalog/ControlCatalog.csproj

@@ -4,6 +4,7 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <Nullable>enable</Nullable>
     <IncludeAvaloniaGenerators>true</IncludeAvaloniaGenerators>
+    <AvsIncludeSkiaSharp3>true</AvsIncludeSkiaSharp3>
   </PropertyGroup>
   <ItemGroup>
     <Compile Update="**\*.xaml.cs">

samples/ControlCatalog/MainView.xaml

@@ -202,6 +202,9 @@
       <TabItem Header="Screens">
         <pages:ScreenPage />
       </TabItem>
+      <TabItem Header="SKSLEffect">
+        <pages:SKSLEffectPage />
+      </TabItem>
       <FlyoutBase.AttachedFlyout>
         <Flyout>
           <StackPanel Width="152" Spacing="8">

samples/ControlCatalog/Pages/SKSLEffectPage.xaml

@@ -0,0 +1,12 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
+             x:Class="ControlCatalog.Pages.SKSLEffectPage">
+  <UniformGrid Columns="3" Height="200">
+    <Rectangle x:Name="Rectangle0" Fill="Red" Margin="20"/>
+    <Rectangle x:Name="Rectangle1" Fill="Red" Margin="20"/>
+    <Rectangle x:Name="Rectangle2" Fill="Red" Margin="20"/>
+  </UniformGrid>
+</UserControl>

samples/ControlCatalog/Pages/SKSLEffectPage.xaml.cs

@@ -0,0 +1,185 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Text;
+using Avalonia;
+using Avalonia.Animation;
+using Avalonia.Controls;
+using Avalonia.Controls.Shapes;
+using Avalonia.Data;
+using Avalonia.Markup.Xaml;
+using Avalonia.Media;
+using Avalonia.Platform;
+using Avalonia.Skia.Effects;
+using Avalonia.Styling;
+using SkiaSharp;
+
+namespace ControlCatalog.Pages
+{
+    public partial class SKSLEffectPage : UserControl
+    {
+        public SKSLEffectPage()
+        {
+            InitializeComponent();
+            InitEffect();
+        }
+
+        private void InitializeComponent()
+        {
+            AvaloniaXamlLoader.Load(this);
+        }
+
+        private void InitEffect()
+        {
+            var rectangle1 = this.FindControl<Rectangle>("Rectangle1")!;
+            var shaderBuilder = CreateSimpleShaderBuilder();
+            if (shaderBuilder != null)
+            {
+                rectangle1.Effect = new SKSLEffect(shaderBuilder)
+                {
+                    ChildShaderNames = ["src"],
+                    Inputs = [null],
+                };
+            }
+
+            var rectangle2 = this.FindControl<Rectangle>("Rectangle2")!;
+            try
+            {
+                var effect = new DissolveSKSLEffect();
+                effect.Progress = 0.5f;
+                effect[!DissolveSKSLEffect.ResolutionProperty] = new Binding
+                {
+                    Source = rectangle2,
+                    Path = "Bounds.Size",
+                };
+                rectangle2.Effect = effect;
+
+                var animation = new Animation
+                {
+                    Duration = TimeSpan.FromSeconds(2),
+                    IterationCount = IterationCount.Infinite,
+                    PlaybackDirection = PlaybackDirection.Alternate,
+                    Children = {
+                        new KeyFrame
+                        {
+                            Setters =
+                            {
+                                new Setter(DissolveSKSLEffect.ProgressProperty, 0f),
+                            },
+                            KeyTime = TimeSpan.FromSeconds(0),
+                        },
+                        new KeyFrame
+                        {
+                            Setters =
+                            {
+                                new Setter(DissolveSKSLEffect.ProgressProperty, 1f),
+                            },
+                            KeyTime = TimeSpan.FromSeconds(2),
+                        }
+                    }
+                };
+
+                _ = animation.RunAsync(effect);
+            }
+            catch
+            {
+                // Do not crash.
+            }
+        }
+
+        private SKRuntimeShaderBuilder? CreateSimpleShaderBuilder()
+        {
+            var sksl = @"
+                uniform shader src;
+
+                float4 main(float2 coord) {
+                    return src.eval(coord).bgra;
+                }
+";
+            var effect = SKRuntimeEffect.CreateShader(sksl, out var str);
+            if (effect != null)
+            {
+                return new SKRuntimeShaderBuilder(effect);
+            }
+            else
+            {
+                return null;
+            }
+        }
+    }
+
+    public class DissolveSKSLEffect : SKSLEffect
+    {
+        public static readonly StyledProperty<float> ProgressProperty = AvaloniaProperty.Register<DissolveSKSLEffect, float>(nameof(Progress), default);
+
+        public float Progress
+        {
+            get => GetValue(ProgressProperty);
+            set => SetValue(ProgressProperty, value);
+        }
+
+        public static readonly StyledProperty<Size> ResolutionProperty = AvaloniaProperty.Register<DissolveSKSLEffect, Size>(nameof(Resolution), default);
+
+        public Size Resolution
+        {
+            get => GetValue(ResolutionProperty);
+            set => SetValue(ResolutionProperty, value);
+        }
+
+        public DissolveSKSLEffect() : base(CreateShaderBuilder())
+        {
+            ChildShaderNames = ["src"];
+            Inputs = [null];
+            AffectsRender<SKSLEffect>(ProgressProperty);
+
+            RegisterUniform("progress", ProgressProperty);
+            RegisterUniform("resolution", ResolutionProperty);
+        }
+
+        private static SKRuntimeShaderBuilder? s_shaderBuilder;
+        private static SKRuntimeShaderBuilder CreateShaderBuilder()
+        {
+            if (s_shaderBuilder != null)
+            {
+                return s_shaderBuilder;
+            }
+
+            var sksl = @"
+                uniform float2 resolution; 
+                uniform shader src;
+                uniform shader noise;
+                uniform float2 noiseResolution; 
+                uniform float  progress;
+
+                float4 main(float2 coord) {
+                    float val = noise.eval(fract(coord / resolution) * noiseResolution).x;
+
+                    if(val < progress)
+                    {
+                        return src.eval(coord);
+                    }
+                    else
+                    {
+                        return float4(0,0,0,0);
+                    }
+                }
+";
+            var effect = SKRuntimeEffect.CreateShader(sksl, out var str);
+            if (effect != null)
+            {
+                var noise = AssetLoader.Open(new Uri("avares://ControlCatalog/Assets/noise.png"));
+                var noiseImage = SKImage.FromEncodedData(noise);
+                var noiseImageShader = SKShader.CreateImage(noiseImage);
+                var builder = new SKRuntimeShaderBuilder(effect);
+                builder.Uniforms["noiseResolution"] = new SKSize(noiseImage.Width, noiseImage.Height);
+                builder.Children["noise"] = noiseImageShader;
+                s_shaderBuilder = builder;
+                return s_shaderBuilder;
+            }
+            else
+            {
+                throw new NotSupportedException();
+            }
+        }
+    }
+}

src/Avalonia.Base/Media/Effects/EffectExtesions.cs

@@ -26,6 +26,11 @@ internal static Thickness GetEffectOutputPadding(this IEffect? effect)
             return new Thickness(Math.Max(0, 0 - rc.X),
                 Math.Max(0, 0 - rc.Y), Math.Max(0, rc.Right), Math.Max(0, rc.Bottom));
         }
+        if (effect is IShaderEffect)
+        {
+            // Shader effect should not have padding.
+            return default;
+        }
 
         throw new ArgumentException("Unknown effect type: " + effect.GetType());
     }
@@ -53,4 +58,4 @@ internal static bool EffectEquals(this IImmutableEffect? immutable, IEffect? rig
             return immutable.Equals(right);
         return false;
     }
-}
+}

src/Avalonia.Base/Media/Effects/IShaderEffect.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Avalonia.Media
+{
+    public interface IShaderEffect : IEffect
+    {
+    }
+}

src/Skia/Avalonia.Skia/Avalonia.Skia.csproj

@@ -4,6 +4,7 @@
     <IncludeLinuxSkia>true</IncludeLinuxSkia>
     <IncludeWasmSkia>true</IncludeWasmSkia>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <AvsIncludeSkiaSharp3>true</AvsIncludeSkiaSharp3>
   </PropertyGroup>
   <ItemGroup>
     <EmbeddedResource Include="Assets\NoiseAsset_256X256_PNG.png" />

src/Skia/Avalonia.Skia/DrawingContextImpl.Effects.cs

@@ -1,5 +1,6 @@
 using System;
 using Avalonia.Media;
+using Avalonia.Skia.Effects;
 using SkiaSharp;
 
 namespace Avalonia.Skia;
@@ -44,6 +45,12 @@ public void PopEffect()
             return SKImageFilter.CreateDropShadow((float)drop.OffsetX, (float)drop.OffsetY, sigma, sigma, color);
         }
 
+        if (effect is ISKSLEffect skslEffect)
+        {
+            var builder = skslEffect.ShaderBuilder;
+            return SKImageFilter.CreateRuntimeShader(builder, skslEffect.MaxSampleRadius, skslEffect.ChildShaderNames, skslEffect.Inputs);
+        }
+
         return null;
     }
 

src/Skia/Avalonia.Skia/Effects/SKSLEffect.cs

@@ -0,0 +1,94 @@
+using System.Collections.Generic;
+using Avalonia.Logging;
+using Avalonia.Media;
+using SkiaSharp;
+
+namespace Avalonia.Skia.Effects
+{
+    public class SKSLEffect : Effect, ISKSLEffect, IMutableEffect
+    {
+        public SKRuntimeShaderBuilder ShaderBuilder { get; set; }
+
+        public float MaxSampleRadius { get; set; } = 0f;
+
+        public string[] ChildShaderNames { get; set; } = [];
+
+        public SKImageFilter?[] Inputs { get; set; } = [];
+
+        private readonly Dictionary<string, AvaloniaProperty> _uniformProperties = new Dictionary<string, AvaloniaProperty>();
+
+        public SKSLEffect(SKRuntimeShaderBuilder builder)
+        {
+            ShaderBuilder = builder;
+        }
+
+        public void RegisterUniform(string name, AvaloniaProperty<int> property) => _uniformProperties.Add(name, property);
+
+        public void RegisterUniform(string name, AvaloniaProperty<float> property) =>  _uniformProperties.Add(name, property);
+
+        public void RegisterUniform(string name, AvaloniaProperty<Size> property) => _uniformProperties.Add(name, property);
+
+        public IImmutableEffect ToImmutable()
+        {
+            SKRuntimeShaderBuilder builder = new SKRuntimeShaderBuilder(ShaderBuilder);
+            foreach (var property in _uniformProperties)
+            {
+                var value = GetValue(property.Value);
+                if (value is int intVal)
+                {
+                    builder.Uniforms[property.Key] = intVal;
+                }
+                else if (value is float floatVal)
+                {
+                    builder.Uniforms[property.Key] = floatVal;
+                }
+                else if (value is Size sizeVal)
+                {
+                    float[] val = [(float)sizeVal.Width, (float)sizeVal.Height];
+                    builder.Uniforms[property.Key] = val;
+                }
+                else
+                {
+                    Logger.TryGet(LogEventLevel.Error, "Effect")?.Log(this, $"Unsupported uniform type: {value?.GetType() ?? null}");
+                }
+            }
+
+            return new ImmutableSKSLEffect(builder, MaxSampleRadius, ChildShaderNames, Inputs);
+        }
+    }
+
+    public class ImmutableSKSLEffect : ISKSLEffect, IImmutableEffect
+    {
+        public SKRuntimeShaderBuilder ShaderBuilder { get; }
+
+        public float MaxSampleRadius { get; }
+
+        public string[] ChildShaderNames { get; }
+
+        public SKImageFilter?[] Inputs { get; }
+
+        public ImmutableSKSLEffect(SKRuntimeShaderBuilder builder, float maxSampleRadius, string[] childShaderNames, SKImageFilter?[] inputs)
+        {
+            ShaderBuilder = builder;
+            MaxSampleRadius = maxSampleRadius;
+            ChildShaderNames = childShaderNames;
+            Inputs = inputs;
+        }
+
+        public bool Equals(IEffect? other)
+        {
+            return false;
+        }
+    }
+
+    public interface ISKSLEffect : IShaderEffect
+    {
+        SKRuntimeShaderBuilder ShaderBuilder { get; }
+
+        float MaxSampleRadius { get; }
+
+        string[] ChildShaderNames { get; }
+
+        SKImageFilter?[] Inputs { get; }
+    }
+}