Exportar (0) Imprimir
Expandir todo
Este artículo se tradujo de forma manual. Mueva el puntero sobre las frases del artículo para ver el texto original.
Traducción
Original
Este tema aún no ha recibido ninguna valoración - Valorar este tema

ShaderEffect (Clase)

Proporciona un efecto de mapa de bits personalizado mediante PixelShader.

Espacio de nombres:  System.Windows.Media.Effects
Ensamblado:  PresentationCore (en PresentationCore.dll)
public abstract class ShaderEffect : Effect

El tipo ShaderEffect expone los siguientes miembros.

  NombreDescripción
Método protegidoShaderEffectInicializa una nueva instancia de la clase ShaderEffect.
Arriba
  NombreDescripción
Propiedad públicaCanFreezeObtiene un valor que indica si el objeto se puede convertir en no modificable. (Se hereda de Freezable).
Propiedad protegidaDdxUvDdyUvRegisterIndexObtiene o establece un valor que indica el registro de sombreador que se va a usar para los derivados parciales de las coordenadas de textura con respecto al espacio de pantalla.
Propiedad públicaDependencyObjectTypeObtiene el objeto DependencyObjectType que ajusta el tipo CLR de esta instancia.  (Se hereda de DependencyObject).
Propiedad públicaDispatcherObtiene el objeto Dispatcher al que está asociado DispatcherObject. (Se hereda de DispatcherObject).
Propiedad protegidaEffectMappingCuando se invalida en una clase derivada, transforma la entrada del mouse y los sistemas de coordenadas a través del efecto. (Se hereda de Effect).
Propiedad públicaHasAnimatedPropertiesObtiene un valor que indica si uno o más objetos AnimationClock se asocian a cualquiera de las propiedades de dependencia de este objeto. (Se hereda de Animatable).
Propiedad públicaIsFrozenObtiene un valor que indica si el objeto es modificable actualmente. (Se hereda de Freezable).
Propiedad públicaIsSealedObtiene un valor que indica si esta instancia está actualmente sellada (es de solo lectura). (Se hereda de DependencyObject).
Propiedad protegidaPaddingBottomObtiene o establece un valor que indica que la textura de salida del efecto es mayor que su textura de entrada a lo largo del borde inferior.
Propiedad protegidaPaddingLeftObtiene o establece un valor que indica que la textura de salida del efecto es mayor que su textura de entrada a lo largo del borde izquierdo.
Propiedad protegidaPaddingRightObtiene o establece un valor que indica que la textura de salida del efecto es mayor que su textura de entrada a lo largo del borde derecho.
Propiedad protegidaPaddingTopObtiene o establece un valor que indica que la textura de salida del efecto es mayor que su textura de entrada a lo largo del borde superior.
Propiedad protegidaPixelShaderObtiene o establece el objeto PixelShader que se usará para el efecto.
Arriba
  NombreDescripción
Método públicoApplyAnimationClock(DependencyProperty, AnimationClock)Aplica un objeto AnimationClock al objeto DependencyProperty especificado. Si la propiedad ya está animada, se usa el comportamiento de entrega de SnapshotAndReplace. (Se hereda de Animatable).
Método públicoApplyAnimationClock(DependencyProperty, AnimationClock, HandoffBehavior)Aplica un objeto AnimationClock al objeto DependencyProperty especificado. Si la propiedad ya está animada, se usa el objeto HandoffBehavior especificado. (Se hereda de Animatable).
Método públicoBeginAnimation(DependencyProperty, AnimationTimeline)Aplica una animación al objeto DependencyProperty especificado. La animación empieza cuando se representa el siguiente fotograma. Si la propiedad especificada ya está animada, se usa el comportamiento de entrega de SnapshotAndReplace. (Se hereda de Animatable).
Método públicoBeginAnimation(DependencyProperty, AnimationTimeline, HandoffBehavior)Aplica una animación al objeto DependencyProperty especificado. La animación empieza cuando se representa el siguiente fotograma. Si la propiedad especificada ya está animada, se usa el objeto HandoffBehavior especificado. (Se hereda de Animatable).
Método públicoCheckAccessDetermina si el subproceso de la llamada tiene acceso a DispatcherObject. (Se hereda de DispatcherObject).
Método públicoClearValue(DependencyProperty)Borra el valor local de una propiedad. La propiedad que se va a borrar se especifica mediante un identificador de DependencyProperty. (Se hereda de DependencyObject).
Método públicoClearValue(DependencyPropertyKey)Borra el valor local de una propiedad de sólo lectura. DependencyPropertyKey especifica la propiedad que se va a borrar. (Se hereda de DependencyObject).
Método públicoCloneCrea un clon modificable de este objeto ShaderEffect y hace copias en profundidad de sus valores. Cuando se copian las propiedades de dependencia de este objeto, este método copia las referencias de recursos y los enlaces de datos (que podrían no resolverse), pero no copia las animaciones ni sus valores actuales.
Método protegidoCloneCoreConvierte la instancia en un clon (copia en profundidad) de la clase Freezable especificada con los valores de la propiedad base (no animada). (Invalida a Freezable.CloneCore(Freezable)).
Método públicoCloneCurrentValueCrea un clon modificable de este objeto ShaderEffect y hace copias en profundidad de sus valores actuales. Las referencias de recursos, los enlaces de datos y las animaciones no se copian, pero sí sus valores actuales.
Método protegidoCloneCurrentValueCoreConvierte la instancia en un clon modificable (en profundidad) del objeto Freezable especificado utilizando los valores de las propiedades actuales. (Invalida a Freezable.CloneCurrentValueCore(Freezable)).
Método públicoCoerceValueConvierte el valor de la propiedad de dependencia especificada. Esto se logra invocando cualquier función de CoerceValueCallback especificada en los metadatos de la propiedad de dependencia cuando existe en el objeto DependencyObject de llamada. (Se hereda de DependencyObject).
Método protegidoCreateInstanceInicializa una nueva instancia de la clase Freezable. (Se hereda de Freezable).
Método protegidoCreateInstanceCoreCuando se implementa en una clase derivada, crea una nueva instancia de la clase Freezable derivada. (Invalida a Freezable.CreateInstanceCore()).
Método públicoEqualsDetermina si un objeto DependencyObject proporcionado es equivalente al objeto DependencyObject actual. (Se hereda de DependencyObject).
Método protegidoFinalize Permite que un objeto intente liberar recursos y realizar otras operaciones de limpieza antes de ser reclamado por la recolección de elementos no utilizados. (Se hereda de Object).
Método públicoFreeze()Convierte el objeto actual en no modificable y establece su propiedad IsFrozen en true. (Se hereda de Freezable).
Método protegidoFreezeCoreConvierte este objeto Animatable en no modificable o determina si se puede convertir en no modificable. (Se hereda de Animatable).
Método públicoGetAnimationBaseValueDevuelve el valor no animado del objeto DependencyProperty especificado. (Se hereda de Animatable).
Método públicoGetAsFrozenCrea una copia inmovilizada de Freezable, con los valores de la propiedad base (no animada). Puesto que se inmoviliza la copia, se copia cualquier subobjeto inmovilizado por referencia. (Se hereda de Freezable).
Método protegidoGetAsFrozenCoreConvierte la instancia en un clon inmovilizado de la clase Freezable especificada con los valores de la propiedad base (no animada). (Invalida a Freezable.GetAsFrozenCore(Freezable)).
Método públicoGetCurrentValueAsFrozenCrea una copia inmovilizada de Freezable con los valores de propiedad actuales. Puesto que se inmoviliza la copia, se copia cualquier subobjeto inmovilizado por referencia. (Se hereda de Freezable).
Método protegidoGetCurrentValueAsFrozenCoreConvierte la instancia actual en un clon inmovilizado de la clase Freezable especificada. Si el objeto tiene propiedades de dependencia animadas, se copian sus valores animados actuales. (Invalida a Freezable.GetCurrentValueAsFrozenCore(Freezable)).
Método públicoGetHashCodeObtiene un código hash de este objeto DependencyObject. (Se hereda de DependencyObject).
Método públicoGetLocalValueEnumeratorCrea un enumerador especializado para determinar qué propiedades de dependencia han establecido localmente los valores en DependencyObject. (Se hereda de DependencyObject).
Método públicoGetType Obtiene el Typede la instancia actual. (Se hereda de Object).
Método públicoGetValueDevuelve el valor efectivo actual de una propiedad de dependencia en esta instancia de DependencyObject. (Se hereda de DependencyObject).
Método públicoInvalidatePropertyVuelve a evaluar el valor efectivo para la propiedad de dependencia especificada. (Se hereda de DependencyObject).
Método protegidoMemberwiseClone Crea una copia superficial del Object actual. (Se hereda de Object).
Método protegidoOnChangedSe llama cuando se modifica el objeto Freezable actual. (Se hereda de Freezable).
Método protegidoOnFreezablePropertyChanged(DependencyObject, DependencyObject)Se asegura de que se establecen los punteros contextuales adecuados para un miembro de datos DependencyObjectType que se acaba de establecer. (Se hereda de Freezable).
Método protegidoOnFreezablePropertyChanged(DependencyObject, DependencyObject, DependencyProperty)Este miembro admite la infraestructura de Windows Presentation Foundation (WPF) y no se debe usar directamente desde el código. (Se hereda de Freezable).
Método protegidoOnPropertyChangedInvalida la implementación de DependencyObject de OnPropertyChanged para invocar también cualquier controlador Changed como respuesta a un cambio de propiedad de dependencia de tipo Freezable. (Se hereda de Freezable).
Método protegidoMiembro estáticoPixelShaderConstantCallbackAsocia un valor de propiedad de dependencia a un registro de constante float de un sombreador de píxeles.
Método protegidoMiembro estáticoPixelShaderSamplerCallback(Int32)Asocia un valor de propiedad de dependencia al registro de muestra de un sombreador de píxeles.
Método protegidoMiembro estáticoPixelShaderSamplerCallback(Int32, SamplingMode)Asocia un valor de propiedad de dependencia al registro de muestra de un sombreador de píxeles y un SamplingMode.
Método públicoReadLocalValueDevuelve el valor local de una propiedad de dependencia, si existe. (Se hereda de DependencyObject).
Método protegidoReadPreambleSe asegura de que se tiene acceso a Freezable desde un subproceso válido. Los herederos de Freezable deben llamar a este método al inicio de las API que lean miembros de datos que no son propiedades de dependencia. (Se hereda de Freezable).
Método protegidoMiembro estáticoRegisterPixelShaderSamplerProperty(String, Type, Int32)Asocia una propiedad de dependencia a un registro de muestra de sombreador.
Método protegidoMiembro estáticoRegisterPixelShaderSamplerProperty(String, Type, Int32, SamplingMode)Asocia una propiedad de dependencia a un registro de muestra de sombreador y un SamplingMode.
Método públicoSetCurrentValueEstablece el valor de una propiedad de dependencia sin cambiar el origen de su valor. (Se hereda de DependencyObject).
Método públicoSetValue(DependencyProperty, Object)Establece el valor local de una propiedad de dependencia, especificado por su identificador de propiedad de dependencia. (Se hereda de DependencyObject).
Método públicoSetValue(DependencyPropertyKey, Object)Establece el valor local de una propiedad de dependencia de sólo lectura, especificado por el identificador DependencyPropertyKey de la propiedad de dependencia. (Se hereda de DependencyObject).
Método protegidoShouldSerializePropertyDevuelve un valor que indica si los procesos de serialización deben serializar el valor de la propiedad de dependencia proporcionada. (Se hereda de DependencyObject).
Método públicoToString Retorna una cadena que representa al objeto actual. (Se hereda de Object).
Método protegidoUpdateShaderValueNotifica al efecto que se debería actualizar la constante o la muestra de sombreador que corresponde a la propiedad de dependencia especificada.
Método públicoVerifyAccessExige que el subproceso de la llamada tenga acceso a DispatcherObject. (Se hereda de DispatcherObject).
Método protegidoWritePostscriptProvoca el evento Changed de Freezable e invoca su método OnChanged. Las clases que se derivan de Freezable deben llamar a este método al final de cualquier API que modifique miembros de clase que no se almacenen como propiedades de dependencia. (Se hereda de Freezable).
Método protegidoWritePreambleComprueba que no se inmovilice Freezable y que se tiene acceso desde un contexto de subproceso válido. Los herederos de Freezable deben llamar a este método al inicio de cualquier API que escriba en miembros de datos que no sean propiedades de dependencia. (Se hereda de Freezable).
Arriba
  NombreDescripción
Evento públicoChangedSe produce cuando se modifican la clase Freezable o un objeto que la contiene. (Se hereda de Freezable).
Arriba
  NombreDescripción
Campo protegidoMiembro estáticoPixelShaderPropertyIdentifica la propiedad de dependencia PixelShader.
Arriba

Derive de la clase ShaderEffect para implementar un efecto personalizado basado en un sombreador de píxeles único.

En los pasos siguientes se muestra cómo crear un efecto personalizado.

  1. Cargue un PixelShader desde código de bytes HLSL (High Level Shading Language) precompilado.

  2. Defina propiedades de dependencia que representen los parámetros del efecto y las entradas de superficie basadas en Brush. Use una de las sobrecargas RegisterPixelShaderSamplerProperty para asociar estas entradas a los números de registro a los que se hace referencia en el código de bytes HLSL.

El número de ejemplos se limita a 4.

Se aplican las siguientes restricciones al uso de un sombreador de PS 3.0.

  • Cuando se asigna un sombreador de PS 3.0, el número de catadores aumenta a 8. Asigne el sombreador de PS 3.0 antes de otros sombreadores para permitir registrar 8 muestras.

  • Se usa el límite de registro de contante de sombreador completo de 224 para valores flotantes. Para obtener más información, vea ps_3_0.

  • Los siguientes tipos de datos solo son compatibles con sombreadores de PS 3.0. Se produce una excepción si éstos se usan en versiones inferiores del sombreador.

    • int y tipos que se pueden convertir en int: uint, byte, sbyte, long, ulong, short, ushort, char

    • bool

  • Si un carga un sombreador de PS 3.0 válido en un equipo que no tiene compatibilidad de hardware para PS 3.0, se omite el sombreador. Si el sombreador no es válido, no se produce ninguna excepción.

  • Si un equipo tiene más de una tarjeta de vídeo, el comportamiento lo define la tarjeta de vídeo menos capaz. Por ejemplo, si el equipo tiene dos tarjetas de vídeo, una de las cuales admite PS 3.0 y otra no, el comportamiento es igual que si el equipo no admitiese PS 3.0.

  • Si un equipo permite representar PS 3.0 en hardware, pero se asigna un sombreador de PS 3.0 no válido, se provoca el evento InvalidPixelShaderEncountered. Un ejemplo de un sombreador de PS 3.0 no válido es uno compilado con la marca ps_3_sw. La clase ShaderEffect solo acepta sombreadores de PS 3.0 que están compilados con la marca ps_3_0 pasada a fxc.exe. Para obtener más información, vea Effect-Compiler Tool.

NotaNota

Los sombreadores de PS 2.0 se ejecutan al representarse en software. Sin embargo, aun cuando el hardware del sistema proporciona soporte técnico para PS 3.0, los sombreadores de PS 3.0 no se ejecutan durante la representación del software.

En el ejemplo de código siguiente se muestra cómo derivar de la clase ShaderEffect.


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


En el ejemplo de código siguiente se muestra un sombreador que corresponde a la clase ShaderEffect anterior.


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


En el código XAML siguiente se muestra cómo usar el efecto de sombreador personalizado.


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


.NET Framework

Compatible con: 4, 3.5 SP1, 3.0 SP2

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Windows 7, Windows Vista SP1 o posterior, Windows XP SP3, Windows Server 2008 (no se admite Server Core), Windows Server 2008 R2 (se admite Server Core con SP1 o posterior), Windows Server 2003 SP2

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.
Todos los miembros static (Shared en Visual Basic) públicos de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.
¿Te ha resultado útil?
(Caracteres restantes: 1500)
Gracias por sus comentarios

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft. Reservados todos los derechos.