Discussion :

[qnop]

Bonjour à vous tous.
Ayant pour projet de gérer les ombres dans mon moteur 3D, je demande de l'aide car j'ai un problème avec le rendu offscreen (je débute totalement dans cette matière).
Pour le moment, j'essaie de simplement projeter l'ombre d'une araignée sur un sol, mais voilà, comme qui dirait, j'ai un petit problème ^^.
Voila ma manière de procéder : J'active ma shadowmap, j'"affiche" le rendu que je veux (en fait je n'envoie juste les vertices sans me préoccuper de la texture, de la couleur et des normales), et j'essaie d'affiché ma shadowmap. Mais voilà, elle est blanche enfin on voit très très peu la différence, faut bien se forcer). Alors que en essayant sans utilisé de shadow map, on a bien le rendu

Voilà le code d'affichage basique sans rendu offscreen, et avec un screen de ce qui est renvoyé :

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
#include "include.h"
 
#include "device.h"
#include "matrix.h"
#include "model.h"
#include "camera.h"
#include "sceneManager.h"
#include "fbo.h"
 
Shader shader_Model1;
Shader shadow;
Shader tex;
 
ShadowMap sm;
 
int main ( int argc, char** argv )
{
    SceneManager scene(new Device(800, 600, false, 0));
    Device *driver = scene.getDriver();
 
    ModelNode *spider;
 
    try{
        spider = scene.addModel("models/OBJ/spider.obj");
        shader_Model1.load("Shaders/Model.vert", "Shaders/Model.frag");
        shadow.load("Shaders/DepthRender.vert", "Shaders/DepthRender.frag");
        tex.load("Shaders/texture.vert", "Shaders/texture.frag");
 
        sm.load();
    }
    catch(exception const &e)
    {
        cerr << e.what() << endl;
        return 1;
    }
 
    driver->activeCulling(true);
 
    while(!driver->quit())
    {
        glm::mat4 mat[2];
        glm::mat4 proj = perspective(70.0f, 16.0f/9.0f, 1.0f, 1000.0f);
        proj *= lookAt(vec3(0., 100.,0.1), vec3(0., 0., 0.), vec3(0., 1., 0.));
        mat[1] = proj;
        shader_Model1.use(true);
        shader_Model1.sendConstPtr("matrix", 2, mat);
        shader_Model1.sendConst("lightAmbientColor", vec3(1, 1, 1));
        spider->model->draw(shader_Model1);
 
        driver->run();
    }
 
    (void)argc, (void)argv;
 
    return 0;
}

Voilà maintenant mon code qui affiche la texture (qui est blanche donc)

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
#include "include.h"
 
#include "device.h"
#include "matrix.h"
#include "model.h"
#include "camera.h"
#include "sceneManager.h"
#include "fbo.h"
 
Shader shader_Model1;
Shader shadow;
Shader tex;
 
ShadowMap sm;
 
int main ( int argc, char** argv )
{
    SceneManager scene(new Device(800, 600, false, 0));
    Device *driver = scene.getDriver();
 
    ModelNode *spider;
 
    try{
        spider = scene.addModel("models/OBJ/spider.obj");
        shader_Model1.load("Shaders/Model.vert", "Shaders/Model.frag");
        shadow.load("Shaders/DepthRender.vert", "Shaders/DepthRender.frag");
        tex.load("Shaders/texture.vert", "Shaders/texture.frag");
 
        sm.load();
    }
    catch(exception const &e)
    {
        cerr << e.what() << endl;
        return 1;
    }
 
    driver->activeCulling(true);
 
    static const GLfloat g_quad[] = {
		-1.0f, -1.0f, 0.0f,
		 1.0f, -1.0f, 0.0f,
		-1.0f,  1.0f, 0.0f,
		-1.0f,  1.0f, 0.0f,
		 1.0f, -1.0f, 0.0f,
		 1.0f,  1.0f, 0.0f,
	};
 
    while(!driver->quit())
    {
        sm.write();
        glViewport(0, 0, 1024, 1024);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
        shadow.use(true);
 
		glm::mat4 depthProjectionMatrix = glm::perspective(70.0f, 1.0f, 1.0f, 1000.0f);
		glm::mat4 depthViewMatrix = glm::lookAt(vec3(0., 100.,0.1), glm::vec3(0.,0.,0.), glm::vec3(0.,1.,0.));
		glm::mat4 depthMVP = depthProjectionMatrix * depthViewMatrix;
		shadow.sendConst("matrix", depthMVP);
 
        spider->model->drawWithShadow(shadow);
 
        VBO::noUseVbo();
        VBO::noUseIbo();
        glBindFramebuffer(GL_FRAMEBUFFER, 0);
        glViewport(0, 0, 800, 600);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
        tex.use(true);
        sm.read(0);
 
        tex.sendVar("vertexPosition_modelspace", 3, 0, g_quad);
        tex.sendConst("texture", 0);
        glDrawArrays(GL_TRIANGLES, 0, 6);
 
        driver->run();
    }
 
    (void)argc, (void)argv;
 
    return 0;
}

Et voilà l'image de la shadowMap presque blanche


En gros voilà, je me demandais si il était normal que la texture soit si blanche que ça, ou si j'avais justement un problème... Car en utilisant glm::ortho j'obtient un résultat plus foncé, mais je ne suis pas encore parvenu à le régler comme il faut... Donc si pouvez m'aiguillé ^^.

Merci à vous. (Mon code est un presque copié coller de OpenGL_Tutorial), donc le shader de la depthmap ne fait en gros que : gl_FragDepth = gl_FragCoord.z.

Merci

EDIT : J'ai résolu mon problème : Utilisé la projection : glm::mat4 depthProjectionMatrix = glm::perspective(70.0f, 1.f, 1.f, -1.f);
fonctionne très bien .

[LittleWhite]

Bonjour,

Généralement, les depth map sont très blanches pour la raison qu'elle n'est pas linéaire. Du coup, il faut essayer de calculer une matrice de projection qui permette de voir l'objet en entier, tout en ayant un far plane le plus proche possible sur near plane.

[qnop]

Salut. Ben justement, en mettant un far a -1 et un near a 1, ça a l'air d'être pas trop mal ^^.