Archives de l’auteur : cezium

Introduction au moteur 3D Ogre3D – Afficher des modèles – partie 2

ogre3

Intro :

Voici la partie 2 du tutoriel sur l’introduction de Ogre3D.

Prérequis :

– Savoir lire du C++

– Avoir suivi la première partie de ce tutoriel.

Explications :

Avant tout quelques éléments de vocabulaire sur les objet qu’utilise Ogre3D :

SceneManager : gestionnaire qui gère l’organisation et le rendu d’une scène composée d’une collection de SceneNode. Tout ce qui est affiché à l’écran est géré par le SceneManager.

SceneNode : correspond à un objet que l’on relie au SceneManager. Possède les attributs de position, de rotation ou d’agrandissement. On peut relier plusieurs objets à une SceneNode de façon a ce que le SceneNode parent ait une position relative à son enfant.

Entity : représente un mesh (un modèle 3D composé de ses vertices et fait par un artiste) que l’on relie à une SceneNode.

1) Établissement d’une scène en affichant quelques modèles :

 

Résumé :

Références :

Introduction au moteur 3D Ogre3D – Installation – partie 1

ogre3

Intro :

Voici la partie 1 du tutoriel sur l’introduction de Ogre3D.

Ogre3D (Object-Oriented Graphics Rendering Engine) est un moteur 3D libre et multiplate-forme (compatible Linux, Win32, OS X, iOS, Android, Windows Phone 8)

Il peut utiliser les deux globales API de rendu 3D : OpenGL et DirectX 11 et 9

Prérequis :

– Savoir lire du C++

– Savoir configurer les dépendances (include / libs) dans Visual Studio C++ (voir ce lien)

– Avoir téléchargé et extrait le SDK de Ogre3D en fonction de la version de votre Visual Studio C++.

Explications :

Si vous n’avez pas le SDK (voir le lexique) il faut le télécharger sur le site de Ogre3D.

Installation de Ogre3D dans Visual Studio C++ :

Voici le répertoire du SDK une fois extrait :

sdk_rep

Il faut aller en suite dans les sous-répertoires pour voir où sont situées réellement les dépendances.

Configuration des fichiers d’en-têtes et bibliothèques :

1) Allez dans les propriétés de votre projet :

1

2) Allez dans la sous-partie « Répertoires VC++ » et ajoutez les chemins des fichiers de dépendances.

2

Il faut ne pas oublier d’ajouter les dépendances de boost.

Copiage des fichiers DLL :

Il faut copier toutes les DLLs requises depuis le repertoire bin\debug du SDK vers votre répertoire où est situé le fichier exécutable .exe (généralement : C:\Users\Yoann\Documents\Visual Studio 2010\Projects\Ogre3D – partie 1\Debug)

dll 

Configuration des fichiers d’entêtes précompilés :

Voir ce tutoriel

Copiage des fichiers .cfg :

Créez un fichier plugins_d.cfg dans le répertoire de votre exécutable :

 


Résumé :

L’installation du SDK de Ogre3D s’opère en plusieurs étapes qu’il faut suivre et respecter à la chaîne.

Références :

– http://bauland.developpez.com/tutoriel/ogre/install/

Lire un fichier ligne par ligne

file

Intro :

Parfois on a besoin de lire ligne par ligne un fichier, par exemple pour lire un fichier de modèle 3D ou un fichier de configuration.

Prerequis :

– Savoir lire du C++

Explications :

Voici le code pour obtenir le contenu d’un fichier :

Remarque : on utilise la classe ifstream (Input File) pour la lecture de fichier et ofstream (Output File stream) pour l’écriture de fichier.

Il faut noter que l’on peut lire sur le flux avec l’opérateur chevrons (>>) mot par mot. Et qu’on peut lire ligne par ligne avec la fonction std::getline().


Résumé :

Nous avons vu comment lire ligne par ligne un fichier par la fonction std::getline().

Références :

– Openclassroom.com

Introduction à DirectX 10 – Activer le super échantillonnage – partie 5

directx9c

Intro :

Dans une application graphique, les objets du rendu peuvent subir ce qu’on appelle un « crénelage » ou un « aliasing » en anglais.

Il apparaît comme un escalier autour de la ligne affichée.

La ligne du bas représente la correction de l’effet d’escalier de la ligne du haut.

crénélage

Prérequis :

– Savoir initialiser DirectX 10.1

Explications :

Cinquième partie :

Par défaut, DirectX 10.1 gère un type d’anticrénelage nommé Multisample anti-aliasing (MSAA)

1) L’anti-aliasing activé :

AA_on

1) L’anti-aliasing désactivé :

AA_off

 

Comment activer le multi-sampling dans le code ?

Lors de l’appel à D3D10CreateDeviceAndSwapChain il faut spécifier dans la structure DXGI_SWAP_CHAIN_DESC :

 

warning_small

Il reste deux étapes à ne pas oublier d’effectuer :


1) Effectuer la même configuration que précédemment, lors la création de la texture du deph-stencil
:

Il faut spécifier la même configuration que précédemment, sinon cela ne fonctionnera pas !


2) Effectuer une certaine configuration lors la création de la DepthStencilView
:

 


 

Voici une fonction qui permet d’afficher les capacités possibles de votre carte graphique en matière d’anti-aliasing.

Il faut obtenir le nombre d’échantillons m_iFSAASampleCount par ce bais :

 

Résumé :

Nous avons présenté comment procéder pour afficher dans DirectX 10 les différents niveaux d’anticrénélages possibles par la carte vidéo et comment les activer.

Références :

– Windows DirectX Graphics Documentation (SDK June 2010)

Transformation d’un système de coordonnées dans un autre

small_22

Intro :

En mathématiques, on peut convertir un vecteur ou un point d’un système de coordonnées dans un autre.

Il existe deux façon de représenter un repère (ou système de coordonnées) en mathématiques.

En l’occurrence, DirectX utilise le système de coordonnées gauche. Voir l’article sur les transformations géométriques.

Prérequis :

– Savoir manipuler les vecteurs et les matrices

Explications :

Il faut noter que la notation \(\vec{v}={(x, y, z, w)}\) décrit un vecteur lorsque que w = 0 ou décrit un point lorsque w = 1.

Lorsqu’un vecteur a ces 4 composantes, comme décrit précédemment, on dit qu’il est en  « homogeneous coordinates ».

Soit un vecteur (ou un point) \(\vec{p}_{A}={(x, y, z, w)}\) d’un repère A et un autre vecteur (ou point) \(\vec{p}_{B}={(x^{\prime}, y^{\prime}, z^{\prime}, w)} \) d’un autre repère B.

Voici un schéma qui représente deux repères relatifs entre-eux et en dimension deux.

small

On obtient le vecteur \(\vec{p_{A}} \) correspondant dans le repère B (devenant le vecteur \(\vec{p_{B}} \)) en faisant la multiplication matricielle suivante :

\(\vec{p_{A}}C = {[x, y, z, w]}\begin{bmatrix} {u_{x}} & {u_{y}} & {u_{z}} & 0 \\ {v_{x}} & {v_{y}} & {v_{z}} & 0 \\ {w_{x}} & {w_{y}} & {w_{z}} & 0 \\ {O_{x}} & {O_{y}} & {O_{z}} & 1 \end{bmatrix}={x\vec{u}} + {y\vec{v}} + {z\vec{w}} + {w\vec{O}}=\vec{p_{B}} \)

 

Les vecteurs \(\vec{O} \)   \(\vec{u} \)  \(\vec{v} \)   \(\vec{w} \) correspondent, respectivement aux positions : de l’origine, l’axe x, l’axe y, l’axe z du repère A relatifs au repère B.

Résumé :

Nous avons expliqué comment convertir un point d’un espace donné dans un autre repère en utilisant la multiplication matricielle de ce point.

Références :

– Introduction to DirectX 9.0c – A Shader Approach –  Franck D. Luna

Calculer le nombre d’images par seconde

Q3_HUD_gameplay

Intro : 

Dans les jeux ou les applications graphiques il peut être utile de savoir combien d’images par seconde sont affichées à l’écran pendant le rendu.

Prérequis :

– Savoir initialiser DirectX 10.1

Explications :

Voici le code pour calculer le temps de rafraichissement par seconde, cette méthode devra être appelée à chaque boucle de rendu.
Il est calculé aussi le temps que met, à peu près, le rendu pour afficher une image.


Résumé :

Nous avons présenté comment calculer le FPS (Images par seconde) dans une application de rendu.

Références : 

Introduction to DirectX 9.0c – A shader approach – Franck D. Luna

Les principaux objets utilisés pour initialiser DirectX 11

objects

Intro :

Il est nécessaire de manipuler une bonne dizaine d’objets ou d’interfaces pour initialiser DirectX 11 avant de commencer tout affichage 3D.

Prérequis :

– Avoir déjà lu le code pour initialiser DirectX 10 ou 11

Explications :

Les-voici énumérés ci-dessous.

 


 

Afficher du rendu 3D :

IDXGISwapChain : interface qui stocke une ou plusieurs surfaces antérieures de rendu avant d’effectuer l’affichage à l’écran.

Voici ses méthodes principales :

 

ID3D11Device : interface qui représente un afficheur vidéo. Elle est utilisée soit pour afficher du rendu 3D soit pour créer des ressources.

Voici ses méthodes principales :

 

ID3D11DeviceContext : une interface qui représente un contexte d’affichage (device context) générant des commandes de rendu.

Voici ses méthodes principales :

 

ID3D11RenderTargetView : une interface qui représente une render-target (voir lexique) qui peut être accédée lors du rendu.

Elle possède la méthode principale :

 

ID3D11Texture2D : une interface qui représente une texture constituée de données texel qui
sont stockées dans la mémoire.

Elle possède la méthode principale :

 

ID3D11DepthStencilState : une interface qui représente l’état du depth-stencil pour que celui-ci
opère des tests à l’étape output-merger.

Elle possède la méthode principale :

 

ID3D11DepthStencilView : une interface qui peut accéder à une texture paramétrée durant le test du depth-stencil.

Elle possède la méthode principale :

 

Cette structure nommée D3D11_DEPTH_STENCIL_VIEW_DESC est décrite ci-dessous :

 

ID3D11RasterizerState : une interface qui permet de configurer l’état du Rasterzizer pour l’étape de rendu Rasterzizer.

Elle possède la méthode principale GetDesc(D3D11_RASTERIZER_DESC *pDesc).
Cette structure nommée D3D11_RASTERIZER_DESC est décrite ci-dessous :

 

Objets de description de données :

Une structure nommée DXGI_SWAP_CHAIN_DESC est décrite ci-dessous :

 

Une structure nommée D3D11_TEXTURE2D_DESC est décrite ci-dessous :

 

Une structure nommée D3D11_VIEWPORT est décrite ci-dessous :

 

Résumé :

L’initialisation de DirectX 11 est assez délicate à mettre en œuvre car elle nécessite la manipulation de nombreux d’objets et interfaces associés.

Références :

– Documentation – DirectX SDK – June 2010

Une simple grille en 3D

grid

Intro :

Savoir créer une grille en 3D peut être utile pour :

– un éditeur de map

– générer un terrain à partir d’une height map

– représenter la surface d’une eau en mouvement

– etc…

Prérequis :

– Savoir initialiser DirectX 10.1

Explications :

Le fichier Grid.h :

 

Le fichier Grid.cpp :

 

Résumé :

Nous avons expliqué comment générer une grille en 3D avec le paramétrage de sa longueur et de sa largeur puis la dimensions de ses faces.

Voici les fichiers sources : Simple Grille.zip

Références :

– Introduction to DirectX 9.0c – Frank D. Luna

La tessellation – Application (DirectX 11)

tessellation

Intro :

Nous allons voir comment mettre en pratique la « tessellation » de DirectX 11.

Prérequis :

– Avoir suivi la première partie de ce tutoriel concernant la tessellation.

Explications :

Le principe est simple : on ajoute de nouvelles vertices à un modèle puis on déplace ces vertices en suivant les données correspondantes d’une « height map». Il s’agit en l’occurrence du procédé de « Displacement Mapping ».

Résumé :

Références :

Les principales étapes de rendu de DirectX 11

Intro :

Les étapes de la chaîne de rendu de DirectX 11 sont les mêmes que celles de DirectX 10.1, sauf qu’il y a été ajouté le support des nouvelles fonctionnalités de tessellation.

Prérequis :

– Connaître les étapes de la chaîne de rendu de DirectX 10.1

Explications :

Voici un schéma qui les résume :

pipeline

Seuls les étapes Hull Shader et Domain Shader sont programmables ; l’étape Tessellator est rigidement fixée par le GPU.

Étape Hull Shader :

 

Étape Tessellator Shader :

Une étape de la chaîne du rendu graphique non-programmable qui s’occupe de subdiviser un « domain » (un une face, un triangle, une ligne) en morceaux plus petits.

Étape Domain Shader :

Un programme shader qui calcule la position du vertex d’un point subdivisé par « l’output patch ».

Résumé :

Nous avons présenté les nouvelles étapes de la « pipeline » du rendu graphique de DirectX 11 concernant la tessellation.

Références :

– DirectX SDK 2010

La tessellation – Théorie (DirectX 11)

tessellation

Intro :

Le principe de la tessellation est simple : on transforme un polygone et on le décompose en morceaux plus petits.

Prérequis :

– Savoir comment fonctionne un programme HLSL

– Savoir comment utiliser DirectX 11

Explications :

Si on prend un carré et qu’on le coupe en deux le long de sa diagonale, on opère une « tessellation » en deux triangles.

Dans DirectX 11, la tessellation est opérée directement par le GPU (c’est-à-dire par le processeur de la carte graphique).

Elle peut être utilisée dans le rendu en faisant du « Displacement Mapping ». Au lieu de précharger, dans la mémoire vidéo, un modèle très détaillé : on peut augmenter ses détails par le GPU ; en effet le Displacement Mapping va de paire avec la tessellation.

Par exemple au lieu d’implémenter une grille plate très détaillée, à la place, on peut augmenter les détails d’un polygone carré par le procédé de tessellation.

En conséquence et d’autre part, il devient possible de faire varier progressivement le niveau de détail géométrique des modèles.

Les avantages :

– Réduit la mémoire et la bande passante utilisées

– Permet de complexifier des modèles basse résolution en des modèles très détaillés et ceci à la volée

– Déplace le calcul classique de modification géométrique effectué par le CPU vers un calcul effectué par le GPU

– Facilite le LOD (Level of Detail) des objets distants. En effet la tessellation permet de faire varier dynamiquement le niveau de détail d’un modèle

– On peut effectuer le calcul physique de collision ou d’animation avec un modèle non détaillé en mémoire centrale tout en affichant un modèle très détaillé au rendu

– Possibilité d’affichage de meilleurs modèles détaillés

Trois nouvelles étapes de shader :

dx11_pipeline

DirectX 11 implémente la tessellation par 3 nouvelles étapes de chaîne de rendu : l’étape Hull Shader, l’étape Tessellator et l’étape Domain.

Ces trois étapes suive l’étape Vertex Shader et précède l’étape Geometry Shader.

Avant tout, définissons quelques concepts liés à la tessellation par DirectX 11 :

– Patch :
– Control Point :
– Tessellation factor :
– Input primitive :

Lorsque ces deux étapes (Hull Shader & Domain Shader) sont définis dans un fichier shader « .fx », l’étape Vertex Shader ne renvoie pas spécialement un vertex mais renvoie ce qu’on appel un « control point » qui représente le vertex d’un triangle ou d’une face. Ce sera la dernière étape de la « Pipeline » qui se chargera de renvoyer le vertex au Pixel Shader.

Hull Shader :

Est invoqué une fois par « control point » et renvoie des « tessellator factors ». Cette étape est programmable. Cette étape de shader permet de faire savoir à l’étape suivante Tesselator comment opérer la tesselation sur les données d’entrées.

TesselatorLevel

Tessellator Stage :

Génère de nouvelles vertices. Plus les « tessellator factors » reçues sont élevés plus il y a de triangles créés. Cette étape est non-programmable.

Domain Shader :

Cette étape est programmable. Est exécutée une fois par vertex. Convertis et fait correspondre les données (u, v) vers les données d’attributs (x, y, z, w).

Exemples :

1) Un carré subissant une « tessellation »

tesselator

 2) Puis utilisation d’une « displacement map »

tesselator_2

3) Enfin utilisation d’une texture et bump mapping

Tessellation3

Résumé :

Références :

– http://www.nvidia.fr/object/tessellation_fr.html

– https://msdn.microsoft.com/en-us/library/windows/desktop/ff476340%28v=vs.85%29.aspx

– http://www.rastertek.com/dx11tut38.html

– http://richardssoftware.net/Home/Post/28

– 3D Game Programming with DirectX 11 – Franck D. Luna

Le langage shader HLSL

shader

Intro :

Le HLSL signifie : High Level Shading Language. C’est un langage (qui a la même syntaxe que le C) qui permet de programmer le processeur de la carte graphique afin d’effectuer des algorithmes de rendus spécifiques.

Prérequis :

– Savoir configurer DirectX 10

Explications :

Le HLSL permet de générer la diffusion de la lumière, la texture à utiliser, les réflexions et réfractions, l’ombrage, le déplacement de primitives et les effets post-traitement.

C’est un outil très puissant qui permet de créer une vaste gamme d’effets graphiques et esthétiques pour les jeux modernes.

Avant l’existence du langage HLSL il fallait écrire les instructions en langage d’assembleur pour la carte graphique.

Un programme HLSL (en DirectX 11) est constitué par 5 étapes de chaîne rendu :

– Le vertex shader
– Le compute shader
– Le geometry shader
– Le tessellation shader
– Le domain shader
– Le pixel shader

Les vertex et pixel shaders doivent être obligatoirement programmés ; les autres ne doivent pas être nécessairement être programmés.

Le vertex shader :

Le vertex shader opère les transformations de repère, le skinning (l’animation squelettale), le déplacement de vertex et le calcul d’attributs de vertex pour les materials.

Le pixel shader :

Le pixel shader opère le blending de texturage, le calcul lumineux, etc…

Exemple :

Voici quelques fonctions intrinsèques utilisables dans le HLSL :

abs(x) : valeur absolue
ceil(x) : retourne le plus petit entier qui est égale ou supérieur à x
clamp(x, min, max) : retourne x dans l’intervalle [min, max]
cos(x) : retourne le cosinus de x
clip(x) : ignore le pixel en cours si x est inférieur à 0
cross(x, y) : retourne le produit vectoriel de deux vecteurs 3D
dot(x, y) : retourne le produit scalaire de deux vecteurs
length(v) : retourne la longueur du vecteur v
lerp(x, y, s) : retourne x + s(y – x)
normalize(x) : retourne un vecteur normalisé
max(x, y) : retourne le plus grand entier entre x et y
min(x, y) : retourne le plus petit entier entre x et y
mul(x, y) : retourne la multiplication des matrices x et y
reflect(i, n) : retourne un vecteur de reflection en utilisant le rayon d’insidence et la normale à la surface
refract(i, n, η) : retourne un vecteur de refraction en utilisant un rayon d’entrée, la normale à la surface, et un index de refraction
saturate(x) : clamp entre les valeurs 0 et 1
sqrt(x) : retourne la racine carrée de x
transpose(x) : retourne la matrice transposée de x
tex2D(s, t) : retourne une texture samplée

 


 

Les variables globales se déclarent et se définissent ainsi :

 

Voici un petit exemple d’un programme écrit en HLSL qui créé un effet « bois » procédural en tant que texture.

Comment créer un effet shader à parti d’un fichier .fx :

 

 

Résumé :

Le langage shader HLSL est un outil très puissant pour le rendu graphique des jeux vidéo.

Tous les effets graphiques dans les jeux DirectX d’aujourd’hui sont construits à partir de fichier script shader HLSL.

Références :

– http://www.neatware.com/lbstudio/web/hlsl.html

– https://msdn.microsoft.com/fr-fr/library/ms810449.aspx

La normale (vecteur)

normale

Intro :

La normale est un vecteur perpendiculaire à un triangle ou une face quelconque.

Prérequis :

– Savoir ce qu’est un vecteur et les opérations algébriques associées.

Explications :

La normale décrit dans quelle direction une face est dirigée. La normale est un vecteur d’unité 1, puisqu’il a été normalisé. Elle est perpendiculaire à tous les points de la face.

Comment calculer la normale ?

On cherche à trouver deux vecteurs d’une face donnée en prenant le produit vectoriel de ces deux là.

Pour trouver la normale d’un triangle \(\Delta\vec{p_0}\vec{p_1}\vec{p_2} \), on calcule ces deux vecteurs d’arrêtes (côtés) du triangle.

\(\vec{u} = \vec{p_1} – \vec{p_2} \)
\(\vec{v} = \vec{p_2} – \vec{p_0} \)
\(\vec{n} = (\vec{u}\times\vec{v}) / \|\vec{u}\times\vec{v}\| \)

Voici l’algorithme en C++ :

On peut la calculer autrement :

\(n_{x} = u_{y}v_{z} – u_{z}v_{y} \)
\(n_{y} = u_{z}v_{x} – u_{x}v_{z} \)
\(n_{z} = u_{x}v_{y} – u_{y}v_{x} \)

Comment la normaliser ?

\({\vec{v}}_{norm}=\frac{{\vec{n}}}{\|{\vec{n}}\|} \)

Voici l’algorithme en C++ :

A quoi sert la normale ?

La normale est utilisée dans le calcul de la nuance de lumière d’une face en utilisant la loi de Lambert. De cette façon nous pouvons déterminer l’angle à laquelle la lumière frappe un vertex.

Elle est aussi utilisée dans le rendu du « Bump Mapping ».

Transformation de la normale par une mise à l’échelle non uniforme :

On doit faire attention aux vecteurs normales lorsqu’on fait une opération d’agrandissement (de mise à l’échelle / de scaling) autre que d’unité 1 ou non-uniforme.

[schéma / dessin]

La normale est correctement transformée avec la matrice de transformation d’agrandissement inversée et transposée.

Résumé :

Nous avons présenté le vecteur normal ; entité mathématique qui sert notamment à effectuer le calcul lumineux d’un modèle.

Références :

– https://www.opengl.org/wiki/Calculating_a_Surface_Normal

Les matrices

matrice

Intro :

Une matrice est un tableau de nombres ordonnés en lignes et en colonnes entourés par des parenthèses ou des crochets permettant d’effectuer des transformations géométriques dans un repère cartésien (un espace). Ces transformations peuvent être des agrandissements, des rotations ou des translations.

En effet, elles sont utilisées lors de l’affichage du rendu 3D à l’écran, de façon à ce que l’espace 3D du jeu soit transformée dans l’espace 2D de l’écran.

Les matrices servent à transformer un espace de départ vers un espace d’arrivé. Elles permettent de changer les coordonnées d’un point ou d’un vecteur depuis un espace à un autre.

Voir aussi cet article traitant les transformations.

Prérequis :

– Savoir faire des opérations sur les vecteurs.

– Savoir appliquer le produit scalaire.

Explications :

On peut réaliser sur les matrices des opérations proches de celles que l’on applique sur les nombres réels comme l’addition, la soustraction, la multiplication ou l’inversion.

Les nombres dans une matrice sont appelés coefficients. On représente un coefficient d’une matrice par : \(\textbf{M}_{i, j} \).
Le premier indice i correspond à la ligne et le second indice j correspond à la colonne.

Une matrice avec M lignes et N colonnes est appelée une matrice MxN.

Multiplication de deux matrices :

Il est nécessaire pour multiplier deux matrices \(\textbf{A} \) et \(\textbf{B} \) que le nombre de colonnes de \(\textbf{A} \) vaut le nombre de lignes de \(\textbf{B} \).

Si \(\textbf{A} \) est une matrice MxN et \(\textbf{B} \) une matrice NxP, alors le produit \(\textbf{AB} \) est possible et est une matrice \(\textbf{C} \) de dimension MxP.

Le coefficient \(\textbf{C}_{i, j} \) est donné en faisant le produit scalaire de la \({i}_{eme} \) ligne de \(\textbf{A} \) par la \({j}_{eme} \) colonne de \(\textbf{B} \).

Voici la formule : \(\textbf{C}_{i, j} = \textbf{A}_{i, *} \cdot \textbf{B}_{*, j} \).
Le symbole de l’étoile représente tous les coefficients de la matrice.

Rappel du produit scalaire :  \({v}\cdot{w}={v}_{x}{w}_{x}+{v}_{y}{w}_{y}+{v}_{z}{w}_{z}\)

Voici un exemple :

\(\begin{bmatrix} -1 & 2 & 2 \\ 4 & 6 & 3 \end{bmatrix} \begin{bmatrix} 6 & 7 & 8 \\ 2 & 1 & 1 \\ 1 & 4 & 8 \end{bmatrix} = \begin{bmatrix} (-1, 2, 2) \cdot (6, 2, 1) & (-1, 2, 2) \cdot (7, 1, 4) & (-1, 2, 2) \cdot (8, 1, 8) \\ (4, 6, 3) \cdot (6, 2, 1) & (4, 6, 3) \cdot (7, 1, 4) & (4, 6, 3) \cdot (8, 1, 8) \end{bmatrix} = \newline\newline\begin{bmatrix} (-1 \times 6) + (2 \times 2) + (2 \times 1) & (-1 \times 7) + (2 \times 1) + (2 \times 4) & (-1 \times 8) + (2 \times 1) + (-1 \times 8) \\ (4 \times 6) + (6 \times 2) + (3 \times 1) & (4 \times 7) + (6 \times 1) + (3 \times 4) & (4 \times 8) + (6 \times 1) + (3 \times 8) \end{bmatrix} = \newline\newline\begin{bmatrix} 0 & 3 & -14 \\ 39 & 46 & 62 \end{bmatrix} \)


Matrice carrée :

C’est une matrice ayant le même nombres de colonnes et de lignes.

Voici une matrice carrée :

\(\begin{pmatrix} 2 & 3 \\ 4 & 5 \end{pmatrix} \)

Ordre d’une matrice :

L’ordre d’une matrice est l’autre dénomination de la taille d’une matrice. Une matrice à M lignes et N colonnes est dites d’ordre MxN.

Matrice identité :

C’est une matrice carrée dont tout les coefficients en diagonale valent 1 ; tandis que les autres valent 0.

Si nous multiplions un vecteur par une matrice identité, le vecteur ne sera absolument pas changé ; de même pour une matrice.

Voici une matrice identité d’ordre 3 :

\(\begin{pmatrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \end{pmatrix} \)

Multiplication d’un vecteur par une matrice :

On procède comme la multiplication de deux matrices. Sauf que le vecteur est considéré comme une matrice 1xN.

La multiplication est possible que si le nombre de colonnes de la matrice est égal au nombre de coordonnées du vecteur. On fait l’opération de cet ordre : \(\textbf{v}\textbf{M} \) ; d’abord le vecteur \(\textbf{v} \) à l’opérande gauche ensuite la matrice \(\textbf{M} \) à l’opérande droite.

La multiplication de matrices n’est pas commutative, c’est-à-dire que M1 x M2 ne sera pas forcément égal à M2 x M1.

Transposée d’une matrice :

La transposée d’une matrice \(\textbf{M} \), notée \(\textbf{M}^{T} \), est la matrice générée par l’inversion des éléments de la matrice d’origine par rapport à la diagonale.

Une matrice MxN devient une matrice NxM.

Exemple :

\(\textbf{A} = \begin{pmatrix} 2 & 3 & 1 \\ 5 & 8 & 4 \end{pmatrix} \)   donne \(\textbf{A}^T = \begin{pmatrix} 2 & 5 \\ 3 & 8 \\ 1 & 4 \end{pmatrix} \)

Propriétés remarquables :

\(\textbf{(A + B)}^T = \textbf{A}^T + \textbf{B}^T\)

\((c\textbf{A})^T=c{\textbf{A}}^T \)

\((\textbf{AB})^T=\textbf{B}^T\textbf{A}^T\)

\((\textbf{A}^T)^T=\textbf{A}\)

\((\textbf{A}^{-1})^T=(\textbf{A}^T)^{-1}\)

Ajouter deux matrices :

On ajoute deux matrices de même dimension en ajoutant un à un leur coefficient correspondant.

Soustraire deux matrices :

On procède comme suit : \(\textbf{A} – \textbf{B} = \textbf{A} + (-1 \cdot \textbf{B}) = \textbf{A} + (-\textbf{B}) \)

Multiplier une matrice par un réel :

On multiplie le réel par tous les coefficients de la matrice.

Inverse d’une matrice :

Seul les matrices carrées sont inversibles.

Noté \(\textbf{M}^{-1} \), la matrice inverse vérifie cette expression : \(\textbf{MM}^{-1} = \textbf{M}^{-1} \textbf{M} = \textbf{I} \).
\(\textbf{I} \) étant la matrice identité.

Une matrice est inversible si et seulement si son déterminant n’est pas nul.

L’inverse d’une matrice permet de retrouver l’espace précédent suite à une transformation de repère.

Voici un schéma résumant ce principe :

img008

Déterminant d’une matrice :

Associativité :

\(\textbf{A}(\textbf{B } {+} \textbf{ C}) = \textbf{AB} + \textbf{AC} \)

\((\textbf{AB})\textbf{C} = \textbf{A}(\textbf{BC}) \)

Résumé :

Nous avons vu les opérations courantes concernant l’algèbre matricielle.

L’utilisation des matrices (afin d’effectuer des transformations) est fondamentale dans le rendu 3D de jeu vidéo.

Une classe AlphaPass pour activer la transparence (façon RAII)

alpha

Intro :

Parfois on veut afficher certaines modèles tout en activant la transparence.

Ici je présente une façon simple de gérer cela avec le principe du RAII.

Prérequis :

– Comprendre le principe du RAII

– Savoir initialiser DirectX 10 à travers la classe D3D10Renderer

Explications :

Voici le code du fichier AlphaPass.h :

 

Voici le fichier AlphaPass.cpp :

 

warning

Vos entités transparentes doivent être affichées en dernier lors de le boucle de rendu et tout en désactivant le Z-Buffer.

Résumé :

Nous avons établi un objet AlphaPass qui permet d’activer, lors de sa création sur la pile, la transparence dans le rendu. La transparence est restauré lors de la destruction de l’objet en sortant du bloc de code.

Créer une icône de barre des tâches pour votre programme

taskbar

Intro :

Au lieu de garder l’icône représentative par défaut de votre programme, vous pouvez la remplacer en mettant une image de votre choix. Cette dernière image devra être du format .ico.

Vous pouvez en trouver à travers le web.

Prérequis :

– Savoir lire du C++

– Savoir initialiser DirectX 10 à travers la classe System

Explications :

– Télécharger une icône. Par exemple : Icone.ico

– Créer un fichier « Res.rc »

Mettez ces fichiers dans le dossier des fichiers de ressources :

ressource

 

Le compilateur de Visual Studio C++ reconnaîtra automatiquement l’icône à lier dans votre programme et la chargera au lancement de votre programme.

Résumé :

Nous avons présenté une méthode permettant de remplacer l’icône classique de votre programme.

Créer un curseur de souris customisé pour votre jeu

wow_cursors

Intro :

Dans un jeu, il peut être plus joli de changer l’image du curseur de la souris en fonction de ce que pointe la souris.

Prérequis :

– Savoir lire du C++

– Savoir initialiser DirectX 10 à travers la classe System

Explications :

– Téléchargez un curseur (par exemple WoW.cur)

– Créez un fichier « Res.rc » :

 

– Créez un fichier « Ressource.h » :

Mettez ces fichiers dans le dossier des fichiers de ressources :

ressource

Voici la fonction pour fixer le curseur de la souris sur la fenêtre de rendu :

 

Il vaut mieux utiliser l’appel à la fonction SetClassLong que l’appel à la fonction SetCursor ;
en effet le programme gardera constamment l’image de la souris même si le pointeur de souris sort de la fenêtre.

Résumé :

Nous avons présenté une méthode permettant de changer l’image du curseur de la souris.

Une classe pour afficher des lignes en 3D avec une certaine couleur

3D_lines

Intro :

Il peut être utile d’afficher des lignes dans la surface de rendu ; par exemple pour représenter des normales, des trajectoires, un repère, etc…

Prérequis :

– Savoir lire du C++

– Savoir utiliser la classe MeshSceneNode

– Savoir utiliser la classe ShaderTechnique et les déclarations de vertices.

Explications :

Voici le fichier Vertex3DLine.h :

 

Voici le fichier Vertex3DLine.cpp :

 

Voici le fichier ShaderTechnique_Vertex3DLine.h :

 

Voici le fichier ShaderTechnique_Vertex3DLine.cpp :

 

Voici le fichier 3DLine.fx correspondant :

 

Résumé :

Nous avons présenté un système permettant d’afficher des lignes dans la surface de rendu tout en pouvant spécifier leur couleur.