Utilizzo di CAMediaTimingFunction per calcolare il valore all'istante (t)

Question

In Cocoa/Touch, CAMediaTimingFunction rappresenta quattro punti di controllo che specificano una curva bezier cubica di una funzione di temporizzazione. Per un'applicazione che sto scrivendo mi piacerebbe essere in grado di estrarre il risultato di detta curva di bezier ad un tempo arbitrario t (0 -> 1). Quello che mi sta confondendo è che quando guardo come do this, il risultato dovrebbe essere un punto così, non è uno scalare:

Tuttavia, i risultati di implementazione di Apple in un valore scalare (è possibile vedere su questo grafico tramano x (t) vs t: http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/Animation_Types_Timing/Articles/Timing.html#//apple_ref/doc/uid/TP40006670-SW1)

Così fa Apple ha semplicemente ignorare la coordinata y del risultato e trattare solo con la x? Questo sembra strano perché in questo caso non è necessario passare in punti di controllo, ma piuttosto controllare gli scalari poiché gli y non influenzano affatto il risultato.

Answer 1

Nota: Non sono un esperto di CoreAnimation. Questa è solo la mia comprensione dal leggere i documenti che hai collegato.

Apple sta mixando i sistemi di coordinate qui, creando confusione.

x(t) nei grafici di esempio rappresenta una progressione scalare lungo un percorso, non una coordinata fisica.

I punti di controllo utilizzati in CAMediaTimingFunction vengono utilizzati per descrivere questa progressione, non un punto geometrico. Per aggiungere confusione, x nei punti di controllo esegue effettivamente la mappatura su t nei grafici e nei punti di controllo su x(t) sui grafici.

Per prendere il grafico per kCAMediaTimingFunctionEaseInEaseOut come esempio, questo grafico sarebbe descritto approssimativamente dai punti di controllo (0,0), (0,5,0), (0,5,1), (1,1).

Answer 2

Il miglior suggerimento sarebbe probabilmente UnitBezier.h nel codice sorgente di WebKit. In effetti, credo che Apple usi lo stesso codice all'interno di Core Animation.

Più lungo, utilizzano il parametro t calcolare (che non ha nulla a che fare con il tempo) dato un valore di x che in realtà contiene il valore di tempo. Quindi usano Newton-Raphson method (additional explanation with examples). Dal momento che può fallire, itera un po 'di più sull'uso della bisezione ("divide e conquista"). Vedi questo nel metodo solveCurveX().

Dopo aver ottenuto il parametro t (che è necessario dato che i Bezier cubici sono definiti parametricamente), lo usano semplicemente per calcolare . Vedi questo nel metodo solve().

Tra l'altro, un grande fan di cappuccino, e ancora sperando in un rilascio di Atlas :-)

Answer 3

Core Animation di CAMediaTimingFunction fa quello che si vuole, ma non espone ottenere 'y' per una data 'x' per un uso versatile (animazione), ma piuttosto nutre semplicemente i valori risolti in modo opaco per il sistema di animazione sotto il cofano.

Ne avevo bisogno anch'io quindi built a class with the interface and capabilities exactly like CAMediaTimingFunction but with the needed -valueForX: method; esempio di utilizzo:

RSTimingFunction *heavyEaseInTimingFunction = [RSTimingFunction timingFunctionWithControlPoint1:CGPointMake(0.8, 0.0) controlPoint2:CGPointMake(1.0, 1.0)]; 
CGFloat visualProgress = [heavyEaseInTimingFunction valueForX:progress]; 

È possibile creare la facilità-in, la facilità-out, facilità in-ease-out o realmente qualsiasi curve che possono essere descritti con a cubic Bézier curve. La matematica dell'implementazione è basata su WebCore (WebKit), che presumibilmente è anche utilizzato da CoreAnimation.

Godetevi, Raphael

Answer 4

E 'un peccato, ma Core Animation non espone il suo modello di calcolo interno per la sua tempistica animazione. Tuttavia, ciò che ha funzionato molto bene per me è usare Core Animation per fare il lavoro!

1. Creare un CALayer per servire come un valutatore
2. impostare il suo telaio per ((0.0, 0.0), (1.0, 1.0))
3. Impostare isHidden a true
4. Impostare speed a 0.0
5. Aggiungi questo livello a qualche strato contenitore

6. Quando si desidera valutare qualsiasi CAMediaTimingFunction, creare un riferimento Animazione:

   let basicAnimation = CABasicAnimation(keyPath: "bounds.origin.x") 
   basicAnimation.duration = 1.0 
   basicAnimation.timingFunction = timingFunction 
   basicAnimation.fromValue = 0.0 
   basicAnimation.toValue = containerLayer.bounds.width 
   
   referenceLayer.add(basicAnimation, forKey: "evaluatorAnimation") 
   

7. Impostare il livello del timeOffset a qualsiasi valore di ingresso normalizzato di riferimento (vale a dire, tra il 0.0 e 1.0) si desidera valutare:

   referenceLayer.timeOffset = 0.3 // 30% into the animation 
   

8. Richiedi livello di presentazione del livello di riferimento e ottiene il suo valore x dell'origine dell'origine corrente:

   if let presentationLayer = referenceLayer.presentation() as CALayer? { 
       let evaluatedValue = presentationLayer.bounds.origin.x/containerLayer.bounds.width 
   } 
   

In pratica, si sta utilizzando Core Animation per eseguire un'animazione per un livello invisibile. Ma il numero speed del livello è 0.0, quindi non avanza l'animazione. Usando timeOffset, possiamo regolare manualmente la posizione corrente dell'animazione e ottenere la posizione x del suo livello di presentazione. Questo rappresenta l'attuale valore percepito di tale proprietà come guidato dall'animazione.

È un po 'non convenzionale, ma non c'è nulla di hacky a riguardo. È una rappresentazione fedele del valore di output di uno CAMediaTimingFunction che puoi ottenere perché Core Animation lo sta effettivamente utilizzando.

L'unica cosa di cui essere a conoscenza è che i livelli di presentazione sono vicini approssimazioni dei valori presentati sullo schermo. Core Animation non fornisce garanzie sulla loro accuratezza, ma in tutti i miei anni di utilizzo di Core Animation, non l'ho mai visto impreciso. Tuttavia, se la tua applicazione richiede una precisione assoluta, è possibile che questa tecnica non sia la migliore.