Dessiner des images sur une BufferedImage

Bonjour à tous,

Pour le jeu sur lequel je travaille, je dois afficher un grand nombre d'images dans toutes les directions imaginables (==> rotations, mises à l'échelle), et pour l'instant j'affiche tout ça avec des instructions du type
"g.rotate(..)
g.translate(..)
g.drawImage(..)"
Utiliser les AffineTransform ferait le même effet.

Au point où il en est, mon jeu est encore très fluide, mais pour la suite, avec beaucoup plus d'éléments à afficher, j'aurai besoin d'afficher tout le rendu d'un coup au lieu d'afficher les éléments les uns après les autres.
Je n'ai donc pas encore essayé de créer une BufferedImage pixel par pixel, mais je pense que ce serait une énorme perte de performances.
Donc voilà mes questions:
Est-ce qu'il existe un autre moyen d'écrire une BufferedImage que de définir chaque pixel avec ses coordonnées et sa couleur RGBA ?
Est-ce qu'on peut "additionner" des objets de type Area (avec sa couleur) ou Image sur une BufferedImage (ou un type similaire) ?

Salut,

Je suppose que les "g.rotate(..), g.translate(..), g.drawImage(..)" dont tu parles, tu les invoques sur l'instance de Graphics passée en paramètre de la méthode paint() d'un Canvas (ou paintComponent d'un JPanel), n'est-ce-pas ?
Et bien dessiner dans une image, çà utilise exactement le même système :
Code:

1 2 3 4 5 6 7 Graphics2D g = bufferedImage.createGraphics(); try { //ici tu dessines avec g exactement de la même manière que dans pour le Graphics des méthodes paintxxx. En plus, même pas besoin de caster en Graphics2D si nécessaire } finally { g.dispose(); // toujours penser à libérer la mémoire à la fin }
Ensuite, tu parles d'additionner des objets de type Area directement (ou combiner plus généralement) : alors, non, on ne peut pas le faire. Tout ce qui est dessiner dans le contexte bitmap est en bitmap : la nature vectorielle (d'une instance d'Area) est donc perdue. On peut faire toutes les combinaisons voulues avant de faire le dessin final, mais ceci est plutôt lent comparé au dessin bitmap. Il y a plusieurs techniques qui permettent de s'en sortir :

dessiner une forme dans une image transparente et la dessiner elle-même sur l'image globale. Si ta forme est censée varier, tu peux dessiner plusieurs images, chacune correspondant à chaque variation. Cela va prendre beaucoup plus de mémoire, mais accélérera nettement le rendu graphique (c'est d'ailleurs la plupart du temps le cas : pour accélérer du code, on consomme plus de mémoire (principe même des caches).
utiliser les composites qui pourront te permettront de faire certaines combinaisons bitmap entre 2 images (par union ou intersection, mais également en combinant avec la couche alpha, pour faire par exemple, une notion de projecteur de lumière qui révèle une partie de l'image)

Enfin, il y a également la notion de multibuffering qui est un peu une solution intermédiaire entre la solution de tout dessiner en direct dans le contexte graphique, ou de passer par des images bitmap intermédiaires. Cette technique est là surtout pour éviter le flickering dû au fait qu'on peut ne pas avoir fini de dessiner l'écran, alors qu'on a besoin de rafraîchir l'écran: en combinant des images bitmap et cette technique tu gagneras surtout en fluidité.

En tout, dessiner une image point par point est à proscrire (donc sous entendu en faisant des double boucles) : ce sera effectivement très très long. Éventuellement, des transferts de tableau (de raster) sur certaines parties peuvent être faits assez rapidement.

:merci: