ExpressionAnimation Classe

Definição

Namespace:

Microsoft.UI.Composition

Uma Animação de Composição que usa uma equação matemática para calcular o valor de uma propriedade de animação a cada quadro.

public ref class ExpressionAnimation sealed : CompositionAnimation

/// [Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
/// [Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
/// [Windows.Foundation.Metadata.ContractVersion(Microsoft.Foundation.WindowsAppSDKContract, 65536)]
class ExpressionAnimation final : CompositionAnimation

[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
[Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
[Windows.Foundation.Metadata.ContractVersion(typeof(Microsoft.Foundation.WindowsAppSDKContract), 65536)]
public sealed class ExpressionAnimation : CompositionAnimation

Public NotInheritable Class ExpressionAnimation
Inherits CompositionAnimation

Herança

Object Platform::Object IInspectable CompositionObject CompositionAnimation ExpressionAnimation

Atributos

ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Exemplos

void AnimateOpacity()
{
  // The Expression below will animate the opacity of the target Visual based on its position to the edge of the window.
  ExpressionAnimation exp = _compositor.CreateExpressionAnimation();
  float xWinSize = (float) Window.Current.Bounds.Width;
  SpriteVisual targetVisual = _compositor.CreateSpriteVisual();

  // Define the Expression Equation and references
  exp.Expression = "this.Target.Offset.X / xWindowSize";
  exp.SetScalarParameter("xWindowSize", xWinSize);

  // Attach the animation to the target Opacity property
  targetVisual.StartAnimation("Opacity", exp);
}

// Creates an Expression that calculates the angle between two Visual's Offset vectors 
// And assigns it to the RotationAngle of a third Visual
void angleBetweenVectors()
{
  SpriteVisual visualA = _compositor.CreateSpriteVisual();
  SpriteVisual visualB = _compositor.CreateSpriteVisual();

  SpriteVisual lineVisual = _compositor.CreateSpriteVisual();
  lineVisual.Size = new Vector2(50.0f, 5.0f);

  var rotationAnimation = _compositor.CreateExpressionAnimation();
  rotationAnimation.SetReferenceParameter("A", visualA);
  rotationAnimation.SetReferenceParameter("B", visualB);

  rotationAnimation.Expression = "ACos( ( (A.Offset.X * B.Offset.X) + (A.Offset.Y*B.Offset.Y) + (A.Offset.Z * B.Offset.Z) ) / ( Length(A.Offset) * 	Length(B.Offset) ) )";
  lineVisual.StartAnimation("RotationAngle", rotationAnimation);
}

Comentários

O núcleo de ExpressionAnimations permite que um desenvolvedor defina uma equação matemática que pode ser usada para calcular o valor de uma propriedade de animação direcionada a cada quadro. Isso contrasta KeyFrameAnimation s, que usam um interpolador para definir como a propriedade de animação muda ao longo do tempo. A equação matemática pode ser definida usando referências a propriedades de objetos de composição, funções matemáticas e operadores e Entrada. Animações de expressão abrem a porta para tornar experiências como cabeçalhos pegajosos e paralaxe facilmente descrevendo.

Para obter um passo a passo detalhado sobre como usar ExpressionAnimation de Composição, confira o documento visão geral de animações.

Use os métodos CompositionObject.StartAnimation e CompositionObject.StopAnimation para iniciar e parar a animação.

Então, por que animações de expressão são úteis?

O poder real das Animações de Expressão vem de sua capacidade de criar uma relação matemática com referências a propriedades em outros objetos. Isso significa que você pode ter uma equação referenciando valores de propriedade em outros objetos de composição, variáveis locais ou até mesmo valores compartilhados em Conjuntos de Propriedades de Composição. À medida que essas referências forem alteradas e atualizadas ao longo do tempo, sua expressão também será alterada. Isso abre possibilidades maiores além das animações tradicionais do KeyFrame, em que os valores devem ser discretos e predefinidos– ExpressionAnimations podem criar experiências de animação mais dinâmicas.

Aspectos a considerar

• ExpressionAnimation tem um tempo de vida infinito – eles continuarão a ser executados até serem explicitamente interrompidos.

• A equação matemática será inserida na expressão como uma cadeia de caracteres – isso pode ser feito ao construir a ExpressionAnimation ou separadamente alterando a propriedade. Se terminar durante a construção, a propriedade será definida. + ExpressionAnimation exp = _compositor. CreateExpressionAnimation(); Exp. Expressão = "this. Target.Offset.X / xWindowSize";

  • ExpressionAnimation exp = _compositor. CreateExpressionAnimation("this. Target.Offset.X / xWindowSize")

• A equação matemática será usada a cada quadro para calcular o valor da propriedade de animação (isso está em contraste com KeyFrameAnimations que usam um interpolador)

• Preste atenção ao tipo da propriedade que você planeja animar– sua equação deve ser resolvida para o mesmo tipo. Caso contrário, um erro será gerado quando a expressão for calculada. Se sua equação for resolvida para Nan (número/0), o sistema usará o valor calculado anteriormente

A chave para criar a interface do usuário de animação dinâmica com animações de expressão é criar uma equação na qual as referências a propriedades ou outros valores serão alteradas ao longo do tempo.

Quando anexado a uma propriedade de animação, o sistema usará essa equação para calcular o valor da propriedade para cada quadro. Isso significa que, como resultado, o sistema reavaliará todas as referências que conduzirão as alterações à equação. Por exemplo, no exemplo acima, se o Visual A ou B se mover devido a outra animação ou entrada, o ângulo de rotação do visual de linha será alterado de acordo com a equação.

Ao construir a equação matemática, há vários componentes diferentes a serem considerados (para obter um passo a passo detalhado de cada um desses componentes, consulte a Visão geral da animação):

• Operadores, precedência e associatividade + A cadeia de caracteres expression dá suporte ao uso de operadores matemáticos típicos (+, -, /, etc.) que você esperaria usar em qualquer equação.

  • Quando a expressão for avaliada, ela aderirá à precedência e associatividade do operador, conforme definido na especificação da linguagem C#.

• Parâmetros de propriedade + Ao definir sua expressão, você tem a opção de definir referências de tipo a outras propriedades em Visuais de Composição, Conjuntos de Propriedades ou outros objetos C#.

  • Para usar em uma cadeia de caracteres de expressão, utilize as funções "SetParameter" com base no tipo, definindo a cadeia de caracteres utilizada na cadeia de caracteres de expressão e seu valor mapeado. Essas funções são listadas como parte da classe CompositionAnimation de nível superior.

• Funções auxiliares e construtores + A expressão também pode aproveitar uma lista de funções e construtores para diferentes tipos de objeto na equação.

  • Há também métodos de construtor que construirão um tipo de objeto quando a equação for avaliada pelo sistema
  • Uma lista das funções por tipo é listada mais abaixo

• Palavras-chave + A Expressão também pode aproveitar várias palavras-chave que são tratadas de forma diferente quando a cadeia de caracteres de expressão é avaliada. Considere essas palavras-chave e não pode ser usada como uma chave de cadeia de caracteres em referências de propriedade.

  • Lista de palavras-chave disponíveis listadas mais abaixo

• Condicional + Uma expressão também pode utilizar instruções condicionais usando o operador Ternary (condição ? ifTrue_expression: ifFalse_expression)

  • Operadores ternários podem ser aninhados como a expressão para as instruções verdadeiras ou falsas.

Palavras-chave de expressão

Palavra-chave	Descrição
This.StartingValue	Fornece uma referência ao valor inicial original da propriedade que está sendo animada.
This.CurrentValue	Fornece uma referência ao valor atualmente "conhecido" da propriedade
This.FinalValue	Fornece uma referência ao valor final da animação (se definido) Observação: Relevante para animações implícitas, para explícito, mantém a mesma funcionalidade que This.StartingValue
Pi	Fornece uma referência de palavra-chave ao valor de PI
Verdadeiro/Falso	Fornece uma referência aos valores boolianos de "true" ou "false"
This.Target	Fornece uma referência ao objeto de destino ao qual as animações estão associadas.

Funções de expressão por tipo

Escalar

Operações de função e construtor	Descrição
Abs(Valor float)	Retorna um Float que representa o valor absoluto do parâmetro float
Clamp(Float value, Float min, Float max)	Retorna um valor flutuante maior que o mínimo e menor que o máximo ou o mínimo se o valor for menor que o mínimo ou máximo se o valor for maior que o máximo
Max (Valor flutuante1, valor flutuante2)	Retorna o float maior entre o valor1 e o valor2.
Min (valor float1, valor float2)	Retorna o float menor entre value1 e value2.
Lerp(Float value1, Float value2, Float progress)	Retorna um float que representa o cálculo de interpolação linear calculado entre os dois valores escalares com base no progresso (Observação: o progresso está entre 0,0 e 1,0)
Slerp(Float value1, Float value2, Float progress)	Retorna um Float que representa a interpolação esférica calculada entre os dois valores float com base no progresso (Observação: o progresso está entre 0,0 e 1,0)
Mod(Float value1, Float value2)	Retorna o restante do Float resultante da divisão de value1 e value2
Ceil(Valor flutuante)	Retorna o parâmetro Float arredondado para o próximo número inteiro maior
Floor(Float value)	Retorna o parâmetro Float para o próximo número inteiro menor
Sqrt(Valor float)	Retorna a raiz quadrada do parâmetro Float
Square(Float value)	Retorna o quadrado do parâmetro Float
Sin(Float value1) Asin(Float value2)	Retorna o Sin ou ArcSin do parâmetro Float
Cos(Float value1) ACos(Float value2)	Retorna o Cos ou ArcCos do parâmetro Float
Tan(Float value1) ATan(Float value2)	Retorna o Tan ou ArcTan do parâmetro Float
Round(Float value)	Retorna o parâmetro Float arredondado para o número inteiro mais próximo
Log10(Valor flutuante)	Retorna o resultado de Log (base 10) do parâmetro Float
Ln(Valor float)	Retorna o resultado do Log Natural do parâmetro Float
Pow(Valor float, potência flutuante)	Retorna o resultado do parâmetro Float elevado a uma potência específica
ToDegrees(Radianos flutuantes)	Retorna o parâmetro Float convertido em Graus
ToRadians(Graus flutuantes)	Retorna o parâmetro Float convertido em Radians

Vector2

Operações de função e construtor	Descrição
Abs (valor Vector2)	Retorna um Vector2 com valor absoluto aplicado a cada componente
Clamp (Vector2 value1, Vector2 min, Vector2 max)	Retorna um Vector2 que contém os valores fixados para cada componente respectivo
Max (Vector2 value1, Vector2 value2)	Retorna um Vector2 que executou um Máximo em cada um dos componentes correspondentes de value1 e value2
Min (Vector2 value1, Vector2 value2)	Retorna um Vector2 que executou um Min em cada um dos componentes correspondentes de value1 e value2
Scale(Valor vector2, fator float)	Retorna um Vector2 com cada componente do vetor multiplicado pelo fator de dimensionamento.
Transform(valor Vector2, matriz Matrix3x2)	Retorna um Vector2 resultante da transformação linear entre um Vector2 e um Matrix3x2 (também conhecido como multiplicando um vetor por uma matriz).
Lerp(Vector2 value1, Vector2 value2, progresso escalar)	Retorna um Vector2 que representa o cálculo de interpolação linear calculado entre os dois valores Vector2 com base no progresso (Observação: o progresso está entre 0,0 e 1,0)
Length(Vector2 value)	Retorna um valor Float que representa o comprimento/magnitude do Vector2
LengthSquared(Vector2)	Retorna um valor Float que representa o quadrado do comprimento/magnitude de um Vector2
Distance(Vector2 value1, Vector2 value2)	Retorna um valor Float que representa a distância entre dois valores Vector2
DistanceSquared(Vector2 value1, Vector2 value2)	Retorna um valor Float que representa o quadrado da distância entre dois valores Vector2
Normalize(valor Vector2)	Retorna um Vector2 que representa o vetor de unidade do parâmetro em que todos os componentes foram normalizados
Vector2(Float x, Float y)	Constrói um Vector2 usando dois parâmetros Float

Vector3

Operações de função e construtor	Descrição
Abs (valor Vector3)	Retorna um Vector3 com valor absoluto aplicado a cada componente
Clamp (Vector3 value1, Vector3 min, Vector3 max)	Retorna um Vector3 que contém os valores fixados para cada componente respectivo
Max (Vector3 value1, Vector3 value2)	Retorna um Vector3 que executou um Máximo em cada um dos componentes correspondentes do valor1 e do valor2
Min (Vector3 value1, Vector3 value2)	Retorna um Vector3 que executou um Min em cada um dos componentes correspondentes de value1 e value2
Scale(Vector3 value, Float factor)	Retorna um Vector3 com cada componente do vetor multiplicado pelo fator de dimensionamento.
Lerp(Vector3 value1, Vector3 value2, Float progress)	Retorna um Vector3 que representa o cálculo de interpolação linear calculado entre os dois valores vector3 com base no progresso (Observação: o progresso está entre 0,0 e 1,0)
Length(Vector3 value)	Retorna um valor Float que representa o comprimento/magnitude do Vector3
LengthSquared(Vector3)	Retorna um valor Float que representa o quadrado do comprimento/magnitude de um Vector3
Distance(Vector3 value1, Vector3 value2)	Retorna um valor Float que representa a distância entre dois valores Vector3
DistanceSquared(Vector3 value1, Vector3 value2)	Retorna um valor Float que representa o quadrado da distância entre dois valores Vector3
Normalize(vector3 value)	Retorna um Vector3 que representa o vetor de unidade do parâmetro em que todos os componentes foram normalizados
Vector3(Float x, Float y, Float z)	Constrói um Vector3 usando três parâmetros Float

Vector4

Operações de função e construtor	Descrição
Abs (valor Vector4)	Retorna um Vector3 com valor absoluto aplicado a cada componente
Clamp (Vector4 value1, Vector4 min, Vector4 max)	Retorna um Vector4 que contém os valores fixados para cada componente respectivo
Max (Vector4 value1 Vector4 value2)	Retorna um Vector4 que executou um Máximo em cada um dos componentes correspondentes de value1 e value2
Min (Vector4 value1 Vector4 value2)	Retorna um Vector4 que executou um Min em cada um dos componentes correspondentes de value1 e value2
Scale(Vector3 value, Float factor)	Retorna um Vector3 com cada componente do vetor multiplicado pelo fator de dimensionamento.
Transform(valor Vector4, matriz Matrix4x4)	Retorna um Vector4 resultante da transformação linear entre um Vector4 e um Matrix4x4 (também conhecido como multiplicando um vetor por uma matriz).
Lerp(Vector4 value1, Vector4 value2, Float progress)	Retorna um Vector4 que representa o cálculo de interpolação linear calculado entre os dois valores Vector4 com base no progresso (Observação: o progresso está entre 0,0 e 1,0)
Length(Vector4 value)	Retorna um valor Float que representa o comprimento/magnitude do Vector4
LengthSquared(Vector4)	Retorna um valor Float que representa o quadrado do comprimento/magnitude de um Vector4
Distance(Vector4 value1, Vector4 value2)	Retorna um valor Float que representa a distância entre dois valores Vector4
DistanceSquared(Vector4 value1, Vector4 value2)	Retorna um valor Float que representa o quadrado da distância entre dois valores Vector4
Normalize(valor Vector4)	Retorna um Vector4 que representa o vetor de unidade do parâmetro em que todos os componentes foram normalizados
Vector4(Float x, Float y, Float z, Float w)	Constrói um Vector4 usando quatro parâmetros Float

Matrix3x2

Operações de função e construtor	Descrição
Scale(Matrix3x2 value, Float factor)	Retorna uma Matrix3x2 com cada componente da matriz multiplicado pelo fator de dimensionamento.
Inverso(Valor de matriz 3x2)	Retorna um objeto Matrix3x2 que representa a matriz recíproca
Matrix3x2(Float M11, Float M12, Float M21, Float M22, Float M31, Float M32)	Constrói uma Matrix3x2 usando 6 parâmetros float
Matrix3x2.CreateFromScale(escala Vector2)	Constrói uma Matrix3x2 de um Vector2 que representa a escala[escala. X, 0,0 0,0, escala. Y 0.0, 0.0 ]
Matrix3x2.CreateFromTranslation(tradução vector2)	Constrói uma Matrix3x2 de um Vector2 que representa a tradução[1.0, 0.0, 0.0, 1.0, Tradução. X, tradução. Y]
Matrix3x2.CreateSkew(Float x, Float y, Vector2 centerpoint)	Constrói um Matrix3x2 de dois Float e Vector2[1.0, Tan(y), Tan(x), 1.0, -centerpoint. Y * Tan(x), -centerpoint. X * Tan(y)]
Matrix3x2.CreateRotation(Float radians)	Constrói uma Matrix3x2 a partir de uma rotação em radianos[Cos(radians), Sin(radians), -Sin(radians), Cos(radians), 0.0, 0.0 ]
Matrix3x2.CreateTranslation(tradução vector2)	(Exatamente igual a CreateFromTranslation para Matrix3x2, nomenclatura diferente para nova consistência)
Matrix3x2.CreateScale(escala Vector2)	(Exatamente igual a CreateFromScale para Matrix3x2, nomenclatura diferente para nova consistência)

Matriz4x4

Operações de função e construtor	Descrição
Scale(Valor matrix4x4, fator float)	Retorna uma Matriz 4x4 com cada componente da matriz multiplicado pelo fator de dimensionamento.
Inverso(Matrix4x4)	Retorna um objeto Matrix4x4 que representa a matriz recíproca
Matrix4x4(Float M11, Float M12, Float M13, Float M14, Float M21, Float M22, Float M23, Float M24, Float M31, Float M32, Float M33, Float M34, Float M41, Float M42, Float M43, Float M44)	Constrói um Matrix4x4 usando 16 parâmetros float
Matrix4x4(matriz Matrix3x2)	Constrói uma Matriz4x4 usando um Matrix3x2[matrix.11, matrix.12, 0, 0, matrix.21, matrix.22, 0, 0, 0, 0, 1, 0, matrix.31, matrix.32, 0, 1]
Matrix4x4.CreateFromScale(Escala vector3)	Constrói uma Matrix4x4 de um Vector3 que representa a escala[escala. X, 0.0, 0.0, 0.0, 0,0, escala. Y, 0.0, 0.0, 0,0, 0,0, escala. Z, 0,0, 0.0, 0.0, 0.0, 1.0]
Matrix4x4.CreateFromTranslation(tradução vector3)	Constrói uma Matrix4x4 de um Vector3 que representa a tradução[1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, Tradução. X, tradução. Y, tradução. Z, 1,0]
Matrix4x4.CreateTranslation(tradução vector3)	(Exatamente igual a CreateFromTranslation para Matrix4x4, nomenclatura diferente para nova consistência)
Matrix4x4.CreateScale(Escala vector3)	(Exatamente igual a CreateFromScale para Matrix4x4, nomenclatura diferente para nova consistência)
Matrix4x4.CreateFromAxisAngle(eixo Vector3, ângulo float)	Constrói uma Matrix4x4 de um eixo Vector3 e um Float que representa um ângulo

Quaternion

Operações de função e construtor	Descrição
Slerp(Quaternion value1, Quaternion value2, Float progress)	Retorna um Quatérnio que representa a interpolação esférica calculada entre os dois valores quatérnios com base no progresso (Observação: o progresso está entre 0,0 e 1,0)
Concatenate(Quaternion value1 Quaternion value2)	Retorna um Quatérnio que representa uma concatenação de dois Quatérnios (também conhecido como Quatérnio que representa duas rotações individuais combinadas)
Length(Quaternion value)	Retorna um valor Float que representa o comprimento/magnitude do Quatérnio.
LengthSquared(Quaternion)	Retorna um valor Float que representa o quadrado do comprimento/magnitude de um Quatérnio
Normalize(valor quatérnio)	Retorna um Quatérnio cujos componentes foram normalizados
Quaternion.CreateFromAxisAngle(eixo Vector3, ângulo escalar)	Constrói um Quatérnio de um eixo Vector3 e um escalar que representa um ângulo
Quaternion(Float x, Float y, Float z, Float w)	Constrói um Quatérnio com base em quatro valores float

Cor

Operações de função e construtor	Descrição
ColorLerp(Color colorTo, Color colorFrom, Float progress)	Retorna um objeto Color que representa o valor de interpolação linear calculado entre dois objetos de cor com base em um determinado progresso. (Observação: o progresso está entre 0.0 e 1.0)
ColorLerpRGB(Color colorTo, Color ColorFrom, Float progress)	Retorna um objeto Color que representa o valor de interpolação linear calculado entre dois objetos com base em um determinado progresso no espaço de cores RGB.
ColorLerpHSL(Color colorTo, Color ColorFrom, Float progress)	Retorna um objeto Color que representa o valor de interpolação linear calculado entre dois objetos com base em um determinado progresso no espaço de cor HSL.
ColorRGB(Float a, Float r, Float g, Float b)	Constrói um objeto que representa a Cor definida pelos componentes ARGB. (Observação: os componentes ARGB estão entre 0,0 e 255,0)
ColorHsl(Float h, Float s, Float l)	Constrói um objeto que representa a Cor definida pelos componentes HSL (Observação: Hue é definido de 0 e 2pi)

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)
DispatcherQueue	Obtém o DispatcherQueue para o CompositionObject. (Herdado de CompositionObject)
Expression	A equação matemática que especifica como o valor animado é calculado a cada quadro. A Expressão é o núcleo de uma ExpressionAnimation e representa a equação que o sistema usará para calcular o valor da propriedade de animação de cada quadro. A equação é definida nessa propriedade na forma de uma cadeia de caracteres. Embora as expressões possam ser definidas por equações matemáticas simples, como "2+2", o poder real reside na criação de relações matemáticas em que os valores de entrada podem alterar quadro sobre quadro.
ImplicitAnimations	A coleção de animações implícitas anexadas a esse objeto. (Herdado de CompositionObject)
InitialValueExpressions	Obtém os valores iniciais da animação. (Herdado de CompositionAnimation)
Properties	A coleção de propriedades associadas ao CompositionObject. (Herdado de CompositionObject)
Target	O destino da animação. (Herdado de CompositionAnimation)

Métodos

Nome	Description
ClearAllParameters()	Limpa todos os parâmetros da animação. (Herdado de CompositionAnimation)
ClearParameter(String)	Limpa um parâmetro da animação. (Herdado de CompositionAnimation)
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)
SetBooleanParameter(String, Boolean)	Define um parâmetro de valor booliano para uso com um ExpressionAnimation ou um quadro-chave de expressão. (Herdado de CompositionAnimation)
SetColorParameter(String, Color)	Define um parâmetro de valor color para uso com um ExpressionAnimation ou um quadro-chave de expressão. (Herdado de CompositionAnimation)
SetExpressionReferenceParameter(String, IAnimationObject)	Define um objeto que implementa IAnimationObject como um parâmetro de referência em um ExpressionAnimation. (Herdado de CompositionAnimation)
SetMatrix3x2Parameter(String, Matrix3x2)	Define um parâmetro de valor Matrix3x2 para uso com um ExpressionAnimation ou um quadro-chave de expressão. (Herdado de CompositionAnimation)
SetMatrix4x4Parameter(String, Matrix4x4)	Define um parâmetro de valor Matrix4x4 para uso com um ExpressionAnimation ou um quadro-chave de expressão. (Herdado de CompositionAnimation)
SetQuaternionParameter(String, Quaternion)	Define um valor Quaternion para uso com um ExpressionAnimation ou um quadro-chave de expressão. (Herdado de CompositionAnimation)
SetReferenceParameter(String, CompositionObject)	Define uma referência a um objeto Composition para uso com um ExpressionAnimation ou um quadro-chave de expressão. (Herdado de CompositionAnimation)
SetScalarParameter(String, Single)	Define um parâmetro de valor escalar para uso com um ExpressionAnimation ou um quadro-chave de expressão. (Herdado de CompositionAnimation)
SetVector2Parameter(String, Vector2)	Define um parâmetro de valor Vector2 para uso com um ExpressionAnimation ou um quadro-chave de expressão. (Herdado de CompositionAnimation)
SetVector3Parameter(String, Vector3)	Define um parâmetro de valor Vector3 para uso com um ExpressionAnimation ou um quadro-chave de expressão. (Herdado de CompositionAnimation)
SetVector4Parameter(String, Vector4)	Define um parâmetro de valor Vector4 para uso com um ExpressionAnimation ou um quadro-chave de expressão. (Herdado de CompositionAnimation)
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)

Confira também

• Expression
• Documento de visão geral de animações