Bonjour bonjour tout le monde !

Bon voila, je vous expose mon problème : je cherche à créer un éditeur de cartes pour un jeu 2D de type "Zelda".

Pour le moment, je me contente d'effectuer des setColor(...), drawRect(...) et fillRect(...) pour afficher la carte avec un quadrillage et des couleurs quant aux différentes tuiles. Par la suite, j'afficherai des images pour remplacer les couleurs par des textures. Jusque là pas de soucis. Le hic survient quand je place ma carte dans un JScrollPane (celle-ci étant trop grande pour être affichée entièrement à l'écran) et que, ensuite, je me déplace au moyen des ScrollBar... En effet, un repaint() s'effectue à chaque déplacement et consomme donc inutilement des ressources!

Ma question est la suivante : pour éviter tout repaint() intempestif et inutile de ma carte 2D (et donc économiser les ressources matérielles utilisées), existe-t-il un moyen quelconque pour "bufferiser" (de la mettre en mémoire donc) cette dernière? Si oui, lequel est-il et comment procéder?

Une simple mise sur la voie sera plus qu'appréciée !

Merci d'avance de vos réponses !

Regarde du côté des images bufférisées (BufferedImage)

Merci! Mais... euh... un exemple d'utilisation ne serait pas de refus ; j'ai un peu du mal à comprendre la
Comment cela va m'aider à récupérer une image (via son path par exemple) et l'afficher ensuite?

hé bien si j'ai bien compris, plutôt que d'imprimer ta carte dans la zone graphique directement,

tu dessine sur une image. ... que tu peins par la suite ...
ainsi quand tu déplace ton JscrollPanel, tu ne dois pas faire de calcul =/

edit : mais pas sur que c'est le top (voir suite)

mais ne saurais tu pas centraliser tes calcules °_0 ??
j'entends pas la de ne repeindre que ce qui apparait dans l'écran et ne pas tenir compte du reste °_0
ça limiterai dejà les calcules .... (et ne plus utiliser JscrollPanel)

c'est ce que j'essaie de faire justement : limiter les calculs effectués par le processeur. Mais pour le moment, j'ai du mal... !
En gros, ce que je souhaite faire c'est quelque chose ressemblant à un quadrillage dont chaque cellule correspond à une tuile souhaitée. Et, par la suite, à chaque déplacement, éviter d'effectuer un repaint. Donc de mettre ces tuiles et leur position en mémoire.

Je sais pas si c'est plus clair ?

ben tout dessiner sur une image n'est pas le must ....
mais ça marche ....
suffit de dessiner sur une zone graphique puis de transformer ce Graphics en Image si mes souvenirs sont exacts ...
BufferedImage est la class qui devra être utilisée a mon avis

d'ailleur .... j'ai trouvé la fonction qui t'interesse en 30 seconde sur la doc :s tu aurais peut être du chercher un peu ...

Citation : Doc : API

Graphics2D : createGraphics()
Creates a Graphics2D, which can be used to draw into this BufferedImage.

apres ça ... ben tu utilises le Graphics2D obtenus ... il fonctionne comme Graphics mais il y'a plus de fonction (d'ailleurs je pense que tu peux faire un cast ^_° ((Graphics)new Graphics2D();)
enfin soit bref suffit de dessiner sur cette image et de peindre cette image



mais tu peux aussi simplement ne redessiner que ce qui apparait a l'écrans et pas le reste pour ça suffit de ne pas repeindre tout ton quadrilliage mais juste la partie qui se trouve a l'écrans ....

pour faire ça tu fais
1 calculer qui est le rectangle haut gauche
2 calculer qui est le rectangle bas droite
ne dessiner que les rectangles entre ces deux là




A ta place je n'utiliserais pas une grande image ...
quand elle fera 10000000000000000000000 de pixel sur 1000000000000000000000000000000
tu verras comme ton pc va galérer

J'ai cherché. Je ne connais juste pas encore toutes les astuces ... Je ne me doutais pas que cette méthode pouvait vraiment m'aider. Par contre je passe par
Toolkit.getDefaultToolkit().createImage(String path) pour créer mon image que, ensuite, je cast dans une BufferedImage. Chaque image est stockée ensuite dans un objet de type Tile (de ma conception) qui lui-même se retrouve dans une TilesCollection. Cette collection sera ensuite reliées à la carte utilisée pour une question de rapidité et d'optimisation (l'image ne devra pas etre rechargée en mémoire)

L'idée de n'afficher que ce qu'il y a à l'écran est bonne, je vais y réfléchir! Seul problème, je cherche à éviter un repaint inutile. Or avec cette technique, j'effectue d'office un repaint! Mais c'est plus léger pour le processeur, effectivement

ben .... des que ce qui est a l'écran change ...
la fonction repaint est appelée :s
y compris avec les scroll bar :s

oui j'ai fini par le comprendre, merci !