Discussion :

[Pragmateek]

Salut!

Comment faire pour, à partir d'une classe qui gère des graphes par exemple, afficher les graphiques en utilisant une classe dédiée à l'affichage.
Exemple:

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
class Graphiques{
 
ClasseAffichageOpenGL objetOpenGL;
...
void afficheLigne(int x1,int y1,int x2,int y2){
objetOpenGL.dessinerLigne(x1,y1,x2,y2);
}
...
}
 
class ClasseAffichageOpenGL implements GLEventListener,KeyListener,MouseListener,MouseMotionListener{
...
void dessinerLigne(int x1,int y1,int x2,int y2){
gl.glBegin(GL.GL_LINE);
gl.glVertex2d(x1,y1);
gl.glVertex2d(x2,y2);
gl.glEnd();
}
...
}

1)Comment faire pour faire sortir la partie affichage de la méthode "display" classique?
Faut il toujours un objet "GLDrawable" en paramètre?
2)D'ou vient l'objet "GLDrawable":

Code :

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

public void display(GLDrawable glDrawable)

Comment et par qui est il créé et comment est il transmit à toutes les méthodes sans jamais apparaître dans le code?
3)Peut on appeler les fonctions d'affichage de cette classe à partir d'une autre sans devoir passer en paramètre un "GLDrawable"?

Merci de votre aide.

[plegat]

1)Comment faire pour faire sortir la partie affichage de la méthode "display" classique?
Faut il toujours un objet "GLDrawable" en paramètre?

ça dépend... soit tu passes ton GLDrawable en paramètre, soit tu passes ton objet GL correspondant... je crois me souvenir qu'il est préférable de passer le GLDrawable et récupérer le GL, mais je ne saurais plus dire pourquoi.

2)D'ou vient l'objet "GLDrawable":

Code :

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

public void display(GLDrawable glDrawable)

Comment et par qui est il créé et comment est il transmit à toutes les méthodes sans jamais apparaître dans le code?

GLDrawable est une interface qu'implémente GLCanvas par exemple. C'est donc lié à ton composant graphique.

3)Peut on appeler les fonctions d'affichage de cette classe à partir d'une autre sans devoir passer en paramètre un "GLDrawable"?

Ca dépend de ce que font les fonctions... à mon avis, il serait préférable de le passer en paramètre. Sinon tu risques de vouloir afficher sur le mauvais pipeline...

Mais bon, je ne comprends pas trop ce que tu veux faire donc...

[omlip]

c'est en effet une bonne question

mais JOGl fonctionne, dans ses dernières versions, avec un système de callback qui appelle sans cesse ta méthode display

Je pense pas que ce soit possible d'externaliser l'affichage hors de ta méthode display : c'est à dire faire des gl.glBegin();, gl.glEnd(); etc.... hors des 4 méthodes de callback


mais bon je ne comprend pas spécialement bien non plus donc je sais pas t'en dire plus


A+
omlip

[Pragmateek]

soit tu passes ton GLDrawable en paramètre, soit tu passes ton objet GL correspondant

De quelle manière?
Car justement comment récupérer ce "GLDrawable" qui n'apparaît nulle part, a part justement dans les fonctions classiques d'affichage comme "display".
Comme ca:

Code :

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

1
2
public void display(GLDrawable glDrawable){
fonctionQuiFaitLeGraphe(glDrawable,...);

?
Mais il faut toujours passer par cette fonction "display".

Je pense pas que ce soit possible d'externaliser l'affichage hors de ta méthode display

Si c'est effectivement le cas JOGL manque vraiment de souplesse.

Mais bon, je ne comprends pas trop ce que tu veux faire donc...

En fait une classe est chargée de définir les caractéristiques d'un graphique:
fonction à représenter, paramètre d'affichage...
Dans cette classe tous les points du graphique sont calculés, stockés dans un "ArrayList" puis il faudrait pouvoir les envoyer à une fonction qui afficherait tous ces points, du type:

Code :

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

1
2
3
public void display(GLDrawable glDrawable,ArrayList<Double> PointList){
/*Afficher les points*/
}

[plegat]

De quelle manière?
Car justement comment récupérer ce "GLDrawable" qui n'apparaît nulle part, a part justement dans les fonctions classiques d'affichage comme "display".
Comme ca:

Code :

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

1
2
public void display(GLDrawable glDrawable){
fonctionQuiFaitLeGraphe(glDrawable,...);

?

Et oui, par exemple. Si ta fonctionQuiFaitLeGraphe doit afficher quelque chose quelque part, il faut bien qu'elle sache où se situe le "quelque part". Donc soit lui fournir le GLDrawable en paramètre, soit le stocker en tant qu'instance de classe accessible par toutes les méthodes de la classe. Mais dans tous les cas, il faut que la fonction qui dessine ait accès à l'objet où elle doit dessiner.

Mais il faut toujours passer par cette fonction "display".

Elle est appelée à chaque fois qu'il y a besoin de redessiner l'affichage. C'est un point de passage quasi-obligé (je mets le "quasi", car j'en vois bien un ou deux qui vont dire que ce n'est pas forcé...)

Si c'est effectivement le cas JOGL manque vraiment de souplesse.

Pourquoi?
Tu as le même soucis en OpenGL. Il te faut une procédure qui aura en charge de gérer l'affichage.
Pou JOGL, il s'agit de display()...

En fait une classe est chargée de définir les caractéristiques d'un graphique:
fonction à représenter, paramètre d'affichage...
Dans cette classe tous les points du graphique sont calculés, stockés dans un "ArrayList" puis il faudrait pouvoir les envoyer à une fonction qui afficherait tous ces points, du type:

Code :

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

1
2
3
public void display(GLDrawable glDrawable,ArrayList<Double> PointList){
/*Afficher les points*/
}

Perso, je ne vois toujours pas où est ton problème.... Qu'est-ce qui te bloque dans la démarche que tu expliques là?
Tu mets ton arraylist en instance de classe (vu que c'est lié à ton objet graphique), tu le remplis dans une méthode (méthode1), et tu l'affiches avec une autre méthode (méthode2). Il suffit ensuite d'appeler la méthode2 depuis la méthode display() (en passant le GLDrawable de display() en paramètre à la méthode2), et terminé, c'est affiché. Non?

[Pragmateek]

Concètement:
dans la classe qui gère le graphique:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
OpenGLInterface gLInterface;
...
private void drawAxes(){
		ArrayList<Double> xAxe=new ArrayList<Double>(6);
		xAxe.add(-1.);
		xAxe.add(0.);
		xAxe.add(0.);
		xAxe.add(1.);
		xAxe.add(0.);
		xAxe.add(0.);
		GLInterface.display1(/*le GLDrawable*/,xAxe);
	}

Et dans la classe OpenGLInterface:

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
public void display(GLDrawable glDrawable,ArrayList<Double> PointList){
 
		GL gl=glDrawable.getGL();
		GLU glu=glDrawable.getGLU();
		gl.glClearColor(0.f,0.f,0.f,1f);
		gl.glClear(GL.GL_COLOR_BUFFER_BIT);
		glu.gluPerspective(45,1,1,100);
		glu.gluLookAt(0,0,10,0,0,0,0,1,0);
 
		for(int n=0;n<PointList.size();n+=6){
			gl.glBegin(GL.GL_LINE);
			gl.glVertex3d(Double.valueOf(PointList.get(n)),Double.valueOf(PointList.get(n+1)),Double.valueOf(PointList.get(n+2)));
			gl.glVertex3d(Double.valueOf(PointList.get(n+3)),Double.valueOf(PointList.get(n+4)),Double.valueOf(PointList.get(n+5)));
			gl.glEnd();
		}
	}

surchargée pour pouvoir lui passer le tableau de points.
Mais comment créer un "GLDrawable" valide pour le passer en paramètre?

Et la classe qui gère le graphique est quelquonque.

Sinon ce que tu dis est vrai si la classe est du type "OpenGLInterface" et là il n'y a pas de problème mais l'externalisation de l'affichage n'est pas suffisante; il faudrait appeler "display" depuis l'autre classe.

[plegat]

Je crois que ce serait plus simple d'appeler ta méthode drawAxes() (qui retournerait ton arrayList) depuis la méthode display() de ton composant, plutôt que l'inverse comme tu le fais...

Et sinon, au lieu de passer le GLDrawable en paramètre, tu récupère directement le GL de ton composant avec getGL(). Ca sera aussi simple.

[Pragmateek]

Je crois que ce serait plus simple d'appeler ta méthode drawAxes() (qui retournerait ton arrayList) depuis la méthode display() de ton composant, plutôt que l'inverse comme tu le fais...

C'est vrai mais cela oblige à tout mettre dans une seule classe:gestion des données et affichage.

Et sinon, au lieu de passer le GLDrawable en paramètre, tu récupère directement le GL de ton composant avec getGL(). Ca sera aussi simple.

Mais pour avoir un "GL" il faut obligatoirement un "GLDrawable", non?

[plegat]

Mais pour avoir un "GL" il faut obligatoirement un "GLDrawable", non?

Ca dépend de la nature de ton objet OpenGLInterface. Si il implémente GLDrawable (style GLCanvas...), tu as une méthode getGL() qui te retourne le pipeline GL associé.

[Pragmateek]

En rajoutant:

Code :

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

class OpenGLInterface implements GLEventListener,KeyListener,MouseListener,MouseMotionListener,GLDrawable

il faut définir la méthode "getGL()",comment?

[plegat]

En rajoutant:

Code :

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

class OpenGLInterface implements GLEventListener,KeyListener,MouseListener,MouseMotionListener,GLDrawable

il faut définir la méthode "getGL()",comment?

No sé...
T'aurais pas un GLCanvas dans ton application?
Tu affiches où?

[Pragmateek]

Dans la classe qui gère le graphe il y a cette méthode:

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
private GLCanvas createDefaultCanvas(){
		Frame frame=new Frame("OpenGL");
		GLCanvas canvas1=GLDrawableFactory.getFactory().createGLCanvas(new GLCapabilities());
		frame.add(canvas1);
		frame.setSize(500,500);
		frame.setLocation(400,250);
		frame.setBackground(Color.BLUE);
		frame.addWindowListener(new WindowAdapter(){
			public void windowClosing(WindowEvent e){
				System.exit(0);
			}
			});
		frame.setVisible(true);
		return canvas1;
	}

Alors il faudrait faire un "getGLDrawable" et c'est lui qui permettrait de faire le lien entre les classes?

[plegat]

Alors il faudrait faire un "getGLDrawable" et c'est lui qui permettrait de faire le lien entre les classes?

Ouaip.
Ou un getGL() si tu n'as besoin que du GL.

Quoique je ne saisi pas bien quel pourrait être le lien entre les classes si tu sépares données et affichage... si tu sépares vraiment, tu n'as pas de lien à faire avec un quelconque GL ou GLDrawable. Ces objets doivent rester du côté affichage.
Ou alors je n'ai vraiment pas (encore) tout compris...

[Pragmateek]

En fait la classe qui gère les propriétés du graphique possède comme donnée membre un objet du type la classe qui gère l'affichage.
Donc peut être qu'en passant en paramètre à la méthode "display" de la classe qui fait l'affichage un "GLDrawable" créé dans la classe qui gère les propriétés le lien serait établit.

[plegat]

Donc peut être qu'en passant en paramètre à la méthode "display" de la classe qui fait l'affichage un "GLDrawable" créé dans la classe qui gère les propriétés le lien serait établit.

C'est là, que je ne pige pas...
Le GLDrawable est une propriété... enfin, un objet, de la classe qui fait l'affichage. La classe qui gère les propriétés n'a absolument pas à s'en occuper!
Ou alors c'est qu'elle s'occupe elle aussi de faire de l'affichage, et que tu n'as donc pas réellement fait la séparation données/affichage...

[Pragmateek]

Le principe est de séparer le traitement des caractéristiques du graphique et sa préparation de l'affichage JOGL:
la classe "Graph" prépare le graphique puis fait afficher celui ci par l'intermédiaire d'une instance de la classe "OpenGLInterface".
En gros:

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
class OpenGLInterface implements GLEventListener,KeyListener,MouseListener,MouseMotionListener{
	private GLCanvas canvas;
 
 
	public OpenGLInterface(GLCanvas canvas){
		this.canvas=canvas;
	}
 
	public void init(GLDrawable glDrawable){
		GL gl=glDrawable.getGL();
		gl.glPointSize(4.f);		
	}
	public void display(GLDrawable glDrawable){
 
 
		}
 
 
	public void reshape(GLDrawable glDrawable,int x,int y,int width,int height){
		final GL gl=glDrawable.getGL();
		final GLU glu=glDrawable.getGLU();
 
		gl.glViewport(0,0,width,height);
		gl.glMatrixMode(GL.GL_MODELVIEW);
		gl.glLoadIdentity();		
	}
 
 
	public void displayChanged(GLDrawable arg0, boolean arg1, boolean arg2) {
		// TODO Auto-generated method stub
 
	}
 
	public void keyTyped(KeyEvent arg0) {
		// TODO Auto-generated method stub
 
	}
 
	public void keyPressed(KeyEvent arg0) {
		// TODO Auto-generated method stub
 
	}
 
	public void keyReleased(KeyEvent arg0) {
		// TODO Auto-generated method stub
 
	}
 
	public void mouseClicked(MouseEvent arg0) {
		// TODO Auto-generated method stub
 
	}
 
	public void mousePressed(MouseEvent arg0) {
		// TODO Auto-generated method stub
 
	}
 
	public void mouseReleased(MouseEvent arg0) {
		// TODO Auto-generated method stub
 
	}
 
	public void mouseEntered(MouseEvent arg0) {
		// TODO Auto-generated method stub
 
	}
 
	public void mouseExited(MouseEvent arg0) {
		// TODO Auto-generated method stub
 
	}
 
	public void mouseDragged(MouseEvent arg0) {
		// TODO Auto-generated method stub
 
	}
 
	public void mouseMoved(MouseEvent arg0) {
		// TODO Auto-generated method stub
 
	}
}
 
 
 
 
 
class Graph{
	private class WindowAttribute{
		double xMin=0;
		double xMax=10;
		double yMinr=0;
		double yMax=10;
		double xStep=1;
		double yStep=1;
		boolean showAxes=true;
	};
 
	GLCanvas canvas;
	OpenGLInterface gLInterface;
 
	public Graph(){
		canvas=createDefaultCanvas();
		gLInterface=createInterface();
	}
 
 
	private GLCanvas createDefaultCanvas(){
		Frame frame=new Frame("azerty");
		GLCanvas canvas1=GLDrawableFactory.getFactory().createGLCanvas(new GLCapabilities());
		frame.add(canvas1);
		frame.setSize(500,500);
		frame.setLocation(400,250);
		frame.setBackground(Color.BLUE);
		frame.addWindowListener(new WindowAdapter(){
			public void windowClosing(WindowEvent e){
				System.exit(0);
			}
			});
		frame.setVisible(true);
		return canvas1;
	}
 
	private OpenGLInterface createInterface(){
		OpenGLInterface listener=new OpenGLInterface(canvas);
		canvas.addGLEventListener(listener);
		canvas.addKeyListener(listener);
		canvas.addMouseListener(listener);
		canvas.addMouseMotionListener(listener);
		return listener;
	}
 
	private void drawAxes(){
		ArrayList<Double> xAxe=new ArrayList<Double>(6);
		xAxe.add(-1.);
		xAxe.add(0.);
		xAxe.add(0.);
		xAxe.add(1.);
		xAxe.add(0.);
		xAxe.add(0.);
		/*Ici comment commander l'affichage?*/
	}
};

Une méthode serait de faire un buffer "public" dans la classe "OpenGLInterface" qui contiendrait les points à afficher et c'est dans ce buffer que la classe "Graph" écrirait les points avant de commander l'affichage en appelant la méthode "display" de l'objet "gLInterface".

La question est est-ce possible et si oui comment le faire?

[plegat]

La question est est-ce possible et si oui comment le faire?

Tu crées un attribut privé ArrayList dans ta classe OpenGLInterface, et un accesseur setAxes public afin de pouvoir initialiser l'arraylist depuis l'autre classe.
Et tu affiches tes axes à partir de la méthode display() de la classe OpenGLInterface (qui a donc accès à ton arraylist).

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
class OpenGLInterface implements GLEventListener,KeyListener,MouseListener,MouseMotionListener{
	private GLCanvas canvas;
	private ArrayList<double> axes;
 
	...
 
	public void setAxes(ArrayList<double> _axes) {
		this.axes=_axes;
 
		/*pour rafraichir l'affichage:*/
		this.canvas.repaint();
	}
 
}
 
 
class Graph{
 
	...
 
	private void drawAxes(){
		ArrayList<Double> xAxe=new ArrayList<Double>(6);
		xAxe.add(-1.);
		xAxe.add(0.);
		xAxe.add(0.);
		xAxe.add(1.);
		xAxe.add(0.);
		xAxe.add(0.);
		/*Ici comment commander l'affichage?*/
 
		/*TU NE COMMANDES PAS L'AFFICHAGE DANS CETTE CLASSE!!! */
		gLInterface.setAxes(xAxe);
	}
};

Vérifie les syntaxes java 5, je ne suis pas familier avec (j'en suis resté en 1.4.2! )

[Pragmateek]

OK et donc faire un "ArrayList", dans la classe qui gère l'affichage, contenant tous les points ne posera pas de problème.
Il suffira juste de mettre le "ArrayList" en "public" puis de le remplir avec les points à partir de la classe "Graph" et enfin d'invoquer la méthode "display".
Par contre la méthode "display" est elle appelée en permanence pour rafraîchir l'affichage ou seulement quand elle est explicitement appelée?
Parce qu'il ne faudrait pas qu'elle change l'affichage alors que le "ArrayList" est en train d'être modifié.

[plegat]

Il suffira juste de mettre le "ArrayList" en "public"

C'est pas ce que j'ai écrit... relis mon post précédent...

Par contre la méthode "display" est elle appelée en permanence pour rafraîchir l'affichage ou seulement quand elle est explicitement appelée?

Ni l'un ni l'autre.
Elle est appelé quand il y a besoin de rafraichir l'affichage. Donc quand tu redimensionnes l'affichage (implicitement appelée), ou quand tu demandes un rafraichissement (avec le repaint())

Parce qu'il ne faudrait pas qu'elle change l'affichage alors que le "ArrayList" est en train d'être modifié.

Ce qui ne changera rien, car l'arraylist est modifié dans la classe Graph, et n'est passé à la classe OpenGLInterface que quand il est complètement modifié. Et display n'est appelé qu'une fois que l'arrayList est passé de la classe Grpah à la classe OpenGLInterface.

Cependant, si l'arraylist est en train d'être modifié, c'est qu'il va falloir refaire une mise à jour de l'affichage au final. Donc en quoi ça gêne que display soit appelé un poil trop tôt? A la vitesse où ça va, tu n'y verras que du feu...

[Pragmateek]

C'est pas ce que j'ai écrit... relis mon post précédent...

et n'est passé à la classe OpenGLInterface que quand il est complètement modifié.

Oui mais ne serait il pas plus pratique de le mettre en "public" afin de garder le prototype:

Code :

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

display(GLDrawable)

sans ajouter de paramètres?

Et puis il n'y a pas de méthode "repaint", c'est idem que "display"?