Parce que dans Sqwap, j'ai répété le même code des centaines de fois.
On ne se rend pas compte, mais chaque variation de transparence, de taille, de position exige beaucoup de code.
Et beaucoup de paramètrage.
Je voudrais changer ça : qu'il n'y ait que les paramètres de l'animation à fournir.
Et que l'animation se fasse automatiquement en conséquence.
Donc il faut envisager : l'interpolation, le déplacement linéaire (voire avec accélération et décélération) , l'animation sinusoïdale, etc.
Mais ce n'est pas encore clair dans ma tête.
Il y a beaucoup d'animations qui fonctionnent pareil, que ce soit l'alpha, la taille par exemple.
Et je tiens à mon effet Marshmallow : c'est un scaling non uniforme ou les échelles horizontales et verticales sont opposées.
La réponse la plus adéquate, je crois, c'est de créer un Objet template ValueHolder<...>
En gros, tous les paramètres seraient définis comme ça. (taille, alpha, etc)
Par exemple :
alpha = new ValueHolder<float>();
Ensuite il faudrait la fournir à un animateur. (Mais il faudrait fournir la valeur min, la valeur max, et la vélocité de l'animation)
alphaAnimator = new LinearAnimator(ValueHolder alpha, float minValue, float maxValue, float velocity);
Il suffit d'appeler alphaAnimator.getValue() pour avoir le résultat utilisé pour rendre l'image.
[EDIT]
Je me suis compliqué la vie.
Il n'y a pas de raison de Créer des ValueHolder, vu que les références des objets sont passées par valeur...
J'ai tout revu.
Pour l'instant :
J'ai crée une classe abstraite Animator, qui ne prend que en compte si l'animation est en boucle, et quand elle est finie.
Et deux vraies implémentations,
LinearAnimator, qui prend en paramètre une valeur (un flottant) de début, une vélocité (initiale) et une accélération (Et éventuellement une valeur de fin).
InterpolationAnimator, qui prend un vecteur de valeurs (de flottants) de début, un vecteur de valeurs de fin, et une durée. (Beaucoup plus simple que LinearAnimator).
Il y aura peut-être des variantes.
Mais surtout, maintenant, le plus important, c'est que les valeurs soient mises à jour de manière invisible.
On les crée juste, et on ne fait que récupérer leurs valeurs.
Pour cela, j'ai créé des constructeurs non accessibles.
Seul l'objet "Game" peut les créer.
Donc il faut s'adresser à l'objet Game pour les créer. Et il les stocke dans sa petite liste personnelle, dans son coin.
Normal, car lui en échange les met à jour automatiquement (Selon le temps écoulé entre chaque frame) et les supprime. (Selon le statut de l'animation).
A suivre ...
[EDIT 2]
J'ai fait un autre Animateur :
SinusAnimator, dont le rôle est de faire une sinusoïde au cours du temps.
Les paramètres sont l'angle initial, la vitesse angulaire, et les valeurs min et max que doit prendre la sinusoïde. (max - min = amplitude de la sinusoïde).
Sinon, j'ai abandonné l'idée de centraliser la mise à jour des animators : car si le système est mal utilisé, les animators s'accumulent dans l'objet Game sans qu'ils soient détruits.
Donc c'est à l'utilisateur de les mettre à jour manuellement.
Après c'est pas compliqué, c'est fait en une ligne :
animator.update(deltaTimeMillis);
...
[EDIT 3]
Je viens d'en créer un autre : SinusInterpolationAnimator
Son but est de faire une interpolation entre vecteurs de flottants, mais en suivant une sinusoïde.
Donc il prend en arguments 2 vecteurs de flottants qui sont interpolés via une sinusoïde. (dont les arguments sont l'angle initiale et la vitesse angulaire).
Mes unités sont un peu ésotériques par contre. Les angles sont exprimés en degrés, et la vitesse angulaire, en degrés par milliseconde. Mais c'est adapté pour mon cas.
C'est très utile pour faire des clignotements, des changements de couleur souples, et mon effet marshmallow, ou simplement des mouvements périodiques.
[EDIT 4 ]
Je me suis encore une fois compliqué la vie :
Il y a la méthode update(temps écoulé).
Et la méthode getValue().
Je vais les joindre, il n'y aura plus de méthode update, mais une seule méthode getValue(temps écoulé).
Cela simplifie tout, on met à jours les valeurs au moments où on veut les récupérer.
En précisant le temps écoulé. (Le temps écoulé entre chaque frame est fourni par le moteur en début de frame.)
[EDIT 5]
Lourdingue Premier au rapport.
Il faudrait que j'encapsule ce paramètre "temps écoulé" aussi.
Game fournit le temps écoulé.
En interne, les animateurs l'utilisent.
Mais il y aura tjrs des animations particulières, qui auront besoin du temps écoulé.
Donc je suis dans le flou.
Et cela crée un problème :
Si une animation doit-être mise en pause, c'est impossible.
Alors que si c'est explicite, à chaque frame il suffit de dire que le temps écoulé est zéro (0).
[EDIT6]
Bon, j'ai encore changé le code. Je pense que c'est la bonne cette fois.
Maintenant, le temps doit être explicitement donné aux Animateurs au moment où l'on veut les valeurs, et il y en a de 4 types.
L'un permet de passer d'un réel à un autre via vitesse et accélération.
Un autre permet de faire une interpolation linéaire entre deux vecteurs de réels.
Un autre décrit une sinusoïde au cours du temps.
Et le dernier permet de faire une interpolation sinusoïdale entre 2 vecteurs de réels.
A ce stade, je ne crois pas avoir besoin d'autres.
On pourrait imaginer des interpolations selon Bézier, mais je pense que c'est inutile.
Bref, normalement le post est clos.
)
