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

Un billet de Gilles VASSEUR

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 :


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) :

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) :

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 :

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) ?

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 !