[JOGL] Appeler l'affichage OpenGL à partir d'une classe quelquonque.

Version imprimable

Voir 40 message(s) de cette discussion en une page

Salut!:D

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:

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:

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

06/07/2006, 23h36
plegat

Citation:

Envoyé par seriousme

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.

Citation:

Envoyé par seriousme

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

Code:

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.

Citation:

Envoyé par seriousme

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...
07/07/2006, 09h41
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
07/07/2006, 19h34
Pragmateek
Citation:

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:

1 2 public void display(GLDrawable glDrawable){ fonctionQuiFaitLeGraphe(glDrawable,...);
?
Mais il faut toujours passer par cette fonction "display".

Citation:

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.

Citation:

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:

1 2 3 public void display(GLDrawable glDrawable,ArrayList<Double> PointList){ /*Afficher les points*/ }
07/07/2006, 20h05
plegat
Citation:
Envoyé par seriousme

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:

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.

Citation:

Envoyé par seriousme

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

Citation:

Envoyé par seriousme

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()...
Citation:
Envoyé par seriousme

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:

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?

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

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:

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.

07/07/2006, 21h43
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.
07/07/2006, 22h46
Pragmateek

Citation:

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.

Citation:

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?
07/07/2006, 23h54
plegat

Citation:

Envoyé par seriousme

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é.
08/07/2006, 14h57
Pragmateek

En rajoutant:

Code:

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

il faut définir la méthode "getGL()",comment?
08/07/2006, 21h31
plegat

Citation:

Envoyé par seriousme

En rajoutant:

Code:

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ù?

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

Code:

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?

08/07/2006, 22h21
plegat

Citation:

Envoyé par seriousme

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...
08/07/2006, 22h29
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.
08/07/2006, 23h22
plegat

Citation:

Envoyé par seriousme

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

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:

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?

Citation:

Envoyé par seriousme

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:

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! :mrgreen: )

09/07/2006, 13h08
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é.
09/07/2006, 13h45
plegat

Citation:

Envoyé par seriousme

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

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

Citation:

Envoyé par seriousme

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

Citation:

Envoyé par seriousme

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...
09/07/2006, 14h08
Pragmateek

Citation:

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

Citation:

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:

display(GLDrawable)

sans ajouter de paramètres?

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

Voir 40 message(s) de cette discussion en une page