Comment calculer la position et la normale dans le vertex shader avec OpenGL (GLSL) et Direct3D (HLSL) - première partie

La première étape à effectuer dans un vertex shader est le calcul de la position et si besoin de la normale. Cet article vous explique en détail ce calcul.

3 commentaires Donner une note à l'article (5)

Article lu   fois.

Les deux auteur et traducteur

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

I. Explications

Cet article est valide pour toutes les versions d'OpenGL (2, 3 et 4) ainsi que toutes les versions de Direct3D (9, 10 et 11). Je donne les exemples de code en OpenGL 2 et en Direct3D 9. Les codes sont compatibles avec OpenGL 3/4 et Direct3D 10/11 et peuvent être facilement déduits des versions OpenGL 2/D3D9.

Pour calculer la position transformée(1) (gl_Position en GLSL, dans l'espace de clipping), vous avez besoin de trois matrices : projection, view (vue) et model (modèle). Les matrices de projection et de vue sont les matrices correspondant à la caméra et la matrice de modèle est la matrice de transformation de l'objet actuellement affiché.

Les trois matrices sont passées par l'application hôte au vertex shader comme variables d'entrée (déclarées uniform en GLSL).

Dans le code des vertex shaders suivants, P est la position XYZ du vertex dans l'espace local (espace du point de vue de l'objet), c'est-à-dire la position sans aucune transformation. Il en est de même pour N, la normale du vertex dans l'espace local, sans aucune transformation.

II. Shader OpenGL (GLSL)

 
Sélectionnez
uniform mat4 projectionMatrix;
uniform mat4 viewMatrix;
uniform mat4 modelMatrix;

varying vec3 normal;

void main()
{
    vec3 P = gl_Vertex.xyz;
    vec3 N = gl_Normal.xyz;

    mat4 modelView = viewMatrix * modelMatrix;
    mat4 modelViewProjection = projectionMatrix * modelView;
    gl_Position = modelViewProjection * vec4(P, 1.0);

    normal = modelView * vec4(N, 0.0);
}

III. Shader Direct3D (HLSL)

 
Sélectionnez
float4x4 projectionMatrix;
float4x4 viewMatrix;
float4x4 modelMatrix;

struct VS_OUTPUT
{
    float4 Position : POSITION;
    float3 Normal : TEXCOORD0;
};

VS_OUTPUT VertexShaderD3D(float4 P : POSITION, float3 N : NORMAL)
{
    VS_OUTPUT o;
    float4x4 modelView = mul(modelMatrix, viewMatrix);
    float4x4 modelViewProjection = mul(modelView, projectionMatrix);
    o.Position = mul(float4(P.xyz, 1.0), modelViewProjection);
    o.Normal = mul(N, (float3x3)modelView);
    return o;
}

IV. Conclusion

La convention pour les matrices dans OpenGL est column-major alors que les matrices Direct3D sont row-major. Cela explique pourquoi les multiplications de matrices ne sont pas effectuées dans le même ordre entre OpenGL et Direct3D.

Si vous souhaitez jouer avec le shader GLSL (programmation en live), vous pouvez le trouver dans le pack de code de GeeXlab dans le dossier GLSL_ComputePosNorm/ de l'archive. La dernière version de GeeXlab est disponible sur le site de Geeks3D.

Image non disponible

Lancez GeeXLab et glissez/déposez le fichier de démonstration (GLSL_Compute_PosNorm.xml) dans le logiciel et c'est tout.

V. Remerciements

Cet article est une traduction autorisée de l'article paru sur Geeks3D.com.

Je tiens à remercier Winjerome et dourouc05 pour leur relecture lors de la traduction de cet article, ainsi que ClaudeLELOUP et _Max_ pour leur relecture orthographique.


Note de traduction : si vous avez besoin d'un rappel sur ces notions, vous pouvez lire la page suivante : http://msdn.developpez.com/direct3d/10/tutoriels/base/?page=page_1_4.

  

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2013 Geeks3D. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.