ExpressionAnimation Classe

Definizione

Spazio dei nomi:

Microsoft.UI.Composition

Animazione di composizione che usa un'equazione matematica per calcolare il valore di una proprietà di animazione a ogni fotogramma.

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

Ereditarietà

Object Platform::Object IInspectable CompositionObject CompositionAnimation ExpressionAnimation

Attributi

ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

Esempio

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

Commenti

Il nucleo di ExpressionAnimations consente a uno sviluppatore di definire un'equazione matematica che può essere usata per calcolare il valore di una proprietà di animazione di destinazione per ogni fotogramma. Ciò contrasta KeyFrameAnimation s, che usa un interpolatore per definire il modo in cui la proprietà di animazione cambia nel tempo. L'equazione matematica può essere definita usando riferimenti alle proprietà di oggetti Composition, funzioni matematiche e operatori e Input. Le animazioni di espressioni aprono la porta per creare esperienze come intestazioni permanenti e parallasse facilmente descrittibili.

Per una procedura dettagliata sull'uso di Composition ExpressionAnimation, vedere il documento Cenni preliminari sulle animazioni.

Utilizzare i metodi CompositionObject.StartAnimation e CompositionObject.StopAnimation per avviare e arrestare l'animazione.

Perché le animazioni delle espressioni sono utili?

La vera potenza delle animazioni di espressioni deriva dalla loro capacità di creare una relazione matematica con riferimenti alle proprietà su altri oggetti. Ciò significa che è possibile avere un'equazione che fa riferimento ai valori delle proprietà su altri oggetti Composition, variabili locali o anche valori condivisi nei set di proprietà di composizione. Man mano che questi riferimenti cambiano e aggiornano nel tempo, anche l'espressione verrà modificata. Ciò apre maggiori possibilità oltre alle tradizionali animazioni basate su fotogrammi chiave in cui i valori devono essere discreti e predefiniti: ExpressionAnimations può rendere più esperienze di animazione dinamiche.

Aspetti da considerare

• ExpressionAnimation ha una durata infinita: continueranno a essere eseguite fino a quando non vengono arrestate in modo esplicito.

• L'equazione matematica verrà inserita nell'espressione come stringa. Questa operazione può essere eseguita quando si costruisce ExpressionAnimation o separatamente modificando la proprietà . Se eseguita durante la costruzione, la proprietà verrà impostata. + EspressioneAnimation exp = _compositor. CreateExpressionAnimation(); Exp. Espressione = "this. Target.Offset.X / xWindowSize";

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

• L'equazione matematica verrà usata ogni fotogramma per calcolare il valore della proprietà di animazione (questo è in contrasto con keyFrameAnimations che usa un interpolatore)

• Prestare attenzione al tipo della proprietà che si prevede di animare: l'equazione deve risolversi nello stesso tipo. In caso contrario, viene generato un errore quando l'espressione viene calcolata. Se l'equazione si risolve in Nan (numero/0), il sistema userà il valore calcolato in precedenza

La chiave per creare un'interfaccia utente di animazione dinamica con animazioni di espressione consiste nel creare un'equazione in cui i riferimenti alle proprietà o ad altri valori cambieranno nel tempo.

Se associato a una proprietà di animazione, il sistema utilizzerà questa equazione per calcolare il valore della proprietà per ogni fotogramma. Ciò significa che, di conseguenza, il sistema rivaluta tutti i riferimenti che determineranno modifiche all'equazione. Ad esempio, nell'esempio precedente, se Visual A o B si sposta a causa di un'altra animazione o input, l'angolo di rotazione dell'oggetto visivo linea cambierà di conseguenza a causa dell'equazione.

Quando si costruisce l'equazione matematica, esistono diversi componenti da tenere presenti (Per una procedura dettagliata di ognuno di questi componenti, vedere Cenni preliminari sull'animazione):

• Operatori, precedenza e associatività + La stringa di espressione supporta l'utilizzo di operatori matematici tipici (+, -, /, e così via) che ci si aspetterebbe di usare in qualsiasi equazione.

  • Quando l'espressione viene valutata, verrà rispettata la precedenza e l'associatività degli operatori, come definito nella specifica del linguaggio C#.

• Parametri proprietà + Quando si definisce l'espressione, è possibile definire riferimenti di tipo ad altre proprietà negli oggetti visivi di composizione, set di proprietà o altri oggetti C#.

  • Per usare in una stringa di espressione, utilizzare le funzioni "SetParameter" in base al tipo, definendo la stringa utilizzata nella stringa di espressione e il relativo valore mappato. Queste funzioni sono elencate come parte della classe CompositionAnimation di primo livello.

• Funzioni helper e costruttori + L'espressione può anche sfruttare un elenco di funzioni e costruttori per diversi tipi di oggetto nell'equazione.

  • Esistono anche metodi del costruttore che costrutteranno un tipo di oggetto quando l'equazione viene valutata dal sistema
  • Di seguito è riportato un elenco delle funzioni per tipo

• Le parole chiave e l'espressione possono anche sfruttare una serie di parole chiave trattate in modo diverso quando viene valutata la stringa di espressione. Si considerino queste parole chiave e non possono essere usate come chiave stringa nei riferimenti alle proprietà.

  • Elenco delle parole chiave disponibili elencate di seguito

• Condizionali e un'espressione possono usare anche istruzioni condizionali usando l'operatore Ternario (condizione ? ifTrue_expression : ifFalse_expression)

  • Gli operatori ternari possono essere annidati come espressione per le istruzioni true o false.

Parole chiave di espressione

Parola chiave	Descrizione
This.StartingValue	Fornisce un riferimento al valore iniziale originale della proprietà animata.
This.CurrentValue	Fornisce un riferimento al valore "noto" della proprietà
This.FinalValue	Fornisce un riferimento al valore finale dell'animazione (se definito) Nota: rilevante per le animazioni implicite, per esplicite, mantiene la stessa funzionalità di This.StartingValue
Pi	Fornisce un riferimento di parola chiave al valore di PI
Vero / Falso	Fornisce un riferimento ai valori booleani di "true" o "false"
This.Target	Fornisce un riferimento all'oggetto di destinazione a cui sono associate le animazioni.

Funzioni di espressione per tipo

Scalare

Operazioni relative a funzioni e costruttori	Descrizione
Abs(Float value)	Restituisce un valore Float che rappresenta il valore assoluto del parametro float
Clamp(Float value, Float min, Float max)	Restituisce un valore float maggiore di min e minore di max o min se il valore è minore di min o max se il valore è maggiore di max
Max (Float value1, Float value2)	Restituisce il valore float maggiore tra value1 e value2.
Min (Float value1, Float value2)	Restituisce il valore float minore tra value1 e value2.
Lerp(Float value1, Float value2, Float progress)	Restituisce un valore float che rappresenta il calcolo dell'interpolazione lineare calcolata tra i due valori scalari in base allo stato di avanzamento (nota: lo stato è compreso tra 0,0 e 1,0)
Slerp(Float value1, Float value2, Float progress)	Restituisce un valore Float che rappresenta l'interpolazione sferica calcolata tra i due valori Float in base allo stato di avanzamento (nota: lo stato è compreso tra 0,0 e 1,0)
Mod(Float value1, Float value2)	Restituisce il resto Float risultante dalla divisione di value1 e value2
Ceil(Float value)	Restituisce il parametro Float arrotondato al numero intero maggiore successivo
Floor(Float value)	Restituisce il parametro Float al numero intero minore successivo
Sqrt(Float value)	Restituisce la radice quadrata del parametro Float
Square(Float value)	Restituisce il quadrato del parametro Float
Sin(Float value1) Asin(Float value2)	Restituisce il Sin o ArcSin del parametro Float
Cos(Float value1) ACos(Float value2)	Restituisce il Cos o ArcCos del parametro Float
Tan(Float value1) ATan(Float value2)	Restituisce l'oggetto Tan o ArcTan del parametro Float
Round(Float value)	Restituisce il parametro Float arrotondato al numero intero più vicino
Log10(Float value)	Restituisce il risultato log (base 10) del parametro Float
Ln(Float value)	Restituisce il risultato del log naturale del parametro Float
Pow(Float value, Float power)	Restituisce il risultato del parametro Float generato a una particolare potenza
ToDegrees(Float radians)	Restituisce il parametro Float convertito in Gradi
ToRadians(Float gradi)	Restituisce il parametro Float convertito in radianti

Vector2

Operazioni relative a funzioni e costruttori	Descrizione
Abs (vector2 value)	Restituisce un valore Vector2 con valore assoluto applicato a ogni componente
Clamp (Vector2 value1, Vector2 min, Vector2 max)	Restituisce un valore Vector2 che contiene i valori bloccati per ogni rispettivo componente
Max (Vector2 value1, Vector2 value2)	Restituisce un valore Vector2 che ha eseguito un valore Max su ognuno dei componenti corrispondenti da value1 e value2
Min (Vector2 value1, Vector2 value2)	Restituisce un valore Vector2 che ha eseguito un valore Min su ognuno dei componenti corrispondenti da value1 e value2
Scale(Vector2 value, Float factor)	Restituisce un valore Vector2 con ogni componente del vettore moltiplicato per il fattore di ridimensionamento.
Transform(Vector2 value, Matrix3x2 matrix)	Restituisce un valore Vector2 risultante dalla trasformazione lineare tra Vector2 e Matrix3x2 ,ovvero la moltiplicazione di un vettore per una matrice.
Lerp(Vector2 value1, Vector2 value2, Scalar progress)	Restituisce un valore Vector2 che rappresenta il calcolo dell'interpolazione lineare calcolata tra i due valori Vector2 in base allo stato di avanzamento (nota: lo stato è compreso tra 0,0 e 1,0)
Length(Vector2 value)	Restituisce un valore Float che rappresenta la lunghezza/grandezza di Vector2
LengthSquared(Vector2)	Restituisce un valore Float che rappresenta il quadrato della lunghezza/grandezza di vector2
Distance(Vector2 value1, Vector2 value2)	Restituisce un valore Float che rappresenta la distanza tra due valori Vector2
DistanceSquared(Vector2 value1, Vector2 value2)	Restituisce un valore Float che rappresenta il quadrato della distanza tra due valori Vector2
Normalize(Vector2 value)	Restituisce un valore Vector2 che rappresenta il vettore di unità del parametro in cui tutti i componenti sono stati normalizzati
Vector2(Float x, Float y)	Costruisce un oggetto Vector2 usando due parametri Float

Vector3

Operazioni relative a funzioni e costruttori	Descrizione
Abs (vector3 value)	Restituisce un valore Vector3 con valore assoluto applicato a ogni componente
Clamp (Vector3 value1, Vector3 min, Vector3 max)	Restituisce un valore Vector3 che contiene i valori bloccati per ogni rispettivo componente
Max (Vector3 value1, Vector3 value2)	Restituisce un valore Vector3 che ha eseguito un valore Max su ognuno dei componenti corrispondenti da value1 e value2
Min (Vector3 value1, Vector3 value2)	Restituisce un valore Vector3 che ha eseguito un valore Min su ognuno dei componenti corrispondenti da value1 e value2
Scale(Vector3 value, Float factor)	Restituisce un valore Vector3 con ogni componente del vettore moltiplicato per il fattore di ridimensionamento.
Lerp(Vector3 value1, Vector3 value2, Float progress)	Restituisce un valore Vector3 che rappresenta il calcolo dell'interpolazione lineare calcolata tra i due valori Vector3 in base allo stato di avanzamento (nota: lo stato è compreso tra 0,0 e 1,0)
Length(Vector3 value)	Restituisce un valore Float che rappresenta la lunghezza/grandezza di Vector3
LengthSquared(Vector3)	Restituisce un valore Float che rappresenta il quadrato della lunghezza/grandezza di vector3
Distance(Vector3 value1, Vector3 value2)	Restituisce un valore Float che rappresenta la distanza tra due valori Vector3
DistanceSquared(Vector3 value1, Vector3 value2)	Restituisce un valore Float che rappresenta il quadrato della distanza tra due valori Vector3
Normalize(Vector3 value)	Restituisce un valore Vector3 che rappresenta il vettore di unità del parametro in cui tutti i componenti sono stati normalizzati
Vector3(Float x, Float y, Float z)	Costruisce un oggetto Vector3 usando tre parametri Float

Vector4

Operazioni relative a funzioni e costruttori	Descrizione
Abs (Vector4 value)	Restituisce un valore Vector3 con valore assoluto applicato a ogni componente
Clamp (Vector4 value1, Vector4 min, Vector4 max)	Restituisce un valore Vector4 che contiene i valori bloccati per ogni rispettivo componente
Max (Vector4 value1 Vector4 value2)	Restituisce un valore Vector4 che ha eseguito un valore Max su ognuno dei componenti corrispondenti da value1 e value2
Min (Vector4 value1 Vector4 value2)	Restituisce un valore Vector4 che ha eseguito un valore Min su ognuno dei componenti corrispondenti da value1 e value2
Scale(Vector3 value, Float factor)	Restituisce un valore Vector3 con ogni componente del vettore moltiplicato per il fattore di ridimensionamento.
Transform(Vector4 value, Matrix4x4 matrix)	Restituisce un valore Vector4 risultante dalla trasformazione lineare tra Vector4 e Matrix4x4 ,ovvero la moltiplicazione di un vettore per una matrice.
Lerp(Vector4 value1, Vector4 value2, Float progress)	Restituisce un valore Vector4 che rappresenta il calcolo dell'interpolazione lineare calcolata tra i due valori Vector4 in base allo stato di avanzamento (nota: lo stato è compreso tra 0,0 e 1,0)
Length(Vector4 value)	Restituisce un valore Float che rappresenta la lunghezza/grandezza di Vector4
LengthSquared(Vector4)	Restituisce un valore Float che rappresenta il quadrato della lunghezza/grandezza di vector4
Distance(Vector4 value1, Vector4 value2)	Restituisce un valore Float che rappresenta la distanza tra due valori Vector4
DistanceSquared(Vector4 value1, Vector4 value2)	Restituisce un valore Float che rappresenta il quadrato della distanza tra due valori Vector4
Normalize(Vector4 value)	Restituisce un valore Vector4 che rappresenta il vettore di unità del parametro in cui tutti i componenti sono stati normalizzati
Vector4(Float x, Float y, Float z, Float w)	Costruisce un oggetto Vector4 usando quattro parametri Float

Matrix3x2

Operazioni relative a funzioni e costruttori	Descrizione
Scale(Matrix3x2 value, Float factor)	Restituisce un oggetto Matrix3x2 con ogni componente della matrice moltiplicato per il fattore di ridimensionamento.
Inverse(Matrix 3x2 value)	Restituisce un oggetto Matrix3x2 che rappresenta la matrice reciproca
Matrix3x2(Float M11, Float M12, Float M21, Float M22, Float M31, Float M32)	Costruisce un oggetto Matrix3x2 usando 6 parametri Float
Matrix3x2.CreateFromScale(Vector2 scale)	Costruisce un oggetto Matrix3x2 da vector2 che rappresenta la scala[scala. X, 0.0 0,0, scala. Y 0.0, 0.0 ]
Matrix3x2.CreateFromTranslation(Vector2 translation)	Costruisce un oggetto Matrix3x2 da vector2 che rappresenta la traduzione[1.0, 0.0, 0.0, 1.0, Traduzione. X, traduzione. Y]
Matrix3x2.CreateSkew(Float x, Float y, Vector2 centerpoint)	Costruisce un oggetto Matrix3x2 da due float e Vector2[1.0, Tan(y), Tan(x), 1.0, -centerpoint. Y * Tan(x), -centerpoint. X * Tan(y)]
Matrix3x2.CreateRotation(Float radians)	Costruisce una matrice3x2 da una rotazione in radianti[Cos(radianti), Sin(radianti), -Sin(radianti), Cos(radianti), 0.0, 0.0 ]
Matrix3x2.CreateTranslation(Vector2 translation)	(identico a CreateFromTranslation per Matrix3x2, solo denominazione diversa per la nuova coerenza)
Matrix3x2.CreateScale(Vector2 scale)	(Esattamente come CreateFromScale per Matrix3x2, solo denominazione diversa per la nuova coerenza)

Matrix4x4

Operazioni relative a funzioni e costruttori	Descrizione
Scale(Matrix4x4 value, Float factor)	Restituisce una matrice 4x4 con ogni componente della matrice moltiplicata per il fattore di ridimensionamento.
Inverse(Matrix4x4)	Restituisce un oggetto Matrix4x4 che rappresenta la matrice reciproca
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)	Costruisce un oggetto Matrix4x4 usando 16 parametri Float
Matrix4x4(Matrice3x2)	Costruisce un oggetto Matrix4x4 usando matrix3x2[matrix.11, matrix.12, 0, 0, 0, matrix.21, matrix.22, 0, 0, 0, 0, 1, 0, matrix.31, matrix.32, 0, 1]
Matrix4x4.CreateFromScale(Vector3 scale)	Costruisce un oggetto Matrix4x4 da vector3 che rappresenta la scala[scala. X, 0.0, 0.0, 0.0, 0,0, scala. Y, 0.0, 0.0, 0.0, 0.0, scala. Z, 0.0, 0.0, 0.0, 0.0, 1.0]
Matrix4x4.CreateFromTranslation(Vector3 translation)	Costruisce un oggetto Matrix4x4 da vector3 che rappresenta la traduzione[1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, Traduzione. X, traduzione. Y, traduzione. Z, 1.0]
Matrix4x4.CreateTranslation(Vector3 translation)	(Esattamente come CreateFromTranslation per Matrix4x4, solo un nome diverso per la nuova coerenza)
Matrix4x4.CreateScale(Vector3 scale)	(Esattamente come CreateFromScale per Matrix4x4, denominazione semplicemente diversa per la nuova coerenza)
Matrix4x4.CreateFromAxisAngle(Vector3 axis, Float angle)	Costruisce un oggetto Matrix4x4 da un asse Vector3 e un oggetto Float che rappresenta un angolo

Quaternion

Operazioni relative a funzioni e costruttori	Descrizione
Slerp(Quaternion value1, Quaternion value2, Float progress)	Restituisce un quaternione che rappresenta l'interpolazione sferica calcolata tra i due valori quaternione in base allo stato di avanzamento (nota: lo stato è compreso tra 0,0 e 1,0)
Concatenate(Quaternion value1 Quaternion value2)	Restituisce un quaternione che rappresenta una concatenazione di due quaternioni (noto anche come quaternione che rappresenta due rotazioni singole combinate)
Length(Quaternion value)	Restituisce un valore Float che rappresenta la lunghezza/grandezza del quaternione.
LengthSquared(Quaternion)	Restituisce un valore Float che rappresenta il quadrato della lunghezza/grandezza di un quaternione
Normalize(Quaternion value)	Restituisce un quaternione i cui componenti sono stati normalizzati
Quaternion.CreateFromAxisAngle(Vector3 axis, Scalar angle)	Costruisce un quaternione da un asse Vector3 e un scalare che rappresenta un angolo
Quaternion(Float x, Float y, Float z, Float w)	Costruisce un quaternione da quattro valori Float

Colore

Operazioni relative a funzioni e costruttori	Descrizione
ColorLerp(Color colorTo, Color colorFrom, Float progress)	Restituisce un oggetto Color che rappresenta il valore di interpolazione lineare calcolato tra due oggetti colore in base a un determinato stato di avanzamento. (Nota: lo stato è compreso tra 0,0 e 1,0)
ColorLerpRGB(Color colorTo, Color colorFrom, Float progress)	Restituisce un oggetto Color che rappresenta il valore di interpolazione lineare calcolato tra due oggetti in base a un determinato stato di avanzamento nello spazio colori RGB.
ColorLerpHSL(Color colorTo, Color colorFrom, Float progress)	Restituisce un oggetto Color che rappresenta il valore di interpolazione lineare calcolato tra due oggetti in base a un determinato stato di avanzamento nello spazio colori HSL.
ColorRGB(Float a, Float r, Float g, Float b)	Costruisce un oggetto che rappresenta Il colore definito dai componenti ARGB. (Nota: i componenti ARGB sono compresi tra 0,0 e 255,0)
ColorHsl(Float h, Float s, Float l)	Costruisce un oggetto che rappresenta il colore definito dai componenti HSL (nota: Hue è definito da 0 e 2pi)

Proprietà

Nome	Descrizione
Comment	Stringa da associare all'oggetto CompositionObject. (Ereditato da CompositionObject)
Compositor	Compositor utilizzato per creare questo CompositionObject. (Ereditato da CompositionObject)
DispatcherQueue	Ottiene dispatcherQueue per CompositionObject. (Ereditato da CompositionObject)
Expression	Equazione matematica che specifica il modo in cui viene calcolato il valore animato di ogni fotogramma. Expression è il nucleo di expressionAnimation e rappresenta l'equazione che il sistema userà per calcolare il valore della proprietà di animazione per ogni fotogramma. L'equazione viene impostata su questa proprietà sotto forma di stringa. Sebbene le espressioni possano essere definite da semplici equazioni matematiche, ad esempio "2+2", la potenza reale consiste nella creazione di relazioni matematiche in cui i valori di input possono cambiare frame over frame.
ImplicitAnimations	Raccolta di animazioni implicite associate a questo oggetto. (Ereditato da CompositionObject)
InitialValueExpressions	Ottiene i valori iniziali per l'animazione. (Ereditato da CompositionAnimation)
Properties	Raccolta di proprietà associate a CompositionObject. (Ereditato da CompositionObject)
Target	Destinazione dell'animazione. (Ereditato da CompositionAnimation)

Metodi

Nome	Descrizione
ClearAllParameters()	Cancella tutti i parametri dell'animazione. (Ereditato da CompositionAnimation)
ClearParameter(String)	Cancella un parametro dall'animazione. (Ereditato da CompositionAnimation)
Close()	Chiude CompositionObject e rilascia le risorse di sistema. (Ereditato da CompositionObject)
Dispose()	Esegue attività definite dall'applicazione associate alla liberazione, al rilascio o alla reimpostazione di risorse non gestite. (Ereditato da CompositionObject)
PopulatePropertyInfo(String, AnimationPropertyInfo)	Definisce una proprietà che può essere animata. (Ereditato da CompositionObject)
SetBooleanParameter(String, Boolean)	Imposta un parametro di valore booleano da usare con expressionAnimation o un fotogramma chiave dell'espressione. (Ereditato da CompositionAnimation)
SetColorParameter(String, Color)	Imposta un parametro di valore Color da utilizzare con expressionAnimation o un fotogramma chiave dell'espressione. (Ereditato da CompositionAnimation)
SetExpressionReferenceParameter(String, IAnimationObject)	Imposta un oggetto che implementa IAnimationObject come parametro di riferimento in expressionAnimation. (Ereditato da CompositionAnimation)
SetMatrix3x2Parameter(String, Matrix3x2)	Imposta un parametro di valore Matrix3x2 da usare con expressionAnimation o un fotogramma chiave dell'espressione. (Ereditato da CompositionAnimation)
SetMatrix4x4Parameter(String, Matrix4x4)	Imposta un parametro di valore Matrix4x4 da usare con expressionAnimation o un fotogramma chiave dell'espressione. (Ereditato da CompositionAnimation)
SetQuaternionParameter(String, Quaternion)	Imposta un valore Quaternion da utilizzare con expressionAnimation o un fotogramma chiave dell'espressione. (Ereditato da CompositionAnimation)
SetReferenceParameter(String, CompositionObject)	Imposta un riferimento a un oggetto Composition da utilizzare con un oggetto ExpressionAnimation o un fotogramma chiave dell'espressione. (Ereditato da CompositionAnimation)
SetScalarParameter(String, Single)	Imposta un parametro di valore scalare da usare con expressionAnimation o un fotogramma chiave dell'espressione. (Ereditato da CompositionAnimation)
SetVector2Parameter(String, Vector2)	Imposta un parametro di valore Vector2 da usare con expressionAnimation o un fotogramma chiave dell'espressione. (Ereditato da CompositionAnimation)
SetVector3Parameter(String, Vector3)	Imposta un parametro di valore Vector3 da usare con expressionAnimation o un fotogramma chiave di espressione. (Ereditato da CompositionAnimation)
SetVector4Parameter(String, Vector4)	Imposta un parametro di valore Vector4 da utilizzare con expressionAnimation o un fotogramma chiave dell'espressione. (Ereditato da CompositionAnimation)
StartAnimation(String, CompositionAnimation, AnimationController)	Connette un'animazione con la proprietà specificata dell'oggetto e avvia l'animazione. (Ereditato da CompositionObject)
StartAnimation(String, CompositionAnimation)	Connette un'animazione con la proprietà specificata dell'oggetto e avvia l'animazione. (Ereditato da CompositionObject)
StartAnimationGroup(ICompositionAnimationBase)	Avvia un gruppo di animazioni. Il metodo StartAnimationGroup in CompositionObject consente di avviare CompositionAnimationGroup. Tutte le animazioni nel gruppo verranno avviate contemporaneamente sull'oggetto . (Ereditato da CompositionObject)
StopAnimation(String)	Disconnette un'animazione dalla proprietà specificata e arresta l'animazione. (Ereditato da CompositionObject)
StopAnimationGroup(ICompositionAnimationBase)	Arresta un gruppo di animazioni. (Ereditato da CompositionObject)
TryGetAnimationController(String)	Restituisce un oggetto AnimationController per l'animazione in esecuzione sulla proprietà specificata. (Ereditato da CompositionObject)

Vedi anche

• Expression
• Documento Panoramica delle animazioni