Optimisation - Techniques d'animation par pixels

Version imprimable

20/09/2006, 17h04
buzzkaido

Optimisation - Techniques d'animation par pixels

Bonjour,

Voila, j'ai construit une applet (Swing) qui affiche une animation et je me pose 2 questions paske je trouve que ca rame un peu :

**********
La premiere :
**********

Chaque image de l'animation est une image "rendue" par un petit moteur, c'est à dire que je calcule chaque pixel de l'image à partir de plein de parametres...

Donc, j'ai fait un tableau d'int : buffer[hauteur*largeur] qui contient tout les pixels de l'image.

Les pixels sont calculés dans un thread.

J'ai declaré un MemoryImageSource qui prend sa source dans le buffer.

Lors du paintComponent, je fait un bête g.drawImage(source)

Y-a-t-il mieux pour afficher à l'ecran un tableau de pixels ?
Une autre technique que le MemoryImageSource ?

**********
La seconde :
**********

Pour faire evoluer les parametres de mon animation, j'ai essayé avec un thread, qui fait une pause de 40ms entre chaque boucle, et j'ai essayé avec un timer, appelé toutes les 40ms

Donc logiquement, si j'incremente de 1 un parametre de l'animation à chaque mise à jour, je devrais avoir 25 incrementations par seconde (1000/40)

Or, des fois j'ai 15, des fois j'ai 30....

Est-ce le timer ou le thread qui n'est pas stable ?

Ou je m'y prend mal ?

(je precise que à chaque appel de la mise à jour des parametres, il n'y a que quelques additions, rien de lourd qui ferait ralentir tout ca, et c'est dans un thread separé du reste...)

Merci !
20/09/2006, 17h39
Gfx

Pour l'image il vaut mieux utiliser les BufferedImage et les WritableRaster, qui permettent d'avoir une image accélérée par le matériel.

En ce qui concerne l'animation, tu as raison : le Timer et le Thread ne sont pas justes. Le timing n'est pas garanti par ces classes (d'ailleurs dans un OS non temps réel...). La solution est en fait assez simple. Utilise un Timer et, à chaque fois que tu reçois un "tick", calcule combien de temps s'est écoulé depuis le début de l'animation, puis calcule tes paramètres de dessin à l'aide de ça.

J'explique tout cela en détail dans mes présentations :

- Filthy Rich Clients (http://www.jroller.com/page/gfx/?anc...tation_slides), slides uniquement
- Desktop Java (http://java.developpez.tv/javadesktop-dec2005/), dans la section "FX Animation", slides + vidéo en français
- Extreme GUI Makeover (http://developers.sun.com/learning/j...2005/desktop/), slides + track audio (cherche TS-3605 sur la page, puis clique sur View pour voir les slides avec le son, en anglais)

Je te conseille *vivement* d'utiliser le Timing Framework présenté dans "Filthy Rich Clients" pour gérer tes animations.
20/09/2006, 20h50
buzzkaido

La classe tes presentations !

Et tres instructif, aussi...

Deux autres questions :

* peut-tu m'en dire un peu plus sur l'utilisation des writableRaster ? Ca ne me parait pas tres clair dans la doc de Java (tout ce que je veux, c'est un tableau de pixels où ecrire mon rendu)

* J'ai vu dans la doc que System.currentTimeMillis() pouvait donner des resultats differents selon l'OS. En general (d'apres la doc) cela renvoit en unité de 10ms, ce qui a l'air d'etre le cas sur mon PC-Windows. Comment faire si on a besoin de plus de precision ?

Merci !
20/09/2006, 21h31
Gfx

Je n'ai pas d'exemple de WritableRaster, mais il suffit d'appeler setPixel() ou setDataElements() quand tu en as obtenu un lié à la BufferedImage.

Pour la résolution, elle est plus proche de 16ms sous Windows. Tu peux descendre à une précision de 2/3 ms en utilisant System.nanoTime(). Cela dit, pour une animation, 16ms suffisent (environ 60 fps).
20/09/2006, 22h16
buzzkaido

Ok, ca commence a venir...

Mais comment je fais pour envoyer tout en tableau de pixels à la fois, avec chaque pixel codé ARGB sur un int ?

Parce que pour l'instant, je n'arrive à envoyer que des tableau de pixels avec les pixels codés sur :
A : un int
R : un int
G : un int
B : un int

pourtant j'ai changé de modele de bufferedImage : testé avec TYPE_INT_ARGB et TYPE_4BYTE_ABGR

En fait, je voudrais ne pas separer les différentes composantes du pixel...

Merci !
20/09/2006, 22h17
buzzkaido

Au fait, ensuite le plus efficace dans le paintComponent, c'est de faire

g.drawImage( (Image) imageSource,0,0,null)

ou y'a mieux ?
20/09/2006, 22h21
Gfx

Pour écrire dans l'image sans réunir les composantes il faut utiliser un TYPE_3BGR par exemple mais je te le déconseille car l'image sera incompatible avec le matériel et l'affichage plus lent.

Il faut plutôt utiliser des pixels codés en TYPE_ARGB (autrement dit pixel = A << 24 | R << 16 | G << 8 | B) ce qui est tout de même la pratique la plus courante. Ensuite il te suffira de faire un setDataElements(0, 0, largeurImage, hauteurImage, tableauDePixels).

Si tes compostantes sont déjà toutes contenues dans un int alors il n'y a aucun problème.
20/09/2006, 22h29
buzzkaido

Ok ! Autant pour moi !

C'est ce que j'ai testé en premier, mais ca marchait pas...

J'avais du faire une co***rie puisque maintenant ca marche !

Et puis ca m'arrange sacrement puisque c'est comme ca que je calculait le rendu de mes images jusqu'a present...

Merci pour tout !
20/09/2006, 22h39
buzzkaido

Maintenant tout marche avec des bufferedImage, mais je n'ai pas gagné en vitesse...

Apres quelques test, je suis pratiquement sur que la phase qui ralentit vraiment tout, c'est la copie du tableau de pixels vers l'ecran...

Quel le plus efficace dans le paintComponent, c'est de faire

g.drawImage( (Image) imageSource,0,0,null)

ou y'a mieux ?

Y-a-t-il d'autres optimisations possibles, en dehors du rendu ?

Merci

Utiliser des BufferedImage compatible

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
  static BufferedImage toCompatibleImage(BufferedImage image) {
    int width = image.getWidth();
    int height = image.getHeight();
    int transparency = image.getTransparency();
    GraphicsConfiguration configuration = GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice().getDefaultConfiguration();
    BufferedImage result = configuration.createCompatibleImage(width, height, transparency);
    Graphics graphics = result.getGraphics();
    try {
      graphics.drawImage(image, 0, 0, null);
    }
    finally {
      graphics.dispose();
    }
    return result;
  }

20/09/2006, 23h01
buzzkaido

merci, mais euh... j'avoue que j'ai pas compris grand chose...

compatible entre quoi et quoi ?

En fait, ma bufferedImage, je veux simplement l'afficher (rapidement) à l'ecran.

Pour l'instant j'ai fait un derivé de JPanel, et dans paintComponent, je fait juste

g.drawImage( (Image) maBufferedImage,0,0,null)
20/09/2006, 23h09
sinok

en fait cela permet de t'assurer de la compatibilité de ton image avec ta carte graphique.

Fais une recherche sur "compatible BufferedImage" et tu verras un paquets de posts de Bouye ou Gfx qui en parlent
20/09/2006, 23h12
buzzkaido

merci