ShaderEffect Klasse

Referenz

Definition

Namespace:: System.Windows.Media.Effects

Assembly:: PresentationCore.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Stellt mithilfe von PixelShader einen benutzerdefinierten Bitmapeffekt bereit.

public ref class ShaderEffect abstract : System::Windows::Media::Effects::Effect

public abstract class ShaderEffect : System.Windows.Media.Effects.Effect

type ShaderEffect = class
    inherit Effect

Public MustInherit Class ShaderEffect
Inherits Effect

Vererbung: Object

DispatcherObject

DependencyObject

Freezable

Animatable

Effect
ShaderEffect

Beispiele

Im folgenden Codebeispiel wird gezeigt, wie sie von der ShaderEffect -Klasse abgeleitet werden.

using System;
using System.Windows;
using System.Windows.Media;
using System.Windows.Media.Effects;
using System.Reflection;

namespace ShaderEffectDemo
{

    public class ThresholdEffect : ShaderEffect
    {
        private static PixelShader _pixelShader =
            new PixelShader() { UriSource = MakePackUri("ThresholdEffect.fx.ps") };

        public ThresholdEffect()
        {
            PixelShader = _pixelShader;

            UpdateShaderValue(InputProperty);
            UpdateShaderValue(ThresholdProperty);
            UpdateShaderValue(BlankColorProperty);
        }

        // MakePackUri is a utility method for computing a pack uri
        // for the given resource. 
        public static Uri MakePackUri(string relativeFile)
        {
            Assembly a = typeof(ThresholdEffect).Assembly;

            // Extract the short name.
            string assemblyShortName = a.ToString().Split(',')[0];

            string uriString = "pack://application:,,,/" +
                assemblyShortName +
                ";component/" +
                relativeFile;

            return new Uri(uriString);
        }

        ///////////////////////////////////////////////////////////////////////
        #region Input dependency property

        public Brush Input
        {
            get { return (Brush)GetValue(InputProperty); }
            set { SetValue(InputProperty, value); }
        }

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

        #endregion

        ///////////////////////////////////////////////////////////////////////
        #region Threshold dependency property

        public double Threshold
        {
            get { return (double)GetValue(ThresholdProperty); }
            set { SetValue(ThresholdProperty, value); }
        }

        public static readonly DependencyProperty ThresholdProperty =
            DependencyProperty.Register("Threshold", typeof(double), typeof(ThresholdEffect),
                    new UIPropertyMetadata(0.5, PixelShaderConstantCallback(0)));

        #endregion

        ///////////////////////////////////////////////////////////////////////
        #region BlankColor dependency property

        public Color BlankColor
        {
            get { return (Color)GetValue(BlankColorProperty); }
            set { SetValue(BlankColorProperty, value); }
        }

        public static readonly DependencyProperty BlankColorProperty =
            DependencyProperty.Register("BlankColor", typeof(Color), typeof(ThresholdEffect),
                    new UIPropertyMetadata(Colors.Transparent, PixelShaderConstantCallback(1)));

        #endregion
    }
}

Das folgende Codebeispiel zeigt einen Shader, der der vorherigen ShaderEffect Klasse entspricht.

// Threshold shader 

// Object Declarations

sampler2D implicitInput : register(s0);
float threshold : register(c0);
float4 blankColor : register(c1);

//--------------------------------------------------------------------------------------
// Pixel Shader
//--------------------------------------------------------------------------------------
float4 main(float2 uv : TEXCOORD) : COLOR
{
    float4 color = tex2D(implicitInput, uv);
    float intensity = (color.r + color.g + color.b) / 3;
    
    float4 result;
    if (intensity > threshold)
    {
        result = color;
    }
    else
    {
        result = blankColor;
    }
    
    return result;
}

Der folgende XAML-Code zeigt, wie sie den benutzerdefinierten Shadereffekt verwenden.

<Window x:Class="ShaderEffectDemo.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="clr-namespace:ShaderEffectDemo"
    Title="Window1" Height="300" Width="300">
    <Window.Resources>
        <local:ThresholdEffect x:Key="thresholdEffect" Threshold="0.25" BlankColor="Orange" />
    </Window.Resources>
    
    <Grid Effect="{StaticResource thresholdEffect}">

    </Grid>
</Window>

Hinweise

Von der ShaderEffect -Klasse ableiten, um einen benutzerdefinierten Effekt basierend auf einem einzelnen Pixel-Shader zu implementieren.

Die folgenden Schritte zeigen, wie Sie einen benutzerdefinierten Effekt erstellen.

Laden sie aus PixelShader dem vorkompilierten HLSL-Bytecode (High Level Shading Language).
Definieren Sie Abhängigkeitseigenschaften, die die Parameter des Effekts und die Brush-basierten Oberflächeneingaben darstellen. Verwenden Sie eine der RegisterPixelShaderSamplerProperty Überladungen, um diese Eingaben Registernummern zuzuordnen, auf die im HLSL-Bytecode verwiesen wird.

Die Anzahl der Sampler ist auf 4 beschränkt.

Bei Verwendung eines PS 3.0-Shaders gelten die folgenden Einschränkungen.

Wenn ein PS 3.0-Shader zugewiesen wird, erhöht sich die Anzahl der Sampler auf 8. Weisen Sie den PS 3.0-Shader vor anderen Shadern zu, um die Registrierung von 8 Samplern zu aktivieren.
Für Floats wird der Grenzwert für das vollständige Shaderkonstantenregister von 224 verwendet. Weitere Informationen finden Sie unter ps_3_0.
Die folgenden Datentypen werden nur in PS 3.0-Shadern unterstützt. Eine Ausnahme wird ausgelöst, wenn diese in niedrigeren Shaderversionen verwendet werden.
- intund -Typen, die in konvertiert werden intkönnen: uint, byte, sbytelong, ulong, short, , ushortchar
- bool
Wenn ein gültiger PS 3.0-Shader auf einen Computer geladen wird, der keine Hardwareunterstützung für PS 3.0 bietet, wird der Shader ignoriert. Wenn der Shader ungültig ist, wird keine Ausnahme ausgelöst.
Wenn ein Computer über mehrere Video-Karte verfügt, wird das Verhalten durch den am wenigsten fähigen Video-Karte definiert. Wenn der Computer beispielsweise über zwei Grafikkarten verfügt, von denen eine PS 3.0 unterstützt und eine nicht, ist das Verhalten identisch, als würde der Computer PS 3.0 nicht unterstützen.
Wenn ein Computer das Rendern von PS 3.0 in Hardware unterstützt, aber ein ungültiger PS 3.0-Shader zugewiesen ist, wird das InvalidPixelShaderEncountered Ereignis ausgelöst. Ein Beispiel für einen ungültigen PS 3.0-Shader ist einer, der mit dem ps_3_sw Flag kompiliert wurde. Die ShaderEffect -Klasse akzeptiert nur PS 3.0-Shader, die mit dem ps_3_0 an fxc.exe übergebenen Flag kompiliert werden. Weitere Informationen finden Sie unter Effect-Compiler Tool.

Hinweis

PS 2.0-Shader werden beim Rendern in Software ausgeführt. Selbst wenn PS 3.0 von der Systemhardware unterstützt wird, werden PS 3.0-Shader während des Softwarerenderings nicht ausgeführt.

Konstruktoren

ShaderEffect()

Initialisiert eine neue Instanz der ShaderEffect-Klasse.

Felder

PixelShaderProperty

Bezeichnet die PixelShader-Abhängigkeitseigenschaft.

Eigenschaften

CanFreeze	Ruft einen Wert ab, der anzeigt, ob das Objekt als nicht änderbar festgelegt werden kann. (Geerbt von Freezable)
DdxUvDdyUvRegisterIndex	Ruft einen Wert ab, der das Shaderregister für die partiellen Ableitungen der Texturkoordinaten bezüglich des Bildraums angibt, oder legt diesen Wert fest.
DependencyObjectType	Ruft den ab, der DependencyObjectType den CLR-Typ dieses instance umschließt. (Geerbt von DependencyObject)
Dispatcher	Ruft den Dispatcher ab, der diesem DispatcherObject zugeordnet ist. (Geerbt von DispatcherObject)
EffectMapping	Transformiert beim Überschreiben in einer abgeleiteten Klasse die Mauseingabe und Koordinatensysteme durch den Effekt. (Geerbt von Effect)
HasAnimatedProperties	Ruft einen Wert ab, der angibt, ob einer der Abhängigkeitseigenschaften dieses Objekts ein oder mehrere AnimationClock-Objekte zugeordnet sind. (Geerbt von Animatable)
IsFrozen	Ruft einen Wert ab, der angibt, ob das Objekt derzeit geändert werden kann. (Geerbt von Freezable)
IsSealed	Ruft einen Wert ab, der angibt, ob diese Instanz derzeit versiegelt (schreibgeschützt) ist. (Geerbt von DependencyObject)
PaddingBottom	Ruft einen Wert ab, der angibt, dass die Ausgabetextur des Effekts größer als die entsprechende Eingabetextur entlang des unteren Rands ist, oder legt diesen fest.
PaddingLeft	Ruft einen Wert ab, der angibt, dass die Ausgabetextur des Effekts größer als die entsprechende Eingabetextur entlang des linken Rands ist, oder legt diesen fest.
PaddingRight	Ruft einen Wert ab, der angibt, dass die Ausgabetextur des Effekts größer als die entsprechende Eingabetextur entlang des rechten Rands ist, oder legt diesen fest.
PaddingTop	Ruft einen Wert ab, der angibt, dass die Ausgabetextur des Effekts größer als die entsprechende Eingabetextur entlang des oberen Rands ist, oder legt diesen fest.
PixelShader	Ruft den für den Effekt zu verwendenden PixelShader ab oder legt diesen fest.

Methoden

ApplyAnimationClock(DependencyProperty, AnimationClock)	Wendet einen AnimationClock auf die angegebene DependencyProperty an. Wenn die Eigenschaft bereits animiert wird, wird das SnapshotAndReplace-Übergabeverhalten verwendet. (Geerbt von Animatable)
ApplyAnimationClock(DependencyProperty, AnimationClock, HandoffBehavior)	Wendet einen AnimationClock auf die angegebene DependencyProperty an. Wenn die Eigenschaft bereits animiert wird, wird das angegebene HandoffBehavior verwendet. (Geerbt von Animatable)
BeginAnimation(DependencyProperty, AnimationTimeline)	Wendet eine Animation auf die angegebene DependencyProperty an. Die Animation wird gestartet, wenn der nächste Frame gerendert wird. Wenn die angegebene Eigenschaft bereits animiert wird, wird das SnapshotAndReplace-Übergabeverhalten verwendet. (Geerbt von Animatable)
BeginAnimation(DependencyProperty, AnimationTimeline, HandoffBehavior)	Wendet eine Animation auf die angegebene DependencyProperty an. Die Animation wird gestartet, wenn der nächste Frame gerendert wird. Wenn die angegebene Eigenschaft bereits animiert wird, wird das angegebene HandoffBehavior verwendet. (Geerbt von Animatable)
CheckAccess()	Bestimmt, ob der aufrufende Thread auf dieses DispatcherObject zugreifen kann. (Geerbt von DispatcherObject)
ClearValue(DependencyProperty)	Löscht den lokalen Wert einer Eigenschaft. Die Eigenschaft, deren Wert gelöscht werden soll, wird durch einen DependencyProperty-Bezeichner angegeben. (Geerbt von DependencyObject)
ClearValue(DependencyPropertyKey)	Löscht den lokalen Wert einer schreibgeschützten Eigenschaft. Die Eigenschaft, deren Wert gelöscht werden soll, wird durch einen DependencyPropertyKey angegeben. (Geerbt von DependencyObject)
Clone()	Erstellt einen änderbaren Klon des ShaderEffect-Objekts, indem tiefe Kopien der Werte dieses Objekts erzeugt werden. Beim Kopieren von Abhängigkeitseigenschaften dieses Objekts kopiert diese Methode Ressourcenverweise und Datenbindungen (die jedoch möglicherweise nicht mehr aufgelöst werden können), jedoch keine Animationen oder ihre aktuellen Werte.
CloneCore(Freezable)	Definiert die Instanz als Klon (tiefe Kopie) des angegebenen Freezable-Elements, indem Basiseigenschaftenwerte (nicht animiert) verwendet werden.
CloneCurrentValue()	Erstellt einen änderbaren Klon des ShaderEffect-Objekts, indem tiefe Kopien der aktuellen Werte dieses Objekts erzeugt werden. Ressourcenverweise, Datenbindungen und Animationen werden nicht kopiert, ihre aktuellen Werte werden jedoch kopiert.
CloneCurrentValueCore(Freezable)	Macht die Instanz mithilfe aktueller Eigenschaftswerte zu einem Klon (tiefe Kopie) des angegebenen Freezable-Elements, der geändert werden kann.
CoerceValue(DependencyProperty)	Erzwingt den Wert der angegebenen Abhängigkeitseigenschaft. Dies erfolgt durch den Aufruf einer beliebigen CoerceValueCallback-Funktion, die in den Metadaten für die Abhängigkeitseigenschaft angegeben ist, während sie beim aufrufenden DependencyObject beendet wird. (Geerbt von DependencyObject)
CreateInstance()	Initialisiert eine neue Instanz der Freezable-Klasse. (Geerbt von Freezable)
CreateInstanceCore()	Erstellt eine neue Instanz der aus Freezable abgeleiteten Klasse.
Equals(Object)	Bestimmt, ob ein angegebenes DependencyObject dem aktuellen DependencyObject entspricht. (Geerbt von DependencyObject)
Freeze()	Definiert das aktuelle Objekt als nicht änderbar und legt seine IsFrozen-Eigenschaft auf `true` fest. (Geerbt von Freezable)
FreezeCore(Boolean)	Legt dieses Animatable-Objekt als nicht änderbar fest oder bestimmt, ob es als nicht änderbar festgelegt werden kann. (Geerbt von Animatable)
GetAnimationBaseValue(DependencyProperty)	Gibt den nicht animierten Wert der angegebenen DependencyProperty zurück. (Geerbt von Animatable)
GetAsFrozen()	Erstellt eine fixierte Kopie von Freezable mit Basiseigenschaftswerten (nicht animiert). Da die Kopie fixiert ist, werden alle fixierten Unterobjekte als Verweis kopiert. (Geerbt von Freezable)
GetAsFrozenCore(Freezable)	Definiert die Instanz als fixierten Klon des angegebenen Freezable-Elements, indem Basiseigenschaftenwerte (nicht animiert) verwendet werden.
GetCurrentValueAsFrozen()	Erstellt eine fixierte Kopie von Freezable mit aktuellen Eigenschaftswerten. Da die Kopie fixiert ist, werden alle fixierten Unterobjekte als Verweis kopiert. (Geerbt von Freezable)
GetCurrentValueAsFrozenCore(Freezable)	Macht diese aktuelle Instanz zu einem fixierten Klon des angegebenen Freezable-Objekts. Wenn das Objekt über animierte Abhängigkeitseigenschaften verfügt, werden die aktuellen animierten Werte kopiert.
GetHashCode()	Ruft einen Hashcode für diese DependencyObject ab. (Geerbt von DependencyObject)
GetLocalValueEnumerator()	Erstellt einen spezialisierten Enumerator, mit dem bestimmt wird, welche Abhängigkeitseigenschaften dieses DependencyObject über lokal festgelegte Werte verfügen. (Geerbt von DependencyObject)
GetType()	Ruft den Type der aktuellen Instanz ab. (Geerbt von Object)
GetValue(DependencyProperty)	Gibt den aktuellen effektiven Wert einer Abhängigkeitseigenschaft für diese Instanz eines DependencyObject zurück. (Geerbt von DependencyObject)
InvalidateProperty(DependencyProperty)	Wertet den effektiven Wert für die angegebene Abhängigkeitseigenschaft erneut aus. (Geerbt von DependencyObject)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
OnChanged()	Wird aufgerufen, wenn das aktuelle Freezable-Objekt geändert wird. (Geerbt von Freezable)
OnFreezablePropertyChanged(DependencyObject, DependencyObject)	Stellt sicher, dass entsprechende Kontextzeiger für einen gerade festgelegten DependencyObjectType-Datenmember eingerichtet werden. (Geerbt von Freezable)
OnFreezablePropertyChanged(DependencyObject, DependencyObject, DependencyProperty)	Dieses Member unterstützt die Windows Presentation Foundation -Infrastruktur (WPF) und ist nicht für die direkte Verwendung aus Ihrem Code vorgesehen. (Geerbt von Freezable)
OnPropertyChanged(DependencyPropertyChangedEventArgs)	Überschreibt die DependencyObject-Implementierung von OnPropertyChanged(DependencyPropertyChangedEventArgs), damit in Reaktion auf eine geänderte Abhängigkeitseigenschaft des Typs Freezable auch Changed-Handler aufgerufen werden. (Geerbt von Freezable)
PixelShaderConstantCallback(Int32)	Ordnet dem Gleitkommakonstantenregister eines Pixelshaders den Wert einer Abhängigkeitseigenschaft zu.
PixelShaderSamplerCallback(Int32)	Ordnet dem Samplerregister eines Pixelshaders den Wert einer Abhängigkeitseigenschaft zu.
PixelShaderSamplerCallback(Int32, SamplingMode)	Ordnet dem Samplerregister eines Pixelshaders und SamplingMode den Wert einer Abhängigkeitseigenschaft zu.
ReadLocalValue(DependencyProperty)	Gibt den lokalen Wert einer Abhängigkeitseigenschaft zurück, wenn dieser vorhanden ist. (Geerbt von DependencyObject)
ReadPreamble()	Stellt sicher, dass über einen gültigen Thread auf Freezable zugegriffen wird. Vererber von Freezable müssen diese Methode am Anfang jeder API aufrufen, die Datenmember liest, bei denen es sich nicht um Abhängigkeitseigenschaften handelt. (Geerbt von Freezable)
RegisterPixelShaderSamplerProperty(String, Type, Int32)	Ordnet dem Samplerregister eines Shaders eine Abhängigkeitseigenschaft zu.
RegisterPixelShaderSamplerProperty(String, Type, Int32, SamplingMode)	Ordnet einer Abhängigkeitseigenschaft das Samplerregister eines Shaders und einen SamplingMode zu.
SetCurrentValue(DependencyProperty, Object)	Legt den Wert einer Abhängigkeitseigenschaft fest, ohne deren Wertquelle zu ändern. (Geerbt von DependencyObject)
SetValue(DependencyProperty, Object)	Legt den lokalen Wert einer Abhängigkeitseigenschaft fest, die durch ihren Bezeichner angegeben ist. (Geerbt von DependencyObject)
SetValue(DependencyPropertyKey, Object)	Legt den lokalen Wert einer schreibgeschützten Abhängigkeitseigenschaft fest, die durch den DependencyPropertyKey-Bezeichner der Abhängigkeitseigenschaft angegeben ist. (Geerbt von DependencyObject)
ShouldSerializeProperty(DependencyProperty)	Gibt einen Wert zurück, der angibt, ob Serialisierungsprozesse den Wert der bereitgestellten Abhängigkeitseigenschaft serialisieren sollen. (Geerbt von DependencyObject)
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)
UpdateShaderValue(DependencyProperty)	Benachrichtigt den Effekt darüber, dass die Shaderkonstante oder der Shadersampler, die bzw. der der angegebenen Abhängigkeitseigenschaft entspricht, aktualisiert werden muss.
VerifyAccess()	Erzwingt, dass der aufrufende Thread auf dieses DispatcherObject zugreifen kann. (Geerbt von DispatcherObject)
WritePostscript()	Löst das Changed-Ereignis für das Freezable-Objekt aus und ruft dessen OnChanged()-Methode auf. Klassen, die aus Freezable abgeleitet werden, sollten diese Methode am Ende jeder API aufrufen, die Klassenmember ändert, die nicht als Abhängigkeitseigenschaften gespeichert sind. (Geerbt von Freezable)
WritePreamble()	Stellt sicher, dass das Freezable nicht fixiert ist und dass über einen gültigen Threadkontext darauf zugegriffen wird. Vererber von Freezable sollten diese Methode am Anfang jeder API aufrufen, die Datenmember schreibt, bei denen es sich nicht um Abhängigkeitseigenschaften handelt. (Geerbt von Freezable)

Ereignisse

Changed

Tritt auf, wenn Freezable oder ein darin enthaltenes Objekt geändert wird.

(Geerbt von Freezable)

Gilt für:

Freigeben über