Cenni preliminari sulle animazioni personalizzate
Questo argomento descrive come e quando estendere il sistema di animazione di WPF creando fotogrammi chiave personalizzati, classi di animazione oppure utilizzando il callback per frame per evitare l'operazione.
Prerequisiti
Per comprendere questo argomento, è necessario conoscere i diversi tipi di animazione forniti da WPF. Per ulteriori informazioni, vedere Cenni preliminari sulle animazioni From/To/By, Cenni preliminari sulle animazioni con fotogrammi chiave e Panoramica sulle animazioni percorso.
Dato che le classi di animazione ereditano dalla classe Freezable, dovrebbero essere noti gli oggetti Freezable e come ereditare dalla classe Freezable. Per ulteriori informazioni, vedere Cenni preliminari sugli oggetti Freezable.
Estensione del sistema di animazione
Esistono molti modi di estende il sistema di animazione di WPF, in base al livello di funzionalità incorporate che si desidera utilizzare. Sono tre i punti di estendibilità principali nel motore di animazione di WPF:
Creare un oggetto fotogramma chiave personalizzato ereditando da una delle classi *<Tipo>*KeyFrame, come DoubleKeyFrame. Questo approccio utilizza la maggior parte delle funzionalità incorporate del motore di animazione di WPF.
Creare classi di animazione personalizzate ereditando da AnimationTimeline o da una delle classi *<Tipo>*AnimationBase.
Utilizzare il callback per frame per generare animazioni per ogni frame. Questo approccio ignora completamente il sistema di animazione e di temporizzazione.
Nella tabella riportata di seguito vengono descritti alcuni degli scenari per l'estensione del sistema di animazione.
Per |
Utilizzare il seguente approccio |
|---|---|
Personalizzare l'interpolazione tra i valori di un tipo che abbia una classe <Tipo>AnimationUsingKeyFrames corrispondente. |
Creare un fotogramma chiave personalizzato. Per ulteriori informazioni, vedere la sezione Creare un fotogramma chiave personalizzato. |
Personalizzare più che la semplice interpolazione tra i valori di un tipo che abbia una classe <Tipo>Animation corrispondente. |
Creare una classe di animazione personalizzata che erediti dalla classe <Tipo>AnimationBase che corrisponde al tipo che si desidera animare. Per ulteriori informazioni, vedere la sezione Creare una classe di animazione personalizzata. |
Animare un tipo che non abbia un'animazione WPF corrispondente |
Utilizzare un oggetto ObjectAnimationUsingKeyFrames oppure creare una classe che erediti da AnimationTimeline. Per ulteriori informazioni, vedere la sezione Creare una classe di animazione personalizzata. |
Animare più oggetti con valori calcolati per ogni fotogramma e che si basano sull'ultimo insieme di interazioni oggetto. |
Utilizzare il callback per frame. Per ulteriori informazioni, vedere la sezione Creare un callback per frame. |
Creare un fotogramma chiave personalizzato
La creazione di una classe di fotogrammi chiave personalizzati è il modo più semplice di estendere il sistema di animazione. Utilizzare questo approccio quando si desidera un metodo di interpolazione diverso per un'animazione con fotogrammi chiave. Come descritto in Cenni preliminari sulle animazioni con fotogrammi chiave, un'animazione con fotogrammi chiave utilizza oggetti fotogrammi chiave per generare i valori di output. Ogni oggetto fotogramma chiave consente di eseguire tre funzioni:
Specifica un valore di destinazione mediante la relativa proprietà Value.
Specifica il momento in cui tale valore deve essere raggiunto utilizzando la proprietà KeyTime relativa.
Crea un'interpolazione tra il valore del fotogramma chiave precedente e quello del proprio valore implementando il metodo InterpolateValueCore.
Istruzioni per l'implementazione
Effettuare la derivazione dalla classe astratta *<Tipo>*KeyFrame e implementare il metodo InterpolateValueCore. Il metodo InterpolateValueCore restituisce il valore corrente del fotogramma chiave. Accetta due parametri, vale a dire il valore del fotogramma chiave precedente e un valore di avanzamento che va da 0 a 1. Un avanzamento pari a 0 indica che il fotogramma chiave è appena iniziato e un valore pari a 1 indica che il fotogramma chiave è appena stato completato e che deve restituire il valore specificato dalla relativa proprietà Value.
Dato che la classe *<Tipo>*KeyFrame eredita dalla classe Freezable, è anche necessario eseguire l'override della classe CreateInstanceCore per restituire una nuova istanza della classe. Se la classe non utilizza le proprietà di dipendenza per archiviare i dati o richiede un'ulteriore inizializzazione dopo la creazione, potrebbe essere necessario eseguire l'override di altri metodi; per ulteriori informazioni, vedere Cenni preliminari sugli oggetti Freezable.
Dopo avere creato l'animazione *<Tipo>*KeyFrame personalizzata, è possibile utilizzarla con *<Tipo>*AnimationUsingKeyFrames per tale tipo.
Creare una classe di animazione personalizzata
La creazione di un tipo di animazione personalizzato consente un maggiore controllo sul modo in cui un oggetto viene animato. Sono due i modi consigliati per creare un tipo di animazione personalizzata. È possibile effettuare la derivazione dalla classe AnimationTimeline o dalla classe *<Tipo>*AnimationBase. La derivazione dalla classe *<Tipo>*Animation o *<Tipo>*AnimationUsingKeyFrames non è consigliata.
Derivazione dalla classe <Tipo>AnimationBase
La derivazione da una classe *<Tipo>*AnimationBase è il modo più semplice di creare un nuovo tipo di animazione. Utilizzare questo approccio quando si desidera creare una nuova animazione per il tipo che dispone già di una classe *<Tipo>*AnimationBase corrispondente.
Istruzioni per l'implementazione
Effettuare la derivazione da una classe *<Tipo>*Animation e implementare il metodo GetCurrentValueCore. Il metodo GetCurrentValueCore restituisce il valore corrente dell'animazione. Accetta tre parametri, vale a dire un valore iniziale suggerito, un valore finale suggerito e un oggetto AnimationClock, che viene utilizzato per determinare l'avanzamento dell'animazione.
Dato che la classe *<Tipo>*AnimationBase eredita dalla classe Freezable, è anche necessario eseguire l'override della classe CreateInstanceCore per restituire una nuova istanza della classe. Se la classe non utilizza le proprietà di dipendenza per archiviare i dati o richiede un'ulteriore inizializzazione dopo la creazione, potrebbe essere necessario eseguire l'override di altri metodi; per ulteriori informazioni, vedere Cenni preliminari sugli oggetti Freezable.
Per ulteriori informazioni, vedere la documentazione relativa al metodo GetCurrentValueCore per la classe *<Tipo>*AnimationBase per il tipo che si desidera animare. Per un esempio, vedere Esempio di animazione personalizzata (la pagina potrebbe essere in inglese).
Approcci alternativi
Se si desidera semplicemente modificare il modo in cui i valori dell'animazione vengono interpolati, si prenda in considerazione la derivazione da una delle classi *<Tipo>*KeyFrame. Il fotogramma chiave creato può essere utilizzato con la classe *<Tipo>*AnimationUsingKeyFrames corrispondente fornita da WPF.
Derivazione dalla classe AnimationTimeline
Effettuare la derivazione dalla classe AnimationTimeline quando si desidera creare un'animazione per un tipo che non dispone già di un'animazione WPF corrispondente o se si desidera creare un'animazione che non sia fortemente tipizzata.
Istruzioni per l'implementazione
Effettuare la derivazione dalla classe AnimationTimeline e l'override dei seguenti membri:
CreateInstanceCore: se la nuova classe è concreta, è necessario eseguire l'override di CreateInstanceCore per restituire una nuova istanza della classe.
GetCurrentValue: eseguire l'override di questo metodo per restituire il valore corrente dell'animazione. Accetta tre parametri: un valore di origine predefinito, un valore di destinazione predefinito e un oggetto AnimationClock. Utilizzare l'oggetto AnimationClock per ottenere il momento corrente o lo stato di avanzamento dell'animazione. È possibile scegliere se utilizzare i valori di origine e di destinazione predefiniti.
IsDestinationDefault: eseguire l'override di questa proprietà per indicare se l'animazione utilizza il valore di destinazione predefinito specificato dal metodo GetCurrentValue.
TargetPropertyType: eseguire l'override di questa proprietà per indicare l'oggetto Type di output prodotto dall'animazione.
Se la classe non utilizza le proprietà di dipendenza per archiviare i dati o richiede un'ulteriore inizializzazione dopo la creazione, potrebbe essere necessario eseguire l'override di altri metodi; per ulteriori informazioni, vedere Cenni preliminari sugli oggetti Freezable.
Il paradigma consigliato (utilizzato dall'animazione WPF) consiste nell'utilizzare due livelli di ereditarietà:
Creare una classe astratta *<Tipo>*AnimationBase che deriva da AnimationTimeline. Questa classe deve eseguire l'override del metodo TargetPropertyType. Deve anche introdurre un nuovo metodo astratto, GetCurrentValueCore, ed eseguire l'override di GetCurrentValue per consentire la convalida dei tipi dei parametri del valore di origine predefinito e del valore di destinazione predefinito, quindi chiama GetCurrentValueCore.
Creare un'altra classe che erediti dalla nuova classe *<Tipo>*AnimationBase ed esegua l'override del metodo CreateInstanceCore, del metodo GetCurrentValueCore introdotto e della proprietà IsDestinationDefault.
Approcci alternativi
Se si desidera animare un tipo che non ha alcuna animazione From/To/By o animazione con fotogrammi chiave corrispondente, si prenda in considerazione l'utilizzo di un oggetto ObjectAnimationUsingKeyFrames. Poiché ha una tipizzazione debole, un oggetto ObjectAnimationUsingKeyFrames può animare qualsiasi tipo di valore. Lo svantaggio di questo approccio consiste nel fatto che l'oggetto ObjectAnimationUsingKeyFrames supporta solo l'interpolazione discreta.
Utilizzare il callback per frame
Utilizzare questo approccio quando è necessario ignorare completamente il sistema di animazione di WPF. Uno scenario di questo approccio è rappresentato dalle animazioni fisiche, dove a ciascun passaggio dell'animazione è necessario ricalcolare una nuova direzione o posizione degli oggetti animati in base all'ultima serie di interazioni dell'oggetto.
Istruzioni per l'implementazione
A differenza degli altri approcci descritti in questi cenni preliminari, per utilizzare un callback per frame non è necessario creare un'animazione personalizzata o una classe con fotogrammi chiave.
Al contrario si esegue la registrazione per l'evento Rendering dell'oggetto che contiene gli oggetti da animare. Questo metodo per la gestione eventi viene chiamato una volta per ciascun frame. Ogni volta che WPF esegue il marshalling dei dati di rendering permanenti della struttura ad albero visuale nella struttura ad albero della composizione, viene chiamato il metodo per la gestione eventi.
Nel gestore eventi eseguire i calcoli necessari per l'effetto di animazione e impostare le proprietà degli oggetti da animare con tali valori.
Per ottenere l'ora di presentazione del frame corrente, è possibile eseguire il cast dell'oggetto EventArgs associato a questo evento come RenderingEventArgs che fornisce una proprietà RenderingTime utilizzabile per ottenere l'ora di rendering del frame corrente.
Per ulteriori informazioni, vedere la pagina Rendering.
Vedere anche
Riferimenti
Concetti
Cenni preliminari sulle tecniche di animazione delle proprietà
Cenni preliminari sugli oggetti Freezable
Cenni preliminari sulle animazioni From/To/By
Cenni preliminari sulle animazioni con fotogrammi chiave
Panoramica sulle animazioni percorso
Cenni preliminari sull'animazione
Cenni preliminari sull'animazione e sul sistema di temporizzazione