IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

OpenGL Discussion :

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


Sujet :

OpenGL

  1. #1
    Expert confirmé
    Avatar de Pragmateek
    Homme Profil pro
    Formateur expert .Net/C#
    Inscrit en
    mars 2006
    Messages
    2 635
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Formateur expert .Net/C#
    Secteur : Conseil

    Informations forums :
    Inscription : mars 2006
    Messages : 2 635
    Points : 4 166
    Points
    4 166
    Par défaut [JOGL] Appeler l'affichage OpenGL à partir d'une classe quelquonque.
    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.
    Formateur expert .Net/C#/WPF/EF Certifié MCP disponible sur Paris, province et pays limitrophes (enseignement en français uniquement).
    Mon blog : pragmateek.com

  2. #2
    Expert éminent

    Profil pro
    Fabricant et casseur d'avions
    Inscrit en
    avril 2004
    Messages
    3 748
    Détails du profil
    Informations personnelles :
    Localisation : France, Tarn (Midi Pyrénées)

    Informations professionnelles :
    Activité : Fabricant et casseur d'avions
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : avril 2004
    Messages : 3 748
    Points : 7 310
    Points
    7 310
    Par défaut
    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 : 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.


    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...
    "Errare humanum est, sed perseverare diabolicum"

    Ma page sur DVP.com

  3. #3
    Membre régulier
    Profil pro
    Inscrit en
    septembre 2003
    Messages
    115
    Détails du profil
    Informations personnelles :
    Âge : 38
    Localisation : Belgique

    Informations forums :
    Inscription : septembre 2003
    Messages : 115
    Points : 77
    Points
    77
    Par défaut
    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

  4. #4
    Expert confirmé
    Avatar de Pragmateek
    Homme Profil pro
    Formateur expert .Net/C#
    Inscrit en
    mars 2006
    Messages
    2 635
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Formateur expert .Net/C#
    Secteur : Conseil

    Informations forums :
    Inscription : mars 2006
    Messages : 2 635
    Points : 4 166
    Points
    4 166
    Par défaut
    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*/
    }
    Formateur expert .Net/C#/WPF/EF Certifié MCP disponible sur Paris, province et pays limitrophes (enseignement en français uniquement).
    Mon blog : pragmateek.com

  5. #5
    Expert éminent

    Profil pro
    Fabricant et casseur d'avions
    Inscrit en
    avril 2004
    Messages
    3 748
    Détails du profil
    Informations personnelles :
    Localisation : France, Tarn (Midi Pyrénées)

    Informations professionnelles :
    Activité : Fabricant et casseur d'avions
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : avril 2004
    Messages : 3 748
    Points : 7 310
    Points
    7 310
    Par défaut
    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 : 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.


    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 : 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?
    "Errare humanum est, sed perseverare diabolicum"

    Ma page sur DVP.com

  6. #6
    Expert confirmé
    Avatar de Pragmateek
    Homme Profil pro
    Formateur expert .Net/C#
    Inscrit en
    mars 2006
    Messages
    2 635
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Formateur expert .Net/C#
    Secteur : Conseil

    Informations forums :
    Inscription : mars 2006
    Messages : 2 635
    Points : 4 166
    Points
    4 166
    Par défaut
    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.
    Formateur expert .Net/C#/WPF/EF Certifié MCP disponible sur Paris, province et pays limitrophes (enseignement en français uniquement).
    Mon blog : pragmateek.com

  7. #7
    Expert éminent

    Profil pro
    Fabricant et casseur d'avions
    Inscrit en
    avril 2004
    Messages
    3 748
    Détails du profil
    Informations personnelles :
    Localisation : France, Tarn (Midi Pyrénées)

    Informations professionnelles :
    Activité : Fabricant et casseur d'avions
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : avril 2004
    Messages : 3 748
    Points : 7 310
    Points
    7 310
    Par défaut
    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.
    "Errare humanum est, sed perseverare diabolicum"

    Ma page sur DVP.com

  8. #8
    Expert confirmé
    Avatar de Pragmateek
    Homme Profil pro
    Formateur expert .Net/C#
    Inscrit en
    mars 2006
    Messages
    2 635
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Formateur expert .Net/C#
    Secteur : Conseil

    Informations forums :
    Inscription : mars 2006
    Messages : 2 635
    Points : 4 166
    Points
    4 166
    Par défaut
    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?
    Formateur expert .Net/C#/WPF/EF Certifié MCP disponible sur Paris, province et pays limitrophes (enseignement en français uniquement).
    Mon blog : pragmateek.com

  9. #9
    Expert éminent

    Profil pro
    Fabricant et casseur d'avions
    Inscrit en
    avril 2004
    Messages
    3 748
    Détails du profil
    Informations personnelles :
    Localisation : France, Tarn (Midi Pyrénées)

    Informations professionnelles :
    Activité : Fabricant et casseur d'avions
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : avril 2004
    Messages : 3 748
    Points : 7 310
    Points
    7 310
    Par défaut
    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é.
    "Errare humanum est, sed perseverare diabolicum"

    Ma page sur DVP.com

  10. #10
    Expert confirmé
    Avatar de Pragmateek
    Homme Profil pro
    Formateur expert .Net/C#
    Inscrit en
    mars 2006
    Messages
    2 635
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Formateur expert .Net/C#
    Secteur : Conseil

    Informations forums :
    Inscription : mars 2006
    Messages : 2 635
    Points : 4 166
    Points
    4 166
    Par défaut
    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?
    Formateur expert .Net/C#/WPF/EF Certifié MCP disponible sur Paris, province et pays limitrophes (enseignement en français uniquement).
    Mon blog : pragmateek.com

  11. #11
    Expert éminent

    Profil pro
    Fabricant et casseur d'avions
    Inscrit en
    avril 2004
    Messages
    3 748
    Détails du profil
    Informations personnelles :
    Localisation : France, Tarn (Midi Pyrénées)

    Informations professionnelles :
    Activité : Fabricant et casseur d'avions
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : avril 2004
    Messages : 3 748
    Points : 7 310
    Points
    7 310
    Par défaut
    Citation Envoyé par seriousme
    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ù?
    "Errare humanum est, sed perseverare diabolicum"

    Ma page sur DVP.com

  12. #12
    Expert confirmé
    Avatar de Pragmateek
    Homme Profil pro
    Formateur expert .Net/C#
    Inscrit en
    mars 2006
    Messages
    2 635
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Formateur expert .Net/C#
    Secteur : Conseil

    Informations forums :
    Inscription : mars 2006
    Messages : 2 635
    Points : 4 166
    Points
    4 166
    Par défaut
    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?
    Formateur expert .Net/C#/WPF/EF Certifié MCP disponible sur Paris, province et pays limitrophes (enseignement en français uniquement).
    Mon blog : pragmateek.com

  13. #13
    Expert éminent

    Profil pro
    Fabricant et casseur d'avions
    Inscrit en
    avril 2004
    Messages
    3 748
    Détails du profil
    Informations personnelles :
    Localisation : France, Tarn (Midi Pyrénées)

    Informations professionnelles :
    Activité : Fabricant et casseur d'avions
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : avril 2004
    Messages : 3 748
    Points : 7 310
    Points
    7 310
    Par défaut
    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...
    "Errare humanum est, sed perseverare diabolicum"

    Ma page sur DVP.com

  14. #14
    Expert confirmé
    Avatar de Pragmateek
    Homme Profil pro
    Formateur expert .Net/C#
    Inscrit en
    mars 2006
    Messages
    2 635
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Formateur expert .Net/C#
    Secteur : Conseil

    Informations forums :
    Inscription : mars 2006
    Messages : 2 635
    Points : 4 166
    Points
    4 166
    Par défaut
    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.
    Formateur expert .Net/C#/WPF/EF Certifié MCP disponible sur Paris, province et pays limitrophes (enseignement en français uniquement).
    Mon blog : pragmateek.com

  15. #15
    Expert éminent

    Profil pro
    Fabricant et casseur d'avions
    Inscrit en
    avril 2004
    Messages
    3 748
    Détails du profil
    Informations personnelles :
    Localisation : France, Tarn (Midi Pyrénées)

    Informations professionnelles :
    Activité : Fabricant et casseur d'avions
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : avril 2004
    Messages : 3 748
    Points : 7 310
    Points
    7 310
    Par défaut
    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...
    "Errare humanum est, sed perseverare diabolicum"

    Ma page sur DVP.com

  16. #16
    Expert confirmé
    Avatar de Pragmateek
    Homme Profil pro
    Formateur expert .Net/C#
    Inscrit en
    mars 2006
    Messages
    2 635
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Formateur expert .Net/C#
    Secteur : Conseil

    Informations forums :
    Inscription : mars 2006
    Messages : 2 635
    Points : 4 166
    Points
    4 166
    Par défaut
    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?
    Formateur expert .Net/C#/WPF/EF Certifié MCP disponible sur Paris, province et pays limitrophes (enseignement en français uniquement).
    Mon blog : pragmateek.com

  17. #17
    Expert éminent

    Profil pro
    Fabricant et casseur d'avions
    Inscrit en
    avril 2004
    Messages
    3 748
    Détails du profil
    Informations personnelles :
    Localisation : France, Tarn (Midi Pyrénées)

    Informations professionnelles :
    Activité : Fabricant et casseur d'avions
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : avril 2004
    Messages : 3 748
    Points : 7 310
    Points
    7 310
    Par défaut
    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 : 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! )
    "Errare humanum est, sed perseverare diabolicum"

    Ma page sur DVP.com

  18. #18
    Expert confirmé
    Avatar de Pragmateek
    Homme Profil pro
    Formateur expert .Net/C#
    Inscrit en
    mars 2006
    Messages
    2 635
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Formateur expert .Net/C#
    Secteur : Conseil

    Informations forums :
    Inscription : mars 2006
    Messages : 2 635
    Points : 4 166
    Points
    4 166
    Par défaut
    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é.
    Formateur expert .Net/C#/WPF/EF Certifié MCP disponible sur Paris, province et pays limitrophes (enseignement en français uniquement).
    Mon blog : pragmateek.com

  19. #19
    Expert éminent

    Profil pro
    Fabricant et casseur d'avions
    Inscrit en
    avril 2004
    Messages
    3 748
    Détails du profil
    Informations personnelles :
    Localisation : France, Tarn (Midi Pyrénées)

    Informations professionnelles :
    Activité : Fabricant et casseur d'avions
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : avril 2004
    Messages : 3 748
    Points : 7 310
    Points
    7 310
    Par défaut
    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...
    "Errare humanum est, sed perseverare diabolicum"

    Ma page sur DVP.com

  20. #20
    Expert confirmé
    Avatar de Pragmateek
    Homme Profil pro
    Formateur expert .Net/C#
    Inscrit en
    mars 2006
    Messages
    2 635
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Formateur expert .Net/C#
    Secteur : Conseil

    Informations forums :
    Inscription : mars 2006
    Messages : 2 635
    Points : 4 166
    Points
    4 166
    Par défaut
    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:
    sans ajouter de paramètres?

    Et puis il n'y a pas de méthode "repaint", c'est idem que "display"?
    Formateur expert .Net/C#/WPF/EF Certifié MCP disponible sur Paris, province et pays limitrophes (enseignement en français uniquement).
    Mon blog : pragmateek.com

+ Répondre à la discussion
Cette discussion est résolue.
Page 1 sur 2 12 DernièreDernière

Discussions similaires

  1. Réponses: 2
    Dernier message: 24/12/2006, 19h15
  2. affichage simultané à partir d'une selection combo
    Par donyas dans le forum AWT/Swing
    Réponses: 4
    Dernier message: 27/07/2006, 15h59
  3. [ASP][D8] Appel WebForm2.aspx a partir d'une WenForm1.aspx
    Par pop bob dans le forum Delphi .NET
    Réponses: 1
    Dernier message: 12/09/2005, 16h06
  4. [SERVLET]Appel d'un fichier à partir d'une servlet
    Par fchafia dans le forum Servlets/JSP
    Réponses: 5
    Dernier message: 17/03/2005, 13h21

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo