Double-buffering Soft ou Hardware ?

Version imprimable

29/05/2006, 13h54
orelero

Double-buffering Soft ou Hardware ?

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.
30/05/2006, 10h27
spekal

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.
30/05/2006, 10h56
orelero

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

Pour une surface de 900 par 600, j'ai essayé , c'est meme pas la peine en software...
30/05/2006, 23h21
bouye

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.
31/05/2006, 22h27
orelero

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 :roll:
31/05/2006, 23h07
bouye

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...).
01/06/2006, 11h47
orelero

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

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 :oops: :( :( )
[code édité]

Code:

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);
		}
}
//*****************************************************************************

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:

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:

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

02/06/2006, 02h55
orelero

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 :-o . 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 :roll: .
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 ).

Citation:

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 ?
05/06/2006, 18h44
orelero

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 :roll:

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:

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:

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

06/06/2006, 05h12
orelero

tu a appliqué la methode rotate à chaque tile lors du dessin du background ? J'ai essayé et je descend à 3fps 8O
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 :roll: .
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 8O ).

Grand merci à ton aide Bouye. Pour ceux qui lisent tous les posts de ce thread, j'èspère que c'est pas trop fouilli:oops: .
J'attends aussi des remarques depuis le forum java games (lien que tu m'as donné Bouye).

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

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

Citation:

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

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

Citation:

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:

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

http://img91.imageshack.us/img91/6080/test8cd.th.jpg

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) :
http://img71.imageshack.us/img71/3428/test26bo.th.jpg

06/06/2006, 13h01
orelero

Citation:

Il te faut faire :

Code :
mainFrame.setLayout(null);

:oops: en effet, ça résout bien des problèmes, merci ;)

Citation:

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 ?

Citation:

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.
06/06/2006, 20h22
orelero

j'ai testé la grosse texture vite fait, et bien ça m'a l'air bien mieux :-o ! 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.
06/06/2006, 23h53
bouye

Citation:

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).
10/06/2006, 18h42
orelero

Je suis passé en Fullscreen mode, et bien ça doppe carrement le rendu ! :P
11/06/2006, 23h40
bouye

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 (?)
12/06/2006, 20h51
orelero

j'ai juste eu des réponse pour un problème :
Je voulais un peu optimiser par du clipping (ca se dit?), avec rectclip.
En fait mon problème c'était de vouloir déssinner une image de fond dans la partie hors du rectangle clippé. Quand je fait ça l'image figée ne semble être repainte et on observe donc un scintillement trés marqué :? . Sinon ils ont l'air de vite cerner le sujet sur ce site que tu m'as donné :).

Pour le MP, j'étais tellement désespéré que je t'ai écrit mais c'est vrai que ça se fait pas :oops: . Je pourrai trés bien poster ce que j'ai fait jusque là mais il faudrait que j'élague certaines choses sinon ça prendrait un peu de la place :-o.
Mais bon maintenant le scrolling marche trés bien et si quelqu'un veut savoir comment j'ai fait, dites le moi en MP :-p.

PS: l'intitulé du topic ne correspond plu exactement à l'ensemble des posts. Mais quand j'essai de le renommer, ça ne marche pas 8O .
13/06/2006, 00h00
bouye

Aucun probleme.
Cependant j'ai en ce moment un probleme de disque dur et j'ai donc la un peu la tete ailleurs.
19/06/2006, 12h37
Gfx

Petite information : n'utilisez pas la méthode de rendu BICUBIC qui ne dispose pas encore de boucles accélérées dans le pipeline de rendu de Java2D. La différence avec BILINEAR est tellement maigre que la perte de performance occasionnée n'en vaut pas la peine.
19/06/2006, 13h03
orelero

Salut gfx, merci pour l'info.
Sinon est-ce que tu sais comment activer le pipeline opengl sans passer par la ligne de commande ?
19/06/2006, 13h31
Gfx

C'est un paramètre de la JVM, donc on ne peut pas faire autrement. Tout logiciel qui permet de lancer un programme Java (ton IDE, un launcher, etc.) permet de spécifier les paramètres de la JVM. Tu dois pouvoir aussi le faire sous Windows depuis le panneau de configuration. C'est comme cela par exemple que tu peux activer certains paramètres pour les applets. Je n'ai pas de Windows sous la main donc je ne peux pas vérifier mais jette un oeil.
19/06/2006, 18h44
orelero

ok c'est bien à quoi je m'attendais, sur un blog d'un spécialiste une personne lui avais demandé pourquoi on ne pouvais pas le faire depuis le programme et l'auteur à répondu que ça le sera sans doute prochainement (ds mustang?).

Si y'a moyen de l'activer depuis un programme, je pourrai trés bien proposer aux utilisateurs une version openGL du programme pour chaque OS.
Par contre sous linux ou macOS j'ai pas de moyen pour vérifier :roll: .
22/06/2006, 19h28
orelero

Par contre, est-ce que le pipeline est disponible et activé par défaut dans la beta de java 6 ?
22/06/2006, 19h32
Gfx

Le pipeline OpenGL ? Il est disponible dans Mustang (et Tiger/J2SE 5.0 d'ailleurs) mais pas activé par défaut.
22/06/2006, 20h44
orelero

ok merci, de toute facon j'ai fait comme tu m'as dit , je lance mon jar avec l'option -Dsun.java2d.opengl=True (grace un batch sous windows). Par contre sous linux ca doit etre un peu prés pareil mais je n'ai pas linux et je sais pas comment faire un script shell :roll: . AUtre chose, comment linux va gerer java.exe 8O ?
22/06/2006, 23h23
bouye
Pas java.exe ; java tout court.
Code:

1 2 #!/bin/sh java <... le reste des arguments habituels ici>
Il faut juste que l'interpreter soit dans le PATH.
Ca devrait fonctionner sur tous les UNIX et derives d'ailleurs pas uniquement Linux (voir FreeBSD et MacOS).

Tu peux appeler ton script machin.sh pour faire la distinction mais c'est juste une precision supplementaire non-obligatoire. L'etat d'executabilite sous Unix fait partie des droits d'acces au fichiers et n'est pas specialement indiquee par son extension.
23/06/2006, 17h54
orelero

hmm ok bouye, sinon y'a un thread qui me semblait interessant :
http://www.javagaming.org/forums/ind...?topic=14092.0

Citation:

you can set the same system property in your main() method:

System.setProperty("sun.java2d.opengl", "true");

Pourtant moi ça ne marche pas de cette façon
24/06/2006, 07h22
bouye

Apparement et d'après le topic que tu cites (je n'ai pas essayé) il faudrai que tu fasses cet appel dans les toutes première lignes de ton main() bien avant qu'un quelconque élément graphique n'ai été initialisé (en espérant que tu n'ai rien de statique en rapport avec graphisme qui soit initilalisé dans cette même classe).
24/06/2006, 10h25
orelero

Citation:

en espérant que tu n'ai rien de statique en rapport avec graphisme qui soit initilalisé dans cette même classe

je l'ai mis dans le main en première ligne, mais j'ai des elements graphiques statiques :roll: .
Pour mettre à jour mon jar (sans passer par jws), je voulais démarrer l'application par un autre jar. Il y a peut-etre un moyen de lancer une vm avec options à partir de ce jar ?
25/06/2006, 23h18
bouye

Avec Runtime.exec() probablement, mais dans ce cas tu aurai 2 VM en memoire. J'ignore si tu peux quitter ton launcher sans terminer le programme lance de cette maniere. A tester.

De plus n'existe t-il pas certains systemes surlesquels ils ont reussi a faire une VM partagee (MacOS ? Est-ce le cas Gfx ?) re-utilisee par toutes les apps ; dans ce cas cela ne reglerai probablement pas le probleme. Et de maniere plus generale il me semble que cela fait partit des projets futurs pour eviter/diminer le temps de chargement des applications Java.
26/06/2006, 19h56
orelero

Citation:

De plus n'existe t-il pas certains systemes surlesquels ils ont reussi a faire une VM partagee

Peut-etre qu'on pourra toujours en lancer une autre en parallele ?
Pour les deux vm lancées sequentiellement par deux jar, c'est une idée que j'ai eu sur javagaming et apparement ça fonctionne bien :? .
10/07/2006, 18h38
orelero

juste comme ça, j'ai mis tous les objets graphiques de la classe principale dans une sorte de structure de donnée et j'ai mis le setProperty(...) (pour activer l'opengl) en premiere ligne du main et ça fonctionne bien. Pour ceux qui veulent changer une variable d'environement (pour la plupart) depuis une application jws, il faut signer le jar :? .