WPF Writeablebitmap und Effekte

Question

Im in mit der WPF Writeablebitmap Klasse zu suchen versucht, meiner Anwendung zu ermöglichen, eine Opazität Maske auf ein Bild anzuwenden.

Im Prinzip habe ich ein blaues Rechteck als ein Bild, und weiteres 100% transparent grünes Rechteck Bild über die Spitze der blauen.

Wenn der Benutzer bewegt die Maus über das grüne (transparent) Bild mag ich die Opazität Maske anwenden (vielleicht eine einfache Ellipse verwendet wird), so dass es aussieht wie ein grünes Leuchten auftritt.

Im absichtlich nicht tut dies XAML und Standard WPF Effekte, weil ich es wirklich brauche Super performant zu sein, und ich werde die Ellipse mit einem fortgeschritteneren blob schließlich tauschen ...

Alle Gedanken ??

Danke!

Answer 1

Es tut mir leid, ich weiß nicht recht, Ihre Absichten verstehen. Vielleicht, wenn ich das Bild sehen kann ich richtig von Anfang antworten konnte, aber hier ist meine erste vielleicht-falsche Antwort.

Wenn Sie sagen, super-performante, werden Sie wahrscheinlich auf Pixel-Shadern suchen. Sie werden verarbeitet von G PU, unterstützt von WPF in Form eines benutzerdefinierten Effekt und sind einfach zu implementieren. Sie können auch Shadern anwenden Video zu spielen, während es schwer ist, mit WritableBitmap zu tun.

Um einen Pixel-Shader zu schreiben, müssen Sie FX-Compiler haben (fxc.exe) von DirectX SDK und Shazzam Tool -. WYSIWYG WPF Shader-Compiler von Walt Ritscher

Wenn Sie sie beide erhalten, gehen Sie voran und versuchen Sie den folgenden HLSL-Code

float X : register(C0); // Mouse cursor X position
float Y : register(C1); // Mouse cursor Y position
float4 Color : register(C2); // Mask color
float R : register(C3); // Sensitive circle radius.

sampler2D implicitInputSampler : register(S0);


float4 main(float2 uv : TEXCOORD) : COLOR
{
    float4 finalColor = tex2D(implicitInputSampler, uv);
    if ( (uv.x - X) * (uv.x - X) + (uv.y - Y) * (uv.y - Y) < R*R)
    {
        finalColor = Color; // Blend/Change/Mask it as you wish here.
    }
    return finalColor;
}

Dies gibt Ihnen den folgenden C # Effekt:

namespace Shazzam.Shaders {
    using System.Windows;
    using System.Windows.Media;
    using System.Windows.Media.Effects;


    public class AutoGenShaderEffect : ShaderEffect {

        public static DependencyProperty InputProperty = ShaderEffect.RegisterPixelShaderSamplerProperty("Input", typeof(AutoGenShaderEffect), 0);

        public static DependencyProperty XProperty = DependencyProperty.Register("X", typeof(double), typeof(AutoGenShaderEffect), new System.Windows.UIPropertyMetadata(new double(), PixelShaderConstantCallback(0)));

        public static DependencyProperty YProperty = DependencyProperty.Register("Y", typeof(double), typeof(AutoGenShaderEffect), new System.Windows.UIPropertyMetadata(new double(), PixelShaderConstantCallback(1)));

        public static DependencyProperty ColorProperty = DependencyProperty.Register("Color", typeof(System.Windows.Media.Color), typeof(AutoGenShaderEffect), new System.Windows.UIPropertyMetadata(new System.Windows.Media.Color(), PixelShaderConstantCallback(2)));

        public static DependencyProperty RProperty = DependencyProperty.Register("R", typeof(double), typeof(AutoGenShaderEffect), new System.Windows.UIPropertyMetadata(new double(), PixelShaderConstantCallback(3)));

        public AutoGenShaderEffect(PixelShader shader) {
            // Note: for your project you must decide how to use the generated ShaderEffect class (Choose A or B below).
            // A: Comment out the following line if you are not passing in the shader and remove the shader parameter from the constructor

            PixelShader = shader;

            // B: Uncomment the following two lines - which load the *.ps file
            // Uri u = new Uri(@"pack://application:,,,/glow.ps");
            // PixelShader = new PixelShader() { UriSource = u };

            // Must initialize each DependencyProperty that's affliated with a shader register
            // Ensures the shader initializes to the proper default value.
            this.UpdateShaderValue(InputProperty);
            this.UpdateShaderValue(XProperty);
            this.UpdateShaderValue(YProperty);
            this.UpdateShaderValue(ColorProperty);
            this.UpdateShaderValue(RProperty);
        }

        public virtual System.Windows.Media.Brush Input {
            get {
                return ((System.Windows.Media.Brush)(GetValue(InputProperty)));
            }
            set {
                SetValue(InputProperty, value);
            }
        }

        public virtual double X {
            get {
                return ((double)(GetValue(XProperty)));
            }
            set {
                SetValue(XProperty, value);
            }
        }

        public virtual double Y {
            get {
                return ((double)(GetValue(YProperty)));
            }
            set {
                SetValue(YProperty, value);
            }
        }

        public virtual System.Windows.Media.Color Color {
            get {
                return ((System.Windows.Media.Color)(GetValue(ColorProperty)));
            }
            set {
                SetValue(ColorProperty, value);
            }
        }

        public virtual double R {
            get {
                return ((double)(GetValue(RProperty)));
            }
            set {
                SetValue(RProperty, value);
            }
        }
    }
}

Jetzt können Sie Mausposition verfolgen, und legen Sie die Eigenschaften Ihrer Wirkung entsprechenden Änderungen auszulösen. Eine Sache beachten hier:. X und Y in HLSL-Code werden reichen von 0 bis 1. So werden Sie tatsächliche Koordinaten in Prozentsatz umwandeln müssen, bevor sie an Shader geben

Dinge mehr über Pixel-Shader und WPF zu lesen:

• Referenz für HLSL auf MSDN.
• Schreiben von benutzerdefinierten GPU-basierten Effekte für WPF von Greg Schechter.

Hope, das hilft:)