Partager via

Porter un convertisseur OpenGL ES 2.0 simple vers Direct3D 11

  • Article

Pour cet exercice de portage, nous allons commencer par les principes de base : apporter un renderer simple pour un cube en forme de vertex de OpenGL ES 2.0 dans Direct3D, afin qu’il corresponde au modèle d’application DirectX 11 (Windows universel) à partir de Visual Studio 2015. À mesure que nous passons à travers ce processus de port, vous allez découvrir les éléments suivants :

  • Comment porter un ensemble simple de mémoires tampons de vertex vers des mémoires tampons d’entrée Direct3D
  • Comment porter des uniformes et des attributs vers des mémoires tampons constantes
  • Comment configurer des objets de nuanceur Direct3D
  • Utilisation de la sémantique HLSL de base dans le développement du nuanceur Direct3D
  • Comment porter un GLSL très simple vers HLSL

Cette rubrique commence après avoir créé un projet DirectX 11. Pour savoir comment créer un projet DirectX 11, lisez Créer un projet DirectX 11 pour plateforme Windows universelle (UWP).

Le projet créé à partir de l’un de ces liens contient tout le code de l’infrastructure Direct3D préparée et vous pouvez commencer immédiatement dans le processus de portage de votre renderer à partir d’Open GL ES 2.0 vers Direct3D 11.

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

  1. Création d’un maillage de cube à partir de données codées en dur. Ce maillage est représenté sous la forme d’une liste de sommets, chaque sommet possédant une position, un vecteur normal et un vecteur de couleur. Ce maillage est placé dans une mémoire tampon de vertex pour que le pipeline d’ombrage soit traité.
  2. Création d’objets nuanceur pour traiter le maillage de cube. Il existe deux nuanceurs : un nuanceur de vertex qui traite les sommets pour la rastérisation, et un nuanceur de fragments (pixels) qui colore les pixels individuels du cube après la rastérisation. Ces pixels sont écrits dans une cible de rendu pour l’affichage.
  3. Former le langage d’ombrage utilisé pour le traitement de vertex et de pixels dans les nuanceurs de vertex et de fragments, respectivement.
  4. Affichage du cube rendu à l’écran.

simple opengl cube

Une fois cette procédure pas à pas terminée, vous devez connaître les différences de base suivantes entre Open GL ES 2.0 et Direct3D 11 :

  • Représentation des mémoires tampons de vertex et des données de vertex.
  • Processus de création et de configuration des nuanceurs.
  • Langages de trame de fond, ainsi que les entrées et sorties des objets nuanceur.
  • Comportements de dessin d’écran.

Dans cette procédure pas à pas, nous faisons référence à une structure de renderer OpenGL simple et générique, qui est 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 a une instance et contient tous les composants nécessaires pour rendre un maillage de vertex très simple.

Notez que tout code OpenGL ES 2.0 de cette rubrique est basé sur l’implémentation de l’API Windows fournie par le groupe Khronos et utilise la syntaxe de programmation Windows C.

 

Bon à savoir

Technologies

Prérequis

Escalier

Sujet Description

Porter les objets nuanceur

Lors du portage du convertisseur simple à partir d’OpenGL ES 2.0, la première étape consiste à configurer les objets de nuanceur de vertex et de fragments équivalents dans Direct3D 11 et à s’assurer que le programme principal peut communiquer avec les objets de nuanceur après leur compilation.

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

Dans cette étape, vous allez définir les mémoires tampons de vertex qui contiennent vos maillages et les mémoires tampons d’index qui permettent aux nuanceurs de parcourir les sommets dans un ordre spécifié.

Porter le langage GLSL

Une fois que vous avez déplacé le code qui crée et configure vos tampons et objets de nuanceur, il est temps de porter le code à l’intérieur de ces nuanceurs à partir du langage GL Shader Language (GLSL) de OpenGL ES 2.0 vers le langage de nuanceur de niveau supérieur (HLSL) de Direct3D 11.

Dessiner sur l’écran

Enfin, nous portons le code qui dessine le cube épinglant à l’écran.

 

Ressources additionnelles