Discussion :

[KevinduC]

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 :



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 :



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 :



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 :

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

glShadeModel(GL_FLAT);

Ou même :

Code :

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

glShadeModel(GL_SMOOTH);

Mais ça n'a rien changé.

Voici le main :

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
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 :

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
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)

[Mathieu.J]

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-.

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 ).

[Kannagi]

Encore de l'OpenGL 1
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

[KevinduC]

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)

Encore de l'OpenGL 1
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 ?

[Kannagi]

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
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).

[KevinduC]

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.

[Kannagi]

Comme ceci ?

C'est plus le vertex shader , même si couplé avec le fragment shader est mieux (pour avoir une belle eau transparente).

[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 ?

[dragonjoker59]

Dans le fragment shader tu pourras moduler les normales, effectivement, par contre tu n'auras de relief

[KevinduC]

Je cherche à reproduire cet effet :



Vertex shader ou fragment shader ?

[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 ?

[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 ).
Nvidia avait présenté sa dernière CG qui permet de le faire en temps réel :

[LittleWhite]

Oui et non. Les reflets existaient (en trichant) avant le raytracing .

[Mat.M]

KevinduC tu devrais chercher dans Google "environment map opengl"
Il y a des sites en anglais qui expliquent ça

[KevinduC]

Le deuxième effet.

[dragonjoker59]

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

[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 :

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

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 ...

[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.

[KevinduC]

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 :



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

Code :

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

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

Code :

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

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 :

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
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 :

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
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 :

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
#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à ?

[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/