Discussion :

[Pinokio3x7]

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]

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

[Pinokio3x7]

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]

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]

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]

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.