Problème de lumiére OpenGL 3.3

**manrugby** · 29/09/2011, 19h50

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:

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 :

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

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

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

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.

Problème de lumiére OpenGL 3.3

OpenGL

Mode arborescent

Discussions similaires

Partager

Partager