OpenGL CPU utilisé à 100%

**Pinokio3x7** · 03/04/2010, 16h46

Bonjour à tous,
je rencontre un petit problème concernant l'utilisation d'une application QT/OpenGL le CPU à 100%,enfaite je sais bien que dans toute les bibliothèques de gestion d'affichage comme SDL,GLUT,GLFW on rencontre ce problème!

ma question est tout simplement comment réduire cette utilisation gourmande de CPU en QT/OpenGL?

je sais aussi que dans quelques bibliothèque on appelle une fonction "Sleep" ou quelques choses de similaire qui est lié au thread de la fonction d'affichage pour régler ce problème...mais il parait qu'il n'est pas préférable en QT d'appeler "Sleep" ou "Wait" dans le thread de QGLWidget...

quelqu'un SVP peut résoudre ce probléme en postant un code.
Merci en avance!

**yan** · 03/04/2010, 17h37

Il faudrait déjà comprendre comment tu fait pour être à 100%.
Ce qui est assez bizzare.

**Pinokio3x7** · 03/04/2010, 17h54

le plus bizarre c'est que le CPU toujours arrive toujours à 100%,même si je dessine un simple polygone!

je ne peut pas deviner ou le CPU va arriver si je dessine des centaines de polygones!

**yan** · 03/04/2010, 18h25

tu peut expliquer ce que tu fait etmettre un peu de code?
Es ce que tu appel repaint ou update?
es ce que tu utilise un timer?

**Pinokio3x7** · 03/04/2010, 18h36

Bon,voici mon code dans qui est situé dans paintGL():

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
 
glInit();
/* preparer les extensions ARB*/
SetUp_GL_ARB_multitexture();
/*les vertices respectifs du carré*/
QVector3D *vertex1=new QVector3D(-0.75,0.75,0);
QVector3D *vertex2=new QVector3D(0.75,0.75,0);
QVector3D *vertex3=new QVector3D(0.75,-0.75,0);
QVector3D *vertex4=new QVector3D(-0.75,-0.75,0);
 
/*les texels respectifs du carré (coordonnés de textures)*/
QVector3D *texel1=new QVector3D(0,1,0);
QVector3D *texel2=new QVector3D(1,1,0);
QVector3D *texel3=new QVector3D(1,0,0);
QVector3D *texel4=new QVector3D(0,0,0);
 
/*la position du notre lumiére dans la scéne*/
QVector3D *worldlightposition=new QVector3D(0,0,10);
 
/* la lumiére de notre scéne*/
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
GLfloat lightparams[]={worldlightposition->x(),worldlightposition->y(),worldlightposition->z(),1};
glLightfv(GL_LIGHT0,GL_POSITION,lightparams);
 
 
 
/* charger la normal map*/
GLint normalmap=bindTexture(QImage("normal.bmp"));
glBindTexture(GL_TEXTURE_2D,normalmap);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
 
/*charger la texture principale*/
GLint textureskin=bindTexture(QImage("brick.bmp"));
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D,textureskin);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
 
 
/*unité texture 0 au cube map de normalisation*/
GLuint cubemapid;
glActiveTexture(GL_TEXTURE0);
glEnable(GL_TEXTURE_CUBE_MAP);
NCM *c=new NCM();
c->create(256,cubemapid);
glBindTexture(GL_TEXTURE_CUBE_MAP,cubemapid);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV,GL_COMBINE_RGB,GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE0_RGB,GL_TEXTURE);
 
/*unité de texture 1 de la normal map*/
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D,normalmap);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV,GL_COMBINE_RGB,GL_DOT3_RGB);
glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE0_RGB,GL_PREVIOUS) ;
glTexEnvi(GL_TEXTURE_ENV,GL_SOURCE1_RGB,GL_TEXTURE) ;
 
 
 
/*unité de texture 2 de la texture principale*/
glActiveTexture(GL_TEXTURE2);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,textureskin);
glTexEnvi( GL_TEXTURE_ENV, GL_COMBINE_RGB,GL_MODULATE);
 
 
 
/* le vecteur vers la lumiére*/
QVector3D *lightvector=new QVector3D();
 
/*on dessine notre carré*/
glPushMatrix();
glRotated(rot,0,0,1);
rot+=0.25;
 
glBegin(GL_POLYGON);
*lightvector=*worldlightposition - *vertex1;
glMultiTexCoord3d(GL_TEXTURE0,lightvector->x(),lightvector->y(),lightvector->z());
glMultiTexCoord2d(GL_TEXTURE1,texel1->x(),texel1->y());
glMultiTexCoord2d(GL_TEXTURE2,texel1->x(),texel1->y());
glVertex3d(vertex1->x(),vertex1->y(),vertex1->z());
 
*lightvector=*worldlightposition - *vertex2;
glMultiTexCoord3d(GL_TEXTURE0,lightvector->x(),lightvector->y(),lightvector->z());
glMultiTexCoord2d(GL_TEXTURE1,texel2->x(),texel2->y());
glMultiTexCoord2d(GL_TEXTURE2,texel2->x(),texel2->y());
glVertex3d(vertex2->x(),vertex2->y(),vertex2->z());
 
*lightvector=*worldlightposition - *vertex3;
glMultiTexCoord3d(GL_TEXTURE0,lightvector->x(),lightvector->y(),lightvector->z());
glMultiTexCoord2d(GL_TEXTURE1,texel3->x(),texel3->y());
glMultiTexCoord2d(GL_TEXTURE2,texel3->x(),texel3->y());
glVertex3d(vertex3->x(),vertex3->y(),vertex3->z());
 
 
*lightvector=*worldlightposition - *vertex4;
glMultiTexCoord3d(GL_TEXTURE0,lightvector->x(),lightvector->y(),lightvector->z());
glMultiTexCoord2d(GL_TEXTURE1,texel4->x(),texel4->y());
glMultiTexCoord2d(GL_TEXTURE2,texel4->x(),texel4->y());
glVertex3d(vertex4->x(),vertex4->y(),vertex4->z());
 
glEnd();
glPopMatrix();
 
update();

il s'agit d'un carré texturé et avec le dot3 mapping...

**yan** · 03/04/2010, 18h43

1- vire tout ces pointeurs et new sur QVector3D. Ca sert à rien et tu as plein de fuite mémoire.
2-vire le update à la fin. Ca viens certainement de là.

A la limite, il faut mieux utiliser un timer et de le connecter au update.

**Pinokio3x7** · 03/04/2010, 21h39

j'ai essayer d'appliquer ce que tu a proposer:
j'ai écrit un autre exemple"un carré qui tourne",j'ai pas pas utiliser des pointeurs et j'ai ajouter un QTimer qui appelle update() a chaque 100ms,mais ça devient très bizarre

:l'utilisation de CPU est très abaissé,mais la fonction update() n'est pas appelé sauf si je déplace la souris, ce qui entraine la rotation du carré???

si je ne déplace pas la souris le carré ne fait pas la rotation,c'est comme que c'est lié à un évènement...

voici le code:

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
 
glPushMatrix();
glRotated(rot,0,0,1);
rot+=0.5;
glBegin(GL_POLYGON);
glVertex3f(-0.5,0.5,0);glColor3f(1,0,0);
glVertex3f(0.5,0.5,0);glColor3f(0,1,0);
glVertex3f(0.5,-0.5,0);glColor3f(0,0,1);
glVertex3f(-0.5,-0.5,0);glColor3f(1,1,0);
glEnd();
glPopMatrix();
 
QTimer *timer = new QTimer();
timer->connect(timer, SIGNAL(timeout()),this,SLOT(update()));
timer->start(100);

**yan** · 03/04/2010, 22h26

Ou as tu créé le timer???

C'est pas updateGl qu'il faut utiliser?
http://qt.developpez.com/doc/latest/qglwidget/#updategl

**Pinokio3x7** · 04/04/2010, 08h46

j'ai créer le timer dans le paintGL(),et j'ai utilisé "update()" et non "updateGL()" comme tu a mentionné yan!
voici l'explication de update():

void QWidget::update () [slot]
Updates the widget unless updates are disabled or the widget is hidden.

This function does not cause an immediate repaint; instead it schedules a paint event for processing when Qt returns to the main event loop. This permits Qt to optimize for more speed and less flicker than a call to repaint() does.

Calling update() several times normally results in just one paintEvent() call.

Qt normally erases the widget's area before the paintEvent() call. If the Qt::WA_OpaquePaintEvent widget attribute is set, the widget is responsible for painting all its pixels with an opaque color.

mais quand j'efface le timer et j'ajoute updateGL() à la fin du paintGL(),ça
plante!

,et si j'ajoute update() au lieux de updateGL() à la fin,ça marche
mais le CPU est 100 % utilisé!

ok,maintenant je vais poster le code entier pour que tu comprend mieux mon problème:
le fichier Display.h

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
 
#ifndef DISPLAY_H
#define DISPLAY_H
 
#include <QtOpenGL>
#include<QGLWidget>
#include<QGLFormat>
 
class Display:public QGLWidget
{
Q_OBJECT
public:
Display(QWidget *parent = 0);
~Display();
protected:
void initializeGL();
void paintGL();
private:
QGLFormat Format;
};
#endif // DISPLAY_H

le fichier Display.cpp:

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
 
#include"Display.h"
#include <QtOpenGL>
#include<QTimer>
 
 
Display::Display(QWidget *parent)
:QGLWidget(QGLFormat(QGL::DoubleBuffer|QGL::DepthBuffer|QGL::Rgba
|QGL::AlphaChannel|QGL::AccumBuffer|QGL::StencilBuffer|QGL::StereoBuffers
|QGL::DirectRendering|QGL::HasOverlay|QGL::SampleBuffers),parent)
{
Format.setRedBufferSize(8);
Format.setGreenBufferSize(8);
Format.setBlueBufferSize(8);
Format.setAlphaBufferSize(8);
Format.setAccumBufferSize(32);
Format.setDepthBufferSize(32);
Format.setStencilBufferSize(32);
this->setFormat(Format);
}
 
Display::~Display()
{}
 
void Display::initializeGL()
{
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_ACCUM_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);
glClearColor(0.25,0.25,0.25,1);
glHint(GL_FOG_HINT,GL_NICEST);
glHint(GL_LINE_SMOOTH_HINT,GL_NICEST);
glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
glHint(GL_POINT_SMOOTH_HINT,GL_NICEST);
glHint(GL_POLYGON_SMOOTH_HINT,GL_NICEST);
glShadeModel(GL_SMOOTH);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
 
double rot=90;
 
void Display::paintGL()
{
glInit();
glPushMatrix();
glRotated(rot,0,0,1);
rot+=0.5;
glBegin(GL_POLYGON);
glVertex3f(-0.5,0.5,0);glColor3f(1,0,0);
glVertex3f(0.5,0.5,0);glColor3f(0,1,0);
glVertex3f(0.5,-0.5,0);glColor3f(0,0,1);
glVertex3f(-0.5,-0.5,0);glColor3f(1,1,0);
glEnd();
glPopMatrix();
 
QTimer *timer = new QTimer();
timer->connect(timer, SIGNAL(timeout()),this,SLOT(update()));
timer->start(100);
 
}

et le fichier main.cpp:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
#include <QApplication>
#include"Display.h"
 
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
Display *display=new Display;
display->setFixedSize(800,600);
display->show();
return app.exec();
}

j'ai tester les exemples OpenGL livré avec QT Creator,et ça marche bien l'utilisation du CPU est trés normale,donc j'ai une fatale erreur dans mon code!

**yan** · 04/04/2010, 10h04

Envoyé par Pinokio3x7

j'ai créer le timer dans le paintGL(),et j'ai utilisé "update()" et non "updateGL()" comme tu a mentionné yan!

j'ai pas dit cela. Reli bien ma réponse.

**Pinokio3x7** · 04/04/2010, 10h53

Merci beaucoup pour ton aide yan!

j'ai utilisé donc updateGL()...
voici comment j'ai fait exactement:
dans le fichier Display.h j'ai ajouter:

Code :

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

1
2
 
void timerEvent(QTimerEvent *);

dans le fichier Display.cpp j'ai le changé comme ça:

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
 
#include"Display.h"
#include <QtOpenGL>
#include<QTimer>
#include<QtGui>
 
 
Display::Display(QWidget *parent)
:QGLWidget(QGLFormat(QGL::DoubleBuffer|QGL::DepthBuffer|QGL::Rgba
|QGL::AlphaChannel|QGL::AccumBuffer|QGL::StencilBuffer|QGL::StereoBuffers
|QGL::DirectRendering|QGL::HasOverlay|QGL::SampleBuffers),parent)
{
Format.setRedBufferSize(8);
Format.setGreenBufferSize(8);
Format.setBlueBufferSize(8);
Format.setAlphaBufferSize(8);
Format.setAccumBufferSize(32);
Format.setDepthBufferSize(32);
Format.setStencilBufferSize(32);
this->setFormat(Format);
this->startTimer(50);
}
 
Display::~Display()
{}
 
void Display::initializeGL()
{
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_ACCUM_BUFFER_BIT|GL_STENCIL_BUFFER_BIT);
glClearColor(0.25,0.25,0.25,1);
glHint(GL_FOG_HINT,GL_NICEST);
glHint(GL_LINE_SMOOTH_HINT,GL_NICEST);
glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
glHint(GL_POINT_SMOOTH_HINT,GL_NICEST);
glHint(GL_POLYGON_SMOOTH_HINT,GL_NICEST);
glShadeModel(GL_SMOOTH);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
 
double rot=90;
 
void Display::paintGL()
{
glInit();
glPushMatrix();
glRotated(rot,0,0,1);
rot+=50;
glBegin(GL_POLYGON);
glVertex3f(-0.5,0.5,0);glColor3f(1,0,0);
glVertex3f(0.5,0.5,0);glColor3f(0,1,0);
glVertex3f(0.5,-0.5,0);glColor3f(0,0,1);
glVertex3f(-0.5,-0.5,0);glColor3f(1,1,0);
glEnd();
glPopMatrix();
}
 
void Display::timerEvent(QTimerEvent *)
{
updateGL();
}

et ça marcher!

Merci une autre fois!

OpenGL CPU utilisé à 100% [2D/3D]

Qt

Discussions similaires

Partager

Partager