ExpressionAnimation Classe
Definição
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Uma Animação de Composição que usa uma equação matemática para calcular o valor de uma propriedade animadora a cada quadro.
public ref class ExpressionAnimation sealed : CompositionAnimation/// [Windows.Foundation.Metadata.ContractVersion(Windows.Foundation.UniversalApiContract, 65536)]
/// [Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
/// [Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
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(Windows.Foundation.UniversalApiContract, 131072)]
class ExpressionAnimation final : CompositionAnimation[Windows.Foundation.Metadata.ContractVersion(typeof(Windows.Foundation.UniversalApiContract), 65536)]
[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
[Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
public sealed class ExpressionAnimation : CompositionAnimation[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
[Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
[Windows.Foundation.Metadata.ContractVersion(typeof(Windows.Foundation.UniversalApiContract), 131072)]
public sealed class ExpressionAnimation : CompositionAnimationPublic NotInheritable Class ExpressionAnimation
Inherits CompositionAnimation- Herança
- Atributos
Requisitos do Windows
| Família de dispositivos |
Windows 10 (introduzida na 10.0.10240.0)
|
| API contract |
Windows.Foundation.UniversalApiContract (introduzida na v1.0)
|
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 composition, funções matemáticas e operadores e Input. 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, marcar o documento Visão geral de animações.
Use os métodos CompostionObject.StartAnimation e CompostionObject.StopAnimation para iniciar e parar a animação.
Para obter uma lista de propriedades animáveis, consulte os comentários em CompostionObject.StartAnimation.
Então por que as 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 composition, 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 mudará. Isso abre possibilidades maiores além das animações tradicionais de quadro-chave, 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 o ExpressionAnimation ou separadamente alterando a propriedade . Se terminar durante a construção, a propriedade será definida.
ExpressionAnimation exp = _compositor.CreateExpressionAnimation(); exp.Expression = "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 contrasta fortemente com KeyFrameAnimations que usam um interpolador)
Preste atenção ao tipo da propriedade que você planeja animar – sua equação deve resolve 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 uma 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 capacidade de associação
- 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 do operador e à associatividade, 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 para 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.
- Também há 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
Condicionais
- 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 true ou false.
Palavras-chave de expressão
| Palavra-chave | Descrição |
|---|---|
| This.StartingValue | Fornece uma referência ao valor original inicial 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 construtor e função | Descrição |
|---|---|
| Abs(Float value) | Retorna um Float que representa o valor absoluto do parâmetro float |
| Clamp(Float value, Float min, Float max) | Retorna um valor float maior que min e menor que max ou min se o valor for menor que min ou max se o valor for maior que max |
| Max (Float value1, Float value2) | Retorna o maior flutuante entre value1 e value2. |
| Min (Float value1, Float value2) | Retorna o menor flutuante entre value1 e value2. |
| Lerp(Float value1, Float value2, Float progress) | Retorna um flutuante que representa o cálculo de interpolação linear calculada entre os dois valores escalares com base no andamento (Observação: o andamento é entre 0,0 e 1,0) |
| Slerp(Float value1, Float value2, Float progress) | Retorna um flutuante que representa a interpolação esférica calculada entre os dois valores flutuantes com base no andamento (Observação: o andamento é entre 0,0 e 1,0) |
| Mod(Float value1, Float value2) | Retorna o flutuante resultante da divisão de value1 e value2 |
| Ceil(Float value) | 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(Float value) | 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(Float value) | Retorna o resultado de Log (base 10) do parâmetro Float |
| Ln(Float value) | Retorna o resultado de Log Natural do parâmetro Float |
| Pow(Float value, Float power) | Retorna o resultado do parâmetro Float elevado a uma potência específica |
| ToDegrees(Float radians) | Retorna o parâmetro Float convertido em graus |
| ToRadians (graus Float) | Retorna o parâmetro Float convertido em radianos |
Vector2
| Operações de construtor e função | Descrição |
|---|---|
| Abs (Vector2 value) | 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 vinculados para cada componente respectivo |
| Max (Vector2 value1, Vector2 value2) | Retorna um Vector2 que executou um Máx em cada um dos componentes correspondentes de value1 e value2 |
| Min (Vector2 value1, Vector2 value2) | Retorna um Vector2 que executou um Mín em cada um dos componentes correspondentes de value1 e value2 |
| Scale(Vector2 value, Float factor) | Retorna um Vector2 com cada componente do vetor multiplicado pelo fator de dimensionamento. |
| Transform(Vector2 value, Matrix3x2 matrix) | Retorna um Vector2 resultante da transformação linear entre um Vector2 e um Matrix3x2 (também conhecido como multiplicação de um vetor por uma matriz). |
| Lerp(Vector2 value1, Vector2 value2, Scalar progress) | Retorna um Vector2 que representa o cálculo de interpolação linear calculada entre os dois valores Vector2 com base no andamento (Observação: o andamento é entre 0,0 e 1,0) |
| Length(Vector2 value) | Retorna um valor flutuante que representa o comprimento/magnitude do Vector2 |
| LengthSquared (Vector2) | Retorna um valor flutuante que representa o quadrado do comprimento/magnitude de um Vector2 |
| Distance(Vector2 value1, Vector2 value2) | Retorna um valor flutuante que representa a distância entre dois valores de Vector2 |
| DistanceSquared (value1 Vector2, value2 Vector2) | Retorna um valor flutuante que representa o quadrado da distância entre dois valores de Vector2 |
| Normalize(Vector2 value) | Retorna um Vector2 que representa o vetor unitário do parâmetro onde todos os componentes foram normalizados |
| Vector2 (Float x, Float y) | Constroi um Vector2 usando dois parâmetros Float |
Vector3
| Operações de construtor e função | Descrição |
|---|---|
| Abs (Vector3 value) | 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 vinculados para cada componente respectivo |
| Max (Vector3 value1, Vector3 value2) | Retorna um Vector3 que executou um Máx em cada um dos componentes correspondentes de value1 e value2 |
| Min (Vector3 value1, Vector3 value2) | Retorna um Vector3 que executou um Mín 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 calculada entre os dois valores Vector3 com base no andamento (Observação: o andamento é entre 0,0 e 1,0) |
| Length(Vector3 value) | Retorna um valor flutuante que representa o comprimento/magnitude do Vector3 |
| LengthSquared(Vector3) | Retorna um valor flutuante que representa o quadrado do comprimento/magnitude de um Vector3 |
| Distance(Vector3 value1, Vector3 value2) | Retorna um valor flutuante que representa a distância entre dois valores de Vector3 |
| DistanceSquared(Vector3 value1, Vector3 value2) | Retorna um valor flutuante que representa o quadrado da distância entre dois valores de Vector3 |
| Normalize(Vector3 value) | Retorna um Vector3 que representa o vetor unitário do parâmetro onde todos os componentes foram normalizados |
| Vector3(Float x, Float y, Float z) | Constroi um Vector3 usando três parâmetros Float |
Vector4
| Operações de construtor e função | Descrição |
|---|---|
| Abs (Vector4 value) | 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 vinculados para cada componente respectivo |
| Max (Vector4 value1 Vector4 value2) | Retorna um Vector4 que executou um Máx em cada um dos componentes correspondentes de value1 e value2 |
| Min (Vector4 value1 Vector4 value2) | Retorna um Vector4 que executou um Mín 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(Vector4 value, Matrix4x4 matrix) | Retorna um Vector4 resultante da transformação linear entre um Vector4 e um Matrix4x4 (também conhecido como multiplicação de um vetor por uma matriz). |
| Lerp(Vector4 value1, Vector4 value2, Float progress) | Retorna um Vector4 que representa o cálculo de interpolação linear calculada entre os dois valores Vector4 com base no andamento (Observação: o andamento é entre 0,0 e 1,0) |
| Length(Vector4 value) | Retorna um valor flutuante que representa o comprimento/magnitude do Vector4 |
| LengthSquared(Vector4) | Retorna um valor flutuante que representa o quadrado do comprimento/magnitude de um Vector4 |
| Distance(Vector4 value1, Vector4 value2) | Retorna um valor flutuante que representa a distância entre dois valores de Vector4 |
| DistanceSquared(Vector4 value1, Vector4 value2) | Retorna um valor flutuante que representa o quadrado da distância entre dois valores de Vector4 |
| Normalize(Vector4 value) | Retorna um Vector4 que representa o vetor unitário do parâmetro onde todos os componentes foram normalizados |
| Vector4(Float x, Float y, Float z, Float w) | Constroi um Vector4 usando quatro parâmetros Float |
Matrix3x2
| Operações de construtor e função | Descrição |
|---|---|
| Scale(Matrix3x2 value, Float factor) | Retorna um Matrix3x2 com cada componente da matriz multiplicado pelo fator de dimensionamento. |
| Inverse(Matrix 3x2 value) | Retorna um objeto Matrix3x2 que representa a matriz recíproca |
| Matrix3x2(Float M11, Float M12, Float M21, Float M22, Float M31, Float M32) | Constroi uma Matrix3x2 usando 6 parâmetros Float |
| Matrix3x2.CreateFromScale(Vector2 scale) | Constrói uma Matrix3x2 de um Vector2 que representa scale[scale. X, 0,0 0.0, scale.Y 0.0, 0.0 ] |
| Matrix3x2.CreateFromTranslation(Vector2 translation) | Constrói um 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(radianos), Sin(radians), -Sin(radians), Cos(radians), 0.0, 0.0 ] |
| Matrix3x2.CreateTranslation(Vector2 translation) | (Exatamente igual a CreateFromTranslation para Matrix3x2, apenas uma nomenclatura diferente para nova consistência) |
| Matrix3x2.CreateScale(Vector2 scale) | (Exatamente igual a CreateFromScale para Matrix3x2, apenas uma nomenclatura diferente para nova consistência) |
Matrix4x4
| Operações de construtor e função | Descrição |
|---|---|
| Scale(Matrix4x4 value, Float factor) | Retorna uma Matrix4x4 com cada componente da matriz multiplicado pelo fator de dimensionamento. |
| Inverse(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) | Constroi uma Matrix4x4 usando 16 parâmetros Float |
| Matrix4x4(Matrix3x2 matrix) | Constrói uma Matrix4x4 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(Vector3 scale) | Constrói uma Matrix4x4 de um Vector3 que representa scale[scale. X, 0.0, 0.0, 0.0, 0.0, scale.Y, 0.0, 0.0, 0.0, 0.0, scale.Z, 0.0, 0.0, 0.0, 0.0, 1.0] |
| Matrix4x4.CreateFromTranslation(Vector3 translation) | 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(Vector3 translation) | (Exatamente igual a CreateFromTranslation para Matrix4x4, apenas uma nomenclatura diferente para nova consistência) |
| Matrix4x4.CreateScale(Vector3 scale) | (Exatamente igual a CreateFromScale para Matrix4x4, apenas nomeação diferente para nova consistência) |
| Matrix4x4.CreateFromAxisAngle(Vector3 axis, Float angle) | Constroi uma Matrix4x4 de um eixo Vector3 e Float que representa um ângulo |
Quatérnion
| Operações de construtor e função | Descrição |
|---|---|
| Slerp(Quaternion value1, Quaternion value2, Float progress) | Retorna um Quatérnion que representa a interpolação esférica calculada entre os dois valores flutuantes Quatérnion com base no andamento (Observação: o andamento é entre 0,0 e 1,0) |
| Concatenate(Quaternion value1 Quaternion value2) | Retorna um Quatérnion que representa uma concatenação de dois Quatérnions (também conhecido como um Quatérnion que representa duas rotações individuais combinadas) |
| Length(Quaternion value) | Retorna um valor flutuante que representa o comprimento/magnitude do Quatérnion. |
| LengthSquared(Quaternion) | Retorna um valor flutuante que representa o quadrado do comprimento/magnitude de um Quatérnion |
| Normalize(Quaternion value) | Retorna um Quatérnion cujos componentes foram normalizados |
| Quaternion.CreateFromAxisAngle(Vector3 axis, Scalar angle) | Constroi um Quatérnion de um eixo Vector3 e um escalar que representa um ângulo |
| Quaternion(Float x, Float y, Float z, Float w) | Constrói um Quatérnion de quatro valores flutuantes |
Cor
| Operações de construtor e função | Descrição |
|---|---|
| ColorLerp(Color colorTo, Color colorFrom, Float progress) | Retorna um objeto de cor que representa o valor calculado de interpolação linear entre dois objetos de cor com base em um andamento determinado. (Observação: o progresso é entre 0,0 e 1,0) |
| ColorLerpRGB(Color colorTo, Color colorFrom, Float progress) | Retorna um objeto de cor que representa o valor calculado de interpolação linear entre dois objetos com base em um andamento determinado no espaço de cores RGB. |
| ColorLerpHSL(Color colorTo, Color colorFrom, Float progress) | Retorna um objeto de cor que representa o valor calculado de interpolação linear entre dois objetos com base em um andamento determinado no espaço de cores 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 por componentes HSL (Observação: matiz definido de 0 e 2pi) |
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) |
| Expression |
A equação matemática que especifica como o valor animado é calculado a cada quadro. A Expressão é o núcleo de um 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 está na criação de relações matemáticas em que os valores de entrada podem alterar o quadro sobre o 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) |