Le dessin de primitives avec Managed DirectX en C#

Date de publication : 07/08/2006 , Date de mise à jour : 07/08/2006

Par funky.data (Tutoriaux C# - DirectX9) (NXEngine - Mon moteur 3D)

Ce tutoriel vous apprendra à afficher des primitives avec Managed Direct X en C#.

I. Introduction
II. Les Triangles
II-1. Les Vertices
II-2. Initialisation des Vertices
III. Les Vertex Buffers
III-1. Initialisation
III-2. Remplir le VertexBuffer avec des Vertices
III-3. Le Rendu
IV. Récapitulatif

I. Introduction

Un objet affiché par DirectX aussi complexe soit-il est toujours composé de triangles. Le triangle sera donc la forme géométrique à la base de tout rendu de scène 3D. Nous allons voir dans ce tutoriel comment générer un triangle puis comment l'afficher.

II. Les Triangles

Comme nous venons de l'apprendre le triangle est la forme géométrique de base utilisée par DirectX et les cartes graphiques 3D. Chaque sommet d'un triangle est appelé "Vertex" (Vertices au pluriel) dans le jargon de la programmation 3D, et donc "Sommet" pour sa version française. J'utiliserais les terme Anglais dans ce tutoriel dans la mesure ou c'est la dénomination utilisée par DirectX. Nous allons donc commencer par nous penchez sur l'initialisation de ces vertices.

II-1. Les Vertices

Il existe beaucoup de type de vertices mais je vais essayer d'être le plus concis possible pour vous les présenter. Tout d'abord vous avez 2 grands types :

Les vertices de type "Transformed"
Les vertices de type "Position"

Les vertices de type "Transformed" sont des vertices dont la position est définie par leur coordonnées à l'écran. Par exemple si nous déclarons un vertice "Transformed" à la position x:100 y:100 z:1 le vertice sera effectivement placer à cette position dans la fenêtre de rendu. Remarquez que la valeur attribuée à la composante z n'a que peut d'intérêt pour l'instant... Sachez quand même que lors de l'utilisation de ce type de vertice une valeur 0 correspond à un vertice sur le devant de la scène et une valeur de 1 à un vertice tout au fond de la scène. Quand nous initialiserons donc un vertice "Transformed" nous indiquerons par la même ses coordonnées à l'écran.

Les vertices de type "Position" sont des vertices dont la position est définie par leurs coordonnées dans la scène 3D. Si nous reprenons notre exemple de tout à l'heure, le vertice "Position" ne sera certainement pas placé aux coordonnées écran x:100 y:100 dans la mesure ou sa position variera avec le point de vue que nous aurons dans la scène. Pour faire simple si nous avions une caméra, le vertice "Position" bougerait à l'écran lors des mouvements de caméra au contraire du vertice "Transformed".

Nous utiliserons donc dans cette première partie du tutoriel des vertices "Transformed". Voyons maintenant les autres options offertes par les différents type de vertices. Pour les vertices, autant les "Transformed" que les "Position", il est possible d'appliquer un certains nombres de paramètres de rendu. Voyons ces possibilités :

"Transformed" et "PositionOnly" : Rien de particulier le vertice indique seulement une position
"TransformedColored" et "PositionColored" : On ajoute à la position une information de couleur
"TransformedTextured" et "PositionTextured" : On ajoute à la position une information de texture
"TransformedColoredTextured" et "PositionColoredTextured" : On ajoute à la position une information de couleur et de texture

Voilà pour cette brève présentation des vertices... passons maintenant à leur initialisation

II-2. Initialisation des Vertices

Comme dit précédemment, nous allons utiliser des vertices de type "Transformed" auquel nous voulons ajouter une information de couleur. Nous utiliserons donc des vertices de type "TransformedColored" pour créer les 3 points qui composeront notre triangle. Voyons tout d'abord la syntaxe du constructeur qui va nous intéresser :

Constructeur d'un vertice 'TransformedColored'

public TransformedColored(
    float xvalue,
    float yvalue,
    float zvalue,
    float rhwvalue,
    int c
);

Paramètre	Description
xvalue	La position sur l'axe x de l'écran
yvalue	La position sur l'axe y de l'écran
zvalue	La position sur l'axe z de l'écran (on mettra 0.5 par défaut pour ce genre de vertices pour l'instant)
rhwvalue	La valeur du "reciprocal homogeneous w". C'est une valeur qui va permettre à DirectX de projeter le vertex (sommet) à l'écran. Si la valeur de ce paramètre est différente de 1 alors nous aurons une projection éronnée. Dans presque tous les cas (en tout cas pour un affichage simple comme nous le réalisons ici) nous initialiserons ce paramètre à 1.
c	La valeur de la couleur attachée au vertice

Maintenant que nous avons vu le constructeur créons nos 3 vertices :

Déclaration des vertices de notre triangle

// On commence par déclaré un tableau pour nos vertices
private CustomVertex.TransformedColored[] Vertices;

// On initialise nos vertices
Vertices = new CustomVertex.TransformedColored[3];
Vertices[0] = new CustomVertex.TransformedColored(200.0f, 125.0f, 0.5f, 1f, Color.Beige.ToArgb());
Vertices[1] = new CustomVertex.TransformedColored(275.0f, 275.0f, 0.5f, 1f, Color.Orange.ToArgb());
Vertices[2] = new CustomVertex.TransformedColored(125.0f, 275.0f, 0.5f, 1f, Color.Red.ToArgb());

Nos vertices étant déclarés il ne nous reste plus qu'à les afficher... c'est ce que nous allons voir dans le chapitre suivant...

III. Les Vertex Buffers

III-1. Initialisation

Les Vertex Buffers (Tampon de sommets en français ;)) sont des objets qui vont nous permettre de lier les informations contenues dans nos vertices vers la fonction de rendu de primitive du device Direct3D. Commençons comme d'habitude par regarder le constructeur d'un vertex buffer.

Le constructeur de l'objet VertexBuffer

public VertexBuffer(
    Type typeVertexType,
    int numVerts,
    Device device,
    Usage usage,
    VertexFormats vertexFormat,
    Pool pool
);

Paramètres	Description
typeVertexType	Le type de vertex que nous voulons stocker
numVerts	Le nombre de vertex que nous voulons stocker
device	Un device direct3D
Usage	Combinaison de valeur indiquant pour quel usage spécial nous utiliserons ce vertex buffer
vertexFormat	Le format des vertex que le vertex buffer va stocker
Pool	Le mode de management de mémoire que Direct 3D doit utiliser pour ce vertex buffer

Passons maintenant à la création de notre VertexBuffer

Création du Vertex Buffer

// On commence par le déclarer
private VertexBuffer vBuffer;

// On appelle le constructeur
vBuffer = new VertexBuffer(typeof(CustomVertex.TransformedColored), Vertices.Length,
    device, 0, CustomVertex.TransformedColored.Format, Pool.Default);

Voilà notre Vertex Buffer est maintenant prêt à accueillir des données de nos vertices (ou vertex).

III-2. Remplir le VertexBuffer avec des Vertices

Il nous reste maintenant à stocker les vertices de notre triangle dans le vertex buffer que nous venons de créer. La fonction "SetData" du vertex buffer permet de lui indiquer l'endroit où sont stockées les vertices. Voyons la syntaxe de cette fonction :

La fonction SetData de la classe 'VertexBuffer'

public void SetData(
    object data,
    int lockAtOffset,
    LockFlags flags
);

Paramètres	Description
data	Représente la structure contenant les informations de nos vertices
lockAtOffset	Indique l'offset dans la structure des vertices qui doit être verrouillé. Pour l'instant ce paramètre n'est pas très important. En effet, nous n'utiliserons un unique verrouillage de notre vertex buffer. En effet nous sommes obligé de verrouiller un VertexBuffer dés que nous voulons lui faire stocker des vertices ou dés que nous voulons mettre à jour leur géométrie (coordonnées par exemple). Dans ce tutoriel, nous ne déplacerons pas les sommets de notre triangle donc nous n'aurons besoin de verrouiller le VertexBuffer qu'une seule fois, en l'occurrence, lors de son remplissage avec nos vertices. Dans ce cas nous utiliserons l'offset 0. A noter pour plus tard que verrouiller les VertexBuffers font chuter drastiquement les performances. En effet un verrouillage oblige un transfert GPU->CPU puis CPU->GPU ce qui prend un certain temps... mais nous verrons ça plus tard.
flags	Indique le type de verrouillage à réaliser sur le vertex buffer. Pour l'instant nous utiliserons le flag "None" dans la mesure ou ne nous voulons justement pas verrouiller le vertexbuffer

Et maintenant le code :

Remplissage du VertexBuffer avec nos Vertices

// Déclaration du VertexBuffer
private VertexBuffer vBuffer;

// Remplissage du VertexBuffer avec nos Vertices
vBuffer.SetData(Vertices, 0, LockFlags.None);

Nous avons donc terminer avec l'initialisation des composants dont nous avions besoin pour afficher notre triangle... passons maintenant au rendu de ce triangle.

III-3. Le Rendu

Le rendu va se décomposer en 3 étapes :

Les 3 étapes du rendu d'un Vertex Buffer

Indiquer au device Direct3D le VertexBuffer à lire
Indiquer au device Direct3D le type des vertices stockées dans ce VertexBuffer
Lancer la fonction de rendu

Pour indiquer le VertexBuffer à lire au device Direct3D, nous utiliserons la fonction "SetStreamSource" du device.

La fonction SetStreamSource du device Direct3D

public void SetStreamSource(
    int streamNumber,
    VertexBuffer streamData,
    int offsetInBytes
);

Paramètres	Description
streamNumber	Indique l'index du VertexBuffer à lire
streamData	Indique l'objet VertexBuffer que nous allons lire
offsetInBytes	Indique à quel offset dans le VertexBuffer le device Direct3D doit commencer à lire

En maintenant le code :

device.SetStreamSource(0, vBuffer, 0);

Seconde étape indiquer au device Direct3D le type de Vertex que nous avons stocké dans le VertexBuffer. Pour cela rien de plus simple :

device.VertexFormat = CustomVertex.TransformedColored.Format;

Dernière étape... le rendu. Comme je vous l'ai préciser au début du tutoriel, DirectX ne se base que sur des triangles pour effectuer le rendu d'une scène. Donc une scène est une multitude de triangles. Pour dessiner un triangle il faut donc définir de quelle façon nous allons lier les vertices les unes aux autres... ces liaisons composeront l'objet final. Il existe beaucoup de type de liaison possible avec Direct3D mais je ne vais que vous en présenter 3. Ce sont les trois que vous utiliserez dans 99% des cas : le "TriangleList", le "TriangleStrip" et le "TriangleFan". Comme un bon dessin vaut mieux qu'un beau discours je vous propose ces trois illustrations pour que vous compreniez la différence de logique de liaison entre ces types :

Vous remarquerez sans mal que le "TriangleList" est sans contexte celui qui sera le plus adapté à notre rendu de triangle.

Pour dessiner notre triangle nous ferons appel à la fonction "DrawPrimitives" du device Direct3D.

La fonction de rendu de primitives du device Direct3D

public void DrawPrimitives(
    PrimitiveType primitiveType,
    int startVertex,
    int primitiveCount
);

Paramètres	Description
primitiveType	Le type de primitive
startVertex	Index du vertex de départ
primitiveCount	Nombre de primitives

La seule précision que j'apporterais concerne le nombre de primitives. Dans notre exemple ce sera le nombre de vertices stockées dans notre VertexBuffer divisé par 3. Si nous avions stocké par exemple des lignes dans notre VertexBuffer nous diviserions le nombre de vertices par 2... Voyons maintenant le code :

device.DrawPrimitives(PrimitiveType.TriangleList, 0, Vertices.Length / 3);

IV. Récapitulatif

Nous avons donc appris jusqu'à présent à :

Initialiser des vertices (ou vertex)
Initialiser un VertexBuffer
Remplir un VertexBuffer
Afficher les données d'un VertexBuffer à l'écran

Voyons le récapitulatif du code source :

Afficher un triangle colorié à l'écran

public partial class Form1 : Form
{
	// Notre device
	private Device device = null;
	// Notre VertexBuffer
	private VertexBuffer vBuffer;
	// Nos Vertices
	private CustomVertex.TransformedColored[] Vertices;
	
	// Initialisation de la form
	public Form1()
	{
	    InitializeComponent();
	    // Appel de la procédure d'initialisation du device Direct3D
	    InitializeGraphics();
	    CreateTriangle();
	    // Evènement pour la boucle de rendu
	    this.Paint += new PaintEventHandler(this.Render);
	}
	
	// Procédure d'initialisation du device Direct3D
	private void InitializeGraphics()
	{
	    // Définition des PresentParameters
	    PresentParameters presentParams = new PresentParameters();
	    presentParams.Windowed = true;
	    presentParams.SwapEffect = SwapEffect.Discard;
	
	    // Creation de notre device
	    device = new Device(0, DeviceType.Hardware, this, CreateFlags.SoftwareVertexProcessing, presentParams);
	}
	
	// Procédure de création de notre triangle
	private void CreateTriangle()
	{
	    // On défini les vertices de notre triangle
	    Vertices = new CustomVertex.TransformedColored[3];
	    Vertices[0] = new CustomVertex.TransformedColored(200.0f, 125.0f, 0.5f, 1f, Color.Beige.ToArgb());
	    Vertices[1] = new CustomVertex.TransformedColored(275.0f, 275.0f, 0.5f, 1f, Color.Orange.ToArgb());
	    Vertices[2] = new CustomVertex.TransformedColored(125.0f, 275.0f, 0.5f, 1f, Color.Red.ToArgb());
	
	    // On crée le vertex buffer
	    vBuffer = new VertexBuffer(typeof(CustomVertex.TransformedColored), Vertices.Length,
	       device, 0, CustomVertex.TransformedColored.Format, Pool.Default);
	
	    // On stocke les vertices dans le vertex buffer
	    vBuffer.SetData(Vertices, 0, LockFlags.None);
	}
	
	// La boucle de rendu
	private void Render(object sender, PaintEventArgs e)
	{
	    // Effacement de la scène
	    device.Clear(ClearFlags.Target, 0, 1.0f, 0);
	    // Début de la scène
	    device.BeginScene();
	    // On défini le vertex buffer à lire
	    device.SetStreamSource(0, vBuffer, 0);
	    // On défini le type des vertices stockées dans notre vertex buffer
	    device.VertexFormat = CustomVertex.TransformedColored.Format;
	    // On dessine le vertex buffer
	    device.DrawPrimitives(PrimitiveType.TriangleList, 0, Vertices.Length / 3);
	
	    // Fin de la scène
	    device.EndScene();
	    // Présentation de la scène à l'écran
	    device.Present();
	}
}

Et un petit screenshot de ce que vous devriez obtenir...

Screenshot de l'application réalisée à l'aide de ce tutoriel

Index - Tutoriel Précédent - Ce Tutoriel en PDF

Ce document est issu de http://www.developpez.com et reste la propriété exclusive de son auteur. La copie, modification et/ou distribution par quelque moyen que ce soit est soumise à l'obtention préalable de l'autorisation de l'auteur.