ExpressionAnimation Classe

Définition

Espace de noms:

Microsoft.UI.Composition

Animation de composition qui utilise une équation mathématique pour calculer la valeur d’une propriété d’animation à chaque image.

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

Héritage

Object Platform::Object IInspectable CompositionObject CompositionAnimation ExpressionAnimation

Attributs

ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Exemples

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

Remarques

Le cœur d’ExpressionAnimations permet à un développeur de définir une équation mathématique qui peut être utilisée pour calculer la valeur d’une propriété d’animation ciblée chaque image. Cela contraste les éléments KeyFrameAnimation , qui utilisent un interpolateur pour définir la façon dont la propriété d’animation change au fil du temps. L’équation mathématique peut être définie à l’aide de références aux propriétés des objets Composition, aux fonctions mathématiques et aux opérateurs et à l’entrée. Les animations d’expression ouvrent la porte à la création d’expériences telles que les en-têtes collants et la parallaxe facilement décriables.

Pour obtenir une procédure pas à pas détaillée de l’utilisation de Composition ExpressionAnimation, case activée le document Vue d’ensemble des animations.

Utilisez les méthodes CompositionObject.StartAnimation et CompositionObject.StopAnimation pour démarrer et arrêter l’animation.

En quoi les animations par expressions sont-elles utiles ?

Le véritable pouvoir des animations d’expression provient de leur capacité à créer une relation mathématique avec des références à des propriétés sur d’autres objets. Cela signifie que vous pouvez avoir une équation référençant des valeurs de propriété sur d’autres objets Composition, des variables locales ou même des valeurs partagées dans les jeux de propriétés de composition. À mesure que ces références changent et se mettent à jour au fil du temps, votre expression sera également. Cela ouvre de plus grandes possibilités au-delà des animations d’images clés traditionnelles, où les valeurs doivent être discrètes et prédéfinies . ExpressionAnimations peut créer des expériences d’animation plus dynamiques.

Points à noter

• ExpressionAnimation a une durée de vie infinie : ils continueront à s’exécuter jusqu’à ce qu’ils soient arrêtés explicitement.

• L’équation mathématique sera entrée dans l’expression sous la forme d’une chaîne . Cela peut être effectué lors de la construction de l’ExpressionAnimation ou séparément en modifiant la propriété. Si cette opération est effectuée pendant la construction, la propriété est définie. + ExpressionAnimation exp = _compositor. CreateExpressionAnimation() ; Exp. Expression = « this. Target.Offset.X / xWindowSize » ;

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

• L’équation mathématique sera utilisée chaque image pour calculer la valeur de la propriété d’animation (ce qui contraste fortement avec keyFrameAnimationqui utilise un interpolateur)

• Faites attention au type de la propriété que vous envisagez d’animer : votre équation doit se résoudre au même type. Dans le cas contraire, une erreur est générée lorsque l’expression est calculée. Si votre équation est résolue en Nan (nombre/0), le système utilise la valeur calculée précédemment

La clé pour créer une interface utilisateur d’animation dynamique avec des animations d’expression est de créer une équation dans laquelle les références aux propriétés ou à d’autres valeurs changeront au fil du temps.

Lorsqu’il est attaché à une propriété d’animation, le système utilise cette équation pour calculer la valeur de la propriété pour chaque image. Cela signifie que le système réévalue toutes les références qui entraînent les modifications apportées à l’équation. Par instance, dans l’exemple ci-dessus, si visual A ou B se déplace en raison d’une autre animation ou d’une autre entrée, l’angle de rotation du visuel de ligne change en conséquence en raison de l’équation.

Lors de la construction de l’équation mathématique, il existe un certain nombre de composants différents à garder à l’esprit (pour obtenir une procédure pas à pas détaillée de chacun de ces composants, consultez vue d’ensemble de l’animation) :

• Opérateurs, précédence et associativité + La chaîne Expression prend en charge l’utilisation d’opérateurs mathématiques classiques (+, -, /, , etc.) que vous attendez à utiliser dans n’importe quelle équation.

  • Lorsque l’expression est évaluée, elle adhère à la priorité et à l’associativité de l’opérateur, telles que définies dans la spécification du langage C#.

• Paramètres de propriété + Lors de la définition de votre expression, vous avez la possibilité de définir des références de type à d’autres propriétés sur des visuels de composition, des jeux de propriétés ou d’autres objets C#.

  • Pour utiliser dans une chaîne d’expression, utilisez les fonctions « SetParameter » en fonction du type, en définissant la chaîne utilisée dans la chaîne d’expression et sa valeur mappée. Ces fonctions sont répertoriées dans la classe CompositionAnimation de niveau supérieur.

• Fonctions d’assistance et constructeurs + L’expression peut également tirer parti d’une liste de fonctions et de constructeurs pour différents types d’objets dans l’équation.

  • Il existe également des méthodes de constructeur qui construisent un type d’objet lorsque l’équation est évaluée par le système
  • Une liste des fonctions par type est répertoriée ci-dessous.

• Mots clés + L’expression peut également tirer parti d’un certain nombre de mots clés traités différemment lorsque la chaîne d’expression est évaluée. Considérez ces mots clés et ne peuvent pas être utilisés comme clé de chaîne dans les références de propriété.

  • Liste des mots clés disponibles listés ci-dessous

• Conditionnels + Une expression peut également utiliser des instructions conditionnelles à l’aide de l’opérateur ternaire (condition ? ifTrue_expression : ifFalse_expression)

  • Les opérateurs ternaires peuvent être imbriqués en tant qu’expression pour les instructions true ou false.

Mots-clés d’expression

Mot clé	Description
This.StartingValue	Fournit une référence à la valeur de départ d’origine de la propriété animée.
This.CurrentValue	Fournit une référence à la valeur actuellement « connue » de la propriété
This.FinalValue	Fournit une référence à la valeur finale de l’animation (si définie) Remarque : Pertinent pour les animations implicites, pour explicite, conserve les mêmes fonctionnalités que This.StartingValue
Pi	Fournit une référence de mot-clé à la valeur de PI
True / False	Fournit une référence aux valeurs booléennes « true » ou « false »
This.Target	Fournit une référence à l’objet cible auquel les animations sont liées.

Fonctions d’expression par type

Scalaire

Fonction et opérations de constructeur	Description
Abs(valeur Float)	Retourne une valeur Float représentant la valeur absolue du paramètre Float
Clamp (valeur Float, Float min, Float max)	Retourne une valeur Float qui est supérieure à la valeur minimale et inférieure à la valeur maximale ou minimale si la valeur est inférieure à min ou max si la valeur est supérieure à la valeur maximale
Max (valeur1 de Float, valeur2 de Float)	Retourne la valeur Float supérieure entre la valeur1 et la valeur2.
Min (valeur1 de Float, valeur2 de Float)	Retourne la valeur Float inférieure entre la valeur1 et la valeur2.
Lerp(valeur1 de Float, valeur2 de Float, progression de Float)	Retourne une valeur Float qui représente le calcul d’une interpolation linéaire calculée entre les deux valeurs Scalar en fonction de la progression (Remarque : la progression se situe entre 0.0 et 1.0)
Slerp(valeur1 de Float, valeur2 de Float, progression de Float)	Retourne une valeur Float qui représente l’interpolation sphérique calculée entre les deux valeurs Float en fonction de la progression (Remarque : la progression se situe entre 0.0 et 1.0)
Mod(valeur1 de Float, valeur2 de Float)	Retourne le reste de la valeur Float résultant de la division des valeurs1 et 2
Ceil(valeur Float)	Retourne le paramètre Float arrondi au nombre entier supérieur suivant
Floor(valeur Float)	Retourne le paramètre Float arrondi au nombre entier inférieur suivant
Sqrt(valeur Float)	Retourne la racine carrée du paramètre Float
Square(valeur Float)	Retourne le carré du paramètre Float
Sin(Float value1) Asin(Float value2)	Retourne le sin ou ArcSin du paramètre Float
Cos(Float value1) ACos(Float value2)	Retourne les Cos ou ArcCos du paramètre Float
Tan(Float value1) ATan(Float value2)	Renvoie le Tan ou ArcTan du paramètre Float
Round(valeur Float)	Retourne le paramètre Float arrondi au nombre entier le plus proche
Log10(valeur Float)	Retourne le résultat Log (base 10) du paramètre Float
Ln(valeur Float)	Retourne le résultat Natural Log du paramètre Float
Pow (valeur Float, puissance Float)	Retourne le résultat du paramètre Float élevé à une puissance spécifique
ToDegrees(valeurs Float en radians)	Retourne le paramètre Float converti en degrés
ToRadians (degrés Float)	Retourne le paramètre Float converti en radians

Vector2

Fonction et opérations de constructeur	Description
Abs (valeur Vector2)	Retourne une valeur Vector2 avec une valeur absolue appliquée à chacun des composants
Clamp (valeur1 de Vector2, Vector2 min, Vector2 max)	Retourne un Vector2 contenant les valeurs limitées pour chaque composant respectif
Max (valeur1 de Vector2 , valeur2 de Vector2)	Retourne une valeur Vector2 ayant atteint une valeur Max sur chacun des composants correspondants de valeur1 et valeur2
Min (valeur1 de Vector2 , valeur2 de Vector2)	Retourne une valeur Vector2 ayant atteint une valeur Min sur chacun des composants correspondants de valeur1 et valeur2
Scale(valeur Vector2, facteur Float)	Retourne un Vector2 avec chaque composant du vecteur multiplié par le facteur d’échelle.
Transform(valeur Vector2, matrice Matrix3x2)	Retourne une valeur Vector2 résultant de la transformation linéaire entre Vector2 et Matrix3x2 (c’est-à-dire la multiplication d’un vecteur par une matrice).
Lerp(Vector2 value1, Vector2 value2, Scalar progress)	Retourne une valeur Vector2 qui représente le calcul d’une interpolation linéaire calculée entre les deux valeurs Vector2 en fonction de la progression (Remarque : la progression se situe entre 0.0 et 1.0)
Length(valeur Vector2)	Retourne une valeur Float qui représente la longueur/la magnitude de Vector2
LengthSquared(Vector2)	Retourne une valeur Float qui représente le carré de la longueur/la magnitude d’une valeur Vector2
Distance(valeur1 de Vector2 , valeur2 de Vector2)	Retourne une valeur Float qui représente la distance entre deux valeurs Vector2
DistanceSquared(valeur1 de Vector2 , valeur2 de Vector2)	Retourne une valeur Float qui représente le carré de la distance entre deux valeurs Vector2
Normalize(valeur Vector2)	Retourne une valeur Vector2 représentant le vecteur unitaire du paramètre dans lequel tous les composants ont été normalisés
Vector2(Float x et Float y)	Crée un Vector2 à l’aide de deux paramètres Float

Vector3

Fonction et opérations de constructeur	Description
Abs (valeur Vector3)	Retourne une valeur Vector3 avec une valeur absolue appliquée à chacun des composants
Clamp (valeur1 de Vector3, Vector3 min, Vector3 max)	Retourne une valeur Vector3 contenant les valeurs limitées pour chaque composant respectif
Max (valeur1 de Vector3, valeur2 de Vector3)	Retourne une valeur Vector3 ayant atteint une valeur Max sur chacun des composants correspondants de valeur1 et valeur2
Min (valeur1 de Vector3, valeur2 de Vector3)	Retourne une valeur Vector3 ayant atteint une valeur Min sur chacun des composants correspondants de valeur1 et valeur2
Scale(valeur Vector3, facteur Float)	Retourne un Vector3 avec chaque composant du vecteur multiplié par le facteur d’échelle.
Lerp(valeur1 de Vector3, valeur2 de Vector3, progression de Float)	Retourne une valeur Vector3 qui représente le calcul d’une interpolation linéaire calculée entre les deux valeurs Vector3 en fonction de la progression (Remarque : la progression se situe entre 0.0 et 1.0)
Length(valeur de Vector3)	Retourne une valeur Float qui représente la longueur/la magnitude de Vector3
LengthSquared(Vector3)	Retourne une valeur Float qui représente le carré de la longueur/la magnitude d’une valeur Vector3
Distance(valeur1 de Vector3, valeur2 de Vector3)	Retourne une valeur Float qui représente la distance entre deux valeurs Vector3
DistanceSquared(valeur1 de Vector3, valeur2 de Vector3)	Retourne une valeur Float qui représente le carré de la distance entre deux valeurs Vector3
Normalize(valeur Vector3)	Retourne une valeur Vector3 représentant le vecteur unitaire du paramètre dans lequel tous les composants ont été normalisés
Vector3(Float x, Float y, Float z)	Crée un Vector3 à l’aide de trois paramètres Float

Vector4

Fonction et opérations de constructeur	Description
Abs (valeur Vector4)	Retourne une valeur Vector3 avec une valeur absolue appliquée à chacun des composants
Clamp (valeur1 de Vector4, Vector4 min, Vector4 max)	Retourne une valeur Vector4 contenant les valeurs limitées pour chaque composant respectif
Max (valeur1 de Vector4, valeur2 de Vector4)	Retourne une valeur Vector4 ayant atteint une valeur Max sur chacun des composants correspondants de valeur1 et valeur2
Min (valeur1 de Vector4, valeur2 de Vector4)	Retourne une valeur Vector4 ayant atteint une valeur Min sur chacun des composants correspondants de valeur1 et valeur2
Scale(valeur Vector3, facteur Float)	Retourne un Vector3 avec chaque composant du vecteur multiplié par le facteur d’échelle.
Transform(valeur Vector4, matrice Matrix4x4)	Retourne une valeur Vector4 résultant de la transformation linéaire entre Vector4 et Matrix4x4 (c’est-à-dire la multiplication d’un vecteur par une matrice).
Lerp(valeur1 de Vector4, valeur2 de Vector4, progression de Float)	Retourne une valeur Vector4 qui représente le calcul d’une interpolation linéaire calculée entre les deux valeurs Vector4 en fonction de la progression (Remarque : la progression se situe entre 0.0 et 1.0)
Length(valeur Vector4)	Retourne une valeur Float qui représente la longueur/la magnitude de Vector4
LengthSquared(Vector4)	Retourne une valeur Float qui représente le carré de la longueur/la magnitude d’une valeur Vector4
Distance(valeur1 de Vector4, valeur2 de Vector4)	Retourne une valeur Float qui représente la distance entre deux valeurs Vector4
DistanceSquared(valeur1 de Vector4, valeur2 de Vector4)	Retourne une valeur Float qui représente le carré de la distance entre deux valeurs Vector4
Normalize(valeur de Vector4)	Retourne une valeur Vector4 représentant le vecteur unitaire du paramètre dans lequel tous les composants ont été normalisés
Vector4(Float x, Float y, Float w)	Crée un Vector4 à l’aide de quatre paramètres Float

Matrix3x2

Fonction et opérations de constructeur	Description
Scale(valeur Matrix3x2, facteur Float)	Retourne une Matrix3x2 avec chaque composant de la matrice multiplié par le facteur d’échelle.
Inverse(valeur de Matrix3x2)	Renvoie un objet Matrix3x2 représentant la matrice réciproque.
Matrix3x2(Float M11, Float M12, Float M21, Float M22, Float M31, Float M32)	Crée une matrice Matrix3x2 à l’aide de six paramètres Float
Matrix3x2.CreateFromScale(échelle Vector2)	Construit un matrix3x2 à partir d’un vecteur2 représentant scale[scale. X, 0,0 0.0, scale.Y 0.0, 0.0 ]
Matrix3x2.CreateFromTranslation(translation de Vector2)	Construit un Matrix3x2 à partir d’un vecteur2 représentant la traduction[1.0, 0.0, 0.0, 1.0, Translation. X, traduction. Y]
Matrix3x2.CreateSkew (Float x, Float y, point central Vector2)	Construit un Matrix3x2 à partir de deux float et vector2[1.0, Tan(y), Tan(x), 1.0, -Centerpoint. Y * Tan(x), -centerpoint. X * Tan(y)]
Matrix3x2.CreateRotation (radians Float)	Construit un Matrix3x2 à partir d’une rotation en radians[Cos(radians), Sin(radians), -Sin(radians), Cos(radians), 0.0, 0.0 ]
Matrix3x2.CreateTranslation(translation de Vector2)	(Exactement identique à CreateFromTranslation pour Matrix3x2, juste un nom différent pour une nouvelle cohérence)
Matrix3x2.CreateScale(échelle Vector2)	(Exactement identique à CreateFromScale pour Matrix3x2, nommage juste différent pour une nouvelle cohérence)

Matrix4x4

Fonction et opérations de constructeur	Description
Scale(valeur Matrix4x4, facteur Float)	Retourne une matrice Matrix4x4 avec chaque composant de la matrice multiplié par le facteur d’échelle.
Inverse(Matrix4x4)	Renvoie un objet Matrix4x4 représentant la matrice réciproque.
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)	Crée une matrice Matrix4x4 à l’aide de 16 paramètres Float
Matrix4x4(matrice Matrix3x2)	Construit un Matrix4x4 à l’aide d’un 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(échelle Vector3)	Construit un Matrix4x4 à partir d’un vecteur3 représentant 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(translation de Vector3)	Construit un Matrix4x4 à partir d’un vector3 représentant la traduction[1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, Translation. X, traduction. Y, traduction. Z, 1.0]
Matrix4x4.CreateTranslation(translation de Vector3)	(Exactement identique à CreateFromTranslation pour Matrix4x4, juste un nom différent pour une nouvelle cohérence)
Matrix4x4.CreateScale(échelle Vector3)	(Exactement identique à CreateFromScale pour Matrix4x4, juste un nom différent pour une nouvelle cohérence)
Matrix4x4.CreateFromAxisAngle(axe Vector3, angle Float)	Crée une matrice Matrix4x4 à partir d’un axe Vector3 et d’une valeur Float représentant un angle

Quaternion

Fonction et opérations de constructeur	Description
Slerp(valeur1 de Quaternion, valeur2 de Quaternion, progression de Float)	Retourne une valeur Quaternion qui représente l’interpolation sphérique calculée entre les deux valeurs Quaternion en fonction de la progression (Remarque : la progression se situe entre 0.0 et 1.0)
Concatenate(valeur1 de Quaternion, valeur2 de Quaternion)	Retourne une valeur Quaternion qui représente la concaténation de deux Quaternions (c’est-à-dire, un Quaternion qui représente deux rotations individuelles combinées)
Length(valeur Quaternion)	Retourne une valeur Float qui représente la longueur/la magnitude du Quaternion.
LengthSquared(Quaternion)	Retourne une valeur Float qui représente le carré de la longueur/la magnitude d’un Quaternion
Normalize(valeur Quaternion)	Retourne un Quaternion dont les composants ont été normalisés
Quaternion.CreateFromAxisAngle(axe Vector3, angle Scalar)	Crée un Quaternion à partir d’un axe Vector3 et d’une valeur Scalar représentant un angle
Quaternion(Float x, Float y, Float z, Float w)	Crée un Quaternion à partir de quatre valeurs Float

Couleur

Fonction et opérations de constructeur	Description
ColorLerp(colorTo de Color, colorFrom de Color, progression de Float)	Retourne un objet Color représentant la valeur calculée d’une interpolation linéaire entre deux objets Color, en fonction d’une progression donnée. (Remarque : la progression se situe entre 0.0 et 1.0)
ColorLerpRGB(colorTo de Color, colorFrom de Color, progression de Float)	Retourne un objet Color représentant la valeur calculée d’une interpolation linéaire entre deux objets, en fonction d’une progression donnée dans l’espace de couleur RVB.
ColorLerpHSL(colorTo de Color, colorFrom de Color, progression de Float)	Retourne un objet Color représentant la valeur calculée d’une interpolation linéaire entre deux objets, en fonction d’une progression donnée dans l’espace de couleur HSL.
ColorRGB(Float a, Float r, Float g, Float b)	Construit un objet représentant la couleur définie par les composants ARGB. (Remarque : Les composants ARGB sont compris entre 0,0 et 255,0)
ColorHsl(Float h, Float s, Float l)	Crée un objet représentant Color, défini par les composants HSL (Remarque : la teinte Hue est définie entre 0 et 2pi)

Propriétés

Comment	Chaîne à associer à CompositionObject. (Hérité de CompositionObject)
Compositor	Compositor utilisé pour créer cet Objet CompositionObject. (Hérité de CompositionObject)
DispatcherQueue	Obtient le DispatcherQueue pour l’objet CompositionObject. (Hérité de CompositionObject)
Expression	Équation mathématique spécifiant la façon dont la valeur animée est calculée chaque image. L’expression est le cœur d’une ExpressionAnimation et représente l’équation que le système utilisera pour calculer la valeur de la propriété d’animation de chaque image. L’équation est définie sur cette propriété sous la forme d’une chaîne. Bien que les expressions puissent être définies par des équations mathématiques simples telles que « 2+2 », le pouvoir réel réside dans la création de relations mathématiques où les valeurs d’entrée peuvent changer d’image sur image.
ImplicitAnimations	Collection d’animations implicites attachées à cet objet. (Hérité de CompositionObject)
InitialValueExpressions	Obtient les valeurs initiales de l’animation. (Hérité de CompositionAnimation)
Properties	Collection de propriétés associées à CompositionObject. (Hérité de CompositionObject)
Target	Cible de l’animation. (Hérité de CompositionAnimation)

Méthodes

ClearAllParameters()	Efface tous les paramètres de l’animation. (Hérité de CompositionAnimation)
ClearParameter(String)	Efface un paramètre de l’animation. (Hérité de CompositionAnimation)
Close()	Ferme l’objet CompositionObject et libère les ressources système. (Hérité de CompositionObject)
Dispose()	Exécute les tâches définies par l'application associées à la libération ou à la redéfinition des ressources non managées. (Hérité de CompositionObject)
PopulatePropertyInfo(String, AnimationPropertyInfo)	Définit une propriété qui peut être animée. (Hérité de CompositionObject)
SetBooleanParameter(String, Boolean)	Définit un paramètre de valeur booléenne à utiliser avec une image cléExpressionAnimation ou expression. (Hérité de CompositionAnimation)
SetColorParameter(String, Color)	Définit un paramètre de valeur de couleur à utiliser avec une image cléExpressionAnimation ou expression. (Hérité de CompositionAnimation)
SetExpressionReferenceParameter(String, IAnimationObject)	Définit un objet qui implémente IAnimationObject en tant que paramètre de référence dans une ExpressionAnimation. (Hérité de CompositionAnimation)
SetMatrix3x2Parameter(String, Matrix3x2)	Définit un paramètre de valeur Matrix3x2 à utiliser avec une image cléExpressionAnimation ou expression. (Hérité de CompositionAnimation)
SetMatrix4x4Parameter(String, Matrix4x4)	Définit un paramètre de valeur Matrix4x4 à utiliser avec une image cléExpressionAnimation ou expression. (Hérité de CompositionAnimation)
SetQuaternionParameter(String, Quaternion)	Définit une valeur quaternion à utiliser avec une image cléExpressionAnimation ou expression. (Hérité de CompositionAnimation)
SetReferenceParameter(String, CompositionObject)	Définit une référence à un objet Composition à utiliser avec une image cléExpressionAnimation ou expression. (Hérité de CompositionAnimation)
SetScalarParameter(String, Single)	Définit un paramètre de valeur scalaire à utiliser avec une image cléExpressionAnimation ou expression. (Hérité de CompositionAnimation)
SetVector2Parameter(String, Vector2)	Définit un paramètre de valeur Vector2 à utiliser avec une image cléExpressionAnimation ou expression. (Hérité de CompositionAnimation)
SetVector3Parameter(String, Vector3)	Définit un paramètre de valeur Vector3 à utiliser avec une image cléExpressionAnimation ou expression. (Hérité de CompositionAnimation)
SetVector4Parameter(String, Vector4)	Définit un paramètre de valeur Vector4 à utiliser avec une image cléExpressionAnimation ou expression. (Hérité de CompositionAnimation)
StartAnimation(String, CompositionAnimation, AnimationController)	Connecte une animation à la propriété spécifiée de l’objet et démarre l’animation. (Hérité de CompositionObject)
StartAnimation(String, CompositionAnimation)	Connecte une animation à la propriété spécifiée de l’objet et démarre l’animation. (Hérité de CompositionObject)
StartAnimationGroup(ICompositionAnimationBase)	Démarre un groupe d’animations. La méthode StartAnimationGroup sur CompositionObject vous permet de démarrer CompositionAnimationGroup. Toutes les animations du groupe seront démarrées en même temps sur l’objet. (Hérité de CompositionObject)
StopAnimation(String)	Déconnecte une animation de la propriété spécifiée et arrête l’animation. (Hérité de CompositionObject)
StopAnimationGroup(ICompositionAnimationBase)	Arrête un groupe d’animations. (Hérité de CompositionObject)
TryGetAnimationController(String)	Renvoie un AnimationController pour l’animation en cours d’exécution sur la propriété spécifiée. (Hérité de CompositionObject)

Voir aussi

• Expression
• Document vue d’ensemble des animations