Double-buffering Soft ou Hardware ?

**orelero** · 29/05/2006, 13h54

Bonjour,
J'aimerai essayer de faire un jeu simple sans animation rapides. Je pensais accelerer les animations par doublebuffering software.
Par contre j'aimerai rendre possible un scrolling assez rapide et fluide de la carte du jeu (comme dans les jeux de strategie). Quelle accélération semblerait être la plus appropriée ?
Merci.

**spekal** · 30/05/2006, 10h27

Je connais pas beaucoup, mais je pense que tu pourras trouver des réponses sur les blog et articles de Chet Haase, en particulier VolatileBufferedToolkitImage Strategies. Mais je suis peut être complètement à coté de la plaque.

**orelero** · 30/05/2006, 10h56

je m'attendais à avoir plus de réactions, mais je me suis peut-être trompé de forum ? Sinon merci pour le lien !

**orelero** · 30/05/2006, 19h09

Pour une surface de 900 par 600, j'ai essayé , c'est meme pas la peine en software...

**bouye** · 30/05/2006, 23h21

Essaie de poser ta question sur le forum 2D de http://www.javagaming.org (en anglais).
Tu peux egalement voir dans la javadoc les flag a utiliser pour activer l'acceleration DirectX ou OpenGL de Java2D (suivant la version de la JVM dont tu disposes).

Egalement, n'hesite pas a poster des bouts de code pour qu'on puisse essayer de voir (et de tester) ce qui pose probleme.

**orelero** · 31/05/2006, 22h27

http://www.javagaming.org
Ok merci pour le lien !!
Par contre j'ai aucune connaissance en openGL, j'espere que ça ne m'handicapera pas trop

**bouye** · 31/05/2006, 23h07

Si tu restes en 2D, tu n'as rien besoin de savoir car cette acceleration t'es cachee. Tout ce que tu as a connaitre ce sont les commandes de dessin Java2D et les techniques d'animation software ou materielles (via un BufferStrategy, etc...).

**orelero** · 01/06/2006, 11h47

quand tu parles de flags pour activer l'opengl, c'est sur cette page là qu'ils expliquent ?: http://java.sun.com/j2se/1.5.0/docs/guide/2d/flags.html
Ca s'active depuis le programme ou manuellement ?
Si l'accélération est activée juste par un flag, ça me parait un peu facile

mais je m'en plaindrais pas. Si c'est aussi simple, je pense que je vais l'activer une fois ls parties les plus basiques de mon jeu, finies.

**orelero** · 01/06/2006, 15h24

Je viens de tester BufferStrategy, ça améliore nettement mais je vois toujours des imperfections comme dans cet exemple :
(C'est un scrolling d'une map assemblée d'images 150*150, on arrive à observer des fois le dessins se créer. Dans aucun jeu meme à la limite du potable on observe ça ...En plus si je teste si isDoubleBuffered appliqué au canvas renvoie bien true, et bien j'obtiens false !! Je comprends plus rien. Autre problème, meme en implementant les méthodes de redimensionnement du canvas, sa taille ne se fixe pas !!!! A l'aide

)
[code édité]

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
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
//MISC
import java.awt.*;
import java.awt.image.*;
import javax.swing.*;
import java.awt.event.*;
import java.awt.geom.*;
 
//synth
import de.javasoft.plaf.synthetica.SyntheticaStandardLookAndFeel;
 
 
 
public class TanXTheGame
{
	//STATIC DATA
	public static DoubleBufferedCanvas mainCanvas;
	public static JFrame mainFrame;
	public static GameLoop gameLoop;
	public static int mouseX;
	public static int mouseY;
	public static int viewPortX=0;
	public static int viewPortY=0;
	public static BufferedImage bufferedImageDesert = Tools.toBufferedImage(Toolkit.getDefaultToolkit().createImage("sprites/tile22.png"));
	public static int scrollState;
	//SYNCHRONIZED METHODS
 
	//*****************************************************************************
	//*****************************************************************************
	public static void main(String s[])
	{
	    //L&F
	    try 
    	{
      		UIManager.setLookAndFeel(new SyntheticaStandardLookAndFeel());
    	} 
    	catch (Exception e) 
    	{
     		 e.printStackTrace();
    	}
 
	    //FRAME
	    mainFrame = new JFrame();
	    mainFrame.setBackground(Color.BLACK);
	    mainFrame.setSize(900, 600);
 
	    //CANVAS
	    mainCanvas = new DoubleBufferedCanvas();
	    mainCanvas.setBackground(Color.BLACK);
	    mainCanvas.setIgnoreRepaint(true);
	    mainFrame.getContentPane().add(mainCanvas);
	    mainCanvas.setBounds(0,0,100,560);
	    mainFrame.setVisible(true);
	    gameLoop = new GameLoop();
	    gameLoop.start();
	}
	//*****************************************************************************
	//*****************************************************************************
}
 
 
 
//OTHER CLASSES***************************************************************
 
class DoubleBufferedCanvas extends Canvas
{
			public Dimension getPreferredSize()
			{
				return new Dimension(100,560);
			}
 
			public Dimension getMinimumSize()
			{
				return new Dimension(100,560);
			}
 
			public Dimension getMaximumSize()
			{
				return new Dimension(100,560);
			}
 
			public DoubleBufferedCanvas()
			{
				addKeyListener
	    		(
	    			new KeyAdapter()
	    			{
	    				public void keyPressed(KeyEvent e)
	    				{
	    					int keyCode = e.getKeyCode();
	    					switch(keyCode)
	    					{
	    						case KeyEvent.VK_UP :
	    						TanXTheGame.viewPortY=TanXTheGame.viewPortY+50;
	    						TanXTheGame.scrollState=1;
	    						break;
	    						case KeyEvent.VK_RIGHT :
	    						TanXTheGame.viewPortX=TanXTheGame.viewPortX-50;
	    						TanXTheGame.scrollState=0;	    						
	    						break;
	    						case KeyEvent.VK_DOWN :
	    						TanXTheGame.viewPortY=TanXTheGame.viewPortY-50;
	    						TanXTheGame.scrollState=0;
	    						break;
	    						case KeyEvent.VK_LEFT :
	    						TanXTheGame.viewPortX=TanXTheGame.viewPortX+50;
	    						TanXTheGame.scrollState=1;	    						
	    						break;
	    					}
	    				}
	    			}
	    		);
	    		addMouseMotionListener
	    		(
	    			new MouseMotionAdapter()
	    			{
	    				public void mouseMoved(MouseEvent e)
	    				{
	    					TanXTheGame.mouseX = e.getX();
	    					TanXTheGame.mouseY = e.getY();
	    				}
	    			}
	    		);
 
	    	}
}
//*****************************************************************************
class MatrixMap
{
	String _name;
	Dimension _dimensions;
	int _type;
 
	public MatrixMap(String name, Dimension dimensions, int type, int[][] data)
	{
		_name=name;_dimensions=dimensions;_type=type;
	}
}
//***********************GAME LOOP*********************************************
class GameLoop extends Thread
{
	public BufferStrategy strategy ;
	public Graphics2D backBuffer ;
	public DoubleBufferedCanvas _mainCanvas;
	public int fps;
	public long measuredTime=0;
	public long measured=1;
	public long max=1;
	public GameLoop()
	{
		_mainCanvas = TanXTheGame.mainCanvas;
		_mainCanvas.setIgnoreRepaint(true);
		_mainCanvas.createBufferStrategy(2);
 		strategy = _mainCanvas.getBufferStrategy();
		backBuffer = (Graphics2D)strategy.getDrawGraphics() ;
	}
 
	public void run()
	{
		render();
	}
 
	public void render()
 	{
 		while(true)
 		{	
 			measuredTime = System.currentTimeMillis();
 			//backBuffer.setColor(Color.WHITE);
 			backBuffer.fillRect(0,0,_mainCanvas.getWidth(), _mainCanvas.getHeight());
 			//backBuffer.drawImage(TanXTheGame.bufferedImage,null,TanXTheGame.mouseX,TanXTheGame.mouseY);
 			if(TanXTheGame.scrollState==1)drawTileBackgroundPLUS(); else drawTileBackgroundMOINS();
 			measured = (System.currentTimeMillis()-measuredTime)+1;
 			backBuffer.drawString("minimum fps: "+1000/max+"  current fps: "+1000/measured,4,14);
 			backBuffer.draw3DRect(2, 2, 200, 15, false);
 			strategy.show();
 			if(measured>max)max=measured;
 		}
	}
 
	public void drawTileBackgroundMOINS()
	{
		int i=0,j = 0;
		while(i<10)
		{
			while(j<10)
			{
				backBuffer.drawImage(TanXTheGame.bufferedImageDesert,null,(150*j)+TanXTheGame.viewPortX,(150*i)+TanXTheGame.viewPortY);
				j++;
			}
			j=0;i++;
		}
	}
 
	public void drawTileBackgroundPLUS()
	{
		int i=9,j=9;
		while(i>=0)
		{
			while(j>=0)
			{
				backBuffer.drawImage(TanXTheGame.bufferedImageDesert,null,(150*j)+TanXTheGame.viewPortX,(150*i)+TanXTheGame.viewPortY);
				j--;
			}
			j=10;i--;
		}
	}
}
//*****************************************************************************
class Tools
{
		//TOOLS
		static BufferedImage toBufferedImage(Image image)
		{
	        if( image instanceof BufferedImage )
	        {
	                return( (BufferedImage)image );
	        }
	        else
	        {
	                image = new ImageIcon(image).getImage();
	                BufferedImage bufferedImage = new BufferedImage(image.getWidth(null),image.getHeight(null),BufferedImage.TYPE_INT_ARGB );
	                Graphics g = bufferedImage.createGraphics();
	                g.drawImage(image,0,0,null);
	                g.dispose();
	                return( bufferedImage );
	        } 
		}
		//
		static BufferedImage rotateBuffer(BufferedImage bi,double angle)
		{
			AffineTransform tx = new AffineTransform();
			tx.rotate(angle);
			AffineTransformOp op = new AffineTransformOp(tx, AffineTransformOp.TYPE_BILINEAR);
	    	return op.filter(bi, null);
		}
}
//*****************************************************************************

**bouye** · 02/06/2006, 00h30

Hum la ca sort un peu de mon domaine de competences, sur mon ordi du boulot ca marche : le scrolling est plutot rapide, sans etre super-fluide pour autant. J'ai modifie le code voir plus bas et le curseur clignote pas mal pres de la fenetre (mais j'ai une carte video de daube).

Cenpendant je peux te conseiller d'utiliser ImageIO pour beneficier d'un chargement synchrone plutot que Toolkit (chargement asynchrone). Ceci peut te permettre d'eviter d'utiliser une image non-completement chargee (voir carrement de faire planter ton programme) dans les premieres boucles d'affichage.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
      try {
        java.net.URL url = TanXTheGame.class.getResource("/sprites/tile22.png");
        if (url == null) {
          System.err.println("ERROR cannot reach sprite image.");
          System.exit(1);
        }
        bufferedImageDesert = javax.imageio.ImageIO.read(url);
      }
      catch (Exception e) {
        System.err.println("ERROR while reading sprite image.");
        System.exit(1);
      }

L'utilisation d'une URL et d'un ClassLoader (utilise indirectement via getResource()) permettent egalement d'utiliser le meme code indistinctement dans une arborescence de repertoire ou dans un JAR. Note le repertoire contenant le repertoire sprites doit etre dans le classpath du projet (voir les proprietes du projet dans ton IDE).

J'ai egalement rajoute un

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

pour que le programme se ferme correctement.

En tant normal je t'aurais dis que melanger une Canvas et Swing c'est pas bien (http://java.developpez.com/faq/java/..._melange_SWING) et d'utiliser un JPanel a la place mais bon c'est vrai qu'on ne peut pas creer de BufferStragegy avec les composant Swing... et c'est pas top... Donc c'est probablement mieux ainsi en tout cas pour le moment. Attention cependant si tu penses vouloir rajouter des menu (entre autre) a ta frame il te faudra utiliser la methode JPopupMenu.setDefaultLightWeightPopupEnabled(false).

Egalement tu peux etre interesse par l'utilisation du monde plein ecran exclusif (FullScreen Exclusive Mode) qui te debarrasse de beacoup de ralentissements lies au systeme de fenetrage.

Une astuce... mais dont je doute qu'elle puisse t'aider avec des fonds compose de plusieurs tiles et en cas de scrolling differentiel : on peut obtenir le meme resultat en utilisant tout simplement un TexturePaint dont on change l'origine du rectangle de coordonnees pour peindre un grand rectangle en fond du JPanel/Canvas...

**orelero** · 02/06/2006, 02h55

vraiment merci bouye !
Pour le class loader j'avais oublié :-s.
Sinon pour ce qui est du chargement des données images avec ImageIO je ne savais pas du tout

. SQuand tu dis que tu as une carte graphique un peu nulle et que ça rame un peu, ça me fait peur parceque c'est justement un jeu pour ceux qui n'ont pas de bonnes cartes

.
A propos de swing et awt, c'est vrai que y'a pas beaucoup d'autres moyens :-s. De toute façon je ne vais pas rajouter de menu avec composants swing je vais plutot essayer de faire un HUD dessiné à meme le canvas (j'espere que c'est pas une mauvaise idée ).

Une astuce... mais dont je doute qu'elle puisse t'aider avec des fonds compose de plusieurs tiles et en cas de scrolling differentiel : on peut obtenir le meme resultat en utilisant tout simplement un TexturePaint dont on change l'origine du rectangle de coordonnees pour peindre un grand rectangle en fond du JPanel/Canvas...

SI si, justement si tu penses que c'est une meilleur optimisation, c'est trés faisable : suffit de rassembler l'ensemble des tiles dans une meme grande texture lorsque la carte est chargée ?

**orelero** · 05/06/2006, 18h44

Je viens d'essayer avec ImageIO, et ça me descend mes 58fps à 1fps, le scrolling est ultra lent

ainsi que les autres programmes que j'ai ouverts.
pourtant j'ai simplement copié collé les lignes de code que tu m'as donné plus haut

**bouye** · 06/06/2006, 02h54

Ce n'est pas normal etant donne que ImageIO ne se charge que de la lecture des fichiers sur le disque. En faisaint tourner ton test avec une image de mon cru, le FPS est toujours a 1000*, sauf quand je deplace la fenetre ou la ca descend vers 57~58.

* Note quand je disais pas fluide c'est principalement du a des pb de synchronisation avec le taux de rafraichissement nottement quand on arrive au bord de la zone texturee ou on appercoit des effets d'escaliers lors du rafraichissement (ca le fait moins, mais c'est present, quand on est en train de scroller au beau milieu de la zone texturee).

Cependant, apres avoir joue un peu avec ta methode rotate() et avoir vu effectivement le FPS passer a 1 ou 0 je pense qu'il dois y avoir un probleme d'images non-compatibles avec ton affichage. Je te proposes donc de rajouter cette methode dans ta classe Tools. Tu peux essayer de l'appeler si besoin juste apres le chargement des images et aussi modifier ta methode toBufferedImage() en s'inspirant de celle-ci.

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

Dans mon cas ca a regle le probleme mais je ne te garantit rien.
J'ai donc aussi modifie la methode rotate() pour le besoin des tests (note : l'image n'est plus correcte apres plusieurs rotations) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
  static BufferedImage rotateBuffer(BufferedImage bi, double angle) {
    AffineTransform tx = new AffineTransform();
    tx.rotate(angle, bi.getWidth() / 2.0, bi.getHeight() / 2.0);
    AffineTransformOp op = new AffineTransformOp(tx, AffineTransformOp.TYPE_NEAREST_NEIGHBOR);
    //AffineTransformOp op = new AffineTransformOp(tx, AffineTransformOp.TYPE_BILINEAR);
    //AffineTransformOp op = new AffineTransformOp(tx, AffineTransformOp.TYPE_BICUBIC);
    return Tools.toCompatibleImage(op.filter(bi, null));
  }

Note : avec une rotation BILINEAR ou BICUBIC, le FPS tombe quand meme aux alentours de 30~58 meme avec une image compatible, il reste a 1000 avec NEAREST_NEIGHBOR (evidement c'est pas beau a voir).

**orelero** · 06/06/2006, 05h12

tu a appliqué la methode rotate à chaque tile lors du dessin du background ? J'ai essayé et je descend à 3fps

Pour le chargement avec ImageIO, en appliquant creatCompatibleImage, ca fonctionne (meme si je plafonne à 58fps maximum, donc je peux pas savoir si ça a de meilleures performance qu'avec toolkit).
Par contre je me demande pourquoi _mainCanvas.isDoubleBuffered( ) me renvoie false

.
Autre chose : est ce que toi aussi, lorsque tu change la position du canvas dans la jframe, la plupart du temps ça ne change rien (en effet ça a marché une fois et je n'arrive plus à le reproduire

).

Grand merci à ton aide Bouye. Pour ceux qui lisent tous les posts de ce thread, j'èspère que c'est pas trop fouilli

.
J'attends aussi des remarques depuis le forum java games (lien que tu m'as donné Bouye).

**bouye** · 06/06/2006, 06h19

J'ai juste rajoute ca dans la gestion des touches du clavier :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
          case KeyEvent.VK_V:
            TanXTheGame.bufferedImageDesert = Tools.rotateBuffer(TanXTheGame.bufferedImageDesert, 2 * Math.PI / 10);
            break;
          case KeyEvent.VK_C:
            TanXTheGame.bufferedImageDesert = Tools.rotateBuffer(TanXTheGame.bufferedImageDesert, -2 * Math.PI / 10);
            break;

C'etait principalement pour voir ce que ca donnai. Sans image compatible, le FPS s'effrondre.

Le gros embetement avec Toolkit c'est que ton image peut ne pas etre completement chargee en memoire lorsque tu la transformes en BufferedImage, ce qui peut faire planter le programme (mon cas, car les dimensions etaient <= 0) ou faire que la BufferedImage resultante peut etre completement ou en partie noire (car tous ou certains pixels peuvent ne pas avoir ete charges).

Par contre je me demande pourquoi _mainCanvas.isDoubleBuffered( ) me renvoie false

Aucune idee, j'ai peu fait d'animations de ce genre.

Autre chose : est ce que toi aussi, lorsque tu change la position du canvas dans la jframe, la plupart du temps ça ne change rien (en effet ça a marché une fois et je n'arrive plus à le reproduire ).

Il te faut faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

mainFrame.setLayout(null);

Et apres tu peux la mettre ou tu veux avec setBounds() ou setLocation(). Le layout par defaut doit etre un FlowLayout (puisque le contentPane d'une JFrame est un JPanel ou equivalent), ce qui fait aussi que ta canvas prend automatiquement la taille complete de la frame. Tu remarqueras d'ailleurs que, par contre, le buffer strategy n'est jamais aggrandit lorsque tu redimensionnee ta frame (manque un ComponentListener sur la Canvas ou la JFame ?), outre la zone texturee qui reste limitee on peut voir une difference de couleur (en tout cas sur mon ordi) entre les deux noirs (la zone residente en memoire video et la zone software ?).

Truc bizarre : un fois le layout nullifie, si tu garde la taille que tu as donne a ta canvas (100x560) le FPS s'effondre... si tu met (560x560) c'est fluide a nouveau... un pb de gestion de sa memoire par la carte video quand on alloue des buffers trop petits ?

ex : test avec (0, 0, 200x560) :

**orelero** · 06/06/2006, 13h01

Il te faut faire :

Code :
mainFrame.setLayout(null);

en effet, ça résout bien des problèmes, merci

Tu remarqueras d'ailleurs que, par contre, le buffer strategy n'est jamais aggrandit lorsque tu redimensionnee ta frame

Pas pensé à ça

. Normalement si la taille du canvas n'est pas modifiée (si c'est le cas, je me demande ce qu'il se passerait), je pense pas que ça ai de l'importance ?

difference de couleur (en tout cas sur mon ordi) entre les deux noirs

Bizarre, je n'ai pas cette difference de noir

. Je sais pas si ça a une incidence mais maintenant j'utilise une Frame à la place d'une JFrame.

Je vais tester ce que tu m'avais conseillé, à savoir, créer une grosse texture à partir des tiles, ensuite selectionner la zone à afficher grace à subimage.

**orelero** · 06/06/2006, 20h22

j'ai testé la grosse texture vite fait, et bien ça m'a l'air bien mieux

! En tout cas y'a plus l'effet d'escalier lors du scrolling, y'a juste un léger ralentissement lorsque que je scroll avec un increment de 5.

**bouye** · 06/06/2006, 23h53

Envoyé par orelero

Pas pensé à ça

. Normalement si la taille du canvas n'est pas modifiée (si c'est le cas, je me demande ce qu'il se passerait), je pense pas que ça ai de l'importance ?

Une seulement partie du Canvas est accelere et ce que tu dessines dans le strategy reste de taille limitee quand on aggrandit la fenetre (voir screenshot precedent). Je n'ai pas trop teste ce qui se passe quand on reduite la fenetre cependant (et je ne peux pas tester car mon PC est en rade aujourd'hui et je ne peux pas installer le JDK sur celui que j'utilise maintenant).

Rien de bien grave cependant, surtout si dans ton programme/jeu final, elle n'est jamais redimensionnee (a tester).

**orelero** · 10/06/2006, 18h42

Je suis passé en Fullscreen mode, et bien ça doppe carrement le rendu !

**bouye** · 11/06/2006, 23h40

As-tu eut des reponses sur javagaming.org ?

Concernant ton MP, le mieux est probablement de poster ton code directement ici (ou dans un autre sujet si la question est differente), il doit bien y avoir d'autre personnes plus pointues que moi dans ce domaine ici quand meme (?)

Double-buffering Soft ou Hardware ?

Graphisme Java

Discussions similaires

Partager

Partager