add Gooey Effect Demo

src/Shared/HandyControl_Shared/HandyControl_Shared.projitems

@@ -68,7 +68,11 @@
     <Compile Include="$(MSBuildThisFileDirectory)Media\Animation\LinearGeometryKeyFrame.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Media\Animation\ResolvedKeyFrameEntry.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Media\Animation\SplineGeometryKeyFrame.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Media\Effects\BrightnessEffect.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Media\Effects\ColorComplementEffect.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Media\Effects\ColorMatrixEffect.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Media\Effects\ContrastEffect.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Media\Effects\EffectBase.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Media\Effects\GrayScaleEffect.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Tools\Converter\BorderCircularClipConverter.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Tools\Converter\ColLayoutConverter.cs" />

src/Shared/HandyControl_Shared/Media/Effects/BrightnessEffect.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Windows;
+using System.Windows.Media.Effects;
+using HandyControl.Data;
+
+namespace HandyControl.Media.Effects
+{
+    public class BrightnessEffect : EffectBase
+    {
+        private static readonly PixelShader Shader;
+
+        static BrightnessEffect()
+        {
+            Shader = new PixelShader
+            {
+                UriSource = new Uri("pack://application:,,,/HandyControl;component/Resources/Effects/BrightnessEffect.ps")
+            };
+        }
+
+        public BrightnessEffect()
+        {
+            PixelShader = Shader;
+
+            UpdateShaderValue(InputProperty);
+            UpdateShaderValue(BrightnessProperty);
+        }
+
+        public static readonly DependencyProperty BrightnessProperty = DependencyProperty.Register(
+            "Brightness", typeof(double), typeof(BrightnessEffect), new PropertyMetadata(ValueBoxes.Double1Box, PixelShaderConstantCallback(0)));
+
+        public double Brightness
+        {
+            get => (double)GetValue(BrightnessProperty);
+            set => SetValue(BrightnessProperty, value);
+        }
+    }
+}

src/Shared/HandyControl_Shared/Media/Effects/ColorComplementEffect.cs

@@ -1,14 +1,10 @@
 using System;
-using System.Windows;
-using System.Windows.Media;
 using System.Windows.Media.Effects;
 
 namespace HandyControl.Media.Effects
 {
-    public class ColorComplementEffect : ShaderEffect
+    public class ColorComplementEffect : EffectBase
     {
-        public static readonly DependencyProperty InputProperty = RegisterPixelShaderSamplerProperty("Input", typeof(ColorComplementEffect), 0);
-
         private static readonly PixelShader Shader;
 
         static ColorComplementEffect()
@@ -25,11 +21,5 @@ namespace HandyControl.Media.Effects
 
             UpdateShaderValue(InputProperty);
         }
-
-        public Brush Input
-        {
-            get => (Brush)GetValue(InputProperty);
-            set => SetValue(InputProperty, value);
-        }
     }
 }

src/Shared/HandyControl_Shared/Media/Effects/ColorMatrixEffect.cs

@@ -0,0 +1,247 @@
+using System;
+using System.Windows;
+using System.Windows.Media.Effects;
+using HandyControl.Data;
+
+namespace HandyControl.Media.Effects
+{
+    public class ColorMatrixEffect : EffectBase
+    {
+        private static readonly PixelShader Shader;
+
+        static ColorMatrixEffect()
+        {
+            Shader = new PixelShader
+            {
+                UriSource = new Uri("pack://application:,,,/HandyControl;component/Resources/Effects/ColorMatrixEffect.ps")
+            };
+        }
+
+        public ColorMatrixEffect()
+        {
+            PixelShader = Shader;
+
+            UpdateShaderValue(InputProperty);
+
+            UpdateShaderValue(M11Property);
+            UpdateShaderValue(M21Property);
+            UpdateShaderValue(M31Property);
+            UpdateShaderValue(M41Property);
+            UpdateShaderValue(M51Property);
+
+            UpdateShaderValue(M12Property);
+            UpdateShaderValue(M22Property);
+            UpdateShaderValue(M32Property);
+            UpdateShaderValue(M42Property);
+            UpdateShaderValue(M52Property);
+
+            UpdateShaderValue(M13Property);
+            UpdateShaderValue(M23Property);
+            UpdateShaderValue(M33Property);
+            UpdateShaderValue(M43Property);
+            UpdateShaderValue(M53Property);
+
+            UpdateShaderValue(M14Property);
+            UpdateShaderValue(M24Property);
+            UpdateShaderValue(M34Property);
+            UpdateShaderValue(M44Property);
+            UpdateShaderValue(M54Property);
+        }
+
+        #region Line1
+
+        public static readonly DependencyProperty M11Property = DependencyProperty.Register(
+            "M11", typeof(double), typeof(ColorMatrixEffect), new PropertyMetadata(ValueBoxes.Double1Box, PixelShaderConstantCallback(0)));
+
+        public double M11
+        {
+            get => (double)GetValue(M11Property);
+            set => SetValue(M11Property, value);
+        }
+
+        public static readonly DependencyProperty M21Property = DependencyProperty.Register(
+            "M21", typeof(double), typeof(ColorMatrixEffect), new PropertyMetadata(ValueBoxes.Double0Box, PixelShaderConstantCallback(1)));
+
+        public double M21
+        {
+            get => (double)GetValue(M21Property);
+            set => SetValue(M21Property, value);
+        }
+
+        public static readonly DependencyProperty M31Property = DependencyProperty.Register(
+            "M31", typeof(double), typeof(ColorMatrixEffect), new PropertyMetadata(ValueBoxes.Double0Box, PixelShaderConstantCallback(2)));
+
+        public double M31
+        {
+            get => (double)GetValue(M31Property);
+            set => SetValue(M31Property, value);
+        }
+
+        public static readonly DependencyProperty M41Property = DependencyProperty.Register(
+            "M41", typeof(double), typeof(ColorMatrixEffect), new PropertyMetadata(ValueBoxes.Double0Box, PixelShaderConstantCallback(3)));
+
+        public double M41
+        {
+            get => (double)GetValue(M41Property);
+            set => SetValue(M41Property, value);
+        }
+
+        public static readonly DependencyProperty M51Property = DependencyProperty.Register(
+            "M51", typeof(double), typeof(ColorMatrixEffect), new PropertyMetadata(ValueBoxes.Double0Box, PixelShaderConstantCallback(4)));
+
+        public double M51
+        {
+            get => (double)GetValue(M51Property);
+            set => SetValue(M51Property, value);
+        }
+
+        #endregion
+
+        #region Line2
+
+        public static readonly DependencyProperty M12Property = DependencyProperty.Register(
+            "M12", typeof(double), typeof(ColorMatrixEffect), new PropertyMetadata(ValueBoxes.Double0Box, PixelShaderConstantCallback(5)));
+
+        public double M12
+        {
+            get => (double)GetValue(M12Property);
+            set => SetValue(M12Property, value);
+        }
+
+        public static readonly DependencyProperty M22Property = DependencyProperty.Register(
+            "M22", typeof(double), typeof(ColorMatrixEffect), new PropertyMetadata(ValueBoxes.Double1Box, PixelShaderConstantCallback(6)));
+
+        public double M22
+        {
+            get => (double)GetValue(M22Property);
+            set => SetValue(M22Property, value);
+        }
+
+        public static readonly DependencyProperty M32Property = DependencyProperty.Register(
+            "M32", typeof(double), typeof(ColorMatrixEffect), new PropertyMetadata(ValueBoxes.Double0Box, PixelShaderConstantCallback(7)));
+
+        public double M32
+        {
+            get => (double)GetValue(M32Property);
+            set => SetValue(M32Property, value);
+        }
+
+        public static readonly DependencyProperty M42Property = DependencyProperty.Register(
+            "M42", typeof(double), typeof(ColorMatrixEffect), new PropertyMetadata(ValueBoxes.Double0Box, PixelShaderConstantCallback(8)));
+
+        public double M42
+        {
+            get => (double)GetValue(M42Property);
+            set => SetValue(M42Property, value);
+        }
+
+        public static readonly DependencyProperty M52Property = DependencyProperty.Register(
+            "M52", typeof(double), typeof(ColorMatrixEffect), new PropertyMetadata(ValueBoxes.Double0Box, PixelShaderConstantCallback(9)));
+
+        public double M52
+        {
+            get => (double)GetValue(M52Property);
+            set => SetValue(M52Property, value);
+        }
+
+        #endregion
+
+        #region Line3
+
+        public static readonly DependencyProperty M13Property = DependencyProperty.Register(
+            "M13", typeof(double), typeof(ColorMatrixEffect), new PropertyMetadata(ValueBoxes.Double0Box, PixelShaderConstantCallback(10)));
+
+        public double M13
+        {
+            get => (double)GetValue(M13Property);
+            set => SetValue(M13Property, value);
+        }
+
+        public static readonly DependencyProperty M23Property = DependencyProperty.Register(
+            "M23", typeof(double), typeof(ColorMatrixEffect), new PropertyMetadata(ValueBoxes.Double0Box, PixelShaderConstantCallback(11)));
+
+        public double M23
+        {
+            get => (double)GetValue(M23Property);
+            set => SetValue(M23Property, value);
+        }
+
+        public static readonly DependencyProperty M33Property = DependencyProperty.Register(
+            "M33", typeof(double), typeof(ColorMatrixEffect), new PropertyMetadata(ValueBoxes.Double1Box, PixelShaderConstantCallback(12)));
+
+        public double M33
+        {
+            get => (double)GetValue(M33Property);
+            set => SetValue(M33Property, value);
+        }
+
+        public static readonly DependencyProperty M43Property = DependencyProperty.Register(
+            "M43", typeof(double), typeof(ColorMatrixEffect), new PropertyMetadata(ValueBoxes.Double0Box, PixelShaderConstantCallback(13)));
+
+        public double M43
+        {
+            get => (double)GetValue(M43Property);
+            set => SetValue(M43Property, value);
+        }
+
+        public static readonly DependencyProperty M53Property = DependencyProperty.Register(
+            "M53", typeof(double), typeof(ColorMatrixEffect), new PropertyMetadata(ValueBoxes.Double0Box, PixelShaderConstantCallback(14)));
+
+        public double M53
+        {
+            get => (double)GetValue(M53Property);
+            set => SetValue(M53Property, value);
+        }
+
+        #endregion
+
+        #region Line4
+
+        public static readonly DependencyProperty M14Property = DependencyProperty.Register(
+            "M14", typeof(double), typeof(ColorMatrixEffect), new PropertyMetadata(ValueBoxes.Double0Box, PixelShaderConstantCallback(15)));
+
+        public double M14
+        {
+            get => (double)GetValue(M14Property);
+            set => SetValue(M14Property, value);
+        }
+
+        public static readonly DependencyProperty M24Property = DependencyProperty.Register(
+            "M24", typeof(double), typeof(ColorMatrixEffect), new PropertyMetadata(ValueBoxes.Double0Box, PixelShaderConstantCallback(16)));
+
+        public double M24
+        {
+            get => (double)GetValue(M24Property);
+            set => SetValue(M24Property, value);
+        }
+
+        public static readonly DependencyProperty M34Property = DependencyProperty.Register(
+            "M34", typeof(double), typeof(ColorMatrixEffect), new PropertyMetadata(ValueBoxes.Double0Box, PixelShaderConstantCallback(17)));
+
+        public double M34
+        {
+            get => (double)GetValue(M34Property);
+            set => SetValue(M34Property, value);
+        }
+
+        public static readonly DependencyProperty M44Property = DependencyProperty.Register(
+            "M44", typeof(double), typeof(ColorMatrixEffect), new PropertyMetadata(ValueBoxes.Double1Box, PixelShaderConstantCallback(18)));
+
+        public double M44
+        {
+            get => (double)GetValue(M44Property);
+            set => SetValue(M44Property, value);
+        }
+
+        public static readonly DependencyProperty M54Property = DependencyProperty.Register(
+            "M54", typeof(double), typeof(ColorMatrixEffect), new PropertyMetadata(ValueBoxes.Double0Box, PixelShaderConstantCallback(19)));
+
+        public double M54
+        {
+            get => (double)GetValue(M54Property);
+            set => SetValue(M54Property, value);
+        }
+
+        #endregion
+    }
+}

src/Shared/HandyControl_Shared/Media/Effects/ContrastEffect.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Windows;
+using System.Windows.Media.Effects;
+using HandyControl.Data;
+
+namespace HandyControl.Media.Effects
+{
+    public class ContrastEffect : EffectBase
+    {
+        private static readonly PixelShader Shader;
+
+        static ContrastEffect()
+        {
+            Shader = new PixelShader
+            {
+                UriSource = new Uri("pack://application:,,,/HandyControl;component/Resources/Effects/ContrastEffect.ps")
+            };
+        }
+
+        public ContrastEffect()
+        {
+            PixelShader = Shader;
+
+            UpdateShaderValue(InputProperty);
+            UpdateShaderValue(ContrastProperty);
+        }
+
+        public static readonly DependencyProperty ContrastProperty = DependencyProperty.Register(
+            "Contrast", typeof(double), typeof(ContrastEffect), new PropertyMetadata(ValueBoxes.Double1Box, PixelShaderConstantCallback(0)));
+
+        public double Contrast
+        {
+            get => (double)GetValue(ContrastProperty);
+            set => SetValue(ContrastProperty, value);
+        }
+    }
+}

src/Shared/HandyControl_Shared/Media/Effects/EffectBase.cs

@@ -0,0 +1,17 @@
+using System.Windows;
+using System.Windows.Media;
+using System.Windows.Media.Effects;
+
+namespace HandyControl.Media.Effects
+{
+    public abstract class EffectBase : ShaderEffect
+    {
+        public static readonly DependencyProperty InputProperty = RegisterPixelShaderSamplerProperty("Input", typeof(EffectBase), 0);
+
+        public Brush Input
+        {
+            get => (Brush)GetValue(InputProperty);
+            set => SetValue(InputProperty, value);
+        }
+    }
+}

src/Shared/HandyControl_Shared/Media/Effects/GrayScaleEffect.cs

@@ -1,15 +1,12 @@
 using System;
 using System.Windows;
-using System.Windows.Media;
 using System.Windows.Media.Effects;
 using HandyControl.Data;
 
 namespace HandyControl.Media.Effects
 {
-    public class GrayScaleEffect : ShaderEffect
+    public class GrayScaleEffect : EffectBase
     {
-        public static readonly DependencyProperty InputProperty = RegisterPixelShaderSamplerProperty("Input", typeof(GrayScaleEffect), 0);
-
         private static readonly PixelShader Shader;
 
         static GrayScaleEffect()
@@ -28,12 +25,6 @@ namespace HandyControl.Media.Effects
             UpdateShaderValue(ScaleProperty);
         }
 
-        public Brush Input
-        {
-            get => (Brush)GetValue(InputProperty);
-            set => SetValue(InputProperty, value);
-        }
-
         public static readonly DependencyProperty ScaleProperty = DependencyProperty.Register(
             "Scale", typeof(double), typeof(GrayScaleEffect), new PropertyMetadata(ValueBoxes.Double1Box, PixelShaderConstantCallback(0)));
 

src/Shared/HandyControl_Shared/Resources/Effects/BrightnessEffect.fx

@@ -0,0 +1,10 @@
+sampler2D implicitInput : register(s0);
+float brightness : register(C0);
+
+float4 main(float2 uv : TEXCOORD) : COLOR
+{
+    float4 color = tex2D(implicitInput, uv); 
+    color.rgba *= brightness;
+    
+    return color;
+}

src/Shared/HandyControl_Shared/Resources/Effects/ColorComplementEffect.fx

@@ -1,3 +1,5 @@
+sampler2D implicitInput : register(s0);
+
 float4 main(float2 uv : TEXCOORD) : COLOR
 {
     float4 color = tex2D(implicitInput, uv);

src/Shared/HandyControl_Shared/Resources/Effects/ColorMatrixEffect.fx

@@ -0,0 +1,56 @@
+sampler2D implicitInput : register(s0);
+float a : register(c0);
+float b : register(c1);
+float c : register(c2);
+float d : register(c3);
+float e : register(c4);
+
+float f : register(c5);
+float g : register(c6);
+float h : register(c7);
+float i : register(c8);
+float j : register(c9);
+
+float k : register(c10);
+float l : register(c11);
+float m : register(c12);
+float n : register(c13);
+float o : register(c14);
+
+float p : register(c15);
+float q : register(c16);
+float r : register(c17);
+float s : register(c18);
+float t : register(c19);
+
+/*
+
+     --             --        --   --
+     | a  b  c  d  e |        |  R  |
+     | f  g  h  i  j |        |  G  |
+ A = | k  l  m  n  o |   C =  |  B  |  R = AC
+     | p  q  r  s  t |        |  A  |
+     --             --        |  1  |
+                              --   --
+
+*/
+
+float4 main(float2 uv : TEXCOORD) : COLOR
+{
+    float4 color = tex2D(implicitInput, uv);
+    
+    float4x4 matrixA1 =
+    {
+        a, b, c, d,
+        f, g, h, i,
+        k, l, m, n,
+        p, q, r, s
+    };
+
+    float4 matrixA2 =
+    {
+        e, j, o, t
+    };
+    
+    return mul(matrixA1, color) + matrixA2;
+}

src/Shared/HandyControl_Shared/Resources/Effects/ContrastEffect.fx

@@ -0,0 +1,12 @@
+sampler2D implicitInput : register(s0);
+float contrast : register(C0);
+
+float4 main(float2 uv : TEXCOORD) : COLOR
+{
+    float4 color = tex2D(implicitInput, uv); 
+    float value = (1 - contrast) / 2;
+
+    color.rgba = color.rgba * contrast + value;
+    
+    return color;
+}