Bonjour à tous.

J'ai décidé de revoir mon approche depuis le début et d'y allez pas à pas pour implémenter avec succèes un algo de shadow mapping. Cette fois je veux être sur de comprendre chaque étape et en pas avoir de surprise à la fin.

J'ai décidé de repartir sur des bases plus "saines", à base de FBO et de Shader.
Pour le moment, je suis en train de paramétrer ma première phase : la création de ma depth-map. ma phase d'initialisation est a peu près bonne :

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
 
	m_WindowWidth = Application::Instance().m_Settings.m_ScreenWidth ;
	m_WindowHeight = Application::Instance().m_Settings.m_ScreenHeight ;
 
	//Check for necessary extensions
	if ( !glewIsSupported("GL_ARB_depth_texture"))
		std::cout << "ARB texture *not* supported" << std::endl ;
 
	if ( !glewIsSupported("GL_ARB_shadow"))
		std::cout << "Shadow *not* supported" << std::endl ;
 
	if ( !glewIsSupported("GL_EXT_framebuffer_object"))
		std::cout << "FBO *not* supported" << std::endl ;
 
	// Creation  of a depth-texture
	glActiveTexture(GL_TEXTURE1);
	glEnable(GL_TEXTURE_2D);
	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
	glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB, GL_PREVIOUS);
	glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB, GL_TEXTURE);
 
	glGenTextures(1, &m_ShadowMapTexture);
	glBindTexture(GL_TEXTURE_2D, m_ShadowMapTexture);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, m_ShadowMapSize, m_ShadowMapSize, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL);
 
	// Creation of a fbo to get the depth
	glGenFramebuffersEXT(1, &m_ShadowMapFBO);
	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_ShadowMapFBO);
	glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, m_ShadowMapTexture, 0);
	// No color buffer to draw to or read from
	glDrawBuffer(GL_NONE);
	glReadBuffer(GL_NONE);
 
	// Check framebuffer completeness at the end of initialization.
	CHECK_FBO_STATUS() ;
 
	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
	glBindTexture(GL_TEXTURE_2D, 0);
	glActiveTexture(GL_TEXTURE0);
Je suis en train de faire ma fonction, qui doit se charger de récupérer ma depth-map (celle qui met oepngl dans les bon états, juste avant un premier appel à ma fonction draw() sur les objets de ma scène ).

Je vois le déroulement comme ceci :
-je précise à opengl de ne faire le rendu que de la profondeur, et uniquement dans mon fbo qui va me stocker ça dans ma texture de profondeur.
-je me place du point de vue de la caméra

J'en suis à ce second point, et je me demande comment choisir une matrice de projection qui va bien? Je n'arrive pas à voir pourquoi on devrait prendre autre-chose que celle courante et si l'on doit, comment bien la choisir ?

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
 
	// Set up opengl to render only a depth-map
 
	// 1 - Use our special FBO
	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_ShadowMapFBO);
	glClear(GL_DEPTH_BUFFER_BIT);
 
	// 2 - Position the camera at the light PoV
	glMatrixMode(GL_PROJECTION);
	//gluPerspective?
	//glOrhto?
	glMatrixMode(GL_MODELVIEW);
	// ...
Ci-dessus le début de ma fonction .

EDIT : Quelques question que je viens de mailez à un amis et qui montre où j'en suis et ce qu'il me reste à trouvez :

1) La taille que l'on donne à notre texture de profondeur dépend de celle du viewport exclusivement c'est bien ca? Elle peut-être supérieur ou cela n'aura aucun intérêt et il faut qu'elle soit de même taille ?

2) Lors de la phase de récupération de la texture de profondeur, on doit se placer du point de vue de la lumière, pour cela il faut modifier les matrice modelview et projection mais comment.?
2-a) Pour la projection, j'ai cru comprendre qu'il fallait du gluOrtho pour une lumière omnidirectionelle (comme le soleil) mais j'ai du mal à voir les paramètres (left, right, top, bottom, near, far) qu'il faut utiliser et pourquoi? Pour un spot, je supose que l'on va utiliser du gluPerspective ; l'angle doit représenter l'angle d'ouverture du spot, mais j'ai du mla à voir quel ratio et quel "znear et zfar" lui passer en paramètre ... j'ai lu sur le web un ratio de 1 et un znear et zfar faible et proche (2 et 8) mais je ne comprend pas la logique derrière cela.
2 -b) Pour la modelview, si j'ai un spot , il me faut un gluLookAt avec la position de la lumière, la direction dans laqeulle elle est orientée et enfin le vecteur normal à son orientation, non? Pour une lumière omnidirectionel, a part la position de la lumière, je ne sais pas trop quoi mettre comme 2 et 3eme paramètres.
EDIT2 : J'ai réflécit et suis arrivé à la conclusion que dans le cas d'un spot et de la matrice de projection, le znear et zfar doivent correspondre à la portée de la lumière, non? SI c'est ça, j'en déduis qu'en glOrtho le near et far sont pareil Ca avance ...( enfin j'espère ^^)

EDIT3: (oui je raconte ma vie ) Mon cerveau se réveil et me rappel que le 3ème paramètres du glulookAt n'est pas le vectur normal à la direction mais le vecteur "up" de l'origine, donc du (0,1,0) en général