Compartilhar via


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

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

Exemplos

Aplique uma máscara em forma de star a uma imagem.

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

Aplicando uma máscara de opacidade ao preenchimento de cor sólida para criar uma forma; animar a propriedade de transformação na máscara de opacidade CompositionSurfaceBrush para criar uma animação de bloom de cores

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

Aplicando uma máscara de retângulo arredondada para criar um retângulo arredondado de cor sólida cujo raio de canto não aumenta após o redimensionamento (use CompositionNineGridBrush como entrada para um CompositionMaskBrush ).

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

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

Close()

Fecha o CompositionObject e libera os recursos do sistema.

(Herdado de CompositionObject)
ConnectAnimation(String, CompositionAnimation)

Conecta e animação.

(Herdado de CompositionObject)
DisconnectAnimation(String)

Desconecta uma animação.

(Herdado de CompositionObject)
Dispose()

Realiza tarefas definidas pelo aplicativo associadas à 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