ShaderEffect Classe

Definizione

Spazio dei nomi:: System.Windows.Media.Effects

Assembly:: PresentationCore.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Fornisce un effetto bitmap personalizzato usando un oggetto PixelShader.

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

Ereditarietà: Object

DispatcherObject

DependencyObject

Freezable

Animatable

Effect
ShaderEffect

Esempio

Nell'esempio di codice seguente viene illustrato come derivare dalla ShaderEffect classe .

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
    }
}

Nell'esempio di codice seguente viene illustrato uno shader che corrisponde alla classe precedente ShaderEffect .

// 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;
}

Il codice XAML seguente illustra come usare l'effetto shader personalizzato.

<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>

Commenti

Derivare dalla ShaderEffect classe per implementare un effetto personalizzato basato su un singolo pixel shader.

I passaggi seguenti illustrano come creare un effetto personalizzato.

Caricare un oggetto PixelShader dal bytecode HLSL (High Level Shading Language) precompilato.
Definire le proprietà di dipendenza che rappresentano i parametri dell'effetto e gli input della Brushsuperficie basata su . Usare uno degli RegisterPixelShaderSamplerProperty overload per associare questi input ai numeri di registro a cui viene fatto riferimento nel bytecode HLSL.

Il numero di campionatori è limitato a 4.

Quando si usa uno shader PS 3.0, si applicano le restrizioni seguenti.

Quando viene assegnato uno shader PS 3.0, il numero di campionatori aumenta a 8. Assegnare lo shader PS 3.0 prima di altri shader per abilitare la registrazione di 8 sampler.
Viene usato il limite di registrazione costante completo dello shader pari a 224 per i float. Per altre informazioni, vedere ps_3_0.
I tipi di dati seguenti sono supportati solo negli shader PS 3.0. Viene generata un'eccezione se vengono usate nelle versioni di shader inferiori.
- inte tipi convertibili in int: uint, byte, sbyte, long, ulong, short, ushortchar
- bool
Se uno shader PS 3.0 valido viene caricato in un computer che non dispone del supporto hardware per PS 3.0, lo shader viene ignorato. Se lo shader non è valido, non viene generata alcuna eccezione.
Se un computer dispone di più schede video, il comportamento viene definito dalla scheda video meno idonea. Ad esempio, se il computer ha due schede video, una delle quali supporta PS 3.0 e una delle quali non, il comportamento è uguale a se il computer non supporta PS 3.0.
Se un computer supporta il rendering di PS 3.0 nell'hardware, ma viene assegnato uno shader PS 3.0 non valido, viene generato l'evento InvalidPixelShaderEncountered . Un esempio di shader PS 3.0 non valido è uno compilato con il ps_3_sw flag . La ShaderEffect classe accetta solo shader PS 3.0 compilati con il ps_3_0 flag passato a fxc.exe. Per altre informazioni, vedere strumentoEffect-Compiler.

Note

Gli shader PS 2.0 vengono eseguiti durante il rendering nel software. Tuttavia, anche se PS 3.0 è supportato dall'hardware del sistema, gli shader ps 3.0 non vengono eseguiti durante il rendering software.

Costruttori

Nome	Descrizione
ShaderEffect()	Inizializza una nuova istanza della classe ShaderEffect.

Campi

Nome	Descrizione
PixelShaderProperty	Identifica la PixelShader proprietà di dipendenza.

Proprietà

Nome	Descrizione
CanFreeze	Ottiene un valore che indica se l'oggetto può essere reso non modificabile. (Ereditato da Freezable)
DdxUvDdyUvRegisterIndex	Ottiene o imposta un valore che indica il registro shader da utilizzare per i derivati parziali delle coordinate della trama rispetto allo spazio dello schermo.
DependencyObjectType	Ottiene l'oggetto DependencyObjectType che esegue il wrapping del tipo CLR di questa istanza. (Ereditato da DependencyObject)
Dispatcher	Ottiene l'oggetto Dispatcher DispatcherObject a cui è associato. (Ereditato da DispatcherObject)
EffectMapping	Quando sottoposto a override in una classe derivata, trasforma i sistemi di input e coordinate del mouse attraverso l'effetto . (Ereditato da Effect)
HasAnimatedProperties	Ottiene un valore che indica se uno o più AnimationClock oggetti sono associati a una delle proprietà di dipendenza di questo oggetto. (Ereditato da Animatable)
IsFrozen	Ottiene un valore che indica se l'oggetto è attualmente modificabile. (Ereditato da Freezable)
IsSealed	Ottiene un valore che indica se questa istanza è attualmente sealed (sola lettura). (Ereditato da DependencyObject)
PaddingBottom	Ottiene o imposta un valore che indica che la trama di output dell'effetto è maggiore della trama di input lungo il bordo inferiore.
PaddingLeft	Ottiene o imposta un valore che indica che la trama di output dell'effetto è maggiore della trama di input lungo il bordo sinistro.
PaddingRight	Ottiene o imposta un valore che indica che la trama di output dell'effetto è maggiore della trama di input lungo il bordo destro.
PaddingTop	Ottiene o imposta un valore che indica che la trama di output dell'effetto è maggiore della trama di input lungo il bordo superiore.
PixelShader	Ottiene o imposta l'oggetto PixelShader da utilizzare per l'effetto.

Metodi

Nome	Descrizione
ApplyAnimationClock(DependencyProperty, AnimationClock, HandoffBehavior)	Applica un oggetto AnimationClock all'oggetto specificato DependencyProperty. Se la proprietà è già animata, viene utilizzato l'oggetto specificato HandoffBehavior . (Ereditato da Animatable)
ApplyAnimationClock(DependencyProperty, AnimationClock)	Applica un oggetto AnimationClock all'oggetto specificato DependencyProperty. Se la proprietà è già animata, viene utilizzato il SnapshotAndReplace comportamento di handoff. (Ereditato da Animatable)
BeginAnimation(DependencyProperty, AnimationTimeline, HandoffBehavior)	Applica un'animazione all'oggetto specificato DependencyProperty. L'animazione viene avviata quando viene eseguito il rendering del fotogramma successivo. Se la proprietà specificata è già animata, viene utilizzato l'oggetto specificato HandoffBehavior . (Ereditato da Animatable)
BeginAnimation(DependencyProperty, AnimationTimeline)	Applica un'animazione all'oggetto specificato DependencyProperty. L'animazione viene avviata quando viene eseguito il rendering del fotogramma successivo. Se la proprietà specificata è già animata, viene utilizzato il SnapshotAndReplace comportamento di handoff. (Ereditato da Animatable)
CheckAccess()	Determina se il thread chiamante ha accesso a questo DispatcherObjectoggetto . (Ereditato da DispatcherObject)
ClearValue(DependencyProperty)	Cancella il valore locale di una proprietà. La proprietà da cancellare viene specificata da un DependencyProperty identificatore. (Ereditato da DependencyObject)
ClearValue(DependencyPropertyKey)	Cancella il valore locale di una proprietà di sola lettura. La proprietà da cancellare viene specificata da un oggetto DependencyPropertyKey. (Ereditato da DependencyObject)
Clone()	Crea un clone modificabile di questo ShaderEffect oggetto, eseguendo copie complete dei valori di questo oggetto. Quando si copiano le proprietà di dipendenza di questo oggetto, questo metodo copia i riferimenti alle risorse e i data binding (che potrebbero non essere più risolti), ma non le animazioni o i relativi valori correnti.
CloneCore(Freezable)	Rende l'istanza un clone (copia completa) dell'oggetto specificato Freezable usando valori di proprietà di base (non animati).
CloneCurrentValue()	Crea un clone modificabile di questo ShaderEffect oggetto, eseguendo copie complete dei valori correnti dell'oggetto. I riferimenti alle risorse, i data binding e le animazioni non vengono copiati, ma i relativi valori correnti vengono copiati.
CloneCurrentValueCore(Freezable)	Rende l'istanza un clone modificabile (copia completa) dell'oggetto specificato Freezable utilizzando i valori delle proprietà correnti.
CoerceValue(DependencyProperty)	Forza il valore della proprietà di dipendenza specificata. A tale scopo, richiamare qualsiasi CoerceValueCallback funzione specificata nei metadati della proprietà per la proprietà di dipendenza così come esiste nella chiamata DependencyObjectdi . (Ereditato da DependencyObject)
CreateInstance()	Inizializza una nuova istanza della classe Freezable. (Ereditato da Freezable)
CreateInstanceCore()	Crea una nuova istanza della Freezable classe derivata.
Equals(Object)	Determina se un oggetto specificato DependencyObject è equivalente all'oggetto corrente DependencyObject. (Ereditato da DependencyObject)
Freeze()	Rende l'oggetto corrente non modificabile e imposta la relativa IsFrozen proprietà su `true`. (Ereditato da Freezable)
FreezeCore(Boolean)	Animatable Rende questo oggetto non modificabile o determina se può essere reso non modificabile. (Ereditato da Animatable)
GetAnimationBaseValue(DependencyProperty)	Restituisce il valore non animato dell'oggetto specificato DependencyProperty. (Ereditato da Animatable)
GetAsFrozen()	Crea una copia bloccata della proprietà , utilizzando i valori della Freezableproprietà base (non animati). Poiché la copia è bloccata, tutti gli oggetti secondari bloccati vengono copiati in base al riferimento. (Ereditato da Freezable)
GetAsFrozenCore(Freezable)	Rende l'istanza un clone bloccato dell'oggetto specificato Freezable utilizzando valori di proprietà di base (non animati).
GetCurrentValueAsFrozen()	Crea una copia bloccata dell'oggetto utilizzando i valori correnti delle Freezable proprietà. Poiché la copia è bloccata, tutti gli oggetti secondari bloccati vengono copiati in base al riferimento. (Ereditato da Freezable)
GetCurrentValueAsFrozenCore(Freezable)	Rende l'istanza corrente un clone bloccato dell'oggetto specificato Freezable. Se l'oggetto ha proprietà di dipendenza animate, i valori animati correnti vengono copiati.
GetHashCode()	Ottiene un codice hash per l'oggetto DependencyObject. (Ereditato da DependencyObject)
GetLocalValueEnumerator()	Crea un enumeratore specializzato per determinare quali proprietà di dipendenza hanno valori impostati localmente in questo DependencyObjectoggetto . (Ereditato da DependencyObject)
GetType()	Ottiene il Type dell'istanza corrente. (Ereditato da Object)
GetValue(DependencyProperty)	Restituisce il valore effettivo corrente di una proprietà di dipendenza in questa istanza di un oggetto DependencyObject. (Ereditato da DependencyObject)
InvalidateProperty(DependencyProperty)	Rivaluta il valore effettivo per la proprietà di dipendenza specificata. (Ereditato da DependencyObject)
MemberwiseClone()	Crea una copia superficiale del Objectcorrente. (Ereditato da Object)
OnChanged()	Chiamato quando l'oggetto corrente Freezable viene modificato. (Ereditato da Freezable)
OnFreezablePropertyChanged(DependencyObject, DependencyObject, DependencyProperty)	Questo membro supporta l'infrastruttura Windows Presentation Foundation (WPF) e non deve essere usata direttamente dal codice. (Ereditato da Freezable)
OnFreezablePropertyChanged(DependencyObject, DependencyObject)	Assicura che vengano stabiliti puntatori di contesto appropriati per un DependencyObjectType membro dati appena impostato. (Ereditato da Freezable)
OnPropertyChanged(DependencyPropertyChangedEventArgs)	Esegue l'override dell'implementazione DependencyObject di OnPropertyChanged(DependencyPropertyChangedEventArgs) per richiamare anche i Changed gestori in risposta a una proprietà di dipendenza modificata di tipo Freezable. (Ereditato da Freezable)
PixelShaderConstantCallback(Int32)	Associa un valore della proprietà di dipendenza al registro costante float di un pixel shader.
PixelShaderSamplerCallback(Int32, SamplingMode)	Associa un valore della proprietà di dipendenza al registro sampler di un pixel shader e a un oggetto SamplingMode.
PixelShaderSamplerCallback(Int32)	Associa un valore della proprietà di dipendenza al registro del campionatore di pixel shader.
ReadLocalValue(DependencyProperty)	Restituisce il valore locale di una proprietà di dipendenza, se esistente. (Ereditato da DependencyObject)
ReadPreamble()	Assicura che l'oggetto Freezable sia accessibile da un thread valido. Gli eredi di Freezable devono chiamare questo metodo all'inizio di qualsiasi API che legge i membri dati che non sono proprietà di dipendenza. (Ereditato da Freezable)
RegisterPixelShaderSamplerProperty(String, Type, Int32, SamplingMode)	Associa una proprietà di dipendenza a un registro di sampler shader e a un oggetto SamplingMode.
RegisterPixelShaderSamplerProperty(String, Type, Int32)	Associa una proprietà di dipendenza a un registro degli shader sampler.
SetCurrentValue(DependencyProperty, Object)	Imposta il valore di una proprietà di dipendenza senza modificarne l'origine del valore. (Ereditato da DependencyObject)
SetValue(DependencyProperty, Object)	Imposta il valore locale di una proprietà di dipendenza, specificato dall'identificatore della proprietà di dipendenza. (Ereditato da DependencyObject)
SetValue(DependencyPropertyKey, Object)	Imposta il valore locale di una proprietà di dipendenza di sola lettura, specificato dall'identificatore DependencyPropertyKey della proprietà di dipendenza. (Ereditato da DependencyObject)
ShouldSerializeProperty(DependencyProperty)	Restituisce un valore che indica se i processi di serializzazione devono serializzare il valore per la proprietà di dipendenza specificata. (Ereditato da DependencyObject)
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)
UpdateShaderValue(DependencyProperty)	Notifica all'effetto che deve essere aggiornata la costante shader o il campionatore corrispondente alla proprietà di dipendenza specificata.
VerifyAccess()	Impone che il thread chiamante abbia accesso a questo DispatcherObjectoggetto . (Ereditato da DispatcherObject)
WritePostscript()	Genera l'evento Changed per Freezable e richiama il relativo OnChanged() metodo. Le classi che derivano da Freezable devono chiamare questo metodo alla fine di qualsiasi API che modifica i membri della classe non archiviati come proprietà di dipendenza. (Ereditato da Freezable)
WritePreamble()	Verifica che l'oggetto Freezable non sia bloccato e che sia accessibile da un contesto di threading valido. Freezable Gli eredi devono chiamare questo metodo all'inizio di qualsiasi API che scrive nei membri dati che non sono proprietà di dipendenza. (Ereditato da Freezable)

Eventi

Nome	Descrizione
Changed	Si verifica quando l'oggetto Freezable o un oggetto che contiene viene modificato. (Ereditato da Freezable)

Si applica a

Vedi anche

Commenti e suggerimenti

Questa pagina è stata utile?