Blog de Gilles Vasseur - Pascal et compagnie

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 !