ShaderEffect Klass

Definition

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

Arv

Object

DispatcherObject

DependencyObject

Freezable

Animatable

Effect

ShaderEffect

Exempel

Följande kodexempel visar hur du härleder från ShaderEffect klassen.

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

I följande kodexempel visas en skuggning som motsvarar föregående ShaderEffect klass.

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

Följande XAML visar hur du använder den anpassade skuggningseffekten.

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

Kommentarer

Härled från ShaderEffect klassen för att implementera en anpassad effekt baserat på en enskild pixelskuggning.

Följande steg visar hur du skapar en anpassad effekt.

1. Läs in en PixelShader från förkompilerad HLSL-bytekod (High Level Shading Language).

2. Definiera beroendeegenskaper som representerar parametrarna för effekten och de Brush-baserade ytindata. Använd en av överlagringarna RegisterPixelShaderSamplerProperty för att associera dessa indata med registernummer som refereras till i HLSL-bytekoden.

Antalet provtagare är begränsat till 4.

Följande begränsningar gäller när du använder en PS 3.0-skuggning.

• När en PS 3.0-skuggning tilldelas ökar antalet provtagare till 8. Tilldela PS 3.0-skuggningen före andra skuggningar för att aktivera registrering av 8 provtagare.

• Den fullständiga skuggningskonstantens registergräns på 224 för flyttal används. Mer information finns i ps_3_0.

• Följande datatyper stöds endast i PS 3.0-skuggningar. Ett undantag utlöses om dessa används i lägre skuggningsversioner.

  • intoch typer konvertibla till int: uint, byte, sbyte, long, ulong, short, , ushortchar

  • bool

• Om en giltig PS 3.0-skuggning läses in på en dator som inte har maskinvarustöd för PS 3.0 ignoreras skuggningen. Om skuggningen är ogiltig utlöses inget undantag.

• Om en dator har fler än ett grafikkort definieras beteendet av det minst kompatibla grafikkortet. Om datorn till exempel har två grafikkort, varav ett stöder PS 3.0 och ett av dem inte gör det, är beteendet detsamma som om datorn inte stöder PS 3.0.

• Om en dator stöder återgivning av PS 3.0 i maskinvara, men en ogiltig PS 3.0-skuggning tilldelas, InvalidPixelShaderEncountered utlöses händelsen. Ett exempel på en ogiltig PS 3.0-skuggning är en som kompilerats med ps_3_sw flaggan. Klassen ShaderEffect accepterar endast PS 3.0-skuggningar som kompileras med ps_3_0 flaggan som skickas till fxc.exe. Mer information finns iEffect-Compiler Tool.

Se även

• Effect
• PixelShader