Porter un convertisseur OpenGL ES 2.0 simple vers Direct3D 11

  • Article

Cet exercice de portage permet de mettre en pratique une notion de base : porter un convertisseur simple d’OpenGL ES 2.0 sur Direct3D, afin d’adapter un cube en rotation inclus dans un nuanceur de vertex au modèle d’application DirectX 11 (Windows universelle) fourni dans Visual Studio 2015. À mesure que nous avancerons dans le processus de portage, nous découvrirons comment effectuer les différentes tâches suivantes :

  • Porter un ensemble simple de mémoires tampons de vertex vers des mémoires tampons d’entrée Direct3D
  • Porter des variables uniform et attribute vers des mémoires tampons constantes
  • Configurer des objets nuanceur Direct3D
  • Utiliser des sémantiques HLSL simples pour développer un nuanceur Direct3D
  • Porter du code GLSL très simple vers HLSL

Cette rubrique suppose que vous avez déjà créé votre projet DirectX 11. Pour savoir comment créer un projet DirectX 11, voir Créer un projet DirectX 11 pour la plateforme Windows universelle (UWP).

Si vous avez créé votre projet à partir d’un de ces liens, ce projet contient tout le code requis pour l’infrastructure Direct3D. Vous pouvez donc commencer immédiatement le processus de portage de votre convertisseur d’Open GL ES 2.0 sur Direct3D 11.

Cette rubrique examine deux chemins de code qui effectuent la même tâche graphique de base : afficher un cube en forme de vertex qui tourne dans une fenêtre. Dans les deux cas, le code couvre le processus suivant :

  1. Création d’un maillage du cube à partir des données codées en dur. Ce maillage est représenté par une liste de vertex, où chaque vertex est associé à une position, un vecteur normal et un vecteur de couleur. Il est ensuite stocké dans une mémoire tampon de vertex en attendant d’être traité par le pipeline de nuanceurs.
  2. Création des deux objets nuanceur requis pour le traitement du maillage du cube. Le nuanceur de vertex traitera les vertex utilisés lors de la rastérisation et le nuanceur de fragments (pixels) appliquera une couleur à chacun des pixels du cube après la rastérisation. Ces pixels seront transmis à la cible de rendu pour affichage.
  3. Écriture du code d’ombrage utilisé pour le traitement des vertex et des pixels dans les nuanceurs de vertex et de fragments, respectivement.
  4. Affichage à l’écran du cube rendu.

Cube OpenGL simple

Au terme de cette procédure pas à pas, vous aurez normalement passé en revue les principales différences entre Open GL ES 2.0 et Direct3D 11 :

  • Représentation des mémoires tampons et données de vertex
  • Processus de création et de configuration des nuanceurs
  • Codes d’ombrage, et entrées et sorties des nuanceurs
  • Comportements du dessin à l’écran

Cette procédure pas à pas utilise une structure de convertisseur OpenGL simple et générale, définie comme suit :

typedef struct 
{
    GLfloat pos[3];        
    GLfloat rgba[4];
} Vertex;

typedef struct
{
  // Integer handle to the shader program object.
  GLuint programObject;

  // The vertex and index buffers
  GLuint vertexBuffer;
  GLuint indexBuffer;

  // Handle to the location of model-view-projection matrix uniform
  GLint  mvpLoc; 
   
  // Vertex and index data
  Vertex  *vertices;
  GLuint   *vertexIndices;
  int       numIndices;

  // Rotation angle used for animation
  GLfloat   angle;

  GLfloat  mvpMatrix[4][4]; // the model-view-projection matrix itself
} Renderer;

Cette structure n’a qu’une seule instance ; elle contient tous les éléments requis pour effectuer le rendu d’un maillage très simple d’un nuanceur de vertex.

Remarque Le code OpenGL ES 2.0 employé dans cette rubrique est basé sur l’implémentation de l’API Windows fournie par Khronos Group. Par ailleurs, il utilise la syntaxe de programmation Windows C.

 

Bon à savoir

Technologies

Prérequis

Étapes

Rubrique Description

Porter les objets nuanceur

Dans le cadre du portage du convertisseur simple OpenGL ES 2.0, vous devez commencer par créer les objets des nuanceurs de vertex et de fragments équivalents dans Direct3D 11, mais également vous assurer que le programme principal sera en mesure de communiquer avec ces différents objets une fois compilés.

Porter les mémoires tampons et données de vertex

Lors de cette étape, vous allez définir les mémoires tampons de vertex qui contiendront vos maillages ainsi que les mémoires tampons d’index qui permettront aux nuanceurs de parcourir les vertex dans l’ordre indiqué.

Porter le langage GLSL

Après avoir adapté le code utilisé pour créer et configurer vos mémoires tampons et vos objets nuanceurs, vous pouvez procéder au portage du code de ces nuanceurs du langage GLSL (GL Shader Language) d’OpenGL ES 2.0 vers le langage HLSL (High-level Shader Language) de Direct3D 11.

Dessiner vers l’écran

Pour finir, nous portons le code qui trace le cube tournant à l’écran.

 

Ressources supplémentaires