Voir le flux RSS

Blog de Gilles Vasseur - Pascal et compagnie

[Actualité] Les interpolations et fonctions d'easing avec Lazarus V - Les fonctions utilisant des degrés de polynômes

Noter ce billet
par , 21/01/2019 à 11h03 (1074 Affichages)
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 - Visualiser dans une fenêtre à part
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 - Visualiser dans une fenêtre à part
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 - Visualiser dans une fenêtre à part
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 - Visualiser dans une fenêtre à part
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 - Visualiser dans une fenêtre à part
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 !

Envoyer le billet « Les interpolations et fonctions d'easing avec Lazarus V - Les fonctions utilisant des degrés de polynômes » dans le blog Viadeo Envoyer le billet « Les interpolations et fonctions d'easing avec Lazarus V - Les fonctions utilisant des degrés de polynômes » dans le blog Twitter Envoyer le billet « Les interpolations et fonctions d'easing avec Lazarus V - Les fonctions utilisant des degrés de polynômes » dans le blog Google Envoyer le billet « Les interpolations et fonctions d'easing avec Lazarus V - Les fonctions utilisant des degrés de polynômes » dans le blog Facebook Envoyer le billet « Les interpolations et fonctions d'easing avec Lazarus V - Les fonctions utilisant des degrés de polynômes » dans le blog Digg Envoyer le billet « Les interpolations et fonctions d'easing avec Lazarus V - Les fonctions utilisant des degrés de polynômes » dans le blog Delicious Envoyer le billet « Les interpolations et fonctions d'easing avec Lazarus V - Les fonctions utilisant des degrés de polynômes » dans le blog MySpace Envoyer le billet « Les interpolations et fonctions d'easing avec Lazarus V - Les fonctions utilisant des degrés de polynômes » dans le blog Yahoo

Mis à jour 21/01/2019 à 17h11 par gvasseur58

Catégories
Free Pascal , Lazarus , Graphisme

Commentaires