IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

Les interpolations et fonctions d'easing avec Lazarus V - Les fonctions utilisant des degrés de polynômes
Un billet de Gilles VASSEUR

Le , par gvasseur58

0PARTAGES

Les paragraphes qui suivent proposent une implémentation originale d'algorithmes bien connus. Les classes seront construites dans un second temps.

Certains algorithmes (dans les billets suivants !) feront appel à des calculs complexes souvent réduits dans les formules à des valeurs numériques énigmatiques. Ces calculs ne sont pas nécessaires à la compréhension de la suite. Je n'ai parfois trouvé qu'une explication en japonais que les traducteurs automatiques avaient bien du mal à traduire...

Les fonctions utilisant des degrés de polynômes

Comme indiqué dans un précédent billet, les fonctions comprenant les termes Quad, Cubic, Quart et Quint s'appuient respectivement sur des formules de degrés 2, 3, 4 et 5. Ces fonctions utilisent la fonction Power qui renvoie une puissance d'un nombre flottant fourni en paramètre.

Nous définissons en premier lieu les trois méthodes générales suivantes :

Code delphi : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
  
function TMainForm.InPower(AStart, AChange, AStep: Single; APower: Integer 
  ): Single; 
// *** calcul d'une interpolation de type IN pour les puissances *** 
begin 
  Result := AChange * Power(AStep / fDuration, APower) + AStart; 
end; 
  
function TMainForm.OutPower(AStart, AChange, AStep: Single; APower: Integer 
  ): Single; 
// *** calcul d'une interpolation de type OUT pour les puissances *** 
var 
  LSign: Integer; 
begin 
  LSign := ifthen(Odd(APower), 1, -1); 
  Result := LSign * AChange * (Power(AStep / fDuration - 1, APower) + LSign) + AStart; 
end; 
  
function TMainForm.InOutPower(AStart, AChange, AStep: Single; APower: Integer 
  ): Single; 
// *** calcul d'une interpolation de type INOUT pour les puissances *** 
var 
  LSign: Integer; 
begin 
  LSign := ifthen(Odd(APower), 1, -1); 
  AStep := AStep / fDuration * 2; 
  if AStep < 1 then 
    Result := AChange / 2 * Power(AStep, APower) + AStart 
  else 
    Result :=  LSign * AChange / 2 * (Power(AStep - 2, APower) + LSign * 2) + AStart; 
end;

Nous avons choisi de traiter à part la durée (d'où son préfixe particulier "f"), car elle est sous contrôle de la valeur du composant de type TTrackbar. Dans cet exemple, nos fonctions n'ont donc que trois paramètres en entrée sur les quatre attendus.

Vous remarquerez que nous avons utilisé la fonction ifthen pour simplifier le test des conditions. Cette fonction est présente dans l'unité math qu'il faut donc référencer dans la clause uses de la section implementation de l'unité.

La fonction ifthen prend trois paramètres en entrée :
  • une valeur booléenne ;
  • une expression renvoyée si la valeur booléenne est vraie ;
  • une expression renvoyée si la valeur booléenne est fausse.


Elle renvoie donc une des deux expressions selon la valeur booléenne.

Une fois ces bases définies, l'implémentation des fonctions est plutôt simple, voire répétitive !

Voici les fonctions associées à la catégorie Quad (degré 2) :

Code delphi : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
function TMainForm.EaseInQuad(AStart, AChange, AStep: Single): Single; 
// *** INQUAD *** 
begin 
  Result := InPower(AStart, AChange, AStep, 2); 
end; 
  
function TMainForm.EaseOutQuad(AStart, AChange, AStep: Single): Single; 
// *** OUTQUAD *** 
begin 
  Result := OutPower(AStart, AChange, AStep, 2); 
end; 
  
function TMainForm.EaseInOutQuad(AStart, AChange, AStep: Single): Single; 
// *** INOUTQUAD *** 
begin 
  Result := InOutPower(AStart, AChange, AStep, 2); 
end; 
  
function TMainForm.EaseOutInQuad(AStart, AChange, AStep: Single): Single; 
// *** OUTINQUAD *** 
begin 
  if AStep < fDuration / 2 then 
    Result := EaseOutQuad(AStart, AChange / 2, AStep * 2) 
  else 
    Result := EaseInQuad(AStart + AChange / 2, AChange / 2, AStep * 2 - fDuration); 
end;

Nous n'avons fait qu'appeler les fonctions de base avec le degré voulu. Il en sera de même pour les fonctions associées à la catégorie Cubic (degré 3) :

Code delphi : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
function TMainForm.EaseInCubic(AStart, AChange, AStep: Single): Single; 
// *** INCUBIC *** 
begin 
  Result := InPower(AStart, AChange, AStep, 3); 
end; 
  
function TMainForm.EaseOutCubic(AStart, AChange, AStep: Single): Single; 
// *** OUTCUBIC *** 
begin 
  Result := OutPower(AStart, AChange, AStep, 3); 
end; 
  
function TMainForm.EaseInOutCubic(AStart, AChange, AStep: Single): Single; 
// *** INOUTCUBIC *** 
begin 
  Result := InOutPower(AStart, AChange, AStep, 3); 
end; 
  
function TMainForm.EaseOutInCubic(AStart, AChange, AStep: Single): Single; 
// *** OUTINCUBIC *** 
begin 
  if AStep < fDuration / 2 then 
    Result := EaseOutCubic(AStart, AChange / 2, AStep * 2) 
  else 
    Result := EaseInCubic(AStart + AChange / 2, AChange / 2, AStep * 2 - fDuration); 
end;

Les fonctions relatives à la catégorie Quart (degré 4) ne font pas exception :

Code delphi : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
function TMainForm.EaseInQuart(AStart, AChange, AStep: Single): Single; 
// *** INQUART *** 
begin 
  Result := InPower(AStart, AChange, AStep, 4); 
end; 
  
function TMainForm.EaseOutQuart(AStart, AChange, AStep: Single): Single; 
// *** OUTQUART *** 
begin 
  Result := OutPower(AStart, AChange, AStep, 4); 
end; 
  
function TMainForm.EaseInOutQuart(AStart, AChange, AStep: Single): Single; 
// *** INOUTQUART *** 
begin 
  Result := InOutPower(AStart, AChange, AStep, 4); 
end; 
  
function TMainForm.EaseOutInQuart(AStart, AChange, AStep: Single): Single; 
// *** OUTINQUART *** 
begin 
  if AStep < fDuration / 2 then 
    Result := EaseOutQuart(AStart, AChange / 2, AStep * 2) 
  else 
    Result := EaseInQuart(AStart + AChange / 2, AChange / 2, AStep * 2 - fDuration); 
end;

Est-il besoin de préciser qu'il en est de même pour la catégorie Quint (degré 5) ?

Code delphi : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
function TMainForm.EaseInQuint(AStart, AChange, AStep: Single): Single; 
// *** INQUINT *** 
begin 
  Result := InPower(AStart, AChange, AStep, 5); 
end; 
  
function TMainForm.EaseOutQuint(AStart, AChange, AStep: Single): Single; 
// *** OUTQUINT *** 
begin 
  Result := OutPower(AStart, AChange, AStep, 5); 
end; 
  
function TMainForm.EaseInOutQuint(AStart, AChange, AStep: Single): Single; 
// *** INOUTQUINT *** 
begin 
  Result := InOutPower(AStart, AChange, AStep, 5); 
end; 
  
function TMainForm.EaseOutInQuint(AStart, AChange, AStep: Single): Single; 
// *** OUTINQUINT *** 
begin 
  if AStep < fDuration / 2 then 
    Result := EaseOutQuint(AStart, AChange / 2, AStep * 2) 
  else 
    Result := EaseInQuint(AStart + AChange / 2, AChange / 2, AStep * 2 - fDuration); 
end;

La palette des puissances traitées est largement suffisante pour moduler l'animation souhaitée. Pour rappel, plus l'exposant sera élevé, plus l'animation paraîtra démarrer avec lenteur pour accélérer ensuite de manière fulgurante !

Une erreur dans cette actualité ? Signalez-nous-la !