Probléme OpenGl bump mapping à l'aide d'un cube map de normalisation

Version imprimable

Bonjours à tous,
je suis entrain de tester un exemple OpenGL/QT4.6,j'utilise ici le bump
mapping en utilisant un cube map de normalisation. l'exemple est simple,il affiche
un carreau,mais,8O,le carré s'affiche mais sans l'effet bump map!
ce que je suis certain que la faute est dans les environnements de textures,soit une mauvaise combinaison ou multiplication des unités des texture,ou quelques choses de manquants quelques parts !:(

voici le code de cube map de normalisation dans mon exemple:

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
 
#include"NCM.h"
 
NCM::NCM()
{}
 
NCM::~NCM()
{}
 
void NCM::create(unsigned int facesize,GLuint &id)
{
glEnable(GL_TEXTURE_CUBE_MAP);
glBindTexture(GL_TEXTURE_CUBE_MAP,id);
double *cubemap = new double [facesize*facesize*3];
double offset = 0.5;
double halfsize = facesize /2;
unsigned int x,y;
unsigned int index=0;
for(unsigned char face=0; face<=6; face++)
{
for (y=0; y<facesize; y++)
{
for (x=0; x<facesize; x++)
{
switch (face)
{
case 0:temp=new QVector3D(halfsize,y+offset-halfsize,-(x+offset-halfsize));break;
case 1:temp=new QVector3D(-halfsize,y+offset-halfsize,x+offset-halfsize );break;
case 2:temp=new QVector3D(x+offset-halfsize,-halfsize,y+offset-halfsize);break;
case 3:temp=new QVector3D(x+offset-halfsize,halfsize,-(y+offset-halfsize));break;
case 4:temp=new QVector3D(x+offset-halfsize,y+offset-halfsize,halfsize);break;
case 5:temp=new QVector3D(-(x+offset-halfsize),(y+offset-halfsize),-halfsize);break;
}
temp->normalize();
cubemap[index++]=(double)(temp->x());
cubemap[index++]=(double)(temp->y());
cubemap[index++]=(double)(temp->z());
}
}
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+face,0,GL_RGB,facesize,facesize,0,GL_RGB,GL_UNSIGNED_BYTE,cubemap);
index=0;
}
glTexParameteri(GL_TEXTURE_CUBE_MAP,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP,GL_TEXTURE_WRAP_R,GL_CLAMP_TO_EDGE);
delete cubemap;
glDisable(GL_TEXTURE_CUBE_MAP);
}

et celui ci est le code d'affichage:

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
 
QVector3D *cubev1=new QVector3D(-0.5,0.5,0);
QVector3D *cubev2=new QVector3D(0.5,0.5,0);
QVector3D *cubev3=new QVector3D(0.5,-0.5,0);
QVector3D *cubev4=new QVector3D(-0.5,-0.5,0);
QVector3D *cubetv1=new QVector3D(0,1,0);
QVector3D *cubetv2=new QVector3D(1,1,0);
QVector3D *cubetv3=new QVector3D(0,0,0);
QVector3D *cubetv4=new QVector3D(1,0,0);
 
 
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
QVector3D *worldlightposition=new QVector3D(0,0,10);
float lightparams[]={worldlightposition->x(),worldlightposition->y(),worldlightposition->z(),1};
glLightfv(GL_LIGHT0,GL_POSITION,lightparams);
 
 
GLuint cubemapid;
NCM *c=new NCM();
c->create(128,cubemapid);
 
glActiveTexture(GL_TEXTURE0);
glEnable(GL_TEXTURE_CUBE_MAP);
glBindTexture(GL_TEXTURE_CUBE_MAP,cubemapid);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB,GL_REPLACE);
 
 
GLint normalmap=bindTexture(QImage("normal.bmp"));
glActiveTexture(GL_TEXTURE1);
glEnable(GL_TEXTURE_2D);
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);
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);
glTexEnvi(GL_TEXTURE_ENV,GL_OPERAND0_RGB,GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV,GL_OPERAND1_RGB,GL_SRC_COLOR);
 
 
GLint textureskin=bindTexture(QImage("brick.bmp"));
glActiveTexture(GL_TEXTURE2);
glEnable(GL_TEXTURE_2D);
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);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 
 
QVector3D *lightvector=new QVector3D();
 
glBegin(GL_POLYGON);
*lightvector=*worldlightposition - *cubev1;
glMultiTexCoord3d(GL_TEXTURE0,lightvector->x(),lightvector->y(),lightvector->z());
glMultiTexCoord2d(GL_TEXTURE1,cubetv1->x(),cubetv1->y());
glMultiTexCoord2d(GL_TEXTURE2,cubetv1->x(),cubetv1->y());
glVertex3d(cubev1->x(),cubev1->y(),cubev1->z());
 
*lightvector=*worldlightposition - *cubev2;
glMultiTexCoord3d(GL_TEXTURE0,lightvector->x(),lightvector->y(),lightvector->z());
glMultiTexCoord2d(GL_TEXTURE1,cubetv2->x(),cubetv2->y());
glMultiTexCoord2d(GL_TEXTURE2,cubetv2->x(),cubetv2->y());
glVertex3d(cubev3->x(),cubev2->y(),cubev2->z());
 
*lightvector=*worldlightposition - *cubev3;
glMultiTexCoord3d(GL_TEXTURE0,lightvector->x(),lightvector->y(),lightvector->z());
glMultiTexCoord2d(GL_TEXTURE1,cubetv3->x(),cubetv3->y());
glMultiTexCoord2d(GL_TEXTURE2,cubetv3->x(),cubetv3->y());
glVertex3d(cubev3->x(),cubev3->y(),cubev3->z());
 
*lightvector=*worldlightposition- *cubev4;
glMultiTexCoord3d(GL_TEXTURE0,lightvector->x(),lightvector->y(),lightvector->z());
glMultiTexCoord2d(GL_TEXTURE1,cubetv4->x(),cubetv4->y());
glMultiTexCoord2d(GL_TEXTURE2,cubetv4->x(),cubetv4->y());
glVertex3d(cubev1->x(),cubev4->y(),cubev4->z());
 
glEnd();

:cry:
Merci d'avance.

Salut,

Est-ce que tu as essayé d'afficher tes normales pour voir dans quelle direction elles vont?

Un truc du style:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 // Blue glColor3f(0.0f, 0.8f, 1.0f); // Draw normals glBegin(GL_LINES); for(i = 0; i < numVerts; i ++) { memcpy((void*) &vertex, (void*) &vertexArray[i], sizeof(vec3_t)); vectorAdd(normal, vertexArray[i], normalArray[i]); glVertex3fv(vertex); glVertex3fv(normal); } glEnd();
Je sais que j'avais eu un souci avec mes normales sur un programme que j'ai développé il y a un peu plus d'un an.

D'abord mes normales étaient mal orientées, ensuite, ma lumière n'était pas au bon endroit. Une fois mes normales correctement orientées, j'avais donc résolu mon souci avec un:
Code:

1 2 3 4 glPushMatrix(); glLoadIdentity(); glLightfv(GL_LIGHT0, GL_POSITION, light); glPopMatrix();

Enfin j'ai résolu ce cauchemar!:cry::yaisse2: :yaisse2::yaisse2:
finalement le carré est affiché avec l'effet bump map!:yaisse1:
c'était une erreur simple mais trés couteuse!:aie::aie::aie:
j'ai tout débrouiller tout seul!8-)8-):ccool:
google n'a pas m'aider,les tutorials et les explications intéressantes sur le bump mapping ne dépasse pas les doigts d'une seul main!8O8O8O
voici les résultats finales:
le code de cube map de normalisation:

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
 
#include"NCM.h"
 
NCM::NCM()
{}
 
NCM::~NCM()
{}
 
void NCM::create(unsigned int facesize,GLuint &id)
{
 
glBindTexture(GL_TEXTURE_CUBE_MAP,id);
double *cubemap =new double [facesize*facesize*3];
double offset = 0.5;
double halfsize = facesize /2;
unsigned int x,y;
unsigned int index=0;
for(unsigned char face=0; face<=6; face++)
{
for (y=0; y<facesize; y++)
{
for (x=0; x<facesize; x++)
{
switch (face)
{
case 0:temp=new QVector3D(halfsize,y+offset-halfsize,-(x+offset-halfsize));break;
case 1:temp=new QVector3D(-halfsize,y+offset-halfsize,x+offset-halfsize );break;
case 2:temp=new QVector3D(x+offset-halfsize,-halfsize,y+offset-halfsize);break;
case 3:temp=new QVector3D(x+offset-halfsize,halfsize,-(y+offset-halfsize));break;
case 4:temp=new QVector3D(x+offset-halfsize,y+offset-halfsize,halfsize);break;
case 5:temp=new QVector3D(-(x+offset-halfsize),(y+offset-halfsize),-halfsize);break;
}
temp->normalize();
cubemap[index++]=(double)(temp->x());
cubemap[index++]=(double)(temp->y());
cubemap[index++]=(double)(temp->z());
}
}
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X+face,0,GL_RGB,facesize,facesize,0,GL_RGB,GL_UNSIGNED_BYTE,cubemap);
index=0;
}
glTexParameteri(GL_TEXTURE_CUBE_MAP,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_CUBE_MAP,GL_TEXTURE_WRAP_R,GL_CLAMP_TO_EDGE);
delete cubemap;
}

et le code d'affichage:

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
 
/*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();
 
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();

Enfin je peut avancer vers une autre chose:mrgreen: ...