Optimisation et display lists

Version imprimable

Bonjour

Mon application est finie. Mais je souhaite encore l'optimiser.
Ainsi, une mesure sur mon profiler me montre qu'elle passe du temps à dessiner mon réseau. En effet, mon application visualise des réseaux où mes noeuds sont des glutSolidSphere et mes liens des glutSolidCylinder.
Chaque noeud est stocké dans un ArrayList (je code en Java5) et chaque lien est aussi dans un ArrayList. Donc, je dessine séquentiellement:
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 private void drawNodes(GL gl, int mode) { gl.glPushMatrix(); gl.glPopName(); for (int i = 0; i < this.nodes.size(); i++) { if (mode == gl.GL_SELECT) { gl.glLoadName(i); gl.glPushName(i); } displayNode(gl, i); } gl.glPopName(); gl.glPopMatrix(); } private void drawEdges(GL gl, int mode) { gl.glPushMatrix(); for (int i = 0; i < this.edges.size(); i++) { GLEdge e = this.edges.get(i); if (e.isVisible()) { e.draw(gl, new GLU(), mode); } } gl.glPopMatrix(); } private void drawWorld(GL gl, int mode) { drawNodes(gl, mode); setWrap(); //wrap.draw(gl); //wrap.print(); drawEdges(gl, mode); }
Comme vous le voyez sur mon code de dessus, je fais du picking sur mes noeuds.
Ma question: comment puis-je optimiser sachant que ce qui me prend du temps, c'est la restitution des mes cylindres et sphères. On me parle des display lists, mais avec le picking, je ne vois pas comment je peux les placer. Je précise que mes noeuds et liens sont des objets distincts (GLNode et GLEdge). Dans ces objets, j'effectue les transformations géométriques adéquates et j'ordonne le dessin.

Merci d'avance de vos conseils.

@++

07/04/2008, 15h39
ShevchenKik

Salut David,

j'entends souvent que les Frame Buffer Objects sont bien plus performants que les display list. Je n'en suis pas encore arrivé à cette étape d'optimisation dans mon programme donc je n'y connais encore pas grand chose, mais avec un peu de chance picking et FBOs sont compatibles... avis aux experts!
08/04/2008, 11h24
GLDavid

Bonjour ShevchenKik

Merci de ta réponse. Wouah, les frame buffer objects 8O
A vrai dire, je ne connais pas, je suis resté à OpenGL 1.2. Je vais me documenter mais s'il y a plus simple, je prends.
Merci encore de ta suggestion.

@++
08/04/2008, 12h04
ShevchenKik

Oups, je me rends compte que j'ai dit une bêtise: je voulais parler des Vertex Buffer Objects, pas des FBOs. Les FBOs servent, par exemple, à faire du offscreen rendering ou du rendering to texture.

Pour le peu que j'en sais, les VBO c'est une manière de stocker tes vertex sur le GPU une fois au départ, ce qui évite de transferer les vertex du CPU au GPU à chaque frame. Comme dis je ne m'y suis pas encore mis mais c'est prévu, donc si entre temps tu réussis à implémenter ca comme il faut il y moyen qu'un de ces 4 ca soit mon tour de t'interroger là dessus ;)

En tout cas j'utilise des FBOs et ca n'est pas très compliqué. J'imagine (enfin, j'espère...) qu'il en est de même pour les VBOs
08/04/2008, 12h18
bafman

un truc très simple à faire, c'est de tout stocker dans une display list, et de recréer la display liste à chaque changement. pour le picking, tu a juste à faire le rendu sans display list, ça marchera.
08/04/2008, 13h22
GLDavid

Bonjour Bafman et merci encore de ta réponse, toujours très précieuse :king:

Une petite question alors: je ne suis pas très à jour sur les display lists. Je vois qu'on les crée toujours dans la méthode init(). Si je suis ta réponse, dans ma méthode display, je peux donc recréer une liste comme ça me chante ?

@++
08/04/2008, 13h54
bafman

je sais plus trop si on peut recréer une display liste existante, mais dans le pire des cas, tu peut détruire la précédente et la recréer ;)
08/04/2008, 14h21
GLDavid

Ok, merci bafman

J'ai fait un petit code qui normalement, combine picking et display list. Je le proposerais en cours de journée. Rien d'exceptionnel: ça affichera 4 théières et au clic, c'est censé donner l'id de la théière sélectionné.
Je soumettrais ce code aux pros d'OpenGL ;)

@++

Voici le programme en question. Je m'en remet à vos commentaires.

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
 
import com.sun.opengl.util.Animator;
import com.sun.opengl.util.BufferUtil;
import com.sun.opengl.util.GLUT;
import java.awt.Point;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.event.MouseWheelEvent;
import java.awt.event.MouseWheelListener;
import java.nio.IntBuffer;
import javax.media.opengl.GL;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCanvas;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.glu.GLU;
 
public class Render implements GLEventListener, MouseWheelListener, MouseListener, MouseMotionListener {
 
    private GLCanvas lost_canvas;
    private Animator anim;
    private float zoom = 0f;
    private float zoom_inc = 0.05f;
    private int zeList;
    private Point point;
    private final int BUFSIZE = 512;
    private final int RELEASED = 0;
    private final int PICKED = 1;
    private int mouse_state;
    private int selected = -1;
    private int arg3;
    private int arg4;
    private float xm;
    private float ym;
 
    public Render(GLCanvas canvas) {
        this.lost_canvas = canvas;
    }
 
    private void drawSomething(GL gl) {
        gl.glPushMatrix();
        gl.glTranslatef(-5, 5, -20f);
        GLUT glut = new GLUT();
        float mat[] = {1, 1, 1, 0};
        gl.glMaterialfv(GL.GL_FRONT, GL.GL_SPECULAR, mat, 0);
        gl.glMaterialf(GL.GL_FRONT, GL.GL_SHININESS, (float) (.078125 * 128.0f));
        gl.glLoadName(0);
        gl.glPushName(0);
        glut.glutSolidTeapot(1f);
        gl.glPopMatrix();
        gl.glPushMatrix();
        gl.glTranslatef(5, 5, -20f);
        gl.glMaterialfv(GL.GL_FRONT, GL.GL_SPECULAR, mat, 0);
        gl.glMaterialf(GL.GL_FRONT, GL.GL_SHININESS, (float) (.078125 * 128.0f));
        gl.glLoadName(1);
        gl.glPushName(1);
        glut.glutSolidTeapot(1f);
        gl.glPopMatrix();
        gl.glPushMatrix();
        gl.glTranslatef(5, -5, -20f);
        gl.glMaterialfv(GL.GL_FRONT, GL.GL_SPECULAR, mat, 0);
        gl.glMaterialf(GL.GL_FRONT, GL.GL_SHININESS, (float) (.078125 * 128.0f));
        gl.glLoadName(2);
        gl.glPushName(2);
        glut.glutSolidTeapot(1f);
        gl.glPopMatrix();
        gl.glPushMatrix();
        gl.glTranslatef(-5, -5, -20f);
        gl.glMaterialfv(GL.GL_FRONT, GL.GL_SPECULAR, mat, 0);
        gl.glMaterialf(GL.GL_FRONT, GL.GL_SHININESS, (float) (.078125 * 128.0f));
        gl.glLoadName(3);
        gl.glPushName(3);
        glut.glutSolidTeapot(1f);
        gl.glPopMatrix();
    }
 
    private void buildList(GL gl) {
        zeList = gl.glGenLists(1);
        gl.glNewList(zeList, GL.GL_COMPILE);
        drawSomething(gl);
        gl.glEndList();
    }
 
    private void makeLight(GL gl) {
        float ambient[] = {0.0f, 0.0f, 0.0f, 1.0f};
        float amb_pos[] = {0, 0, 20, 0f};
        gl.glLightfv(GL.GL_LIGHT0, GL.GL_SPECULAR, ambient, 0);
        gl.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, amb_pos, 0);
        gl.glFrontFace(GL.GL_CW);
        gl.glEnable(GL.GL_LIGHTING);
        gl.glEnable(GL.GL_LIGHT0);
        gl.glEnable(GL.GL_AUTO_NORMAL);
        gl.glEnable(GL.GL_NORMALIZE);
        gl.glEnable(GL.GL_DEPTH_TEST);
        gl.glDepthFunc(GL.GL_LESS);
    }
 
    public void init(GLAutoDrawable arg0) {
        final GL gl = arg0.getGL();
        gl.glShadeModel(GL.GL_SMOOTH); // Enable Smooth Shading
        gl.glClearColor(1f, 1f, 1f, 1f);
        gl.glClearDepth(1.0f);
        buildList(gl);
        makeLight(gl);
        anim = new Animator(lost_canvas);
        anim.start();
        arg0.addMouseWheelListener(this);
        arg0.addMouseListener(this);
        arg0.addMouseMotionListener(this);
    }
 
    private void pickPoint(GL gl) {
        GLU glu = new GLU();
        int selectBuf[] = new int[BUFSIZE];
        IntBuffer selectBuffer = BufferUtil.newIntBuffer(BUFSIZE);
        int hits;
        int viewport[] = new int[4];
 
        gl.glGetIntegerv(GL.GL_VIEWPORT, viewport, 0);
 
        gl.glSelectBuffer(BUFSIZE, selectBuffer);
        gl.glRenderMode(GL.GL_SELECT);
 
        gl.glInitNames();
        gl.glPushName(0);
 
        gl.glMatrixMode(GL.GL_PROJECTION);
        gl.glPushMatrix();
        gl.glLoadIdentity();
        glu.gluPickMatrix((double) this.point.x,
                (double) (viewport[3] - this.point.y),//
                5.0, 5.0, viewport, 0);
        gl.glTranslatef(0, 0, zoom);
        glu.gluPerspective(45, arg3 / arg4, 1, 50);
 
        gl.glCallList(zeList);
 
        gl.glMatrixMode(GL.GL_PROJECTION);
        gl.glPopMatrix();
        gl.glMatrixMode(GL.GL_MODELVIEW);
        gl.glFlush();
 
        hits = gl.glRenderMode(GL.GL_RENDER);
        selectBuffer.get(selectBuf);
        processHits(hits, selectBuf);
    }
 
    private void processHits(int hits, int buffer[]) {
        int names, ptr = 0;
        if (hits > 0) {
            names = buffer[ptr] - 1;
            selected = names;
        } else {
            selected = -1;
        }
        System.out.println(selected);
    }
 
    public void display(GLAutoDrawable arg0) {
        final GL gl = arg0.getGL();
        gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
 
        gl.glLoadIdentity();
 
        gl.glTranslatef(0, 0, zoom);
 
        if (this.point != null && this.mouse_state == this.PICKED) {
            pickPoint(gl);
        }
        gl.glCallList(zeList);
 
        gl.glFlush();
    }
 
    public void reshape(GLAutoDrawable arg0, int arg1, int arg2, int arg3, int arg4) {
        final GL gl = arg0.getGL();
        this.arg3 = arg3;
        this.arg4 = arg4;
        gl.glViewport(0, 0, arg3, arg4);
        gl.glMatrixMode(GL.GL_PROJECTION);
        gl.glLoadIdentity();
        GLU glu = new GLU();
        glu.gluPerspective(45, arg3 / arg4, 1, 50);
        gl.glMatrixMode(GL.GL_MODELVIEW);
        gl.glLoadIdentity();
    }
 
    public void displayChanged(GLAutoDrawable arg0, boolean arg1, boolean arg2) {
    }
 
    public void mouseWheelMoved(MouseWheelEvent arg0) {
        if (arg0.getWheelRotation() == 1) {
            zoom += zoom_inc;
        } else {
            zoom -= zoom_inc;
        }
    }
 
    public void mouseClicked(MouseEvent arg0) {
    }
 
    public void mousePressed(MouseEvent arg0) {
        if (arg0.getButton() == 0) {
            this.point = arg0.getPoint();
            this.mouse_state = this.PICKED;
        }
 
    }
 
    public void mouseReleased(MouseEvent arg0) {
        this.point = null;
        this.mouse_state = this.RELEASED;
        this.selected = -1;
    }
 
    public void mouseEntered(MouseEvent arg0) {
    }
 
    public void mouseExited(MouseEvent arg0) {
    }
 
    public void mouseDragged(MouseEvent arg0) {
        if (arg0.getButton() == 0) {
            this.point = arg0.getPoint();
            this.mouse_state = this.PICKED;
        }
    }
 
    public void mouseMoved(MouseEvent arg0) {
 
    }
}

@++

08/04/2008, 18h41
bafman

vérifie tes glGetError, tu doit avoir des erreurs quand tu push tes noms alors que tu remplis ta list. A priori, tu ne doit pas pouvoir faire de glPushName dans ce mode la (à verifier dans la doc, je ne suis pas sûre de moi).

plus généralement, c'est une bonne idée de vérifier ses erreurs openGL a chaque tour d'affichage.