Discussion :

[buzzkaido]

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 !

[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.

[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 !

[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).

[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 !

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

[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.

[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 !

[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

[sinok]

Utiliser des BufferedImage compatible

Code :

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
 
  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;
  }

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

[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

[buzzkaido]

merci