Utilisation des Vertex Traits – décrire ses sommets en une seule fois

Un « vertex traits » sert à décrire un format de sommet une seule fois, en C++, et à laisser le compilateur en déduire le reste. Sans lui, le même vertex est décrit à trois endroits qui doivent rester synchronisés à la main.

Prenons un sommet classique avec position, normale et coordonnées de texture :

Il existe trois définitions d’une structure élémentaire GPU. Dans le programme :

struct VertexPNT
{
    DirectX::XMFLOAT3 position;
    DirectX::XMFLOAT3 normal;
    DirectX::XMFLOAT2 uv;
};

struct VertexPNT

{

DirectX::XMFLOAT3 position;

DirectX::XMFLOAT3 normal;

DirectX::XMFLOAT2 uv;

};

A moitié dans le programme, à moitié dans le GPU :

const D3D11_INPUT_ELEMENT_DESC layout[] =
{
    { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0,  D3D11_INPUT_PER_VERTEX_DATA, 0 },
    { "NORMAL",   0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
    { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT,    0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};

const D3D11_INPUT_ELEMENT_DESC layout[] =

{

{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },

{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },

{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0 },

};

Et au final dans le GPU, défini dans un fichier d’effet shader :

struct VSInput
{
    float3 position : POSITION;
    float3 normal   : NORMAL;
    float2 uv       : TEXCOORD0;
};

struct VSInput

{

float3 position : POSITION;

float3 normal : NORMAL;

float2 uv : TEXCOORD0;

};

Si ces trois déclarations divergent : le comportement sera non désirable. Bug d’affichage, problèmes de compilation ou crash applicatif.

Rappel : c’est quoi, un trait ? Un trait est une structure template qui associe des informations à un type, sans modifier ce type. On interroge le trait avec le type en paramètre, et il répond à la compilation.

Première version : spécialiser à la main

#include <array>
#include <cstddef>   // offsetof
#include <d3d11.h>
#include <DirectXMath.h>

// Template primaire : volontairement non défini.
// Utiliser un type non décrit = erreur de compilation.
template <typename TVertex>
struct VertexTraits;

struct VertexPNT
{
    DirectX::XMFLOAT3 position;
    DirectX::XMFLOAT3 normal;
    DirectX::XMFLOAT2 uv;
};

template <>
struct VertexTraits<VertexPNT>
{
    static constexpr UINT Stride = sizeof(VertexPNT);

    static constexpr std::array<D3D11_INPUT_ELEMENT_DESC, 3> Layout =
    {{
        { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0,
          offsetof(VertexPNT, position), D3D11_INPUT_PER_VERTEX_DATA, 0 },
        { "NORMAL",   0, DXGI_FORMAT_R32G32B32_FLOAT, 0,
          offsetof(VertexPNT, normal),   D3D11_INPUT_PER_VERTEX_DATA, 0 },
        { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT,    0,
          offsetof(VertexPNT, uv),       D3D11_INPUT_PER_VERTEX_DATA, 0 },
    }};
};

#include <array>

#include <cstddef> // offsetof

#include <d3d11.h>

#include <DirectXMath.h>

// Template primaire : volontairement non défini.

// Utiliser un type non décrit = erreur de compilation.

template <typename TVertex>

struct VertexTraits;

struct VertexPNT

{

DirectX::XMFLOAT3 position;

DirectX::XMFLOAT3 normal;

DirectX::XMFLOAT2 uv;

};

template <>

struct VertexTraits<VertexPNT>

{

static constexpr UINT Stride = sizeof(VertexPNT);

static constexpr std::array<D3D11_INPUT_ELEMENT_DESC, 3> Layout =

{{

{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0,

offsetof(VertexPNT, position), D3D11_INPUT_PER_VERTEX_DATA, 0 },

{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0,

offsetof(VertexPNT, normal), D3D11_INPUT_PER_VERTEX_DATA, 0 },

{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0,

offsetof(VertexPNT, uv), D3D11_INPUT_PER_VERTEX_DATA, 0 },

}};

};

La technique du Normal Mapping (ou Bump Mapping)

Intro :

Cette technique de rendu des textures sur des modèles 3D permet de simuler un relief mélangé par une texture.

En français on parle de « Placage de Relief ».

Explications :

Cette technique permet de générer un jeu de mélange entre la lumière et les ombres sur une surface classique sans avoir à y renseigner les normales en une multitude de points. En effet les normales sont modifiées (par un effet de variation) pour créer un effet de lumière semblable à du relief.

Ici 4 points peuvent suffire pour générer un effet de relief avancé sur une surface 2D.

La technique du Parallax Mapping

GPU

Intro :

Avant tout, que veux dire « parallax » ou parallaxe ? La parallaxe désigne le phénomène physique et dynamique à propos d’un objet qui visiblement change de forme à cause du point de vue de l’œil de l’observateur.

La technique du Parallax Mapping est une technique de déplacement de surface.
La surface traitée donne un résultat de profondeur et est similaire avec la technique utilisée dans le « bump mapping ».

Cela donne un résultat très joli. En effet, elle permet d’émuler le relief d’un objet à partir d’une texture.

Comme toutes les techniques de déplacement de surface, la technique du PM utilise une image texture spéciale pour effectuer le rendu.

Explications :

C’est une super fonctionnalité !

Il s’agit d’appliquer un décalage des coordonnées (offset) de la texture diffuse directement dans le pixel shader.

Ce décalage dépend de la direction et de la position de la caméra qui observe la scène.
La surface ainsi dessinée à l’écran doit évoluer correctement en respectant la position de la caméra.

La technique du PM utilise une image / texture de couleur noire et blanche.

La simulation s’opère dans l’espace des textures. On opère un décalage des coordonnées des textures avec le vecteur de vue de la caméra plus la valeur courante de la « height map » de texture utilisée.

Le Compute Shader avec DirectX 11 (DirectCompute)

Intro :

Pour faire simple, le compute shader de DirectX 11 permet d’effectuer des calculs directement par le processeur de la carte graphique (nommé GPU) alors qu’ils auraient pu être fait par le CPU (le processeur de la carte-mère du PC). Il est dénommé par un autre nom : le DirectCompute.

A noter que bien que leur sortie s’est faite avec DirectX 11, on peut utiliser les compute shader avec du matériel DirectX 10.

Explications :

Le compute shader permet le partage de la mémoire entre processus légers synchronisés à l’intérieure de la CG et de la mémoire de l’ordinateur. Il utilise le langage HLSL (High Level Shader Language) classique de DirectX.

En théorie on peut calculer n’importe quoi. Le compute shader fait office d’accès mémoire en entrée / sortie par les programmes exécutés par le processeur.

Maintenant et depuis l’ajout de cette fonctionnalité, avec DirectX on peut faire du calcul non graphique en utilisant la CG.

Voici un petit exemple d’initialisation d’un compute shader :

UINT flags = D3DCOMPILE_ENABLE_STRICTNESS;

#if defined( DEBUG ) || defined( _DEBUG )
flags |= D3DCOMPILE_DEBUG;
#endif

// Prefer higher CS shader profile when possible as CS 5.0 provides better performance on 11-class hardware.
LPCSTR profile = ( device->GetFeatureLevel() >= D3D_FEATURE_LEVEL_11_0 ) ? "cs_5_0" : "cs_4_0";

const D3D_SHADER_MACRO defines[] = 
{
     "EXAMPLE_DEFINE", "1",
      NULL, NULL
};

ID3DBlob* shaderBlob = nullptr;
ID3DBlob* errorBlob = nullptr;

HRESULT hr = D3DCompileFromFile( srcFile, defines, D3D_COMPILE_STANDARD_FILE_INCLUDE,
                                     entryPoint, profile,
                                     flags, 0, &shaderBlob, &errorBlob );

UINT flags = D3DCOMPILE_ENABLE_STRICTNESS;

#if defined( DEBUG ) || defined( _DEBUG )

flags |= D3DCOMPILE_DEBUG;

#endif

// Prefer higher CS shader profile when possible as CS 5.0 provides better performance on 11-class hardware.

LPCSTR profile = ( device->GetFeatureLevel() >= D3D_FEATURE_LEVEL_11_0 ) ? "cs_5_0" : "cs_4_0";

const D3D_SHADER_MACRO defines[] =

{

"EXAMPLE_DEFINE", "1",

NULL, NULL

};

ID3DBlob* shaderBlob = nullptr;

ID3DBlob* errorBlob = nullptr;

HRESULT hr = D3DCompileFromFile( srcFile, defines, D3D_COMPILE_STANDARD_FILE_INCLUDE,

entryPoint, profile,

flags, 0, &shaderBlob, &errorBlob );

– Avec srcFile comme le nom du fichier .fx d’un compute shader.
– Avec defines comme structure de déclaration des constantes defines à l’intérieur de l’effet.

Quand le compute shader sera exécuté dans la mémoire de la carte graphique, il pourra tirer avantage d’un grand nombre d’unités d’exécution parallèles à l’intérieur du GPU.

Qu’est-ce qu’un « thread group » ?

Un thread group est un groupe d’unités d’exécution en parallèle qui est interprété et conçu par la CG comme un tableau en 3 dimensions dont chaque membre est un « thread ».

On utilise la méthode ID3D11DeviceContext::Dispatch pour envoyer un « thread group » au GPU. C’est-à-dire qu’on utilise cette méthode pour faire exécuter des commandes un compute shader.

En effet un compute shader peut être exécuté sur plusieurs unité d’exécution en parallèle, le tout formant un « thread group ». On identifie un thread (unité d’exécution parallèle) en particulier avec un numéro d’index assimilé par un vecteur en 3 dimensions (x, y, z).

Dans cette image illustrant un exemple, la taille des « threads groups » est de 5x5x2, soit 50 groupes d’unités d’exécution en parallèle (« thread »). Ici un thread en particulier est adressé par le triplet (4,1,1). A noter que chaque groupe de threads est fait de 16×16 = 256 unité ou threads d’exécution.

Single Thread

Chaque processus léger (« thread ») peut exécuter plusieurs élément de données à travers le compute shader. Et l’application C++ qui gère tous ces calculs peut définir le nombre de threads en exécution.

La principale capacité des compute shaders est le partage et l’accès de la mémoire par plusieurs threads en parallèle.

Le principe de base du calcul par le biais de ces shaders est l’envoi régulier d’une grille de threads. Les threads d’un même groupe s’exécute en parallèle, mais des threads de groupes différents le peuvent dans certaines conditions.

Les données accessibles par le compute shader peuvent être les Buffers et Textures de DirectX 11.

Les applications au compute shader peuvent être :

– Le traitement d’images
– La construction procédurale de modèles
– La physique et l’animation
– Le rendu
– L’intelligence artificielle
– Les effets de particules
– Les algorithmes de tri
– L’encodage vidéo
– Le calcul scientifique
– Des effets graphiques tels que : le depth of field, HDR bloom, le motion blur, etc…

Utilisation des std::array en C++11

Intro :

L’objet de la classe std::array permet de représenter en mémoire un tableau statique dont le nombre d’éléments est connue à la compilation et est fixé à l’avance.

Prérequis :

– Savoir lire du C++

Explications :

On peut l’initialiser d’emblée :

std::array<int, 5> a = {1, 2, 3, 4, 5};

1	std::array<int, 5> a = {1, 2, 3, 4, 5};

Voilà une déclaration supplémentaire :

#include <array>
 
std::array<int, 3> UnArray;

#include <array>

std::array<int, 3> UnArray;

Les données de ce type de tableau sont stockées de manière contigu en mémoire.

Résumé :

A l’opposé des tableaux classiques, les tableaux déclarés avec la classe std::array stocke aussi le nombre d’éléments du tableau en mémoire.

Utilisation de la librairie Zlib pour gérer des flux de compression

Intro :

Il est très utile de pouvoir compresser des données en mémoire ou des fichiers sur disque ou mémoire de masse. Pour cela, on va utiliser la fameuse librairie C open-source nommée Zlib !

Prérequis :

– Savoir lire du C ou du C++

– Savoir configurer l’importation d’une librairie sous Visual C++

Explications :

Elle implémente l’algorithme de compression deflate et peut créer des fichiers au format gzip.
La bibliothèque est aussi multi-plateforme.

Résumé :

Nous avons présenté une classe C++ encapsulant les fonctions de compression de la librairie Zlib ; cette classe permet de compresser des fichiers ou des données en mémoire.

Références :

– http://www.zlib.net/manual.html

– http://www.zlib.net/zlib_how.html

– http://www.zlib.net/zlib_faq.html

Apprendre à utiliser TinyXML pour charger vos fichiers XML

Intro :

Parfois dans un programme ou un jeu vidéo, il est nécessaire de charger des données sous format XML. Par exemple pour un éditeur de scène / monde, on peut vouloir charger les positions des entités directement depuis un fichier Scene.xml par exemple.

Prérequis :

– Savoir lire du C++

– Savoir lire un fichier XML

– Savoir importer des fichiers sources dans Visual C++

Explications :

TinyXML est une toute petite librairie C++ permettant de charger et d’analyser les données stockées dans un fichier XML. Elle est sous la licence Zlib (cela signifie que vous pouvez l’utiliser pour n’importe quoi !)

<?xml version="1.0" ?>
<root>
    <UnElement attribut1="une valeur" />
    <UnAutreElement attribut2="2" attribute3="3">
        <Element3 attribut4="4" />
        Du Texte !
    </UnAutreElement>
</root>

<?xml version="1.0" ?>

<root>

Du Texte !

</UnAutreElement>

</root>

D’abord il vous faut télécharger les sources de TinyXML. La dernière version à la date d’écriture de cet article est la version 2.

Deux choix s’offrent à vous : soit d’utiliser la version 1 ; soit d’utiliser la version 2.

Les avantages de choisir la 2ème : meilleur gestion de la mémoire ; lecture plus rapide du fichier XML ; pas d’utilisation de la STL.

TinyXML charge complètement un fichier XML avec la méthode LoadFile()… Il vous reste ensuite le soin d’analyser votre fichier XML en fonction de son contenu en terme de nœuds.

On précise que XML est l’abréviation de « eXtensible Markup Language ». XML est un format pour stocker des données, pas un langage de programmation !
Celles-ci sont écrites entre des balises ou sous forme d’attributs, et l’ensemble est écrit sous forme d’un arbre.

Voici la structure d’un fichier XML :

Il vous faut importer dans votre projet Visual C++ la librairie directement par l’intermédiaire de ces fichiers :

– tinystr.cpp
– tinyxmlerror.cpp
– tinystr.h
– tinyxml.h
– tinyxml.cpp
– tinyxmlparser.cpp

Dans votre fichier source .cpp utilisant TinyXML, il vous faudra écrire #include « tinyxml.h » en tant que fichier d’en-tête.

Vous pouvez définir le define #define TIXML_USE_STL pour activer l’utilisation de la STL dans TinyXml.

Sachez que TinyXML reconnaît automatiquement l’encodage utilisé par le fichier à charger (il n’est pas nécessaire de renseigner l’attribut « encoding »).

Commençons l’analyse d’un fichier quelconque :

TiXmlDocument doc;
if(!doc.LoadFile("Test.xml"))
{
    std::cerr << doc.ErrorDesc() << std::endl;
    return FAILURE;
}

TiXmlDocument doc;

if(!doc.LoadFile("Test.xml"))

{

std::cerr << doc.ErrorDesc() << std::endl;

return FAILURE;

}

Le fichier « doc » contient toutes les données d’analyse du fichier XML chargé.

TiXmlElement* pRoot = doc.FirstChildElement();
if (pRoot == nullptr)
{
    std::cerr << "Echec chargement du fichier. Aucun élément racine." << std::endl;
    doc.Clear();

    return FAILURE;
}

TiXmlElement* pRoot = doc.FirstChildElement();

if (pRoot == nullptr)

{

std::cerr << "Echec chargement du fichier. Aucun élément racine." << std::endl;

doc.Clear();

return FAILURE;

}

La méthode FirstChildElement() renvoie un pointeur vers un objet TinyXmlElement qui représente le premier nœud du fichier XML en question. FirstChildElement() prend un paramètre une chaîne de caractères représentant le nom du nœud en question.

Une boucle permet d’afficher tout les noms des éléments du fichier :

for (TiXmlElement* pElem = pRoot->FirstChildElement(); pElem != nullptr; pElem = pElem->NextSiblingElement())
{
    std::string elemName = pElem->Value();
}

for (TiXmlElement* pElem = pRoot->FirstChildElement(); pElem != nullptr; pElem = pElem->NextSiblingElement())

{

std::string elemName = pElem->Value();

}

Le principe est le suivant : on parcourt chaque nœud en extrayant de chaque nœud enfant les attributs qui nous intéressent !

const char* attr = nullptr;

if (elemName == "UnElement")
{
    attr = elem->Attribute("attribut1");

    if (attr != nullptr)
    {
        // Faire le travail d'analyse ici
    }
}

const char* attr = nullptr;

if (elemName == "UnElement")

{

attr = elem->Attribute("attribut1");

if (attr != nullptr)

{

// Faire le travail d'analyse ici

}

La variable attr représente la valeur de l’attribut en question. Si l’attribut ne comporte pas le nom spécifié. La méthode Attribute(…) renvoie nullptr.

On peut tester si le contenu d’un nœud est du texte avec la méthode elem->ToText(). Elle renvoie nullptr s’il n’y a pas de texte.

Il peut être utile d’utiliser une structure de données spécifique customisée afin de stocker les données lues depuis le fichier XML. Mais cela reste facultatif !

On fini l’analyse avec l’appel de Clear() : doc.Clear();

Pour faciliter le parcours des nœuds, on peut utiliser ce qu’on appelle des handles.
Exemple :

TiXmlHandle hdl(&doc);
TiXmlElement *elem = hdl.FirstChildElement().FirstChildElement().Element();

1 2	TiXmlHandle hdl(&doc); TiXmlElement *elem = hdl.FirstChildElement().FirstChildElement().Element();

La méthode QueryIntAttribute(…) permet d’obtenir la valeur d’un attribut sous forme de integer

Voici la liste des classes de TinyXML formatée par Doxygen : http://www.grinninglizard.com/tinyxmldocs/annotated.html

Résumé :

Simple et efficace, la petite librairie TinyXML facilitera vos chargement de données sous format XML.

Références :

– http://www.dinomage.com/2012/01/tutorial-using-tinyxml-part-1/

Comment calculer la matrice de rotation d’un Billboard

Intro :

Qu’est-ce un billboard ? Un billboard est un objet 3D (en général d’apparence 2D) qui fait toujours face à la caméra.

Prérequis :

– Savoir ce qu’est une matrice

– Savoir lire une matrice

– Savoir en quoi consiste la matrice de vue

Explications :

Rappelez vous que la matrice de vue (celle de la caméra) est définie ainsi :

En effet, cette matrice est construite à partir de trois vecteurs :

Avec une origine (ainsi nommée « Caméra ») représentant la position de celle-ci par rapport au repère commun à tous les nœuds de la scène, cette dernière concerne la matrice World (matrice de monde)

Une fois construite, la matrice de vue est une matrice qui doit être mise à jour constamment dans la boucle de rendu.

Décomposition de la matrice View :

\(\vec{LookAt}_x = \textbf{View}_{02} \)
\(\vec{LookAt}_y = \textbf{View}_{12} \)
\(\vec{LookAt}_y = \textbf{View}_{22} \)

\(\vec{Right}_x = \textbf{View}_{00} \)
\(\vec{Right}_y = \textbf{View}_{10} \)
\(\vec{Right}_y = \textbf{View}_{20} \)

\(\vec{Up}_x = \textbf{View}_{01} \)
\(\vec{Up}_y = \textbf{View}_{11} \)
\(\vec{Up}_y = \textbf{View}_{21} \)

On normalise ensuite ces trois derniers vecteurs :

\({\vec{LookAt}}_{norm}=\frac{{\vec{LookAt}}}{\|{\vec{LookAt}}\|} \)
\({\vec{Right}}_{norm}=\frac{{\vec{Right}}}{\|{\vec{Right}}\|} \)
\({\vec{Up}}_{norm}=\frac{{\vec{Up}}}{\|{\vec{Up}}\|} \)

A noter que l’on peut retrouver un vecteur connaissant les deux autres. Par exemple, l’on veut retrouver le vecteur \({\vec{Up}} \) connaissant \({\vec{Right}} \) et \({\vec{LookAt}} \). On procède ainsi :

\({\vec{Up}} = {\vec{LookAt}}\times{\vec{Right}} \)

Maintenant pour construire notre Billboard il nous faudra créer une matrice de rotation \(\textbf{R} \). C’est avec cette matrice de rotation que seront multipliés toutes les vertices du Billboard de façon à ce qu’ils soient toujours en face de la caméra !

On calcule la matrice \(\textbf{R} \) de la façon suivante :

\(\textbf{R}_{0*} = {\vec{Right}} \)
\(\textbf{R}_{1*} = {\vec{Up}} \)
\(\textbf{R}_{2*} = {\vec{LookAt}} \)

C’est-à-dire de manière plus détaillée :

\(\textbf{R}_{01} = \vec{Right_x} \)
\(\textbf{R}_{02} = \vec{Right_y} \)
\(\textbf{R}_{03} = \vec{Right_z} \)

\(\textbf{R}_{11} = \vec{Up_x} \)
\(\textbf{R}_{12} = \vec{Up_y} \)
\(\textbf{R}_{13} = \vec{Up_z} \)

\(\textbf{R}_{21} = \vec{LookAt_x} \)
\(\textbf{R}_{22} = \vec{LookAt_y} \)
\(\textbf{R}_{23} = \vec{LookAt_z} \)

Voici le Vertex Shader qui applique le calcul en question :

PS_INPUT VS(VS_INPUT input)
{
    PS_INPUT output = (PS_INPUT)0;
    
    // Extraction du LookAt vector
    float3 look;
    look.x = View[0][2];
    look.y = View[1][2];
    look.z = View[2][2];
    look = normalize(look);    

    // Extraction du Right vector
    float3 right;
    right.x = View[0][0];
    right.y = View[1][0];
    right.z = View[2][0];
    right = normalize(right);
    
    // Détermination du Up vector
    float3 up = cross(look, right);
    up = normalize(up);

    // Matrice de rotation qui fait face à la caméra
    float3x3 R;
    R[0] = right;
    R[1] = up;
    R[2] = look;
    
    float3 posW = mul(input.Pos, R);

    output.Pos = mul( float4(posW, 1.0f), World );
    output.Pos = mul( output.Pos, View );
    output.Pos = mul( output.Pos, Projection );
    
    output.Color = input.Color;    
    output.Page = input.Page;    
    output.Tex = input.Tex;        
    
    return output;
}

PS_INPUT VS(VS_INPUT input)

{

PS_INPUT output = (PS_INPUT)0;

// Extraction du LookAt vector

float3 look;

look.x = View[0][2];

look.y = View[1][2];

look.z = View[2][2];

look = normalize(look);

// Extraction du Right vector

float3 right;

right.x = View[0][0];

right.y = View[1][0];

right.z = View[2][0];

right = normalize(right);

// Détermination du Up vector

float3 up = cross(look, right);

up = normalize(up);

// Matrice de rotation qui fait face à la caméra

float3x3 R;

R[0] = right;

R[1] = up;

R[2] = look;

float3 posW = mul(input.Pos, R);

output.Pos = mul( float4(posW, 1.0f), World );

output.Pos = mul( output.Pos, View );

output.Pos = mul( output.Pos, Projection );

output.Color = input.Color;

output.Page = input.Page;

output.Tex = input.Tex;

return output;

}

Voici un Billboard affiché qui représente une quête disponible :

Résumé :

Nous avons expliqué comment créer un Billboard en construisant une matrice de rotation spéciale qui tourne et qui fait toujours face à la caméra.

Références :

– Des sujets issus de quelques forums Internet comme celui de www.gamedev.net

La bibliothèque standard du C++ (la STL du C++11)

Intro :

Dans un programme C++, il est nécessaire d’utiliser certaines structures de données comme les tableaux, les liste chaînées, les arbres, etc…

La librairie standard du C++ offre trois types d’objets prêts à être utilisés : les conténaires, les algorithmes et les itérateurs.

En l’occurence la STL est une bibliothèque de classes et de fonctions standardisées selon la norme en vigueur du C++.

Elle fournie des outils pour faciliter la programmation de vos programmes :

– pour les chaînes de caractères
– pour la gestion des flux (fichiers, entrée et sortie standard)
– des conteneurs qui facilitent la manipulation de certains objets
– une panoplie d’algorithmes de tri

Prérequis :

– Savoir lire du C++

– Savoir quelques rudiments à propos des structures de données

Explications :

On peut utiliser les fichiers d’en-tête du langage C en C++. Ils sont inclus sous un nom différent, ils sont obtenus en retirant le suffixe ‘.h’ et en ajoutant un ‘c’ au début. Par exemple l’header devient .

Voici la liste des principaux objets les plus utilisés de la STL :

std::array ; std::dequeue ; std::list ; std::map ; std::queue ; std::set ; std::vector

std::mutex ; std::thread ; std::string ; std::exception ; std::function ; std::tuple

Dans cette catégorie d’articles, nous allons étudier et expliquer en détails à quoi servent toutes ces entités / objets.

Résumé :

La STL présente et fournie beaucoup d’objets facilitant votre programme tout en embellissant votre code.

Références :

– http://www.cplusplus.com/reference/

– https://fr.wikipedia.org/wiki/Biblioth%C3%A8que_standard_du_C%2B%2B

Une classe SceneNode pour représenter vos objets et entités dans la scène

Intro :

Dans tout moteur 3D il est représenté un objet SceneNode (noeud de scène).
Cet objet sert à identifier une entité sur la scène avec les composantes suivantes : position, rotation, et mise à l’échelle.

Prérequis :

– Savoir initialiser DirectX 10.1

– Savoir qu’il existe une autre classe liée : SceneManager

Explications :

Voici le fichier SceneNode.h :

#ifndef SCENE_NODE_H
#define SCENE_NODE_H

struct AlphaSceneNode
{
    MeshSceneNode* m_pNode;
    D3DXMATRIX m_concat;
    float m_ScreenZ;

    // Pour le tri de liste de la STL
    bool const operator <(AlphaSceneNode const &other)
    {
        return m_ScreenZ < other.m_ScreenZ;
    }
};

class SceneNode
{
    friend class SceneManager;

public:
    SceneNode(SceneNode* pParent, const D3DXVECTOR3& position, const D3DXVECTOR3& rotation, const D3DXVECTOR3& scale);

    virtual ~SceneNode();

    std::string& GetName();
    void SetName(const std::string& sName);

    bool IsVisible();
    void SetVisible(bool bVisible);

    unsigned int GetID();
    void SetID(unsigned int iID);

    void AddChild(SceneNode* pChild);
    void RemoveChild(SceneNode* pChild);

    void RemoveAll();

    D3DXVECTOR3& GetScale();
    void SetScale(float x, float y, float z);

    D3DXVECTOR3& GetRotation();
    void SetRotation(float x, float y, float z);

    D3DXVECTOR3& GetPosition();

    void SetPosition(const D3DXVECTOR3& position);
    void SetPosition(float x, float y, float z);

    std::vector<SceneNode*> GetChildren();

    void SetParent(SceneNode* pSceneNode);
    SceneNode* GetParent();
    void RemoveParent();

    void Remove();

    D3DMATRIX& GetAbsoluteTransformation();
    D3DXMATRIX& GetRelativeTransformation();

    bool IsReallyVisible() { return true; }

    bool IsTransparent();
    void SetTransparent(bool bTransparent);

    void UpdateRelativeTransformation();
    void UpdateAbsoluteTransformation();

    virtual void OnRegisterSceneNode() {}
    virtual void OnAnimate(float fTimeSinceLastFrame) {}

    D3DXVECTOR3 GetAbsolutePosition();

    virtual bool OnUpdate(float fTimeSinceLastFrame) { return true; }

protected:
    virtual bool OnPreRender(float fTimeSinceLastFrame);
    virtual bool OnRender(float fTimeSinceLastFrame) { return true; }
    virtual bool OnPostRender(float fTimeSinceLastFrame);

protected:
    D3DXVECTOR3 m_RelativeTranslation;
    D3DXVECTOR3 m_RelativeRotation;
    D3DXVECTOR3 m_RelativeScale;

private:
    std::string m_sName;

    D3DXMATRIX m_AbsoluteTransformation;
    D3DXMATRIX m_RelativeTransformation;

    uint32 m_iID;

    bool m_bVisible;

    SceneNode* m_pParent;
    std::vector<SceneNode*> m_children;

    bool m_bTransparent;
};

#endif

100

101

102

103

#ifndef SCENE_NODE_H

#define SCENE_NODE_H

struct AlphaSceneNode

{

MeshSceneNode* m_pNode;

D3DXMATRIX m_concat;

float m_ScreenZ;

// Pour le tri de liste de la STL

bool const operator <(AlphaSceneNode const &other)

{

return m_ScreenZ < other.m_ScreenZ;

}

};

class SceneNode

{

friend class SceneManager;

public:

SceneNode(SceneNode* pParent, const D3DXVECTOR3& position, const D3DXVECTOR3& rotation, const D3DXVECTOR3& scale);

virtual ~SceneNode();

std::string& GetName();

void SetName(const std::string& sName);

bool IsVisible();

void SetVisible(bool bVisible);

unsigned int GetID();

void SetID(unsigned int iID);

void AddChild(SceneNode* pChild);

void RemoveChild(SceneNode* pChild);

void RemoveAll();

D3DXVECTOR3& GetScale();

void SetScale(float x, float y, float z);

D3DXVECTOR3& GetRotation();

void SetRotation(float x, float y, float z);

D3DXVECTOR3& GetPosition();

void SetPosition(const D3DXVECTOR3& position);

void SetPosition(float x, float y, float z);

std::vector<SceneNode*> GetChildren();

void SetParent(SceneNode* pSceneNode);

SceneNode* GetParent();

void RemoveParent();

void Remove();

D3DMATRIX& GetAbsoluteTransformation();

D3DXMATRIX& GetRelativeTransformation();

bool IsReallyVisible() { return true; }

bool IsTransparent();

void SetTransparent(bool bTransparent);

void UpdateRelativeTransformation();

void UpdateAbsoluteTransformation();

virtual void OnRegisterSceneNode() {}

virtual void OnAnimate(float fTimeSinceLastFrame) {}

D3DXVECTOR3 GetAbsolutePosition();

virtual bool OnUpdate(float fTimeSinceLastFrame) { return true; }

protected:

virtual bool OnPreRender(float fTimeSinceLastFrame);

virtual bool OnRender(float fTimeSinceLastFrame) { return true; }

virtual bool OnPostRender(float fTimeSinceLastFrame);

protected:

D3DXVECTOR3 m_RelativeTranslation;

D3DXVECTOR3 m_RelativeRotation;

D3DXVECTOR3 m_RelativeScale;

private:

std::string m_sName;

D3DXMATRIX m_AbsoluteTransformation;

D3DXMATRIX m_RelativeTransformation;

uint32 m_iID;

bool m_bVisible;

SceneNode* m_pParent;

std::vector<SceneNode*> m_children;

bool m_bTransparent;

};

#endif

Voici le fichier SceneNode.cpp :

SceneNode::SceneNode(SceneNode* pParent,
                     const D3DXVECTOR3& position,
                     const D3DXVECTOR3& rotation,
                     const D3DXVECTOR3& scale) :
m_bTransparent(false),
m_bVisible(true),
m_pParent(nullptr),
m_iID(0)
{
    m_RelativeTranslation = D3DXVECTOR3(0.0f, 0.0f, 0.0f);
    m_RelativeRotation = D3DXVECTOR3(0.0f, 0.0f, 0.0f);
    m_RelativeScale = D3DXVECTOR3(1.0f, 1.0f, 1.0f);

    D3DXMatrixIdentity(&m_AbsoluteTransformation);
    D3DXMatrixIdentity(&m_RelativeTransformation);

    UpdateAbsoluteTransformation();
}

SceneNode::~SceneNode()
{
    RemoveAll();
}

unsigned int SceneNode::GetID()
{
    return m_iID;
}

void SceneNode::SetID(unsigned int iID)
{
    m_iID = iID;
}

bool SceneNode::IsVisible()
{
    return m_bVisible;
}

void SceneNode::SetVisible(bool bVisible)
{
    m_bVisible = bVisible;
}

bool SceneNode::OnPreRender(float fTimeSinceLastFrame)
{
    UpdateAbsoluteTransformation();

    SCENE_MANAGER->PushAndSetMatrix(m_AbsoluteTransformation);

    return true;
}

bool SceneNode::OnPostRender(float fTimeSinceLastFrame)
{
    SCENE_MANAGER->PopMatrix();

    return true;
}

D3DXVECTOR3& SceneNode::GetPosition()
{
    return m_RelativeTranslation;
}

void SceneNode::SetPosition(const D3DXVECTOR3& position)
{
    m_RelativeTranslation = position;

    UpdateRelativeTransformation();
}

void SceneNode::SetPosition(float x, float y, float z)
{
    m_RelativeTranslation = D3DXVECTOR3(x, y, z);

    UpdateRelativeTransformation();
}

bool SceneNode::IsTransparent()
{
    return m_bTransparent;
}

void SceneNode::SetTransparent(bool bTransparent)
{
    m_bTransparent = bTransparent;
}

void SceneNode::UpdateRelativeTransformation()
{
    D3DXMATRIX matTrans;
    D3DXMatrixTranslation(&matTrans, m_RelativeTranslation.x, m_RelativeTranslation.y, m_RelativeTranslation.z);

    D3DXMATRIX matRotX;
    D3DXMatrixRotationX(&matRotX, m_RelativeRotation.x);

    D3DXMATRIX matRotY;
    D3DXMatrixRotationY(&matRotY, m_RelativeRotation.y);

    D3DXMATRIX matRotZ;
    D3DXMatrixRotationZ(&matRotZ, m_RelativeRotation.z);

    D3DXMATRIX matRotation = matRotX * matRotY * matRotZ;

    D3DXMATRIX matScale;
    D3DXMatrixScaling(&matScale, m_RelativeScale.x, m_RelativeScale.y, m_RelativeScale.z);

    // Ordre de la multiplication : S*R*T
    m_RelativeTransformation = matScale * matRotation * matTrans;
}

void SceneNode::UpdateAbsoluteTransformation()
{
    if (m_pParent)
    {
        D3DXMATRIX AbsoluteTrans = m_pParent->GetAbsoluteTransformation();
        D3DXMATRIX RelativeTrans = GetRelativeTransformation();
    
        D3DXMatrixMultiply(&m_AbsoluteTransformation, &AbsoluteTrans, &RelativeTrans);
    }
    else
    {
        m_AbsoluteTransformation = GetRelativeTransformation();
    }
}

D3DMATRIX& SceneNode::GetAbsoluteTransformation()
{
    UpdateAbsoluteTransformation();

    return m_AbsoluteTransformation;
}

D3DXMATRIX& SceneNode::GetRelativeTransformation()
{
    UpdateRelativeTransformation();

    return m_RelativeTransformation;
}

std::string& SceneNode::GetName()
{
    return m_sName;
}

void SceneNode::SetName(const std::string& sName)
{
    m_sName = sName;
}

D3DXVECTOR3& SceneNode::GetScale()
{
    return m_RelativeScale;
}

void SceneNode::SetScale(float x, float y, float z)
{
    m_RelativeScale = D3DXVECTOR3(x, y, z);

    UpdateRelativeTransformation();
}

D3DXVECTOR3& SceneNode::GetRotation()
{
    return m_RelativeRotation;
}

void SceneNode::SetRotation(float x, float y, float z)
{
    m_RelativeRotation = D3DXVECTOR3(x, y, z);

    UpdateRelativeTransformation();
}

void SceneNode::AddChild(SceneNode* pChild)
{
    if (pChild && (pChild != this))
    {
        pChild->RemoveParent();
        m_children.push_back(pChild);
        pChild->SetParent(this);

        MeshSceneNode* pChildSceneNode = dynamic_cast<MeshSceneNode*>(pChild);

        if (typeid(pChildSceneNode) == typeid(MeshSceneNode*))
        {
            SCENE_MANAGER->AddSceneNode(pChildSceneNode);
        }
    }
}

void SceneNode::RemoveChild(SceneNode* pChild)
{
    for (auto it = m_children.begin(); it != m_children.end(); it++)
    {
        SceneNode* pCurrentChild = *it;

        if (pCurrentChild == pChild)
        {
            pCurrentChild->RemoveParent();

            m_children.erase(it);
        }
    }
}

void SceneNode::RemoveAll()
{
    for (auto it = m_children.begin(); it != m_children.end(); it++)
    {
        SceneNode* pCurrentChild = *it;
        m_children.erase(it);
    }

    m_children.clear();
}

void SceneNode::SetParent(SceneNode* pSceneNode)
{
    Remove();
    m_pParent = pSceneNode;
}

SceneNode* SceneNode::GetParent()
{
    return m_pParent;
}

void SceneNode::RemoveParent()
{
    m_pParent = nullptr;
}

void SceneNode::Remove()
{
    if (m_pParent)
    {
        m_pParent->RemoveChild(this);
    }
}

std::vector<SceneNode*> SceneNode::GetChildren()
{
    return m_children;
}

D3DXVECTOR3 SceneNode::GetAbsolutePosition()
{
    D3DXVECTOR3 absolutePosition;

    absolutePosition.x = m_AbsoluteTransformation._12;
    absolutePosition.y = m_AbsoluteTransformation._13;
    absolutePosition.z = m_AbsoluteTransformation._14;

    return absolutePosition;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

SceneNode::SceneNode(SceneNode* pParent,

const D3DXVECTOR3& position,

const D3DXVECTOR3& rotation,

const D3DXVECTOR3& scale) :

m_bTransparent(false),

m_bVisible(true),

m_pParent(nullptr),

m_iID(0)

{

m_RelativeTranslation = D3DXVECTOR3(0.0f, 0.0f, 0.0f);

m_RelativeRotation = D3DXVECTOR3(0.0f, 0.0f, 0.0f);

m_RelativeScale = D3DXVECTOR3(1.0f, 1.0f, 1.0f);

D3DXMatrixIdentity(&m_AbsoluteTransformation);

D3DXMatrixIdentity(&m_RelativeTransformation);

UpdateAbsoluteTransformation();

}

SceneNode::~SceneNode()

{

RemoveAll();

}

unsigned int SceneNode::GetID()

{

return m_iID;

}

void SceneNode::SetID(unsigned int iID)

{

m_iID = iID;

}

bool SceneNode::IsVisible()

{

return m_bVisible;

}

void SceneNode::SetVisible(bool bVisible)

{

m_bVisible = bVisible;

}

bool SceneNode::OnPreRender(float fTimeSinceLastFrame)

{

UpdateAbsoluteTransformation();

SCENE_MANAGER->PushAndSetMatrix(m_AbsoluteTransformation);

return true;

}

bool SceneNode::OnPostRender(float fTimeSinceLastFrame)

{

SCENE_MANAGER->PopMatrix();

return true;

}

D3DXVECTOR3& SceneNode::GetPosition()

{

return m_RelativeTranslation;

}

void SceneNode::SetPosition(const D3DXVECTOR3& position)

{

m_RelativeTranslation = position;

UpdateRelativeTransformation();

}

void SceneNode::SetPosition(float x, float y, float z)

{

m_RelativeTranslation = D3DXVECTOR3(x, y, z);

UpdateRelativeTransformation();

}

bool SceneNode::IsTransparent()

{

return m_bTransparent;

}

void SceneNode::SetTransparent(bool bTransparent)

{

m_bTransparent = bTransparent;

}

void SceneNode::UpdateRelativeTransformation()

{

D3DXMATRIX matTrans;

D3DXMatrixTranslation(&matTrans, m_RelativeTranslation.x, m_RelativeTranslation.y, m_RelativeTranslation.z);

D3DXMATRIX matRotX;

D3DXMatrixRotationX(&matRotX, m_RelativeRotation.x);

D3DXMATRIX matRotY;

D3DXMatrixRotationY(&matRotY, m_RelativeRotation.y);

D3DXMATRIX matRotZ;

D3DXMatrixRotationZ(&matRotZ, m_RelativeRotation.z);

D3DXMATRIX matRotation = matRotX * matRotY * matRotZ;

D3DXMATRIX matScale;

D3DXMatrixScaling(&matScale, m_RelativeScale.x, m_RelativeScale.y, m_RelativeScale.z);

// Ordre de la multiplication : S*R*T

m_RelativeTransformation = matScale * matRotation * matTrans;

}

void SceneNode::UpdateAbsoluteTransformation()

{

if (m_pParent)

{

D3DXMATRIX AbsoluteTrans = m_pParent->GetAbsoluteTransformation();

D3DXMATRIX RelativeTrans = GetRelativeTransformation();

D3DXMatrixMultiply(&m_AbsoluteTransformation, &AbsoluteTrans, &RelativeTrans);

}

else

{

m_AbsoluteTransformation = GetRelativeTransformation();

}

D3DMATRIX& SceneNode::GetAbsoluteTransformation()

{

UpdateAbsoluteTransformation();

return m_AbsoluteTransformation;

}

D3DXMATRIX& SceneNode::GetRelativeTransformation()

{

UpdateRelativeTransformation();

return m_RelativeTransformation;

}

std::string& SceneNode::GetName()

{

return m_sName;

}

void SceneNode::SetName(const std::string& sName)

{

m_sName = sName;

}

D3DXVECTOR3& SceneNode::GetScale()

{

return m_RelativeScale;

}

void SceneNode::SetScale(float x, float y, float z)

{

m_RelativeScale = D3DXVECTOR3(x, y, z);

UpdateRelativeTransformation();

}

D3DXVECTOR3& SceneNode::GetRotation()

{

return m_RelativeRotation;

}

void SceneNode::SetRotation(float x, float y, float z)

{

m_RelativeRotation = D3DXVECTOR3(x, y, z);

UpdateRelativeTransformation();

}

void SceneNode::AddChild(SceneNode* pChild)

{

if (pChild && (pChild != this))

{

pChild->RemoveParent();

m_children.push_back(pChild);

pChild->SetParent(this);

MeshSceneNode* pChildSceneNode = dynamic_cast<MeshSceneNode*>(pChild);

if (typeid(pChildSceneNode) == typeid(MeshSceneNode*))

{

SCENE_MANAGER->AddSceneNode(pChildSceneNode);

}

void SceneNode::RemoveChild(SceneNode* pChild)

{

for (auto it = m_children.begin(); it != m_children.end(); it++)

{

SceneNode* pCurrentChild = *it;

if (pCurrentChild == pChild)

{

pCurrentChild->RemoveParent();

m_children.erase(it);

}

void SceneNode::RemoveAll()

{

for (auto it = m_children.begin(); it != m_children.end(); it++)

{

SceneNode* pCurrentChild = *it;

m_children.erase(it);

}

m_children.clear();

}

void SceneNode::SetParent(SceneNode* pSceneNode)

{

Remove();

m_pParent = pSceneNode;

}

SceneNode* SceneNode::GetParent()

{

return m_pParent;

}

void SceneNode::RemoveParent()

{

m_pParent = nullptr;

}

void SceneNode::Remove()

{

if (m_pParent)

{

m_pParent->RemoveChild(this);

}

std::vector<SceneNode*> SceneNode::GetChildren()

{

return m_children;

}

D3DXVECTOR3 SceneNode::GetAbsolutePosition()

{

D3DXVECTOR3 absolutePosition;

absolutePosition.x = m_AbsoluteTransformation._12;

absolutePosition.y = m_AbsoluteTransformation._13;

absolutePosition.z = m_AbsoluteTransformation._14;

return absolutePosition;

}

Résumé :

Nous avons présenté une classe pour gérer les positions, rotations et d’agrandissement de vos entités.

Références :

– Code source d’Irrlicht 3D

Ajouter un fichier ressource Win32 dans votre exécutable

Intro :

Dans un exécutable Windows, on peut stocker plusieurs fichiers. Ces fichiers en question s’appellent des « ressources ».

Prérequis :

– Savoir lire du C++

– Savoir se servir de Visual Studio C++

Explications :

Le fichier à intégrer peut-être de n’importe quel format !

On déclare ainsi dans le fichier de déclaration de ressource, la ressource en question, avec le patron de schéma suivant :

nameID typeID filename

1	nameID typeID filename

Ce contenu doit être mis dans un fichier ressource.h

Le nom du fichier « filename » spécifie le nom d’un fichier contenant des données binaires de la ressource. Le contenu du fichier est intégré dans la ressource spécifiée. A noter que les données doivent être proprement alignées pour récupération sur une autre architecture.

Les données peuvent être définies directement entre les accolades de la manière suivante :

nameID typeID { raw-data }

18 MYRES2
{
   "Here is an ANSI string\0",    // explicitly null-terminated
}

nameID typeID { raw-data }

18 MYRES2

{

"Here is an ANSI string\0", // explicitly null-terminated

}

Paramètres :

nameID : un unique nom ou une valeur de 16 bits en tout (unsigned integer) qui identifie la ressource

typeID : un unique nom (chaîne de caractères) ou un entier de 16 bits (unsigned integer) qui identifie le type de la ressource. Si un nombre est spécifié, il doit être supérieur à 255, les autres nombres sont réservés

filename : nom (chaîne de caractères) du fichier qui contient les données de la ressource. Ce nom doit correspondre à un fichier valide et existant, le nom du fichier doit être un chemin complet s’il n’est pas dans le répertoire courant

raw-data : données brutes consistant en plusieurs entiers ou chaînes de caractères

Résumé :

Nous avons présentée une méthode permettant d’intégrer des fichiers au sein de votre application C++. Il est aisé de récupérer leur contenu avec la fonction présentée ci-dessus.

Références :

– http://stackoverflow.com/questions/2933295/embed-text-file-in-a-resource-in-a-native-windows-application

– https://msdn.microsoft.com/en-us/library/aa381054(VS.85).aspx

Utilisez Doxygen pour documenter vos programme C++ en HTML

Intro :

La documentation d’un programme est une étape fondamentale dans sa compréhension.

Le programme Doxygen permet la générer automatiquement sous couvert d’alimenter le programme en commentaires de code !

Prérequis :

Explications :

Voici les tags à utiliser dans vos programmes en tant que commentaires :

\struct pour documenter une structure C.
\union pour documenter une union C.
\enum pour documenter un type énuméré.
\fn pour documenter une fonction.
\var pour documenter une variable / un typedef / un énuméré.
\def pour documenter un #define.
\typedef pour documenter la définition d’un type.
\file pour documenter un fichier.
\namespace pour documenter un namespace.
\package pour documenter un package Java.
\interface pour documenter une interface IDL.
\brief pour donner une description courte.
\class pour documenter une classe.
\param pour documenter un paramètre de fonction/méthode.
\warning pour attirer l’attention.
\author pour donner le nom de l’auteur.
\return pour documenter les valeurs de retour d’une méthode/fonction.
\see pour renvoyer le lecteur vers quelque chose (une fonction, une classe, un fichier…).
\throws pour documenter les exceptions possiblement levées.
\version pour donner le numéro de version.
\since pour faire une note de version (ex : disponible depuis…).
\exception pour documenter une exception.
\deprecated pour spécifier qu’une fonction/méthode/variable… n’est plus utilisée.
\li pour faire une puce.
\todo pour indiquer une opération restant « à faire ».
\fixme pour indiquer un code défectueux, « à réparer ».

Résumé :

Nous avons présenté le programme Doxygen qui vous permettra de documenter à la volée tout votre code !

Références :

– https://fr.wikipedia.org/wiki/Doxygen

– http://franckh.developpez.com/tutoriels/outils/doxygen/

– http://axiomcafe.fr/tutoriel-documenter-un-code-avec-doxygen

Charger vos fichiers shaders .fx en tant que ressources d’exécutable

Intro :

Il est méconnu que l’on puisse stocker des fichiers à l’intérieur d’un exécutable Win32. Ces fichiers, en l’occurrence, sont appelés ressources.

Prérequis :

– Savoir lire du C++

– Savoir utiliser la classe ShaderTechnique

– Comprendre comment intégrer une ressource à un exécutable

Explications :

Pour cela il faut utiliser la fonction DirectX 10.1 D3DX10CreateEffectFromResource(…)

Résumé :

Références :

Convertissez rapidement vos chaînes de caractères avec swscanf

Intro :

Parfois dans un programme on veut retranscrire rapidement un morceau de chaîne de caractères (en entrée) vers un autre type (en arrivée) que l’on souhaite.

Prérequis :

– Savoir lire du C++

– Être curieux !

Explications :

Pour se faire, on utilisera la fonction définie dans l’en-tête C++ nommée swscanf. Cette fonction lit les données d’une chaîne de caractère étendue et l’analyse selon un format spécifié. Le résultat est stocké dans un endroit spécifié dans les paramètres additionnels.

Le format de cette fonction est le suivant :

int swscanf (const wchar_t* ws, const wchar_t* format, ...);

1	int swscanf (const wchar_t* ws, const wchar_t* format, ...);

Paramètres :

– ws : une chaîne de caractère étendue / large (sur 32 bits) que la fonction se sert pour recevoir les données à traiter.

– format : contient une chaîne de caractères spécifiant le schéma / patron de la chaîne à analyser ; le format spécifié suit le même schéma que la fonction scanf.

– … : il s’agit des paramètres additionnels qui vont servir à stocker les valeurs sortantes.

Valeur de retour :

– La valeur de retour 0 indique qu’aucun champ n’a été assigné
– Retourne le nombre de champs qui sont correctement convertis et assignés

Exemple :

wchar_t sentence [] = L"Clément a 28 ans";
wchar_t str [20];
int i;

swscanf (sentence,L"%ls %*s %d",str,&i);
wprintf (L"%ls -> %d\n",str,i);

wchar_t sentence [] = L"Clément a 28 ans";

wchar_t str [20];

int i;

swscanf (sentence,L"%ls %*s %d",str,&i);

wprintf (L"%ls -> %d\n",str,i);

Affiche : Clément -> 28.

Résumé :

Attention, l’usage de cette fonction est assez lente.

Nous avons présenté une méthode pour convertir une chaîne formatée en entrée.

Références :

– http://www.cplusplus.com/reference/cwchar/swscanf/

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

Les exceptions

Intro :

Les exceptions, en C++, sont un moyen de gérer les erreurs dans les programmes.

Prérequis :

– Savoir lire du C++

Explications :

Pour expliquer rapidement, une exception est une situation donnée dans laquelle un programme, qui dans une circonstance particulière, lance une erreur.

Chaque exception lancée dans le programme doit être traitée, sinon le programme se termine et génère une erreur fatale.

L’apparition d’une exception interrompt l’exécution normale du programme et provoque sa reprise dans le gestionnaire d’exception le plus proche.

Elles sont déclenchées grâce à l’utilisation du mot-clé throw.

Il est conseillé de dériver chaque exception par celle std::exception (en tête ).

Cette classe dispose d’une fonction membre what() qui renvoie une description de l’exception.

On rattrape les exception par référence, on les envoie par valeur.

Exemple d’exception :

#include <iostream>
#include <stdexcept>

void UneFonction()
{
    // [...]
    throw std::runtime_error("Une erreur s'est lancée !");
    // [...]
}

int main()
{
    try
    {
        UneFonction();
    }
    catch (const std::exception& e)
    {
        std::cerr << e.what() << std::endl;
    }
    catch (...) // traite toutes les autres exceptions
    {
        std::cerr << "Erreur inconnue.\n";
    }
}

#include <iostream>

#include <stdexcept>

void UneFonction()

{

// [...]

throw std::runtime_error("Une erreur s'est lancée !");

// [...]

}

int main()

{

try

{

UneFonction();

}

catch (const std::exception& e)

{

std::cerr << e.what() << std::endl;

}

catch (...) // traite toutes les autres exceptions

{

std::cerr << "Erreur inconnue.\n";

}

Il existe une fonction qui permet de personnaliser la fonction d’appel lors d’une exception non gérée ou traitée : set_terminate(…)

A noter qu’on peut coupler le concept du RAII avec les exceptions (voir l’article)

Résumé :

Les exceptions offre un moyen très rapide et élégant de gérer les erreurs dans les programmes.

Références :

– http://guillaume.belz.free.fr/doku.php?id=pourquoi_le_raii_est_fondamental_en_c

– http://cpp.developpez.com/faq/cpp/?page=Utilisation-des-exceptions#Qu-est-ce-qu-une-exception

Une eau semi réaliste de type I

Intro :

Dans un jeu vidéo, on a souvent besoin de représenter une eau réaliste par un effet de shader spécifique.

Cet article représente le premier essai d’une eau réaliste (type I).

Explications :

Résumé :

Références :

Une classe TextureScreenQuad pour afficher vos effets shaders de Post-Traitement

Intro :

Dans un jeu, nous avons besoin d’afficher une texture / image qui prend la place de tout l’écran. Cette image peut être modifiée pour appliquer un rendu de post-effet avec un fichier shader .fx.

Explications :

Nous nous servons d’un tampon de vertices formant un carré ou d’un quad.

Voici le fichier TextureScreenQuad.h :

#ifndef TEXTURE_QUAD_H
#define TEXTURE_QUAD_H

#include <d3dx10.h>
#include <string>

#include "VertexDeclarations.h"
#include "Renderable.h"
#include "RenderTarget.h"
#include "MeshSceneNode.h"

class TextureScreenQuad : public MeshSceneNode
{
public:
    TextureScreenQuad();
    virtual ~TextureScreenQuad();

    bool Initialize();
    virtual void OnRender(float fTimeSinceLastFrame) override;

    void SetTransparency(float fValue);
    void SetColor(const D3DXCOLOR& color);
    void SetQuadSize(uint32 iWidth, uint32 iHeight);

    RenderTarget* GetRT();

    virtual bool SetShaderTechnique(ShaderTechnique* pShader) override;

protected:
    bool Update();

private:
    size_t m_iScreenWidth;
    size_t m_iScreenHeight;

    ID3D10ShaderResourceView* m_pTextureRessourceView;

    float m_fAlpha;

    PTVertex m_aQuadVertices[6];

    RenderTarget* m_pRT;
    D3DXCOLOR m_Color;
};

#endif

#ifndef TEXTURE_QUAD_H

#define TEXTURE_QUAD_H

#include <d3dx10.h>

#include <string>

#include "VertexDeclarations.h"

#include "Renderable.h"

#include "RenderTarget.h"

#include "MeshSceneNode.h"

class TextureScreenQuad : public MeshSceneNode

{

public:

TextureScreenQuad();

virtual ~TextureScreenQuad();

bool Initialize();

virtual void OnRender(float fTimeSinceLastFrame) override;

void SetTransparency(float fValue);

void SetColor(const D3DXCOLOR& color);

void SetQuadSize(uint32 iWidth, uint32 iHeight);

RenderTarget* GetRT();

virtual bool SetShaderTechnique(ShaderTechnique* pShader) override;

protected:

bool Update();

private:

size_t m_iScreenWidth;

size_t m_iScreenHeight;

ID3D10ShaderResourceView* m_pTextureRessourceView;

float m_fAlpha;

PTVertex m_aQuadVertices[6];

RenderTarget* m_pRT;

D3DXCOLOR m_Color;

};

#endif

Voici le fichier TextureScreenQuad.cpp :

#include "TextureScreenQuad.h"
#include "Defines.h"
#include "D3D10Renderer.h"
#include "ShaderTechnique.h"
#include "ShaderTechnique_Declarations.h"

TextureScreenQuad::TextureScreenQuad() :
MeshSceneNode("TextureScreenQuad"),
m_fAlpha(1.0f),
m_pRT(nullptr)
{
    ZeroMemory(&m_aQuadVertices, sizeof(PTVertex) * 6);
    SetDrawMethod(DRAW_INDEXED);
    SetVertexType(VertexLayoutType::PT_VERTEX);
}

TextureScreenQuad::~TextureScreenQuad()
{
    SAFE_RELEASE(m_pTextureRessourceView);
}

bool TextureScreenQuad::Initialize()
{
    m_iScreenWidth = D3D10_RENDERER->GetViewportWidth();
    m_iScreenHeight = D3D10_RENDERER->GetViewportHeight();

    if (!Update())
    {
        MessageBoxA(nullptr, "Erreur d'initialisation d'un TextureScreenQuad !", "Erreur", MB_ICONHAND | MB_OK);
    }

    return true;
}

void TextureScreenQuad::SetTransparency(float fValue)
{
    m_Color.a = fValue;

    if (GetShaderTechnique() != nullptr)
    {
        GetShaderTechnique()->SetColor("Color", m_Color);
    }
}

void TextureScreenQuad::SetColor(const D3DXCOLOR& color)
{
    m_Color = color;
    
    if (GetShaderTechnique() != nullptr)
    {
        GetShaderTechnique()->SetColor("Color", m_Color);
    }
}

void TextureScreenQuad::OnRender(float fTimeSinceLastFrame)
{
    if (IsVisible())
    {
        D3D10_RENDERER->EnableZBuffer(false);

            Renderable::OnRender(fTimeSinceLastFrame);

        D3D10_RENDERER->EnableZBuffer(true);
    }
}

bool TextureScreenQuad::Update()
{
    float left, right, top, bottom;

    left = (float) -m_iScreenWidth / 2;
    right = left + (float) m_iScreenWidth;

    top = (float) -m_iScreenHeight / 2;
    bottom = top + (float) m_iScreenHeight;

    // Premier triangle
    m_aQuadVertices[0].pos = D3DXVECTOR3(left, top, 0.0f);  // Top left.
    m_aQuadVertices[0].texture = D3DXVECTOR2(0.0f, 0.0f);

    m_aQuadVertices[1].pos = D3DXVECTOR3(right, bottom, 0.0f);  // Bottom right.
    m_aQuadVertices[1].texture = D3DXVECTOR2(1.0f, 1.0f);

    m_aQuadVertices[2].pos = D3DXVECTOR3(left, bottom, 0.0f);  // Bottom left.
    m_aQuadVertices[2].texture = D3DXVECTOR2(0.0f, 1.0f);

    // Deuxième triangle
    m_aQuadVertices[3].pos = D3DXVECTOR3(left, top, 0.0f);  // Top left.
    m_aQuadVertices[3].texture = D3DXVECTOR2(0.0f, 0.0f);

    m_aQuadVertices[4].pos = D3DXVECTOR3(right, top, 0.0f);  // Top right.
    m_aQuadVertices[4].texture = D3DXVECTOR2(1.0f, 0.0f);

    m_aQuadVertices[5].pos = D3DXVECTOR3(right, bottom, 0.0f);  // Bottom right.
    m_aQuadVertices[5].texture = D3DXVECTOR2(1.0f, 1.0f);

    // On déclare les tableaux
    std::vector<PTVertex> vertices;
    // On reset les emplacements
    vertices.resize(6);
    // On affecte les valeurs
    std::copy(m_aQuadVertices, m_aQuadVertices + 6, vertices.begin());

    unsigned short i[6] = { 0, 1, 2, 3, 4, 5 };

    // On déclare les tableaux
    std::vector<unsigned short> indices;
    // On reset les emplacements
    indices.resize(6);
    // On affecte les valeurs
    std::copy(i, i + 6, indices.begin());

    BuildMesh(vertices, indices);

    return true;
}

void TextureScreenQuad::SetQuadSize(size_t iWidth, size_t iHeight)
{
    m_iScreenWidth = iWidth;
    m_iScreenHeight = iHeight;

    Update();
}

RenderTarget* TextureScreenQuad::GetRT()
{
    return m_pRT;
}

bool TextureScreenQuad::SetShaderTechnique(ShaderTechnique* pShader)
{
    bool bSuccess = Renderable::SetShaderTechnique(pShader);

    if (m_pRT == nullptr)
    {
        m_pRT = new RenderTarget();
        m_pRT->Initialize(m_iScreenWidth, m_iScreenHeight);

        ShaderTechnique_FXAA* pFXAA = dynamic_cast<ShaderTechnique_FXAA*> (GetShaderTechnique());
        pFXAA->SetRenderTarget(m_pRT);

        SetColor(D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f));
    }

    return bSuccess;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

#include "TextureScreenQuad.h"

#include "Defines.h"

#include "D3D10Renderer.h"

#include "ShaderTechnique.h"

#include "ShaderTechnique_Declarations.h"

TextureScreenQuad::TextureScreenQuad() :

MeshSceneNode("TextureScreenQuad"),

m_fAlpha(1.0f),

m_pRT(nullptr)

{

ZeroMemory(&m_aQuadVertices, sizeof(PTVertex) * 6);

SetDrawMethod(DRAW_INDEXED);

SetVertexType(VertexLayoutType::PT_VERTEX);

}

TextureScreenQuad::~TextureScreenQuad()

{

SAFE_RELEASE(m_pTextureRessourceView);

}

bool TextureScreenQuad::Initialize()

{

m_iScreenWidth = D3D10_RENDERER->GetViewportWidth();

m_iScreenHeight = D3D10_RENDERER->GetViewportHeight();

if (!Update())

{

MessageBoxA(nullptr, "Erreur d'initialisation d'un TextureScreenQuad !", "Erreur", MB_ICONHAND | MB_OK);

}

return true;

}

void TextureScreenQuad::SetTransparency(float fValue)

{

m_Color.a = fValue;

if (GetShaderTechnique() != nullptr)

{

GetShaderTechnique()->SetColor("Color", m_Color);

}

void TextureScreenQuad::SetColor(const D3DXCOLOR& color)

{

m_Color = color;

if (GetShaderTechnique() != nullptr)

{

GetShaderTechnique()->SetColor("Color", m_Color);

}

void TextureScreenQuad::OnRender(float fTimeSinceLastFrame)

{

if (IsVisible())

{

D3D10_RENDERER->EnableZBuffer(false);

Renderable::OnRender(fTimeSinceLastFrame);

D3D10_RENDERER->EnableZBuffer(true);

}

bool TextureScreenQuad::Update()

{

float left, right, top, bottom;

left = (float) -m_iScreenWidth / 2;

right = left + (float) m_iScreenWidth;

top = (float) -m_iScreenHeight / 2;

bottom = top + (float) m_iScreenHeight;

// Premier triangle

m_aQuadVertices[0].pos = D3DXVECTOR3(left, top, 0.0f); // Top left.

m_aQuadVertices[0].texture = D3DXVECTOR2(0.0f, 0.0f);

m_aQuadVertices[1].pos = D3DXVECTOR3(right, bottom, 0.0f); // Bottom right.

m_aQuadVertices[1].texture = D3DXVECTOR2(1.0f, 1.0f);

m_aQuadVertices[2].pos = D3DXVECTOR3(left, bottom, 0.0f); // Bottom left.

m_aQuadVertices[2].texture = D3DXVECTOR2(0.0f, 1.0f);

// Deuxième triangle

m_aQuadVertices[3].pos = D3DXVECTOR3(left, top, 0.0f); // Top left.

m_aQuadVertices[3].texture = D3DXVECTOR2(0.0f, 0.0f);

m_aQuadVertices[4].pos = D3DXVECTOR3(right, top, 0.0f); // Top right.

m_aQuadVertices[4].texture = D3DXVECTOR2(1.0f, 0.0f);

m_aQuadVertices[5].pos = D3DXVECTOR3(right, bottom, 0.0f); // Bottom right.

m_aQuadVertices[5].texture = D3DXVECTOR2(1.0f, 1.0f);

// On déclare les tableaux

std::vector<PTVertex> vertices;

// On reset les emplacements

vertices.resize(6);

// On affecte les valeurs

std::copy(m_aQuadVertices, m_aQuadVertices + 6, vertices.begin());

unsigned short i[6] = { 0, 1, 2, 3, 4, 5 };

// On déclare les tableaux

std::vector<unsigned short> indices;

// On reset les emplacements

indices.resize(6);

// On affecte les valeurs

std::copy(i, i + 6, indices.begin());

BuildMesh(vertices, indices);

return true;

}

void TextureScreenQuad::SetQuadSize(size_t iWidth, size_t iHeight)

{

m_iScreenWidth = iWidth;

m_iScreenHeight = iHeight;

Update();

}

RenderTarget* TextureScreenQuad::GetRT()

{

return m_pRT;

}

bool TextureScreenQuad::SetShaderTechnique(ShaderTechnique* pShader)

{

bool bSuccess = Renderable::SetShaderTechnique(pShader);

if (m_pRT == nullptr)

{

m_pRT = new RenderTarget();

m_pRT->Initialize(m_iScreenWidth, m_iScreenHeight);

ShaderTechnique_FXAA* pFXAA = dynamic_cast<ShaderTechnique_FXAA*> (GetShaderTechnique());

pFXAA->SetRenderTarget(m_pRT);

SetColor(D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f));

}

return bSuccess;

}

Résumé :

Nous avons présenté une façon d’utiliser un Quad de de post-traitement afin de modifier les couleurs de rendu du front buffer.

Références :

– Stackoverflow.com

Une classe RenderTarget pour afficher un tampon d’image de rendu

Intro :

Nous avons parfois besoin de stocker le rendu 3D dans une texture que l’on pourra utiliser n’importe tout dans le programme !

Explications :

Voici le fichier RenderToTexture.h :

#ifndef RENDER_TO_TEXTURE_H
#define RENDER_TO_TEXTURE_H

#include <d3d10.h>
#include "Types.h"

class RenderTarget
{
public:
    RenderTarget();
    virtual ~RenderTarget();

    bool Initialize(uint32 iTextureWidth, uint32 iTextureHeight);

    void SetRenderTarget(ID3D10DepthStencilView* pDepthStencilView);
    void ClearRenderTarget(ID3D10DepthStencilView* pDepthStencilView);

    ID3D10ShaderResourceView* GetShaderResourceView();

private:
    ID3D10Texture2D* m_pRenderTargetTexture;
    ID3D10RenderTargetView* m_pRenderTargetView;
    ID3D10ShaderResourceView* m_pShaderResourceView;
};

#endif

#ifndef RENDER_TO_TEXTURE_H

#define RENDER_TO_TEXTURE_H

#include <d3d10.h>

#include "Types.h"

class RenderTarget

{

public:

RenderTarget();

virtual ~RenderTarget();

bool Initialize(uint32 iTextureWidth, uint32 iTextureHeight);

void SetRenderTarget(ID3D10DepthStencilView* pDepthStencilView);

void ClearRenderTarget(ID3D10DepthStencilView* pDepthStencilView);

ID3D10ShaderResourceView* GetShaderResourceView();

private:

ID3D10Texture2D* m_pRenderTargetTexture;

ID3D10RenderTargetView* m_pRenderTargetView;

ID3D10ShaderResourceView* m_pShaderResourceView;

};

#endif

Voici le fichier RenderToTexture.cpp :

#include "Defines.h"
#include "RenderTarget.h"
#include "D3D10Renderer.h"

RenderTarget::RenderTarget() :
m_pRenderTargetTexture(nullptr),
m_pRenderTargetView(nullptr),
m_pShaderResourceView(nullptr)
{
}

RenderTarget::~RenderTarget()
{
    SAFE_RELEASE(m_pRenderTargetTexture);
    SAFE_RELEASE(m_pRenderTargetView);
    SAFE_RELEASE(m_pShaderResourceView);
}

bool RenderTarget::Initialize(uint32 iTextureWidth, uint32 iTextureHeight)
{
    /* On créé les descriptions de texture 2D, de la render target et de la ressource du shader */
    D3D10_TEXTURE2D_DESC textureDesc;
    D3D10_RENDER_TARGET_VIEW_DESC renderTargetViewDesc;
    D3D10_SHADER_RESOURCE_VIEW_DESC shaderResourceViewDesc;

    HRESULT hr;
    // Initialize the render target texture description.
    ZeroMemory(&textureDesc, sizeof(textureDesc));

    // Setup the render target texture description.
    textureDesc.Width = iTextureWidth;
    textureDesc.Height = iTextureHeight;
    textureDesc.MipLevels = 1;
    textureDesc.ArraySize = 1;
    textureDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
    textureDesc.SampleDesc.Count = 1;
    textureDesc.Usage = D3D10_USAGE_DEFAULT;
    textureDesc.BindFlags = D3D10_BIND_RENDER_TARGET | D3D10_BIND_SHADER_RESOURCE;
    textureDesc.CPUAccessFlags = 0;
    textureDesc.MiscFlags = 0;

    // Create the render target texture.
    hr = D3D10_RENDERER->GetDevice()->CreateTexture2D(&textureDesc, NULL, &m_pRenderTargetTexture);
    if (FAILED(hr))
    {
        return false;
    }

    // Setup the description of the render target view.
    renderTargetViewDesc.Format = textureDesc.Format;
    renderTargetViewDesc.ViewDimension = D3D10_RTV_DIMENSION_TEXTURE2D;
    renderTargetViewDesc.Texture2D.MipSlice = 0;

    // Create the render target view.
    hr = D3D10_RENDERER->GetDevice()->CreateRenderTargetView(m_pRenderTargetTexture, &renderTargetViewDesc, &m_pRenderTargetView);
    if (FAILED(hr))
    {
        return false;
    }

    // Setup the description of the shader resource view.
    shaderResourceViewDesc.Format = textureDesc.Format;
    shaderResourceViewDesc.ViewDimension = D3D10_SRV_DIMENSION_TEXTURE2D;
    shaderResourceViewDesc.Texture2D.MostDetailedMip = 0;
    shaderResourceViewDesc.Texture2D.MipLevels = 1;

    // Create the shader resource view.
    hr = D3D10_RENDERER->GetDevice()->CreateShaderResourceView(m_pRenderTargetTexture, &shaderResourceViewDesc, &m_pShaderResourceView);
    if (FAILED(hr))
    {
        return false;
    }

    return true;
}

void RenderTarget::SetRenderTarget(ID3D10DepthStencilView* pDepthStencilView)
{
    D3D10_RENDERER->GetDevice()->OMSetRenderTargets(1, &m_pRenderTargetView, pDepthStencilView);
}

void RenderTarget::ClearRenderTarget(ID3D10DepthStencilView* pDepthStencilView)
{
    float color[4] = { 1.0f, 1.0f, 1.0f, 1.0f };

    // On efface le back buffer
    D3D10_RENDERER->GetDevice()->ClearRenderTargetView(m_pRenderTargetView, color);

    // On efface le depth buffer
    D3D10_RENDERER->GetDevice()->ClearDepthStencilView(pDepthStencilView, D3D10_CLEAR_DEPTH, 1.0f, 0);
}

ID3D10ShaderResourceView* RenderTarget::GetShaderResourceView()
{
    return m_pShaderResourceView;
}

#include "Defines.h"

#include "RenderTarget.h"

#include "D3D10Renderer.h"

RenderTarget::RenderTarget() :

m_pRenderTargetTexture(nullptr),

m_pRenderTargetView(nullptr),

m_pShaderResourceView(nullptr)

{

}

RenderTarget::~RenderTarget()

{

SAFE_RELEASE(m_pRenderTargetTexture);

SAFE_RELEASE(m_pRenderTargetView);

SAFE_RELEASE(m_pShaderResourceView);

}

bool RenderTarget::Initialize(uint32 iTextureWidth, uint32 iTextureHeight)

{

/* On créé les descriptions de texture 2D, de la render target et de la ressource du shader */

D3D10_TEXTURE2D_DESC textureDesc;

D3D10_RENDER_TARGET_VIEW_DESC renderTargetViewDesc;

D3D10_SHADER_RESOURCE_VIEW_DESC shaderResourceViewDesc;

HRESULT hr;

// Initialize the render target texture description.

ZeroMemory(&textureDesc, sizeof(textureDesc));

// Setup the render target texture description.

textureDesc.Width = iTextureWidth;

textureDesc.Height = iTextureHeight;

textureDesc.MipLevels = 1;

textureDesc.ArraySize = 1;

textureDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;

textureDesc.SampleDesc.Count = 1;

textureDesc.Usage = D3D10_USAGE_DEFAULT;

textureDesc.BindFlags = D3D10_BIND_RENDER_TARGET | D3D10_BIND_SHADER_RESOURCE;

textureDesc.CPUAccessFlags = 0;

textureDesc.MiscFlags = 0;

// Create the render target texture.

hr = D3D10_RENDERER->GetDevice()->CreateTexture2D(&textureDesc, NULL, &m_pRenderTargetTexture);

if (FAILED(hr))

{

return false;

}

// Setup the description of the render target view.

renderTargetViewDesc.Format = textureDesc.Format;

renderTargetViewDesc.ViewDimension = D3D10_RTV_DIMENSION_TEXTURE2D;

renderTargetViewDesc.Texture2D.MipSlice = 0;

// Create the render target view.

hr = D3D10_RENDERER->GetDevice()->CreateRenderTargetView(m_pRenderTargetTexture, &renderTargetViewDesc, &m_pRenderTargetView);

if (FAILED(hr))

{

return false;

}

// Setup the description of the shader resource view.

shaderResourceViewDesc.Format = textureDesc.Format;

shaderResourceViewDesc.ViewDimension = D3D10_SRV_DIMENSION_TEXTURE2D;

shaderResourceViewDesc.Texture2D.MostDetailedMip = 0;

shaderResourceViewDesc.Texture2D.MipLevels = 1;

// Create the shader resource view.

hr = D3D10_RENDERER->GetDevice()->CreateShaderResourceView(m_pRenderTargetTexture, &shaderResourceViewDesc, &m_pShaderResourceView);

if (FAILED(hr))

{

return false;

}

return true;

}

void RenderTarget::SetRenderTarget(ID3D10DepthStencilView* pDepthStencilView)

{

D3D10_RENDERER->GetDevice()->OMSetRenderTargets(1, &m_pRenderTargetView, pDepthStencilView);

}

void RenderTarget::ClearRenderTarget(ID3D10DepthStencilView* pDepthStencilView)

{

float color[4] = { 1.0f, 1.0f, 1.0f, 1.0f };

// On efface le back buffer

D3D10_RENDERER->GetDevice()->ClearRenderTargetView(m_pRenderTargetView, color);

// On efface le depth buffer

D3D10_RENDERER->GetDevice()->ClearDepthStencilView(pDepthStencilView, D3D10_CLEAR_DEPTH, 1.0f, 0);

}

ID3D10ShaderResourceView* RenderTarget::GetShaderResourceView()

{

return m_pShaderResourceView;

}

Comment l’utiliser ?

void D3D10Renderer::Render()
{
    [...]
    
    // Efface la surface de rendu
    m_pd3dDevice->ClearDepthStencilView(m_pDepthStencilView, D3D10_CLEAR_DEPTH, 1.0f, 0 );
    m_pd3dDevice->ClearRenderTargetView(m_pRenderTargetView, afClearColor);

    SCENE_MANAGER->DrawAll(fTimeSinceLastFrame);

    RenderToTexture(fTimeSinceLastFrame);

    m_pQuad->OnRender(fTimeSinceLastFrame);

    m_pSwapChain->Present(0, 0);
}

void D3D10Renderer::RenderToTexture(float fTimeSinceLastFrame)
{
    // Set the render target to be the render to texture.
    m_pQuad->GetRT()->SetRenderTarget(m_pDepthStencilView);

    // Clear the render to texture.
    m_pQuad->GetRT()->ClearRenderTarget(m_pDepthStencilView);

    // Render the scene now and it will draw to the render to texture instead of the back buffer.
    SCENE_MANAGER->DrawAll(fTimeSinceLastFrame);

    // Reset the render target back to the original back buffer and not the render to texture anymore.
    m_pd3dDevice->OMSetRenderTargets(1, &m_pRenderTargetView, m_pDepthStencilView);
}

void D3D10Renderer::Render()

{

[...]

// Efface la surface de rendu

m_pd3dDevice->ClearDepthStencilView(m_pDepthStencilView, D3D10_CLEAR_DEPTH, 1.0f, 0 );

m_pd3dDevice->ClearRenderTargetView(m_pRenderTargetView, afClearColor);

SCENE_MANAGER->DrawAll(fTimeSinceLastFrame);

RenderToTexture(fTimeSinceLastFrame);

m_pQuad->OnRender(fTimeSinceLastFrame);

m_pSwapChain->Present(0, 0);

}

void D3D10Renderer::RenderToTexture(float fTimeSinceLastFrame)

{

// Set the render target to be the render to texture.

m_pQuad->GetRT()->SetRenderTarget(m_pDepthStencilView);

// Clear the render to texture.

m_pQuad->GetRT()->ClearRenderTarget(m_pDepthStencilView);

// Render the scene now and it will draw to the render to texture instead of the back buffer.

SCENE_MANAGER->DrawAll(fTimeSinceLastFrame);

// Reset the render target back to the original back buffer and not the render to texture anymore.

m_pd3dDevice->OMSetRenderTargets(1, &m_pRenderTargetView, m_pDepthStencilView);

}

Résumé :

Nous avons présenter la façon la plus optimale possible d’utiliser une RenderTarget !

Références :

L’anticrénelage FXAA – Shader de Post-Traitement

Intro:

Une image numérique est composée de pixels. Lorsqu’elle est redimensionnée, le bord des formes ayant un angle particulier prend la forme d’escalier : c’est le crénelage, ou aliasing.

Explication :

Voici une technique très efficace et très performante en ressource système afin d’effectuer du rendu anti-crénelage. Elle utilise une render target et un Quad de post-traitement.

Voici le fichier ShaderTechique_Declarations.h :

//------------------------------------------------------
// FXAA shader
//------------------------------------------------------
class ShaderTechnique_FXAA : public ShaderTechnique
{
public:
    ShaderTechnique_FXAA();
    virtual ~ShaderTechnique_FXAA();

    virtual bool Initialize() override;

    virtual void SetupShaderVariables();

    virtual void Update(float fTimeSinceLastFrame);

    void SetRenderTarget(RenderTarget* pRT);

    void SetEnabled(bool bEnabled);
    bool GetEnabled();

private:
    D3DXMATRIX m_WorldMatrix;
    D3DXMATRIX m_ViewMatrix;
    D3DXMATRIX m_OrthoMatrix;

    bool m_bEnabled;
};

//------------------------------------------------------

// FXAA shader

//------------------------------------------------------

class ShaderTechnique_FXAA : public ShaderTechnique

{

public:

ShaderTechnique_FXAA();

virtual ~ShaderTechnique_FXAA();

virtual bool Initialize() override;

virtual void SetupShaderVariables();

virtual void Update(float fTimeSinceLastFrame);

void SetRenderTarget(RenderTarget* pRT);

void SetEnabled(bool bEnabled);

bool GetEnabled();

private:

D3DXMATRIX m_WorldMatrix;

D3DXMATRIX m_ViewMatrix;

D3DXMATRIX m_OrthoMatrix;

bool m_bEnabled;

};

Voici le fichier ShaderTechnique_FXAA.cpp :

#include "ShaderTechnique_Declarations.h"
#include "Defines.h"
#include "D3D10Renderer.h"

ShaderTechnique_FXAA::ShaderTechnique_FXAA() :
ShaderTechnique("FXAA.fx", "Render", VertexLayoutType::PT_VERTEX),
m_bEnabled(true)
{
}

ShaderTechnique_FXAA::~ShaderTechnique_FXAA()
{
}

bool ShaderTechnique_FXAA::Initialize()
{
    if (ShaderTechnique::Initialize() == false)
    {
        return false;
    }

    SetupShaderVariables();

    return true;
}

void ShaderTechnique_FXAA::SetRenderTarget(RenderTarget* pRT)
{
    SetTextureRV("TextureDiffuse", pRT->GetShaderResourceView());
}

void ShaderTechnique_FXAA::SetupShaderVariables()
{
    RegisterMatrixVariable("World", ShaderVariableType::WORLD);
    RegisterMatrixVariable("View", ShaderVariableType::VIEW);
    RegisterMatrixVariable("Projection", ShaderVariableType::PROJECTION);
    RegisterTextureVariable("TextureDiffuse", ShaderVariableType::ANY);
    RegisterVectorVariable("FrameBufferSize", ShaderVariableType::ANY);
    RegisterVectorVariable("Color", ShaderVariableType::ANY);
    RegisterScalarVariable("Enabled", ShaderVariableType::ANY);

    D3DXMatrixIdentity(&m_WorldMatrix);
    D3DXMatrixIdentity(&m_ViewMatrix);
    D3DXMatrixIdentity(&m_OrthoMatrix);

    D3DXVECTOR3 Eye(0.0f, 0.0f, 1.0f);
    D3DXVECTOR3 At(0.0f, 0.0f, 0.0f);
    D3DXVECTOR3 Up(0.0f, 1.0f, 0.0f);

    D3DXMatrixLookAtLH(&m_ViewMatrix, &Eye, &At, &Up);

    float fViewportWidth = (float)D3D10_RENDERER->GetViewportWidth();
    float fViewportHeigth = (float)D3D10_RENDERER->GetViewportHeight();

    D3DXMatrixOrthoLH(&m_OrthoMatrix, fViewportWidth, fViewportHeigth, 0.01f, 20.0f);

    SetVector("FrameBufferSize", D3DXVECTOR2(fViewportWidth, fViewportHeigth));
}

void ShaderTechnique_FXAA::Update(float fTimeSinceLastFrame)
{
    SetMatrix("World", &m_WorldMatrix);
    SetMatrix("View", &m_ViewMatrix);
    SetMatrix("Projection", &m_OrthoMatrix);

    SetAutoMatrix(ShaderVariableType::ANY);
}

void ShaderTechnique_FXAA::SetEnabled(bool bEnabled)
{
    SetScalar("Enabled", bEnabled);
    m_bEnabled = bEnabled;
}

bool ShaderTechnique_FXAA::GetEnabled()
{
    return m_bEnabled;
}

#include "ShaderTechnique_Declarations.h"

#include "Defines.h"

#include "D3D10Renderer.h"

ShaderTechnique_FXAA::ShaderTechnique_FXAA() :

ShaderTechnique("FXAA.fx", "Render", VertexLayoutType::PT_VERTEX),

m_bEnabled(true)

{

}

ShaderTechnique_FXAA::~ShaderTechnique_FXAA()

{

}

bool ShaderTechnique_FXAA::Initialize()

{

if (ShaderTechnique::Initialize() == false)

{

return false;

}

SetupShaderVariables();

return true;

}

void ShaderTechnique_FXAA::SetRenderTarget(RenderTarget* pRT)

{

SetTextureRV("TextureDiffuse", pRT->GetShaderResourceView());

}

void ShaderTechnique_FXAA::SetupShaderVariables()

{

RegisterMatrixVariable("World", ShaderVariableType::WORLD);

RegisterMatrixVariable("View", ShaderVariableType::VIEW);

RegisterMatrixVariable("Projection", ShaderVariableType::PROJECTION);

RegisterTextureVariable("TextureDiffuse", ShaderVariableType::ANY);

RegisterVectorVariable("FrameBufferSize", ShaderVariableType::ANY);

RegisterVectorVariable("Color", ShaderVariableType::ANY);

RegisterScalarVariable("Enabled", ShaderVariableType::ANY);

D3DXMatrixIdentity(&m_WorldMatrix);

D3DXMatrixIdentity(&m_ViewMatrix);

D3DXMatrixIdentity(&m_OrthoMatrix);

D3DXVECTOR3 Eye(0.0f, 0.0f, 1.0f);

D3DXVECTOR3 At(0.0f, 0.0f, 0.0f);

D3DXVECTOR3 Up(0.0f, 1.0f, 0.0f);

D3DXMatrixLookAtLH(&m_ViewMatrix, &Eye, &At, &Up);

float fViewportWidth = (float)D3D10_RENDERER->GetViewportWidth();

float fViewportHeigth = (float)D3D10_RENDERER->GetViewportHeight();

D3DXMatrixOrthoLH(&m_OrthoMatrix, fViewportWidth, fViewportHeigth, 0.01f, 20.0f);

SetVector("FrameBufferSize", D3DXVECTOR2(fViewportWidth, fViewportHeigth));

}

void ShaderTechnique_FXAA::Update(float fTimeSinceLastFrame)

{

SetMatrix("World", &m_WorldMatrix);

SetMatrix("View", &m_ViewMatrix);

SetMatrix("Projection", &m_OrthoMatrix);

SetAutoMatrix(ShaderVariableType::ANY);

}

void ShaderTechnique_FXAA::SetEnabled(bool bEnabled)

{

SetScalar("Enabled", bEnabled);

m_bEnabled = bEnabled;

}

bool ShaderTechnique_FXAA::GetEnabled()

{

return m_bEnabled;

}

Voici les bouts de code pour initialiser le shader FXAA :

bool D3D10Renderer::Initialize(bool bFullscreen)
{
    [...]
    m_pQuad = new TextureScreenQuad();
    m_pQuad->Initialize();
    m_pQuad->SetShaderTechnique( SHADER_MANAGER->GetShader("FXAA") );
    [...]
}

void D3D10Renderer::Render()
{
    [...]
    // Efface la surface de rendu
    m_pd3dDevice->ClearDepthStencilView(m_pDepthStencilView, D3D10_CLEAR_DEPTH, 1.0f, 0 );
    m_pd3dDevice->ClearRenderTargetView(m_pRenderTargetView, afClearColor);

    SCENE_MANAGER->DrawAll(fTimeSinceLastFrame);

    DrawTextInfo();

    RenderToTexture(fTimeSinceLastFrame);

    UpdateWindowTitle();

    m_pQuad->OnRender(fTimeSinceLastFrame);

    m_pSwapChain->Present(0, 0);
    [...]
}

void D3D10Renderer::RenderToTexture(float fTimeSinceLastFrame)
{
    // Set the render target to be the render to texture.
    m_pQuad->GetRT()->SetRenderTarget(m_pDepthStencilView);

    // Clear the render to texture.
    m_pQuad->GetRT()->ClearRenderTarget(m_pDepthStencilView);

    // Render the scene now and it will draw to the render to texture instead of the back buffer.
    SCENE_MANAGER->DrawAll(fTimeSinceLastFrame);

    // Reset the render target back to the original back buffer and not the render to texture anymore.
    m_pd3dDevice->OMSetRenderTargets(1, &m_pRenderTargetView, m_pDepthStencilView);
}

bool D3D10Renderer::Initialize(bool bFullscreen)

{

[...]

m_pQuad = new TextureScreenQuad();

m_pQuad->Initialize();

m_pQuad->SetShaderTechnique( SHADER_MANAGER->GetShader("FXAA") );

[...]

}

void D3D10Renderer::Render()

{

[...]

// Efface la surface de rendu

m_pd3dDevice->ClearDepthStencilView(m_pDepthStencilView, D3D10_CLEAR_DEPTH, 1.0f, 0 );

m_pd3dDevice->ClearRenderTargetView(m_pRenderTargetView, afClearColor);

SCENE_MANAGER->DrawAll(fTimeSinceLastFrame);

DrawTextInfo();

RenderToTexture(fTimeSinceLastFrame);

UpdateWindowTitle();

m_pQuad->OnRender(fTimeSinceLastFrame);

m_pSwapChain->Present(0, 0);

[...]

}

void D3D10Renderer::RenderToTexture(float fTimeSinceLastFrame)

{

// Set the render target to be the render to texture.

m_pQuad->GetRT()->SetRenderTarget(m_pDepthStencilView);

// Clear the render to texture.

m_pQuad->GetRT()->ClearRenderTarget(m_pDepthStencilView);

// Render the scene now and it will draw to the render to texture instead of the back buffer.

SCENE_MANAGER->DrawAll(fTimeSinceLastFrame);

// Reset the render target back to the original back buffer and not the render to texture anymore.

m_pd3dDevice->OMSetRenderTargets(1, &m_pRenderTargetView, m_pDepthStencilView);

}

Voici le fichier shader .fx :

SamplerState SamplerLinear
{
    Filter = ANISOTROPIC;
    AddressU = Wrap;
    AddressV = Wrap;
    MaxAnisotropy = 1;
};

matrix World;
matrix View;
matrix Projection;

Texture2D TextureDiffuse;

float2 FrameBufferSize;

float4 Color;

bool Enabled;

struct VS_INPUT
{
    float4 Pos : POSITION;
    float2 Tex : TEXCOORD;
};
 
struct PS_INPUT
{
    float4 Pos : SV_POSITION;
    float2 Tex : TEXCOORD0;
};

PS_INPUT VS(VS_INPUT input)
{
    PS_INPUT output = (PS_INPUT)0;
     
    output.Pos = mul(input.Pos, World);
    output.Pos = mul(output.Pos, View);
    output.Pos = mul(output.Pos, Projection);
    output.Tex = input.Tex;
    
    return output;
}    

static const float FXAA_SPAN_MAX = 4.0;
static const float FXAA_REDUCE_MUL = 1.0/8.0;
static const float FXAA_REDUCE_MIN = 1.0/128.0;
    
float4 PS(PS_INPUT input) : SV_Target
{
    input.Tex = 1.0f - input.Tex;
    
    float3 rgbNW = TextureDiffuse.Sample(SamplerLinear, input.Tex + (float2(-1.0,-1.0) / FrameBufferSize)).xyz;
    float3 rgbNE = TextureDiffuse.Sample(SamplerLinear, input.Tex + (float2(1.0,-1.0) / FrameBufferSize)).xyz;
    float3 rgbSW = TextureDiffuse.Sample(SamplerLinear, input.Tex + (float2(-1.0,1.0) / FrameBufferSize)).xyz;
    float3 rgbSE = TextureDiffuse.Sample(SamplerLinear, input.Tex + (float2(1.0,1.0) / FrameBufferSize)).xyz;
    float3 rgbM  = TextureDiffuse.Sample(SamplerLinear, input.Tex).xyz;
    
    float3 luma = float3(0.299, 0.587, 0.114);
    
    float lumaNW = dot(rgbNW, luma);
    float lumaNE = dot(rgbNE, luma);
    float lumaSW = dot(rgbSW, luma);
    float lumaSE = dot(rgbSE, luma);
    float lumaM  = dot(rgbM, luma);
    
    float lumaMin = min(lumaM, min(min(lumaNW, lumaNE), min(lumaSW, lumaSE)));
    float lumaMax = max(lumaM, max(max(lumaNW, lumaNE), max(lumaSW, lumaSE)));
    
    float2 dir;
    dir.x = -((lumaNW + lumaNE) - (lumaSW + lumaSE));
    dir.y =  ((lumaNW + lumaSW) - (lumaNE + lumaSE));
    
    float dirReduce = max(
          (lumaNW + lumaNE + lumaSW + lumaSE) * (0.25 * FXAA_REDUCE_MUL),
           FXAA_REDUCE_MIN);
      
    float rcpDirMin = 1.0/(min(abs(dir.x), abs(dir.y)) + dirReduce);
    
    dir = min(float2( FXAA_SPAN_MAX,  FXAA_SPAN_MAX),
              max(float2(-FXAA_SPAN_MAX, -FXAA_SPAN_MAX),
              dir * rcpDirMin)) / FrameBufferSize;
            
    float3 rgbA = (1.0/2.0) * (
            TextureDiffuse.Sample(SamplerLinear, input.Tex + dir * (1.0/3.0 - 0.5)).xyz +
            TextureDiffuse.Sample(SamplerLinear, input.Tex + dir * (2.0/3.0 - 0.5)).xyz);
            
    float3 rgbB = rgbA * (1.0/2.0) + (1.0/4.0) * (
            TextureDiffuse.Sample(SamplerLinear, input.Tex + dir * (0.0/3.0 - 0.5)).xyz +
            TextureDiffuse.Sample(SamplerLinear, input.Tex + dir * (3.0/3.0 - 0.5)).xyz);
            
    float lumaB = dot(rgbB, luma);

    if (Enabled)
    {
        if ((lumaB < lumaMin) || (lumaB > lumaMax))
        {
            return float4(rgbA, 1.0f) * Color;
        }
        else
        {
            return float4(rgbB, 1.0f) * Color;
        }        
    }
    else
    {
        return TextureDiffuse.Sample(SamplerLinear, input.Tex);
    }
}

technique10 Render
{
    pass P0
    {
        SetVertexShader( CompileShader( vs_4_0, VS() ) );
        SetGeometryShader( NULL );
        SetPixelShader( CompileShader( ps_4_0, PS() ) );
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

SamplerState SamplerLinear

{

Filter = ANISOTROPIC;

AddressU = Wrap;

AddressV = Wrap;

MaxAnisotropy = 1;

};

matrix World;

matrix View;

matrix Projection;

Texture2D TextureDiffuse;

float2 FrameBufferSize;

float4 Color;

bool Enabled;

struct VS_INPUT

{

float4 Pos : POSITION;

float2 Tex : TEXCOORD;

};

struct PS_INPUT

{

float4 Pos : SV_POSITION;

float2 Tex : TEXCOORD0;

};

PS_INPUT VS(VS_INPUT input)

{

PS_INPUT output = (PS_INPUT)0;

output.Pos = mul(input.Pos, World);

output.Pos = mul(output.Pos, View);

output.Pos = mul(output.Pos, Projection);

output.Tex = input.Tex;

return output;

}

static const float FXAA_SPAN_MAX = 4.0;

static const float FXAA_REDUCE_MUL = 1.0/8.0;

static const float FXAA_REDUCE_MIN = 1.0/128.0;

float4 PS(PS_INPUT input) : SV_Target

{

input.Tex = 1.0f - input.Tex;

float3 rgbNW = TextureDiffuse.Sample(SamplerLinear, input.Tex + (float2(-1.0,-1.0) / FrameBufferSize)).xyz;

float3 rgbNE = TextureDiffuse.Sample(SamplerLinear, input.Tex + (float2(1.0,-1.0) / FrameBufferSize)).xyz;

float3 rgbSW = TextureDiffuse.Sample(SamplerLinear, input.Tex + (float2(-1.0,1.0) / FrameBufferSize)).xyz;

float3 rgbSE = TextureDiffuse.Sample(SamplerLinear, input.Tex + (float2(1.0,1.0) / FrameBufferSize)).xyz;

float3 rgbM = TextureDiffuse.Sample(SamplerLinear, input.Tex).xyz;

float3 luma = float3(0.299, 0.587, 0.114);

float lumaNW = dot(rgbNW, luma);

float lumaNE = dot(rgbNE, luma);

float lumaSW = dot(rgbSW, luma);

float lumaSE = dot(rgbSE, luma);

float lumaM = dot(rgbM, luma);

float lumaMin = min(lumaM, min(min(lumaNW, lumaNE), min(lumaSW, lumaSE)));

float lumaMax = max(lumaM, max(max(lumaNW, lumaNE), max(lumaSW, lumaSE)));

float2 dir;

dir.x = -((lumaNW + lumaNE) - (lumaSW + lumaSE));

dir.y = ((lumaNW + lumaSW) - (lumaNE + lumaSE));

float dirReduce = max(

(lumaNW + lumaNE + lumaSW + lumaSE) * (0.25 * FXAA_REDUCE_MUL),

FXAA_REDUCE_MIN);

float rcpDirMin = 1.0/(min(abs(dir.x), abs(dir.y)) + dirReduce);

dir = min(float2( FXAA_SPAN_MAX, FXAA_SPAN_MAX),

max(float2(-FXAA_SPAN_MAX, -FXAA_SPAN_MAX),

dir * rcpDirMin)) / FrameBufferSize;

float3 rgbA = (1.0/2.0) * (

TextureDiffuse.Sample(SamplerLinear, input.Tex + dir * (1.0/3.0 - 0.5)).xyz +

TextureDiffuse.Sample(SamplerLinear, input.Tex + dir * (2.0/3.0 - 0.5)).xyz);

float3 rgbB = rgbA * (1.0/2.0) + (1.0/4.0) * (

TextureDiffuse.Sample(SamplerLinear, input.Tex + dir * (0.0/3.0 - 0.5)).xyz +

TextureDiffuse.Sample(SamplerLinear, input.Tex + dir * (3.0/3.0 - 0.5)).xyz);

float lumaB = dot(rgbB, luma);

if (Enabled)

{

if ((lumaB < lumaMin) || (lumaB > lumaMax))

{

return float4(rgbA, 1.0f) * Color;

}

else

{

return float4(rgbB, 1.0f) * Color;

}

else

{

return TextureDiffuse.Sample(SamplerLinear, input.Tex);

}

technique10 Render

{

pass P0

{

SetVertexShader( CompileShader( vs_4_0, VS() ) );

SetGeometryShader( NULL );

SetPixelShader( CompileShader( ps_4_0, PS() ) );

}

Résumé :

Nous avons présenté une technique FXAA par un fichier shader .fx afin d’effectuer le rendu d’anti-crénélage.

Références :

– https://fr.wikipedia.org/wiki/Fast_approximate_anti-aliasing

– http://horde3d.org/wiki/index.php5?title=Shading_Technique_-_FXAA

Une classe DelayedTimerManager pour gérer les délais de temporisation

Intro :

Parfois nous avons besoin, dans le code, d’appeler des fonctions / méthodes à un certain intervalle de temps !

Prérequis :

– Savoir lire du C++

Explications :

Voici le fichier DelayedTimerManager.h :

#ifndef DELAYED_TIMER_MANAGER_H
#define DELAYED_TIMER_MANAGER_H

#include "Singleton.h"

#include <map>

class DelayedTimerManager : public Singleton<DelayedTimerManager>
{
public:
    struct TimerData
    {
        TimerData() : iElapsedTime(0), iLastTime(0), iWaitingTime(0)
        {
        }

        uint64 iElapsedTime;
        uint64 iLastTime;
        uint32 iWaitingTime;
    };

    DelayedTimerManager();
    virtual ~DelayedTimerManager();

    bool TimerWait(const std::string& sTimerName);

    void RegisterTimer(const std::string& sTimerName, uint32 iWaitingTime);
    void UpdateTimer(const std::string& sTimerName, uint32 iWaitingTime);

    void ResetTimer(const std::string& sTimerName);

private:
    std::map<std::string, TimerData> m_timers;
};

#endif

#ifndef DELAYED_TIMER_MANAGER_H

#define DELAYED_TIMER_MANAGER_H

#include "Singleton.h"

#include <map>

class DelayedTimerManager : public Singleton<DelayedTimerManager>

{

public:

struct TimerData

{

TimerData() : iElapsedTime(0), iLastTime(0), iWaitingTime(0)

{

}

uint64 iElapsedTime;

uint64 iLastTime;

uint32 iWaitingTime;

};

DelayedTimerManager();

virtual ~DelayedTimerManager();

bool TimerWait(const std::string& sTimerName);

void RegisterTimer(const std::string& sTimerName, uint32 iWaitingTime);

void UpdateTimer(const std::string& sTimerName, uint32 iWaitingTime);

void ResetTimer(const std::string& sTimerName);

private:

std::map<std::string, TimerData> m_timers;

};

#endif

Voici le contenu du fichier DelayedTimerManager.cpp :

#include "DelayedTimerManager.h"

#include <string>
#include <Windows.h>

template<> DelayedTimerManager* Singleton<DelayedTimerManager>::ms_instance = nullptr;

DelayedTimerManager::DelayedTimerManager()
{
}

DelayedTimerManager::~DelayedTimerManager()
{
}

bool DelayedTimerManager::TimerWait(const std::string& sTimerName)
{
    TimerData* pTimerData = &m_timers[sTimerName];

    uint32 iElapsedTime = GetTickCount() - pTimerData->iLastTime;
    uint32 iWaitingTime = pTimerData->iWaitingTime;

    if (iElapsedTime > iWaitingTime)
    {
        pTimerData->iLastTime = GetTickCount();    

        return true;
    }

    return false;
}

void DelayedTimerManager::RegisterTimer(const std::string& sTimerName, uint32 iWaitingTime)
{
    TimerData timerData;
    timerData.iWaitingTime = iWaitingTime;

    m_timers[sTimerName] = timerData;
}

void DelayedTimerManager::ResetTimer(const std::string& sTimerName)
{
    TimerData* pTimerData = &m_timers[sTimerName];

    pTimerData->iLastTime = 0;
}

void DelayedTimerManager::UpdateTimer(const std::string& sTimerName, uint32 iWaitingTime)
{
    TimerData* pTimerData = &m_timers[sTimerName];

    pTimerData->iWaitingTime = iWaitingTime;
}

#include "DelayedTimerManager.h"

#include <string>

#include <Windows.h>

template<> DelayedTimerManager* Singleton<DelayedTimerManager>::ms_instance = nullptr;

DelayedTimerManager::DelayedTimerManager()

{

}

DelayedTimerManager::~DelayedTimerManager()

{

}

bool DelayedTimerManager::TimerWait(const std::string& sTimerName)

{

TimerData* pTimerData = &m_timers[sTimerName];

uint32 iElapsedTime = GetTickCount() - pTimerData->iLastTime;

uint32 iWaitingTime = pTimerData->iWaitingTime;

if (iElapsedTime > iWaitingTime)

{

pTimerData->iLastTime = GetTickCount();

return true;

}

return false;

}

void DelayedTimerManager::RegisterTimer(const std::string& sTimerName, uint32 iWaitingTime)

{

TimerData timerData;

timerData.iWaitingTime = iWaitingTime;

m_timers[sTimerName] = timerData;

}

void DelayedTimerManager::ResetTimer(const std::string& sTimerName)

{

TimerData* pTimerData = &m_timers[sTimerName];

pTimerData->iLastTime = 0;

}

void DelayedTimerManager::UpdateTimer(const std::string& sTimerName, uint32 iWaitingTime)

{

TimerData* pTimerData = &m_timers[sTimerName];

pTimerData->iWaitingTime = iWaitingTime;

}

Résumé :

Nous avons présenter le code pour gérer un système de temporisation.

Blog de développement de jeux vidéo

Apprenez à programmer des jeux vidéos

Utilisation des Vertex Traits – décrire ses sommets en une seule fois

La technique du Normal Mapping (ou Bump Mapping)

La technique du Parallax Mapping

Le Compute Shader avec DirectX 11 (DirectCompute)

Utilisation des std::array en C++11

Utilisation de la librairie Zlib pour gérer des flux de compression

Apprendre à utiliser TinyXML pour charger vos fichiers XML

Comment calculer la matrice de rotation d’un Billboard

Décomposition de la matrice View :

La bibliothèque standard du C++ (la STL du C++11)

Une classe SceneNode pour représenter vos objets et entités dans la scène

Ajouter un fichier ressource Win32 dans votre exécutable

Utilisez Doxygen pour documenter vos programme C++ en HTML

Charger vos fichiers shaders .fx en tant que ressources d’exécutable

Convertissez rapidement vos chaînes de caractères avec swscanf

Les exceptions

Une eau semi réaliste de type I

Une classe TextureScreenQuad pour afficher vos effets shaders de Post-Traitement

Une classe RenderTarget pour afficher un tampon d’image de rendu

L’anticrénelage FXAA – Shader de Post-Traitement

Une classe DelayedTimerManager pour gérer les délais de temporisation