Problème de lumiére OpenGL 3.3

Version imprimable

2 pièce(s) jointe(s)

Salut a tous,

ça fait un petit moment que j'essaie de faire fonctionner les lumières avec opengl 3.3, mais j'ai des problème(à vrai dire je ne sais pas d'ou ça peut venir ...).

Donc voila ma scene c'est juste un plan et une sphere qui tourne autour de l'axe Y, la lumière est tout en haut de la scene (position(0,10,0).
Voici quelques captures d'ecran:
http://www.developpez.net/forums/att...1&d=1317314378
http://www.developpez.net/forums/att...1&d=1317314378
Donc première chose on remarque que la la position de la lumière est en dessous de la scène(j'y comprend rien)
Voici un peu de code si ca peut aider à m'aider :)
PS: je me suis bien assuré que les données des objets 3d(normal/vertex) sont bien uploadé dans les VBO avec debugger, donc pas de problème de ce coté la)
mais peut être ça peut venir de mes shaders, ou bien des calculs des matrices(modelview/normal etc...)
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
#version 150
#extension GL_ARB_gpu_shader5 : enable
 
in vec3 inPosition;
in vec3 inNormal;
 
uniform mat4 mv;
uniform mat4 p;
uniform mat3 nMatrix;
uniform vec3 lightPos;
uniform vec4 ambient;
uniform vec4 diffuse;
uniform vec4 specular;
uniform float shininess;
 
out vec3 vNormal;
out vec3 vLightDir;
out vec4 vambient;
out vec4 vdiffuse;
out vec4 vspecular;
out float fshininess;
 
void main(void)
{
        vambient=ambient;
        vdiffuse=diffuse;
        vspecular=specular;
        fshininess=shininess;
 
	vNormal = nMatrix * inNormal;
 
	vec4 vPosition4= p * mv * vec4(inPosition,1.0);
        vec3 vPosition3= vPosition4.xyz/vPosition4.w;
 
        vLightDir = normalize(lightPos - vPosition3);
 
	gl_Position=vPosition4;
 
}

Fragment 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
 
#version 150
 
 in vec3 vLightDir;
 in vec3 vNormal;
 in vec4 vambient;
 in vec4 vdiffuse;
 in vec4 vspecular;
 in float fshininess;
 out vec4 finalColor;
 
void main(void)
{
 
 
	float dif=max(0.0,dot(vNormal,vLightDir));
	finalColor = (dif * vdiffuse);
        finalColor+= vambient;
 
	vec3 ref=normalize(reflect(-vLightDir,vNormal));
      /* la couleur specular ne marche pas tres bien jlé commenté */
       /* float spec = max(0.0, dot(vNormal, ref)); 
 
     if(dif != 0)
            spec = pow(max(dot(ref,vNormal),0.0),fshininess);
 
	finalColor.rgb+=vspecular.rgb*vec3(spec,spec,spec);*/
}

Voila mon programme(j'utilise mon moteur donc si vous avez des doutes sur une fonction je peux vous montrer le code pas de problème de ce coté,et aussi le code et mal ecrit parce que je suis entrain de faire des testes donc soyez indulgent de ce coté :) )

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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
#include <MPGE/MPGE.h>
 
#include <MPGE_OpenGL3/MPGE_OpenGL3.h>
 
 
#define FLATF "flat.frag"
#define FLATV "flat.vert"
#define LIGHTF "light.frag"
#define LIGHTV "light.vert"
 
#define FRAGMENT_SHADER LIGHTF
#define VERTEX_SHADER LIGHTV
 
typedef struct Object
{
    MPGEVertexArray vao;
    MPGEVertexBuffer vbo;
    MPGEIndexBuffer ibo;
    MPGEWaveFront obj;
 
} Object;
f32  x=0,y=0;
 
MPGEVector3D lightPos;
 
void loadObject(Object* obj,const c8* filename)
{
    obj->obj=MPGE_WaveFrontLoad(filename);
 
    if(obj->obj->mesh->polyType==4)
        obj->vao=MPGE_VertexArrayNew(MPGE_EGL3VPM_QUADS,3);
    else if(obj->obj->mesh->polyType==3)
        obj->vao=MPGE_VertexArrayNew(MPGE_EGL3VPM_TRIANGLES,3);
 
    obj->vbo=MPGE_VertexBufferNew(MPGE_EGL3VB_STATIC,3);
    obj->ibo=MPGE_IndexBufferNew(MPGE_EGL3IB_STATIC);
 
    MPGE_VertexBufferUploadToGPU(obj->vbo,obj->obj->mesh->vertices,0,obj->obj->mesh->normals);
    MPGE_IndexBufferUploadToGPU(obj->ibo,obj->obj->mesh->ivertices,0,obj->obj->mesh->inormals);
 
    MPGE_VertexArrayAttachVertexBuffer(obj->vao,obj->vbo);
    MPGE_VertexArrayAttachIndexBuffer(obj->vao,obj->ibo);
}
void initResource()
{
    MPGE_ResourceLoadShader(FRAGMENT_SHADER,MPGE_EST_FRAGMENT);
    MPGE_ResourceLoadShader(VERTEX_SHADER,MPGE_EST_VERTEX);
 
}
void drawSphere(Object* sphere,MPGEShader vp)
{
 
 
    if((vp=MPGE_ShaderManagerEnable(MPGE_ESMST_VERTEX3)))
    {
 
        MPGE_RendererMatrixPush();
 
        if(x>=360)
            x-=360;
 
        MPGE_RendererMatrixRotate(x+=1,0,1,0);
        MPGE_RendererMatrixTranslate(2,2,2);
 
        MPGE_ShaderSendMatrix4(vp,"mv",MPGE_RendererMatrixGetModelView());
        MPGE_ShaderSendMatrix4(vp,"p",MPGE_RendererMatrixGetProjection());
        MPGE_ShaderSendMatrix3(vp,"nMatrix",MPGE_RendererMatrixGetNormal());
        MPGE_ShaderSendVector3D(vp,"lightPos",&lightPos);
        MPGE_ShaderSendVector4D(vp,"ambient",&sphere->obj->mtl->materials[0]->ambient);
        MPGE_ShaderSendVector4D(vp,"diffuse",&sphere->obj->mtl->materials[0]->diffuse);
        MPGE_ShaderSendVector4D(vp,"specular",&sphere->obj->mtl->materials[0]->specular);
        MPGE_ShaderSendFloat(vp,"shininess",sphere->obj->mtl->materials[0]->shininess);
 
        MPGE_VertexArrayDraw(sphere->vao,vp);
 
        MPGE_ShaderManagerDisable();
    }
}
void drawPlan(Object* plan,MPGEShader vp)
{
 
    if((vp=MPGE_ShaderManagerEnable(MPGE_ESMST_VERTEX3)))
    {
 
        MPGE_ShaderSendMatrix4(vp,"mv",MPGE_RendererMatrixGetModelView());
        MPGE_ShaderSendMatrix4(vp,"p",MPGE_RendererMatrixGetProjection());
        MPGE_ShaderSendMatrix3(vp,"nMatrix",MPGE_RendererMatrixGetNormal());
        MPGE_ShaderSendVector3D(vp,"lightPos",&lightPos);
        MPGE_ShaderSendVector4D(vp,"ambient",&plan->obj->mtl->materials[0]->ambient);
        MPGE_ShaderSendVector4D(vp,"diffuse",&plan->obj->mtl->materials[0]->diffuse);
        MPGE_ShaderSendVector4D(vp,"specular",&plan->obj->mtl->materials[0]->specular);
        MPGE_ShaderSendFloat(vp,"shininess",plan->obj->mtl->materials[0]->shininess);
 
        MPGE_VertexArrayDraw(plan->vao,vp);
 
        MPGE_ShaderManagerDisable();
    }
 
}
void drawTorus(Object* torus,MPGEShader vp)
{
    if((vp=MPGE_ShaderManagerEnable(MPGE_ESMST_VERTEX3)))
    {
        MPGE_RendererMatrixPush();
 
        if(y>=360)
            y-=360;
 
        MPGE_RendererMatrixTranslate(0,5,0);
        MPGE_RendererMatrixRotate(y+=6,0,1,0);
 
        MPGE_ShaderSendMatrix4(vp,"mv",MPGE_RendererMatrixGetModelView());
        MPGE_ShaderSendMatrix4(vp,"p",MPGE_RendererMatrixGetProjection());
        MPGE_ShaderSendMatrix3(vp,"nMatrix",MPGE_RendererMatrixGetNormal());
        MPGE_ShaderSendVector3D(vp,"lightPos",&lightPos);
        MPGE_ShaderSendVector4D(vp,"ambient",&torus->obj->mtl->materials[0]->ambient);
        MPGE_ShaderSendVector4D(vp,"diffuse",&torus->obj->mtl->materials[0]->diffuse);
        MPGE_ShaderSendVector4D(vp,"specular",&torus->obj->mtl->materials[0]->specular);
        MPGE_ShaderSendFloat(vp,"shininess",torus->obj->mtl->materials[0]->shininess);
        MPGE_VertexArrayDraw(torus->vao,vp);
 
        MPGE_ShaderManagerDisable();
 
        MPGE_RendererMatrixPop();
    }
}
void drawFPS(MPGEText fps,c8* fpsbuffer)
{
    MPGE_RendererMatrixSetOrthographicProjection(800,600);
    MPGE_ParseIntegerToString(MPGE_SDL_WindowGetFPS(),fpsbuffer+4);
    MPGE_TextSetString(fps,fpsbuffer);
    MPGE_TextDrawLine(fps,0);
 
}
int main(int argc,char** argv)
{
    MPGESDLEvent event=null;
    MPGEDevice device;
    MPGEDeviceConfig conf;
    MPGEShader fp;
    MPGEShader vp;
    MPGECamera cam;
    MPGEText fps;
 
    Object plan,sphere,torus;
 
 
    char fpsbuffer[10]="FPS ";
 
 
    conf.autodetect=true;
    conf.fps=60;
    conf.winTitle=MPGE_StringNew("Simple test 3D");
    conf.width=800;
    conf.height=600;
    conf.rendererDimension=MPGE_RENDERER_3D;
    conf.vsync=false;
    conf.fullscreen=false;
    conf.upAxis=1; /* 1=Y is up,0=X is up or 2=Z is up*/
 
    device=MPGE_Init(&conf);
 
    if(device)
    {
        initResource();
 
        loadObject(&sphere,"sphere.obj");
        loadObject(&plan,"plan.obj");
        loadObject(&torus,"torus.obj");
 
        MPGE_RendererSetBackgroundColor(1.0,1.0,1.0,1.0);
 
        event=device->event;
        vp=MPGE_ResourceGetShader(VERTEX_SHADER);
        fp=MPGE_ResourceGetShader(FRAGMENT_SHADER);
 
        if(MPGE_ShaderManagerAdd(&vp,&fp,MPGE_ESMST_VERTEX3,MPGE_ESMST_FRAGMENT3))
        {
 
            MPGE_ShaderManagerUnbind();
        }
        cam=MPGE_RendererGetDefaultCamera();
        MPGE_CameraLookAt(cam,MPGE_Vector3D(0,0,0));
        MPGE_CameraSetPosition(cam,MPGE_Vector3D(8,8,8));
 
        MPGE_SDL_EventKeyRepeatEnable(event);
        fps=MPGE_TextNew();
        MPGE_TextSetFont(fps,MPGE_ResourceGetFont("FreeMono.ttf"));
        MPGE_TextSetString(fps,"FPS=");
 
        lightPos=MPGE_Vector3D(0,10,0);
 
        while(MPGE_SDL_EventRunning(event))
        {
            MPGE_SDL_EventUpdate(event,0);
 
            MPGE_RendererBegin();
 
            if(MPGE_SDL_EventIsKeyPressed(event,MPGE_UP))
                MPGE_CameraMoveUp(cam,0.5);
            else if(MPGE_SDL_EventIsKeyPressed(event,MPGE_DOWN))
                MPGE_CameraMoveUp(cam,-0.5);
 
            MPGE_RendererMatrixSetPerspectiveProjection(800,600);
            MPGE_RendererMatrixMode(MPGE_ERMM_MODELVIEW);
 
            drawPlan(&plan,vp);
            drawSphere(&sphere,vp);
 
            drawFPS(fps,fpsbuffer);
 
            MPGE_RendererEnd();
 
 
        }
    }
 
    MPGE_WaveFrontDelete(plan.obj);
    MPGE_WaveFrontDelete(sphere.obj);
    MPGE_WaveFrontDelete(torus.obj);
    MPGE_VertexArrayDelete(sphere.vao);
    MPGE_VertexArrayDelete(torus.vao);
    MPGE_VertexArrayDelete(plan.vao);
 
    MPGE_Close(device);
 
    return 0;
}

Voila merci d'avance,je galère depuis 2 semaines voir plus,je me retourne vers vous car ça me donne plus envie de continuer le developpement de mon moteur :mouarf:
EDIT:
j'ai remarqué un truc si dans mon shader je remplace cette ligne "vNormal = nMatrix * inNormal;" par "vNormal = -(nMatrix * inNormal);"
le rendu de la sphére est beaucoup mieu mais le plan n'est plus affecté par la lumière il est tout noir.

Bonjour à tous,

J'ai trouver l'erreur c'est l'exporter de blender qui ne calcul pas très bien les normals/vertex normals, je viens d'utiliser Wings3D et ça marche nikel :).
Cependant j'ai une questions pour palier à ce problème de normal et eviter ce genre de problème j'ai decidé de calculer les normals moi même,j'ai fait une petite recherche, et j'ai trouvé qu'il y a 2 type de normals, Face normal et Vertex Normal,j'ai implementer l'algo pour calculer les Face normal,mais j'ai pas trouver sur le net comment calculer un vertex normal,c'est quelqu'un à une idée de comment faire merci.
Je propose quand même mon code pour calculer les normals(parce que parfois ça ne calcul pas très bien ..)
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 static MPGEVector3D MPGE_MeshGetVertexPoint(MPGEMesh mesh,u32 index) { MPGEVector3D point; index = index * mesh->polyType; point.x=mesh->vertices->array[ index ]; point.y=mesh->vertices->array[ index + 1 ]; point.z=mesh->vertices->array[ index + 2 ]; return point; /* retourne x,y,z d'un vertex */ } void MPGE_MeshCalculateVertexNormal(MPGEMesh mesh,bool ccw) { u32 i; MPGEVector3D vNormal; MPGEVector3D p[3]; f32 normal[3]; u32 inormals[3]={0,1,2};/* index normal */ if(mesh && mesh->hasVertices && mesh->hasNormals) { for(i=0; i<mesh->countVertexPoly; i+=mesh->polyType) { p[0]=MPGE_MeshGetVertexPoint(mesh,mesh->ivertices->array[i]); p[1]=MPGE_MeshGetVertexPoint(mesh,mesh->ivertices->array[i+1]); p[2]=MPGE_MeshGetVertexPoint(mesh,mesh->ivertices->array[i+2]); if(ccw) vNormal=MPGE_Vector3DFindNormal(&p[0],&p[1],&p[2]); else vNormal=MPGE_Vector3DFindNormal(&p[2],&p[1],&p[0]); MPGE_Vector3DNormalize(&vNormal); MPGE_Vector3DGetArray(&vNormal,normal); MPGE_MeshAddNormal(mesh,normal); inormals[0]=i; inormals[1]=i+1; inormals[2]=i+2; MPGE_MeshAddIndexNormal(mesh,inormals); } } }
Remarque: je n'ai pas implementé le calcul des normals si j'ai un quad, cet algo calcul la normal d'un triangle(mesh->polyType ==3 )...

01/10/2011, 14h27
LittleWhite

Bonjour,

Pour le calcul des "Vertex normals" (normales pour chaque vertex) il suffit de reprendre les "Face normales" (normales par face) des faces comprenant un vertex et de faire leurs moyenne.
(Soit, la somme des normales des faces pour un vertex / nombre de faces pour ce vertex)
01/10/2011, 14h34
manrugby

Citation:

(Soit, la somme des normales des faces pour un vertex / nombre de faces pour ce vertex)

Hmmm je pige rien là!...,

Ok prenons un exemple j'ai un carré,qui se compose de 4 vertex soit 2 triangles de 3 vertex qui ont un 2 vertex commun.
D'après ce que vous aviez dit,je dois calcul la normale des deux face c'est ça ?,ensuite faire la moyenne de ces 2 normales, et les ajouter à tous les vertex de ce carré ?.
01/10/2011, 14h44
LittleWhite
Citation:

Envoyé par manrugby

Hmmm je pige rien là!...,

Ok prenons un exemple j'ai un carré,qui se compose de 4 vertex soit 2 triangles de 3 vertex qui ont un vertex commun.
D'après ce que vous aviez dit,je dois calcul la normale des deux face c'est ça ?,ensuite faire la moyenne de ces 2 normales, et les ajouter à tous les vertex de ce carré ?.

Oops.

Bon, le carré, imaginons le plié en sa diagonale ok ?
Nous avons 4 vertex, v1 (coin supérieur gauche), v2 , v3 , v4 (sens des aiguilles d'une montre).
Code:

1 2 3 4 5 v1 -- v4 | / | | / | v2 -- v3
Bon, nous avons une normale n1 pour le triangle v1 v2 v4 (vous l'avez calculer en faisant le cross product de v1 - v2 avec v1 - v4, normalement.
Nous avons une seconde normale, n2 pour le traignel v2 v3 v4 (même méthode).
Ce sont les normales pour les faces.

Maintenant, si nous voulons des normales pour chaque vertex, il faut faire la moyenne des normales agissant sur le vertex. (Je ne sais pas comment le dire proprement :s)

La normale de v1 c'est n1
La normale de v3 c'est n2
Car ces deux vertex, ne sont compris que dans une face (que dans un triangle) et le vertex n'est utilisé dans aucun autre.
Par contre, v2 et v4 sont des vertex compris dans deux triangles.
Leurs normales est:
n1 + n2 / 2

(2 étant le nombre de triangles dans lequel on utilise la vertex).

En espérant que cela est plus clair.

(Une explication a été donnée dans le défi Qt N°2 , sur le fil de discussion principal du défi)
01/10/2011, 15h52
manrugby

Oui c'est clair merci,
Cependant y a juste cette technique pour la calcul des normales?, je trouve que l'algo est un peu complexe,je veux dire le calcul sera trop lourd si j'ai un mesh trop grand...comparer les vertices d'une face pour voir s'il y a d'autres faces qui partagent le même vertex c'est beaucoup non ?
01/10/2011, 15h54
LittleWhite

Citation:

Envoyé par manrugby

Oui c'est clair merci,
Cependant y a juste cette technique pour la calcul des normales?, je trouve que l'algo est un peu complexe,je veux dire le calcul sera trop lourd si j'ai un mesh trop grand...comparer les vertices d'une face pour voir s'il y a d'autres faces qui partagent le même vertex c'est beaucoup non ?

Il faut le faire qu'au moment du chargement, déjà. De plus, nous connaissons si un vertex est utilisé plusieurs fois, et ceci grâce aux indices. (En effet, si un même indice apparait deux fois, alors le vertex correspondant est utilisé deux fois).
Donc un parcours efficace des indices pourra vous donner satisfaction.
01/10/2011, 15h58
manrugby

Merci bien littleRabbit,
je vais réfléchir un peu comment faire l'algo et je revienderai si j'ai toujours des problèmes :)
03/10/2011, 10h26
dragonjoker59

A l'algorithme de LittleWhite tu peux ajouter plusieurs choses :

1 - Les smoothing groups :
Tu regroupes tes faces dans des groupes de faces et tu calcules les normales de tes vertex en fonction de ces groupes.
En reprenant l'exemple du carré, si on dit que f1 et f2 sont dans le même groupe, le calcul reste le même que celui déjà fait. Si f1 et f2 sont dans 2 groupes différents, les vertex v2 et v4 auront chacun 2 normales : une pour le groupe contenant f1 (n1) et une pour le groupe contenant f2 (n2). Ça implique généralement des modifications dans l'organisation interne des meshes (doublage de certains vertex pour pouvoir leur appliquer 2 normales, ...)

2 - La prise en compte de l'angle :
En fonction de l'angle entre 2 faces tu peux décider que les vertex qu'elles ont en commun partagent la même normale ou bien qu'ils aient une normale pour chaque face qu'ils partagent (imagine que tes 2 vertex composent une arête d'un cube, tu ne veux pas forcément que leur normale soit la moyenne de la normale des faces auxquelles ils appartiennent)
03/10/2011, 17h32
manrugby

Merci a vous 2.
Je met en résolu