Discussion :

[Yeri]

Bonjour,

Comme beaucoup de monde j'ai énormément apprécié les tutoriaux de loulou su la conception d'un moteur 3D : http://loulou.developpez.com/tutoriels/moteur3d

Par contre, il a quelques points que j'ai du mal à comprendre; il me semble qu'entre OpenGL et Direct3D les matrices ne sont pas stockées de la même façon d'une part et que opengl utilise un sytème de coordonnées droit alors que celui de d3d est gauche d'autre part.

Par contre dans le moteur de loulou je n'ai rien vu qui fait cette distinction mais pourtant tout fonctionne correctement, j'aimerais bien qu'on m'explique comment cela est possible d'autant qu'il me semble que dans d'autre moteur 3d il ya une distinction.

merci

[Laurent Gomila]

il me semble qu'entre OpenGL et Direct3D les matrices ne sont pas stockées de la même façon

Juste dans la documentation. Niveau coding, ça ne change strictement rien.

opengl utilise un sytème de coordonnées droit alors que celui de d3d est gauche d'autre part

Il semblerait que non

La seule différence que j'ai notée au niveau des coordonnées, c'est l'inversion des Y en espace écran.

[Yeri]

Merci pour cette réponse rapide ,
mais je ne suis pas sûr que celle-ci me convenient parfaitement.

J'ai regardé plus précisement le code de Ogre et dans la définition d'une Matrix4 j'ai trouvé cela:

Code :

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

1
2
3
4
5
6
 
The use of column vectors and right-to-left ordering is the
standard in most mathematical texts, and id the same as used in
OpenGL. It is, however, the opposite of Direct3D, which has
inexplicably chosen to differ from the accepted standard and uses
row vectors and left-to-right matrix multiplication.

Un autre point que j'ai du mal à comprendre c la façon de calculer la matrice de projection:
dans ton code tu utilises cela :

Code :

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

1
2
3
4
5
6
7
8
9
 
    float YScale = 1.0f / std::tan(Fov / 2);
    float XScale = YScale / Ratio;
    float Coeff  = Far / (Far - Near);
 
    a11 = XScale; a12 = 0.0f;   a13 = 0.0f;  a14 = 0.0f;
    a21 = 0.0f;   a22 = YScale; a23 = 0.0f;  a24 = 0.0f;
    a31 = 0.0f;   a32 = 0.0f;   a33 = Coeff; a34 = Near * -Coeff;
    a41 = 0.0f;   a42 = 0.0f;   a43 = 1.0f;  a44 = 0.0f;

alors que les formules que j'ai trouvé font cela:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
        Real h = std::cos(Fov/2) / std::sin(Fov/2);
        Real w = h / Ratio;
        Real zn  = Near;
	Real zf  = Far;
 
        a11 = 2*zn/w; a12 = 0.0f;    a13 = 0.0f;	  a14 = 0.0f;
        a21 = 0.0f;     a22 = 2*zn/h; a23 = 0.0f;	  a24 = 0.0f;
        a31 = 0.0f;     a32 = 0.0f;     a33 = zf/(zf-zn); a34 = zn*zf/(zn-zf);
        a41 = 0.0f;     a42 = 0.0f;     a43 =1.0f;          a44 = 0.0f;

J'aimerais bien savoir quelle est la différence entre les deux ?

voilà c tout pour le moment

[Laurent Gomila]

J'ai regardé plus précisement le code de Ogre et dans la définition d'une Matrix4 j'ai trouvé cela:

Pour tout te dire, cette histoire de représentation des matrices a toujours été un grand mystère. La plupart des gens ont ce genre de discours, mais le fait est que dans aucun des moteurs 3D multi-API sur lesquels j'ai travaillé, ça n'a posé le moindre problème. Tu peux d'ailleurs constater que tout fonctionne très bien sans avoir la moindre transposition de matrice pour l'une ou l'autre API.

Un autre point que j'ai du mal à comprendre c la façon de calculer la matrice de projection:
[...]
J'aimerais bien savoir quelle est la différence entre les deux ?

Aucune, si tu décortiques tu te rendras compte que ce sont les mêmes.

[Yeri]

Merci pour ces précisions, c vrai que cette histoire n'est pas très claire, j'avais quelques doutes lorsque j'ai regardé les sources de Ogre mais puisque cela fonctionne très bien comme ça je ne vais pas chercher plus loin.

Aucune, si tu décortiques tu te rendras compte que ce sont les mêmes.

Oups désolé j'aurais du regardé plus attentivement

Il me reste une dernière question; j'essaye actuellement de rajouter la gestion des lumières (sans les shaders), pour cela j'ai créer les fonctions adéquates dans les 2 renderers D3D et OGL, par contre je n'ai pas le même comportement dans les 2 APIs.

J'ai par exemple une scene contenant un cube, et je place une lumiere entre la caméra et le cube; sous d3d aucun problème, par contre avec OGL la lumière se place derrière le cube (il faut que j'inverse la coordonée Z sous OGL).

Y a t'il une différence de comportement entre les lumières ogl et d3d au niveau de la position ?

[Laurent Gomila]

Y a t'il une différence de comportement entre les lumières ogl et d3d au niveau de la position ?

A priori non, ce serait bien étonnant.

[Yeri]

J'ai implanté la fonction suivante dans les renderers du 4ième tutorial:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
void COGLRenderer::EnableLight(TVector3F Direction)
{
	glEnable(GL_LIGHTING);
 
	float lightPos[] = {Direction.x, Direction.y, Direction.z, 1.0};
	GLfloat diffuseLight[] = { 1.0f, 1.0f, 1.0f, 1.0f };	
 
	glEnable(GL_LIGHT0);
	glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuseLight);
	glLightfv(GL_LIGHT0, GL_POSITION, lightPos);	
}

et

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
 
void CDX9Renderer::EnableLight(TVector3F Direction)
{
	m_Device->SetRenderState(D3DRS_LIGHTING, true);
 
	D3DLIGHT9 light_0;
	ZeroMemory( &light_0, sizeof(D3DLIGHT9) );
	light_0.Type = D3DLIGHT_DIRECTIONAL;
 
	D3DXVECTOR3 vecDir(Direction.x, Direction.y, Direction.z);
	D3DXVec3Normalize( (D3DXVECTOR3*)&light_0.Direction, &vecDir ) ;
	light_0.Diffuse.r = 255.0f;
	light_0.Diffuse.g = 255.0f;
	light_0.Diffuse.b = 255.0f;
	m_Device->SetLight( 0, &light_0 );
 
	m_Device->LightEnable( 0, TRUE );
}

Malheureusement lorsque j'utilise ces fonctions pour éclairer une scène, cela fonctionne plutot bien mais sous opengl la direction est inversée par rapport à direct3d. Est ce que j'aurais fait une erreur quelque part ?

[Laurent Gomila]

Une lumière directionnelle doit avoir une position ayant sa composante w égale à 0 sous OpenGL, vu qu'il n'existe pas de flag qui différencie lumières point et directionnelles comme sous DirectX.

[Yeri]

Une lumière directionnelle doit avoir une position ayant sa composante w égale à 0 sous OpenGL, vu qu'il n'existe pas de flag qui différencie lumières point et directionnelles comme sous DirectX.

Désolé je le savais, mais j'ai fait tellement de test que j'ai remis la mauvaise valeur
Mais bon mon problème ne vient pas de là, c la même chose si je met w à 0.

Par contre je crois que j'ai trouvé le pourquoi; apparement sous opengl le vecteur de direction de la lumière est le vecteur (0,0,0) - le vecteur passé en paramètre pour GL_POSITION c pour cela que j'ai un vecteur direction inversé par rapport à direct3d.

[Laurent Gomila]

Par contre je crois que j'ai trouvé le pourquoi; apparement sous opengl le vecteur de direction de la lumière est le vecteur (0,0,0) - le vecteur passé en paramètre pour GL_POSITION c pour cela que j'ai un vecteur direction inversé par rapport à direct3d.

Oui, vu que tu spécifies une position, la direction sera forcément l'inverse

[Yeri]

Merci pour toutes ces réponses !