Questions sur l'éclairage

Version imprimable

Voir 40 message(s) de cette discussion en une page

3 pièce(s) jointe(s)

Questions sur l'éclairage

Bonjour, je n'ai jamais réussi à comprendre le principe de l'éclairage avec OpenGL. Ici par exemple, je définis une source de lumière directionnelle et j'obtiens ceci :

Pièce jointe 426628

Jusqu'ici rien d'anormal, jusqu'à ce que je déplace la caméra : Quelque soit le point de vue, la sphère apparaît toujours éclairée de cette manière.

Autre question : En me contentant d'un sol plat, voici ce que j'obtiens :

Pièce jointe 426630

Ici, le vecteur représentant la direction de la lumière a pour coordonnées (1,1,-1) ; si je le fixe à (0,0,-1), la lumière est censée arriver à la verticale vers le bas et donc éclairer davantage la scène. Pourtant, voici ce que ça donne :

Pièce jointe 426636

Je précise que les normales sont bien définies (Le vecteur normal du sol a pour coordonnées (0,0,1)).

Il y a également un autre problème : Comme vous le constatez sûrement sur la sphère, les arêtes sont visibles et ce n'est pas très esthétique, j'ai essayé de résoudre ce problème en faisant :

Code:

glShadeModel(GL_FLAT);

Ou même :

Code:

glShadeModel(GL_SMOOTH);

Mais ça n'a rien changé.

Voici le main :

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
int main(int argc,char *argv[])
{
    SDL_Surface *fenetre;
    SDL_Event evenement;
    Principale infos;
    Bureau *bureau;
    bool retour;
    unsigned int chrono,dureeMesuree;
 
    srand(time(NULL));
 
    if(SDL_Init(SDL_INIT_VIDEO)<0)
    {
        printf("Erreur initialisation SDL, pressez une toucher pour quitter");
        getch();
        return 0;
    }
 
    Init(&infos);
 
    bureau=infos.getBureau();
 
    if(!bureau->getPleinEcran())
        fenetre=SDL_SetVideoMode(800,600,32,SDL_OPENGL);
    else
        fenetre=SDL_SetVideoMode(bureau->getLargeur(),bureau->getHauteur(),32,SDL_OPENGL|SDL_NOFRAME);
 
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
 
    if(!bureau->getPleinEcran())
        gluPerspective(FOVY,4.0/3,NEAR,FAR);
    else
        gluPerspective(FOVY,bureau->getRatio(),NEAR,FAR);
 
    glEnable(GL_TEXTURE_2D);
    glEnable(GL_DEPTH_TEST);
 
    glEnable(GL_LIGHTING);			//Activation éclairage
    glEnable(GL_LIGHT0);
 
    float couleur[4]={1,1,1,1};			//Définition couleur lumière
    float direction[4]={1,1,-1,0};		//Définition direction lumière
    glLightfv(GL_LIGHT0,GL_AMBIENT,couleur);		//Attribution couleur
    glLightfv(GL_LIGHT0,GL_DIFFUSE,couleur);
    glLightfv(GL_LIGHT0,GL_SPECULAR,couleur);
    glLightfv(GL_LIGHT0,GL_POSITION,direction);		//Attribution direction
 
    infos.chargeTextures();
 
    retour=infos.InitMap();
    if(!retour)
    {
        SDL_Quit();
        return 0;
    }
 
    while(1)
    {
        SDL_PollEvent(&evenement);
        if(evenement.type==SDL_QUIT)
            break;
        else
        if(evenement.type==SDL_KEYDOWN)
        {
            if(evenement.key.keysym.sym==SDLK_ESCAPE&&bureau->getPleinEcran())
                break;
        }
 
        //Rendu et gestion caméra ...
 
        dureeMesuree=SDL_GetTicks()-chrono;
        if(dureeMesuree<DUREE_FRAME)
            SDL_Delay(DUREE_FRAME-dureeMesuree);
 
        chrono=SDL_GetTicks();
    }
 
    SDL_Quit();
    return 0;
}

Voici le rendu, ce dernier se fait à partir d'un fichier .obj dans lequel les normales sont bien définies :

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
void OBJ_drawVBO(OBJ_VBO *VertexBufferObject)
{
    int compteurFaces=0,first=0;
    int numFaceChangeTex1,numFaceChangeTex2,compteurFacesChangeTex=0,compteurTex=0;
    const int nbVertices=3*VertexBufferObject->nbFaces;
 
    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    glEnableClientState(GL_NORMAL_ARRAY);
    glEnableClientState(GL_COLOR_ARRAY);
 
    glEnable(GL_BLEND);
    glEnable(GL_ALPHA_TEST);
    glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
    glAlphaFunc(GL_GREATER,0.2);
 
    glBindBuffer(GL_ARRAY_BUFFER,VertexBufferObject->bufferVRAM);
 
    glVertexPointer(3,GL_FLOAT,0,BUFFER_OFFSET(0));
    glTexCoordPointer(2,GL_FLOAT,0,BUFFER_OFFSET(nbVertices*3*sizeof(float)));
    glNormalPointer(GL_FLOAT,0,BUFFER_OFFSET(nbVertices*3*sizeof(float)+nbVertices*2*sizeof(float)));
    glColorPointer(3,GL_FLOAT,0,BUFFER_OFFSET(nbVertices*3*sizeof(float)+nbVertices*2*sizeof(float)+nbVertices*3*sizeof(float)));
 
    while(1)
	{
		numFaceChangeTex1=VertexBufferObject->liste_faces_change_tex[compteurFacesChangeTex];
		numFaceChangeTex2=VertexBufferObject->liste_faces_change_tex[compteurFacesChangeTex+1];
 
		if(numFaceChangeTex2==-1)
			numFaceChangeTex2=VertexBufferObject->nbFaces;
 
		if(numFaceChangeTex1==compteurFaces)
		{
			if(VertexBufferObject->textures[compteurTex]!=-1)
			{
				glEnable(GL_TEXTURE_2D);
				glBindTexture(GL_TEXTURE_2D,(GLuint)VertexBufferObject->textures[compteurTex]);
			}
			else
				glDisable(GL_TEXTURE_2D);
 
			glDrawArrays(GL_TRIANGLES,first,3*(numFaceChangeTex2-numFaceChangeTex1));		//Dessin des faces jusqu'au prochain changement de texture
			first+=3*(numFaceChangeTex2-numFaceChangeTex1);
			compteurFaces+=(numFaceChangeTex2-numFaceChangeTex1)-1;
 
			compteurFacesChangeTex++;
			compteurTex++;
		}
 
		compteurFaces++;
		if(compteurFaces==VertexBufferObject->nbFaces)
			break;
	}
 
    glDisableClientState(GL_VERTEX_ARRAY);
    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
    glDisableClientState(GL_NORMAL_ARRAY);
    glDisableClientState(GL_COLOR_ARRAY);
 
    glEnable(GL_TEXTURE_2D);
}

Merci de bien vouloir m'éclairer à ce sujet (Non ce n'est pas un jeu de mot ^^) et bonne journée :)

Edit : Ok alors petite négligence de ma part : Il faut définir la direction de la lumière après avoir appelé la matrice modelview, ceci résout le problème de l'éclairage qui ne change pas quelque soit le point de vue. Mais on dirait que l'axe des Z est inversé : Lorsque je définis comme vecteur (1,1,-1) la sphère semble éclairée par le bas et inversément lorsque je définis (1,1,1)

13/11/2018, 16h56
Mathieu.J

Citation:

Envoyé par KevinduC

si je le fixe à (0,0,-1), la lumière est censée arriver à la verticale vers le bas

Je ne suis pas expert dans le domaine mais je dirais à l'horizontale vers l'avant,
vers le bas ce serait (0,-1, 0) si on se base sur (x, y, z) et un repère OpenGL et une caméra dirigée vers Z-.

Citation:

Envoyé par KevinduC

Le vecteur normal du sol a pour coordonnées (0,0,1)

Idem, devrait être (x=0, y=1, z=0)

Pour l'absence de différence entre le SMOOTH et le FLAT vérifie que ton OBJ a bien d'enregistré les vertices avec les normales moyennes calculées et pas un vertex par face avec la normale de la face (Je sais c'est pas clair dit comme ça :mrgreen:).
13/11/2018, 17h11
Kannagi

Encore de l'OpenGL 1 :roll:
Si tu veux faire de la lumière oublie cette vielle version (qui a une façon de gérer la lumière assez bizarre je te l’accorde) , utilise au moins la version 2 et fait un fragment shader , ça sera plus simple et plus rapide ;)
Et de plus , tu peux faire des lumières beaucoup plus avancé (et faire des normal maps par exemple) , vu que GL1 ne gère que le flat ou de gouraud :p
13/11/2018, 18h10
KevinduC

Citation:

Envoyé par Mathieu.J

Je ne suis pas expert dans le domaine mais je dirais à l'horizontale vers l'avant,
vers le bas ce serait (0,-1, 0) si on se base sur (x, y, z) et un repère OpenGL et une caméra dirigée vers Z-.

Non mon repère est bien orienté avec l'axe des Z vertical, mais bon c'est pas grave, j'ai juste à me rappeler que si je veux orienter la lumière selon un vecteur (x,y,z) il faut en fait prendre le vecteur (-x,-y,-z) :mrgreen:

Citation:

Envoyé par Kannagi

Encore de l'OpenGL 1 :roll:
Si tu veux faire de la lumière oublie cette vielle version (qui a une façon de gérer la lumière assez bizarre je te l’accorde) , utilise au moins la version 2 et fait un fragment shader , ça sera plus simple et plus rapide ;)

C'est la version 2.x. Tu pourrais m'expliquer brièvement ce qu'est un fragment shader ? :)
13/11/2018, 18h29
Kannagi

Citation:

Envoyé par KevinduC

C'est la version 2.x. Tu pourrais m'expliquer brièvement ce qu'est un fragment shader ? :)

Ton code c'est du pur jus GL1 si on enleve les VBO :aie:
Le fragment shader permet de choisir la valeur de chaque pixel rendu et donc c'est un code que tu fais coté GPU (avec GLSL).
13/11/2018, 20h01
KevinduC

Citation:

Envoyé par Kannagi

Le fragment shader permet de choisir la valeur de chaque pixel rendu et donc c'est un code que tu fais coté GPU (avec GLSL).

Ah, est-ce que ça permettrait de créer des effets d'ondulation ? Comme un reflet dans l'eau par exemple.
13/11/2018, 21h33
Kannagi

Comme ceci ? https://www.youtube.com/watch?v=a9B0vWduGQY
C'est plus le vertex shader , même si couplé avec le fragment shader est mieux (pour avoir une belle eau transparente).
13/11/2018, 21h54
KevinduC

Pourquoi pas ? :)

En fait je compte réaliser des reflets en effectuant un deuxième rendu symétrique et en jouant avec le stencil buffer mais le reflet apparaîtrait un peu trop parfait dans l'eau.

Donc je me dis que s'il faut créer un effet de déformation il vaut mieux intervenir au niveau des pixels plutôt que des vertices non ?
20/11/2018, 00h10
dragonjoker59

Dans le fragment shader tu pourras moduler les normales, effectivement, par contre tu n'auras de relief
20/11/2018, 02h46
KevinduC

1 pièce(s) jointe(s)

Je cherche à reproduire cet effet :

Pièce jointe 428245

Vertex shader ou fragment shader ?
20/11/2018, 09h24
LittleWhite
Bonjour,
Sur la photo, je vois deux "effets":
- le reflet du paysage sur l'eau ;
- l'effet faisant que l'eau n'est pas plate/lisse.
Du coup, lequel ? :aie:
20/11/2018, 09h46
Kannagi

Les deux j'imagine , mais pour le reflet c'est clairement du raytracing (et il faut avoir un bon GPU pour le faire en temps réel :aie: ).
Nvidia avait présenté sa dernière CG qui permet de le faire en temps réel :
https://www.youtube.com/watch?v=J3ue35ago3Y
20/11/2018, 10h37
LittleWhite

Oui et non. Les reflets existaient (en trichant) avant le raytracing ;).
20/11/2018, 11h07
Mat.M

KevinduC tu devrais chercher dans Google "environment map opengl"
Il y a des sites en anglais qui expliquent ça
20/11/2018, 12h18
KevinduC

Le deuxième effet.
20/11/2018, 12h42
dragonjoker59

1 pièce(s) jointe(s)

Le second effet est faisable avec de la perturbation de normales et une env map.

Pièce jointe 428326
20/11/2018, 14h22
KevinduC
Petite parenthèse : J'ai un problème de fragment shader, je suis dans un projet qui affiche une map avec ou sans textures. Mais les objets dépourvus de texture apparaissent quand même texturés, je me rends compte que mon problème vient de mon fragment shader qui est codé de sorte à gérer les textures dans tous les cas :
Code:

1 2 3 4 5 6 7 8 #version 120 uniform sampler2D tex; void main(void) { gl_FragColor=texture2D(tex,gl_TexCoord[0].st)*gl_Color; }
Il faudrait que je teste la valeur de tex mais je n'arrive pas à déterminer s'il s'agit d'un entier, vec, structure ...
20/11/2018, 16h18
dragonjoker59

Il est impossible de tester dans le shader si le sampler donné est valide.

Il y a plusieurs solutions possible :
- écrire 2 shaders (un pour les objets texturés, un pour les non texturés), et binder celui correspondant à l'objet en cours ;
- créer une texture en 1x1 contenant un simple pixel blanc, et binder cette texture pour les objets non texturés ;
- utiliser une variable uniform dans ton shader permettant de dire si la texture doit être utilisée ou non.

1 pièce(s) jointe(s)

Ok, j'ai opté pour la dernière solution finalement, ce qui m'a fait reprendre pas mal de fonctions de rendu que j'avais codées.
Sinon je suis entrain de coder une mini-lib pour l'éclairage mais j'obtiens quasiment le même résultat qu'avec l'éclairage OpenGL classique :

Pièce jointe 428452

J'ai pour cela codé une fonction d'activation de l'éclairage et une fonction de désactivation :

Code:

1
2
3
4
5
6
void LHT_EnableLighting(const GLuint programID)
{
    const GLint active=glGetUniformLocation(programID,"enableLight");
 
    glUniform1i(active,true);
}

Code:

1
2
3
4
5
6
void LHT_DisableLighting(const GLuint programID)
{
    const GLint active=glGetUniformLocation(programID,"enableLight");
 
    glUniform1i(active,false);
}

J'ai également codé des fonctions pour spécifier la position de la source de lumière et son type (Point ou directionnelle) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void LHT_SetPositionLight(const GLuint programID,const int numLight,const float X,const float Y,const float Z)
{
    GLint positionShader;
    char varPos[10]="pos";
    char numLightChar[3];
 
    if(numLight<=LHT_MAX_LIGHTS-1)
    {
        sprintf(numLightChar,"%d",numLight+1);
 
        strcat(varPos,numLightChar);
 
        positionShader=glGetUniformLocation(programID,varPos);
 
        glUniform3f(positionShader,X,Y,Z);
    }
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void LHT_SetTypeLight(const GLuint programID,const int numLight,const int type)
{
    GLint typeShader;
    char varType[10]="type";
    char numLightChar[3];
 
    if(numLight<=LHT_MAX_LIGHTS-1)
    {
        sprintf(numLightChar,"%d",numLight+1);
 
        strcat(varType,numLightChar);
 
        typeShader=glGetUniformLocation(programID,varType);
 
        glUniform1i(typeShader,type);
    }
}

Voici mon vertex shader :

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
#version 120
 
uniform vec3 pos1;
uniform int type1;
 
uniform vec3 pos2;
uniform int type2;
 
uniform bool enableLight;
 
void main(void)
{
	float colorWithLight;
	vec3 vectorSourceVertex;
 
	gl_Position=gl_ModelViewProjectionMatrix*gl_Vertex;
 
	if(!enableLight)
		gl_FrontColor=gl_Color;
	else
	{
		if(type1==0)
		{
			vectorSourceVertex.x=pos1.x-gl_Vertex.x;		//Vecteur entre source de lumière et vertex
			vectorSourceVertex.y=pos1.y-gl_Vertex.y;
			vectorSourceVertex.z=pos1.z-gl_Vertex.z;
		}
 
		else
		{
			//
		}
 
		colorWithLight=dot(normalize(vectorSourceVertex),gl_Normal);		//Produit scalaire
 
		if(colorWithLight<0)
			colorWithLight=0;
 
		gl_FrontColor[0]=gl_Color[0]*colorWithLight;
		gl_FrontColor[1]=gl_Color[1]*colorWithLight;
		gl_FrontColor[2]=gl_Color[2]*colorWithLight;
		gl_FrontColor[3]=gl_Color[3];
	}
 
	gl_TexCoord[0]=gl_MultiTexCoord0;
}

Pour le moment je ne gère qu'une source de lumière. Pour info les normales sont définies par Blender et écrites dans un VBO.

Qu'est-ce que vous pensez ? Est-ce que c'est normal de se retrouver avec ce rendu-là ?

20/11/2018, 18h43
dragonjoker59

Tu as donc opté pour la pire des solutions (j'aurais pas dû la mettre, tiens...).

Pour l'éclairage, il vaut mieux le faire dans le fragment shader.
Tiens voilà un tutoriel que je te conseille vivement : http://www.lighthouse3d.com/tutorial...tional-lights/

Voir 40 message(s) de cette discussion en une page