Idioma

CompositionMaskBrush Classe

Definição

Pinta um SpriteVisual com um CompositionBrush com uma máscara de opacidade aplicada a ele. A origem da máscara de opacidade pode ser qualquer CompositionBrush do tipo CompositionColorBrush, CompositionLinearGradientBrush, CompositionSurfaceBrush, CompositionEffectBrush ou compositionNineGridBrush. A máscara de opacidade deve ser especificada como um CompositionSurfaceBrush.

public ref class CompositionMaskBrush sealed : CompositionBrush
/// [Windows.Foundation.Metadata.ContractVersion(Windows.Foundation.UniversalApiContract, 196608)]
/// [Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
/// [Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
class CompositionMaskBrush final : CompositionBrush
[Windows.Foundation.Metadata.ContractVersion(typeof(Windows.Foundation.UniversalApiContract), 196608)]
[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
[Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
public sealed class CompositionMaskBrush : CompositionBrush
Public NotInheritable Class CompositionMaskBrush
Inherits CompositionBrush
Herança
Object Platform::Object IInspectable CompositionObject CompositionBrush CompositionMaskBrush
Atributos

Requisitos do Windows

Requisitos Description
Família de dispositivos
Windows 10 Anniversary Edition (introduzida na 10.0.14393.0)
API contract
Windows.Foundation.UniversalApiContract (introduzida na v3.0)

Exemplos

Exemplo completo: aplicar uma máscara de um arquivo de imagem

O exemplo a seguir mostra como criar um CompositionMaskBrush de ponta a ponta, incluindo o carregamento da imagem da máscara. Use um PNG com um canal alfa: áreas totalmente opacas da máscara deixam a origem visível, as áreas totalmente transparentes o ocultam e os valores alfa intermediários produzem transparência parcial. Os valores de cor RGB da máscara não controlam a opacidade; uma imagem opaca em preto e branco não cria uma máscara de transparência.

// Get the Compositor from a XAML element
Compositor compositor = ElementCompositionPreview.GetElementVisual(myElement).Compositor;

// Create the mask brush
CompositionMaskBrush maskBrush = compositor.CreateMaskBrush();

// Create the source (the content to be masked)
CompositionColorBrush colorBrush = compositor.CreateColorBrush(Colors.Blue);
maskBrush.Source = colorBrush;

// Load a mask image and create a surface brush from it
// The PNG's alpha channel defines the mask (opaque = visible, transparent = hidden)
LoadedImageSurface maskSurface = LoadedImageSurface.StartLoadFromUri(new Uri("ms-appx:///Assets/CircleMask.png"));
CompositionSurfaceBrush maskSurfaceBrush = compositor.CreateSurfaceBrush(maskSurface);
maskBrush.Mask = maskSurfaceBrush;

// Apply to a SpriteVisual and add it to the XAML tree
SpriteVisual visual = compositor.CreateSpriteVisual();
visual.Brush = maskBrush;
visual.Size = new System.Numerics.Vector2(200, 200);
ElementCompositionPreview.SetElementChildVisual(myElement, visual);

Aplicar uma máscara em forma de estrela a uma imagem

Os exemplos a seguir mostram várias maneiras de usar CompositionMaskBrush. Cada exemplo recebe instâncias ICompositionSurface pré-criadas. Você pode criar essas superfícies usando LoadedImageSurface , conforme mostrado no exemplo acima ou por meio do Win2D.

private SpriteVisual CreateCircleImage(ICompositionSurface myImageSurface, ICompositionSurface myStarMaskSurface) 
{ 
  // Create SurfaceBrush with image surface and specify stretch and alignment 
  CompositionSurfaceBrush imageBrush = _compositor.CreateSurfaceBrush(myImageSurface); 
  imageBrush.HorizontalAlignmentRatio = 0.5f; 
  imageBrush.VerticalAlignmentRatio = 0.5f; 
  imageBrush.Stretch = CompositionStretch.UniformToFill; 

  // Create surface brush with opacity mask surface and specify stretch and alignment 
  CompositionSurfaceBrush starMaskBrush = _compositor.CreateSurfaceBrush(myStarMaskSurface); 
  starMaskBrush.Stretch = CompositionStretch.Uniform; 

  // SpriteVisual to be painted with masked content 
  SpriteVisual imageVisual = _compositor.CreateSpriteVisual(); 
  imageVisual.Size = new Vector2(200, 200); 

  // Create MaskBrush 
  CompositionMaskBrush maskBrush = _compositor.CreateMaskBrush(); 
  maskBrush.Source = imageBrush; // Set source to content that is to be masked 
  maskBrush.Mask = starMaskBrush; // Set mask to content that is the opacity mask 

  imageVisual.Brush = maskBrush; // Paint SpriteVisual with MaskBrush 

  return imageVisual;           
} 

Animar uma máscara de opacidade para criar um efeito de flores de cor

private void CreateCircleMaskSprite(ICompositionSurface myCircleMaskSurface, ICompositionSurface myImageSurface)
{
  // SpriteVisual to be painted by MaskBrush
  _circleVisual = _compositor.CreateSpriteVisual();
  _circleVisual.Size = MyContainerGrid.RenderSize.ToVector2();

  // SurfaceBrush w/ image as MaskBrush.Source
  CompositionSurfaceBrush imageBrush = _compositor.CreateSurfaceBrush(myImageSurface);
  imageBrush.Stretch = CompositionStretch.UniformToFill;

  // SurfaceBrush w/ opacity mask surface as MaskBrush.Mask
  CompositionSurfaceBrush circleBrush = _compositor.CreateSurfaceBrush(myCircleMaskSurface);

  // Specify stretch and transform properties to scale and position brush for initial state
  circleBrush.Stretch = CompositionStretch.Uniform;
  circleBrush.CenterPoint = _circleVisual.Size / 2;
  circleBrush.Scale = new Vector2(0.5f);

  // Create MaskBrush
  CompositionMaskBrush maskBrush = _compositor.CreateMaskBrush();
  maskBrush.Source = imageBrush;
  maskBrush.Mask = circleBrush;
  _circleVisual.Brush = maskBrush;

  // Set SpriteVisual as child of XAML Grid
  ElementCompositionPreview.SetElementChildVisual(MyContainerGrid, _circleVisual);
}

private void BloomAnimation()
{
  // Create KeyFrame Animation to target Scale transform on SurfaceBrush 
  Vector2KeyFrameAnimation scaleAnimation = _compositor.CreateVector2KeyFrameAnimation();
  scaleAnimation.InsertKeyFrame(1.0f, new Vector2(2));
  scaleAnimation.Duration = TimeSpan.FromMilliseconds(500);

  var maskBrush = (CompositionMaskBrush)_circleVisual.Brush;
  var surfaceBrush = (CompositionSurfaceBrush) maskBrush.Mask;

  // Animate the Scale on the circle opacity mask
  surfaceBrush.StartAnimation("Scale", scaleAnimation);      
}

Usar uma máscara NineGridBrush para um retângulo arredondado

private SpriteVisual CreateMaskedRoundedRectVisual(ICompositionSurface myRoundedRectMaskSurface)
{
  // ColorBrush to be set as MaskBrush.Source
  CompositionColorBrush colorBrush = _compositor.CreateColorBrush(Colors.Blue);

  // SurfaceBrush w/ opacity mask surface
  CompositionSurfaceBrush roundedRectBrush = _compositor.CreateSurfaceBrush(myRoundedRectMaskSurface);
  roundedRectBrush.Stretch = CompositionStretch.Fill; // stretch for center of nine-grid

  // NineGridBrush w/ insets on opacity mask surface
  CompositionNineGridBrush ninegridBrush = _compositor.CreateNineGridBrush();
  ninegridBrush.Source = roundedRectBrush;
  ninegridBrush.SetInsets(_cornerRadius); // the radius, in pixels, of the corner as specified on my opacity mask surface 

  // Create MaskBrush
  CompositionMaskBrush maskBrush = _compositor.CreateMaskBrush();
  maskBrush.Source = colorBrush;
  maskBrush.Mask = ninegridBrush;

  // Paint SpriteVisual with MaskBrush
  SpriteVisual sprite = _compositor.CreateSpriteVisual();
  sprite.Size = new Vector2(300, 200);
  sprite.Brush = maskBrush;
  return sprite;

}

Comentários

CompositionMaskBrush não pode ser definido como o parâmetro de origem para um CompositionEffectBrush. Se você quiser aplicar um IGraphicsEffect ao conteúdo mascarado, use um CompositionEffectBrush com o efeito Composto .

Propriedades

Nome Description
Comment

Uma cadeia de caracteres a ser associada ao CompositionObject.

(Herdado de CompositionObject)
Compositor

O Compositor usado para criar este CompositionObject.

(Herdado de CompositionObject)
Dispatcher

O dispatcher para o CompositionObject.

(Herdado de CompositionObject)
DispatcherQueue

Obtém o DispatcherQueue para o CompostionObject.

(Herdado de CompositionObject)
ImplicitAnimations

A coleção de animações implícitas anexadas a esse objeto.

(Herdado de CompositionObject)
Mask

Um pincel que contém a máscara de opacidade com a qual o conteúdo do pincel de origem deve ser mascarado. Pode ser do tipo CompositionSurfaceBrush ou CompositionNineGridBrush.

Properties

A coleção de propriedades associadas ao CompositionObject.

(Herdado de CompositionObject)
Source

Um pincel cujo conteúdo deve ser mascarado pela máscara de opacidade. Pode ser do tipo CompositionSurfaceBrush, CompositionColorBrush ou CompositionNineGridBrush.

Métodos

Nome Description
Close()

Fecha o CompositionObject e libera os recursos do sistema.

(Herdado de CompositionObject)
Dispose()

Executa tarefas definidas pelo aplicativo associadas à liberação, liberação ou redefinição de recursos não gerenciados.

(Herdado de CompositionObject)
PopulatePropertyInfo(String, AnimationPropertyInfo)

Define uma propriedade que pode ser animada.

(Herdado de CompositionObject)
StartAnimation(String, CompositionAnimation, AnimationController)

Conecta uma animação com a propriedade especificada do objeto e inicia a animação.

(Herdado de CompositionObject)
StartAnimation(String, CompositionAnimation)

Conecta uma animação com a propriedade especificada do objeto e inicia a animação.

(Herdado de CompositionObject)
StartAnimationGroup(ICompositionAnimationBase)

Inicia um grupo de animação.

O método StartAnimationGroup em CompositionObject permite iniciar CompositionAnimationGroup. Todas as animações no grupo serão iniciadas ao mesmo tempo no objeto.

(Herdado de CompositionObject)
StopAnimation(String)

Desconecta uma animação da propriedade especificada e interrompe a animação.

(Herdado de CompositionObject)
StopAnimationGroup(ICompositionAnimationBase)

Interrompe um grupo de animação.

(Herdado de CompositionObject)
TryGetAnimationController(String)

Retorna um AnimationController para a animação em execução na propriedade especificada.

(Herdado de CompositionObject)

Aplica-se a

Confira também