Archives de l’auteur : cezium

Les pointeurs intelligents

Intro :

Les pointeurs intelligents sont une extension des pointeurs bruts et ont été inventés afin d’éviter les fuites de mémoire.

Explications :

Le principe est qu’un pointeur intelligent encapsule un pointeur brut : le pointeur habituel et le muni d’un système de libération automatique de la mémoire. Il suit le principe RAII.

C’est principalement autour de la notion de « durée de vie » qu’un pointeur tient son utilité. En effet le pointeur intelligent opère sur les actions de création, de copie, de destruction, etc… d’un objet.

Dans la version du C++11 il existe trois types différents de pointeurs intelligents.

– unique_ptr, le pointeur ne peut pas être partagé (il ne peut y avoir qu’un seul propriétaire).
Il est préférable d’utiliser ce type de pointeur plutôt que l’ancien type de pointeur (d’avant C++11) : auto_ptr. En effet auto_ptr ne dispose pas d’un système de protection de la copie !

– shared_ptr, le pointeur peut être partagée par un système de comptage de référence.

L’idée est qu’un pointeur intelligent est automatiquement détruit lorsqu’il sort de portée du bout de code.

Voici les opérateurs surchargés d’un pointeur intelligent :

template <typename T>
class PointeurIntelligent
{
    T* operator->() const;
    T& operator*() const;
};

template <typename T>

class PointeurIntelligent

{

T* operator->() const;

T& operator*() const;

};

Exemple :

Une fonction retournant un pointeur : une fois retourné on ne sait pas où, quand et comment libérer la mémoire allouée par ce pointeur !

#include <memory>

Data* getData();

#include <memory>

Data* getData();

Mais depuis C++11, on peut utiliser un type le pointeur intelligent nommé unique_ptr comme suit :

#include <memory>

std::unique_ptr<Data> getData();

#include <memory>

std::unique_ptr<Data> getData();

Il sera détruit automatiquement à la fin de la portée du bloc de code ! Comme le pointeur brut est encapsulé dans l’objet unique_ptr<> : il sera aussi détruit avec. Une de ses particularité est qu’il a toujours un unique propriétaire. Mais la fonction std::move permet d’échanger celui-ci.

Un autre type de pointeur intelligent est le shared_ptr, il peut y être adjoint plusieurs références. Lorsque la dernière référence est disjointe, le pointeur est détruit !

#include <memory>

std::shared_ptr<Data> getData();

#include <memory>

std::shared_ptr<Data> getData();

Pour finir, il est important de noter que l’on peut créer un objet sur le tas en utilisant std::unique_ptr !!

Résumé :

Nous avons présenté le concept et les objets des pointeurs intelligents du C++11 !

Références :

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

– http://en.wikipedia.org/wiki/Smart_pointer

– http://www.informit.com/articles/article.aspx?p=2085179

Debugguez vos fichiers .FX avec l’interface ID3D10Blob

Intro :

Quand on compile un effet shader .fx, on a besoin de savoir où se situe l’erreur de compilation lorsque la compilation a échouée.

Explications :

Voici comment procéder avec le bout de code suivant :

#define ShowMessageBoxDXError(hr) char buf[2048]; \
       sprintf(buf, "Error: %s error description: %s\n", DXGetErrorStringA(hr), \
       DXGetErrorDescriptionA(hr)); \
       MessageBoxA(nullptr, buf, "Erreur", MB_ICONHAND | MB_OK);

DWORD dwShaderFlags = D3D10_SHADER_ENABLE_STRICTNESS;

#if defined( DEBUG ) || defined( _DEBUG )
// Permet d'afficher les éventuelles erreurs de la compilation d'un shader
dwShaderFlags |= D3D10_SHADER_DEBUG;
#endif

#define SAFE_RELEASE(x) if (x != nullptr) { x->Release(); x = nullptr; }

ID3D10Blob* pBlob = nullptr;
// Pour la création du shader, on le compile
HRESULT hr = D3DX10CreateEffectFromFile(L"Effet.fx", NULL, NULL, "fx_4_0", dwShaderFlags, 0,
                                D3D10_RENDERER->GetDevice(), NULL,
                                NULL, &m_pEffect, &pBlob, NULL);

if (FAILED(hr))
{
    if (pBlob)
    {
        // Affiche l'erreur de compilation du shader
        MessageBoxA(NULL, (PCSTR)pBlob->GetBufferPointer(), "Erreur dans le fichier shader", MB_ICONHAND | MB_OK);
    }
    else
    {
        ShowMessageBoxDXError(hr);
    }

    SAFE_RELEASE(pBlob);

    return false;
}

SAFE_RELEASE(pBlob);

#define ShowMessageBoxDXError(hr) char buf[2048]; \

sprintf(buf, "Error: %s error description: %s\n", DXGetErrorStringA(hr), \

DXGetErrorDescriptionA(hr)); \

MessageBoxA(nullptr, buf, "Erreur", MB_ICONHAND | MB_OK);

DWORD dwShaderFlags = D3D10_SHADER_ENABLE_STRICTNESS;

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

// Permet d'afficher les éventuelles erreurs de la compilation d'un shader

dwShaderFlags |= D3D10_SHADER_DEBUG;

#endif

#define SAFE_RELEASE(x) if (x != nullptr) { x->Release(); x = nullptr; }

ID3D10Blob* pBlob = nullptr;

// Pour la création du shader, on le compile

HRESULT hr = D3DX10CreateEffectFromFile(L"Effet.fx", NULL, NULL, "fx_4_0", dwShaderFlags, 0,

D3D10_RENDERER->GetDevice(), NULL,

NULL, &m_pEffect, &pBlob, NULL);

if (FAILED(hr))

{

if (pBlob)

{

// Affiche l'erreur de compilation du shader

MessageBoxA(NULL, (PCSTR)pBlob->GetBufferPointer(), "Erreur dans le fichier shader", MB_ICONHAND | MB_OK);

}

else

{

ShowMessageBoxDXError(hr);

}

SAFE_RELEASE(pBlob);

return false;

}

SAFE_RELEASE(pBlob);

Résumé :

On a expliqué comment procéder pour savoir et afficher où se situe l’erreur de compilation d’un fichier shader .fx.

Théorie sur les lumières

Intro :

Dans les jeux vidéo, la gestion du rendu des lumières est cruciale pour effectuer un rendu à la fois réaliste et joli.

Dans cet article nous allons présenter les rudiments de la théorie sur le rendu des lumières.

Le rendu lumineux est un sujet vaste et complexe et pour cause le sujet est encore soumis à des recherches académiques ou en R&D.

En effet, ces dernières années les jeux vidéos les plus récents affichent des rendus de lumière de plus en plus réalistes, en utilisant par exemple un type de rendu nommé Deferred Shading.

[éclater en plusieurs articles]

Prérequis :

– Savoir ce qu’est une normale

– Savoir lire du C++

– Savoir lire un programme shader HLSL

Explications :

Avant tout, éclaircissons un peu de vocabulaire.

Les deux notions qui suivent ont des propriétés de nature différente :

Les propriétés d’un matériau donnée (or, glace, bois, métal, etc…) déterminent comment un modèle est affiché :

– Emissive :

– ce terme désigne la valeur d’émission d’un matériau permettant d’émettre une couleur de lumière comme si elles avaient été toutes désactivées. Notée Ke.

– Ambient :

– ce terme désigne la valeur ambiante d’émission d’une lumière, comme le soleil.

– Diffuse :

– ce terme désigne la couleur diffuse qu’émet la lumière dans toutes les directions.

– Specular :

– Specular power :

– représente le degré d’éclat de brillance.

Les propriétés d’une lumière donnée déterminent comment la scène est affichée :

– Type de lumière :

– il y a 3 types de lumière :

Point : une lumière qui émet dans toutes les directions.

Spot : une lumière qui émet dans une direction spécifique.

Directional : une lumière qui a une direction donnée mais n’a pas de position donnée, comme par exemple le soleil.

– Color :

– la couleur de la source de lumière

– Position :

– définie la position de la lumière par trois valeurs de coordonnées

– Direction :

– définie la direction à laquelle pointe la lumière

Le but du calcul lumineux est de combiner ces deux catégories de propriétés afin déterminer la couleur finale de la lumière (avec ses nuances d’ombre).

Lumière ambiante :

La lumière ambiante désigne, comme son nom l’indique, une lumière qui éclaire dans toutes les directions. C’est comme un soleil qui illumine partout.

L’équation est toute simple :

Ip = pa * Ia

[utiliser ambient = Ka + Ga]

Ia désigne l’intensité de la lumière ; et pa le coefficient de réflexion de la lumière ambiante. Ip désigne l’intensité de la lumière résultant de la réflexion sur la surface finale.

Ce principe de calcul de la lumière illuminative est très rudimentaire car il n’affiche pas les ombres des modèles que font apparaître indirectement la lumière émissive.

[image lumière ambiante]

La réflexion diffuse :

Le principe de la réflexion diffuse consiste à considérer la position d’émission d’une lumière quelconque (ou plusieurs)

On a remarqué, mathématiquement, que l’intensité en un point de l’effet d’une lumière quelconque dépend de l’angle formé entre le rayon de lumière qui touche le point de la surface et la normale à la surface.

Il se trouve que, plus l’angle formé entre le rayon de lumière et la normale au plan est faible, plus l’intensité lumineuse réfléchie visible par l’observateur est forte.

[ajouter schéma dot product]

Types de calcul lumineux :

Résumé :

Références :

– http://irrlicht-fr.org/lire_tuto.php?id=1014

– https://takinginitiative.wordpress.com/2010/08/30/directx-10-tutorial-8-lighting-theory-and-hlsl/

– http://www.3dgep.com/texturing-lighting-directx-11/

– http://http.developer.nvidia.com/CgTutorial/cg_tutorial_chapter05.html

Nouveautés C++11

Intro :

Des changements ont été ajoutés dans la nouvelle version du C++ (nommée C++11).

Tous les mots-clés en liaison avec les changements sont représentés dans l’image de l’en-tête.

Explications :

Le mot-clé / constante nullptr :

– Il remplace l’ancien « #define NULL 0 » pour définir un pointeur nul.

Le mot-clé auto :

– Il identifie automatiquement le type de la variable correspondante en fonction de l’affectation décrite. Il permet de simplifier l’écriture du code.

Exemple :

for(auto i = nombres.begin() ; i != nombres.end() ; ++i)
{
&#xA0;&#xA0;&#xA0; std::cout &#x3C;&#x3C; (*i) &#x3C;&#x3C; std::endl;
}

for(auto i = nombres.begin() ; i != nombres.end() ; ++i)

{

    std::cout << (*i) << std::endl;

}

decltype :

– Permet de retrouver le type de l’objet lorsque l’on a utilisé le mot-clé auto.

Variadic templates :

– Permet d’utiliser un nombre variable de spécifications de classe sur les templates.

unique_ptr<> :

– Un pointeur intelligent possédant qu’un seul (et unique) propriétaire !

Initialisation des données membres non-statique :

– Les variables membres non-statiques peuvent être définit au sein même de la déclaration de la classe.

class UneClasse
{
public:
    UneClasse() {}
 
    int a = 7;
    int b = 5;
 
private:
    std::string s{"Une chaîne"};
};

class UneClasse

{

public:

UneClasse() {}

int a = 7;

int b = 5;

private:

std::string s{"Une chaîne"};

};

Alias de templates :

– On peut désormais utiliser le mot-clé « using » pour faire un alias à la place du classique typedef

Constructeurs délégués :

– Avec le C++11, un constructeur peut appeler un autre constructeur directement.

struct A
{
    A(int);
    A(): A(42) { } // délègue au constructeur A(int)
};

struct A

{

A(int);

A(): A(42) { } // délègue au constructeur A(int)

};

Range-based for :

– On peut parcourir un tableau, une liste, un vector, etc… avec une boucle simplifiée :

std::vector<double> v;

for (double d : v)
{
    std::cout << d << std::endl;
}

for (auto d : v)
{
    std::cout << d << std::endl;
}

for (auto& d : v)
{
    ++d;
}

for (auto const& d : v)
{
    ++d;
}

std::map<int, std::string> m;

for (auto element : m)
{
    printf("%d\n", element.first);
    printf("%s\n", element.second);
}

std::vector<double> v;

for (double d : v)

{

std::cout << d << std::endl;

}

for (auto d : v)

{

std::cout << d << std::endl;

}

for (auto& d : v)

{

++d;

}

for (auto const& d : v)

{

++d;

}

std::map<int, std::string> m;

for (auto element : m)

{

printf("%d\n", element.first);

printf("%s\n", element.second);

}

Les fonctions lambda :

– La syntaxe est : [ liste de capture ] ( paramètres ) retour { code }

Exemple :

[](int element) {
&nbsp;&nbsp;&nbsp; cout &lt;&lt; element &lt;&lt; endl;
}

[](int element) {

    cout << element << endl;

}

On peut passer une fonction anonyme à une variable :

std::function<int (int, int)> addition = [](int x, int y) -> int {
    return x + y;
};

std::function<int (int, int)> addition = [](int x, int y) -> int {

return x + y;

};

Les énumérations fortement typées :

Dorénavant les numérations peuvent être fortement typées ainsi :

// On rajoute le mot-cl&eacute; &quot;class&quot;
enum class Direction { Haut, Droite, Bas, Gauche }; // Se comporte comme des attributs !

//&nbsp; On est oblig&eacute; de sp&eacute;cifier la classe d&apos;origine &quot;Direction::&quot;
Direction direction = Direction::Haut;

// Pour afficher sa valeur enti&egrave;re on doit convertir :
std::cout &lt;&lt; static_cast&lt;int&gt;(direction) &lt;&lt; std::endl;

// On rajoute le mot-clé "class"

enum class Direction { Haut, Droite, Bas, Gauche }; // Se comporte comme des attributs !

//  On est obligé de spécifier la classe d'origine "Direction::"

Direction direction = Direction::Haut;

// Pour afficher sa valeur entière on doit convertir :

std::cout << static_cast<int>(direction) << std::endl;

Bug template corrigé :

// Avant :
std::vector<std::vector<int> > nombres;

// Après :
std::vector<std::vector<int>> nombres;

// Avant :

std::vector<std::vector<int> > nombres;

// Après :

std::vector<std::vector<int>> nombres;

Les listes d’initialisateurs :

std::vector<int> nombres = { 1, 2, 3, 4, 5 };
std::map<int, std::string> nombres = { { 1, "un" }, { 2, "deux" }, { 3, "trois" } };

1 2	std::vector<int> nombres = { 1, 2, 3, 4, 5 }; std::map<int, std::string> nombres = { { 1, "un" }, { 2, "deux" }, { 3, "trois" } };

Les tableaux à taille fixe :

std::array<int, 5> tableauFixe;

1	std::array<int, 5> tableauFixe;

Tuple :

Mémoire locale pour un thread :

– Avec le mot-clé std::thread_local, on peut spécifier une variable locale à un thread !

Sizeof sur les attributs de classes :

– On peut désormais savoir la taille qu’occupe un attribut d’une classe.

Références :

– http://cpp.developpez.com/redaction/data/pages/users/gbdivers/cpp11/

– http://fr.wikipedia.org/wiki/C%2B%2B11

– http://openclassrooms.com/courses/introduction-a-c-2011-c-0x

Mettre en surbrillance l’icone de la barre des tâches

Intro :

Parfois on a besoin de captiver l’attention du joueur lorsque l’application est minimisée, par exemple lorsque le joueur reçoit un message depuis la messagerie.

Pour cela l’icône dans la barre des tâches peut être mise en surbrillance lorsque l’application est minimisée.

Prérequis :

– Aucun

Explications :

void FlashWindow()
{   
    if (IsIconic(m_Hwnd))
    {
        DWORD now = timeGetTime();
        DWORD then = now;

        // C'est la fonction qui permet de mettre en surbrillance
        FlashWindow(m_Hwnd, true);
         
        while (true)
        {
            if (!IsIconic(m_Hwnd))
            {
                FlashWindow(m_Hwnd, false);
                break;
            }
            else
            {
                // On met en surbrillance l'icône périodiquement !
                now = timeGetTime();
                DWORD timeSpan = now > then ? (now - then) : (then - now);
                if (timeSpan > 1000)
                {
                    then = now;
                    FlashWindow(m_Hwnd, true);
                    break;
                }
            }
        }
    }
}

void FlashWindow()

{

if (IsIconic(m_Hwnd))

{

DWORD now = timeGetTime();

DWORD then = now;

// C'est la fonction qui permet de mettre en surbrillance

FlashWindow(m_Hwnd, true);

while (true)

{

if (!IsIconic(m_Hwnd))

{

FlashWindow(m_Hwnd, false);

break;

}

else

{

// On met en surbrillance l'icône périodiquement !

now = timeGetTime();

DWORD timeSpan = now > then ? (now - then) : (then - now);

if (timeSpan > 1000)

{

then = now;

FlashWindow(m_Hwnd, true);

break;

}

Résumé :

Nous avons appris comment mettre en surbrillance l’icône de votre application dans la barre des tâches.

Fonctions delegates avec std::function et std::bind

Intro :

Nous allons implémenter un système de delegates comme celles existantes en C#.

Tout d’abord qu’est-ce qu’une fonction anonyme (appelée aussi fonction lambda) ?
Une fonction anonyme est tout simplement une fonction qui n’a pas de nom et qui peut être définie à la volée.

Depuis la dernière version C++11 on peut définir des fonctions anonymes.

Dans ce tutoriel nous allons apprendre à utiliser deux objets de la STL que sont : std::function et std::bind.

A noter que je me suis servi de ces delegates pour implémenter le système d’Events de cet article.

Prérequis :

– Savoir un peu lire du C++.

– Disposer d’un compilateur compatible C++11.

Explications :

Une fonction anonyme peut être définie ainsi :

#include <functional>

// Définition d'une fonction anonyme
auto UneFonction = [](int i) -> double { return 2 * i; };

// Appel de cette fonction anonyme
double d = UneFonction(1);

#include <functional>

// Définition d'une fonction anonyme

auto UneFonction = [](int i) -> double { return 2 * i; };

// Appel de cette fonction anonyme

double d = UneFonction(1);

On place des crochets au début pour annoncer une fonction lambda.
Entre parenthèses on indique les paramètres.
Le type indiqué juste après la flèche indique le type de retour de la fonction.

L’objet std::function peut être affecté par une simple fonction ou par une fonction anonyme :

#include <functional>

// Une fonction toute simple
int my_func(int a, int b) { return a + b; }
 
// On peut affecter cette précédente fonction à un objet std::function
std::function<int (int, int)> f = my_func;

// On peut affecter directement une fonction anonyme
std::function<int (int)> UneFonction = [](int i) -> double { return 2 * i; };

#include <functional>

// Une fonction toute simple

int my_func(int a, int b) { return a + b; }

// On peut affecter cette précédente fonction à un objet std::function

std::function<int (int, int)> f = my_func;

// On peut affecter directement une fonction anonyme

std::function<int (int)> UneFonction = [](int i) -> double { return 2 * i; };

On met entre crochets : le type de retour et le type des paramètres entre parenthèses.

L’objet std::bind permet de lier un ou plusieurs paramètres de manière préétablis à un objet std::function :

#include &#x3C;functional&#x3E;
#include &#x3C;iostream&#x3E;

// Une fonction standard
void Afficher(std::string&#x26; texte)
{
    std::cout &#x3C;&#x3C; &#x22;TEXTE: &#x22; &#x3C;&#x3C; texte &#x3C;&#x3C; std::endl;
}

// On peut lier &#xE0; cette pr&#xE9;c&#xE9;dente fonction un param&#xE8;tre pr&#xE9;d&#xE9;fini
std::function &#x3C;void ()&#x3E; f = std::bind(Afficher, &#x22;Du texte !!&#x22;);

f(); // Affiche &#x22;TEXTE : Du texte !!&#x22;

#include <functional>

#include <iostream>

// Une fonction standard

void Afficher(std::string& texte)

{

std::cout << "TEXTE: " << texte << std::endl;

}

// On peut lier à cette précédente fonction un paramètre prédéfini

std::function <void ()> f = std::bind(Afficher, "Du texte !!");

f(); // Affiche "TEXTE : Du texte !!"

On peut faire spécifier ultérieurement un paramètre avec std::placeholder::_* :

#include &#x3C;functional&#x3E;
#include &#x3C;iostream&#x3E;
&#xA0;
int multiply(int a, int b)
{
&#xA0;&#xA0;&#xA0; return a * b;
}
&#xA0;
int main()
{
&#xA0;&#xA0;&#xA0; auto f = std::bind(multiply, 5, std::placeholders::_1);
&#xA0;&#xA0;&#xA0; for (int i = 0; i &#x3C; 10; i++)
&#xA0;&#xA0;&#xA0; {
&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;&#xA0;&#xA0; std::cout &#x3C;&#x3C; &#x22;5 * &#x22; &#x3C;&#x3C; i &#x3C;&#x3C; &#x22; = &#x22; &#x3C;&#x3C; f(i) &#x3C;&#x3C; std::endl;
&#xA0;&#xA0;&#xA0; }

&#xA0;&#xA0;&#xA0; return 0;
}

#include <functional>

#include <iostream>

int multiply(int a, int b)

{

    return a * b;

}

int main()

{

    auto f = std::bind(multiply, 5, std::placeholders::_1);

    for (int i = 0; i < 10; i++)

    {

        std::cout << "5 * " << i << " = " << f(i) << std::endl;

    }

    return 0;

}

On peut stocker des std::function dans un std::vector :

#include <functional>
#include <vector>

std::vector<std::function<double (int)>> fs;

auto UneFonction = [](int i) -> double { return 2 * i; };

fs.push_back(UneFonction);

// On peut invoquer ces fonctions par une boucle automatique
for (auto& f : fs)
{
    f();
}

#include <functional>

#include <vector>

std::vector<std::function<double (int)>> fs;

auto UneFonction = [](int i) -> double { return 2 * i; };

fs.push_back(UneFonction);

// On peut invoquer ces fonctions par une boucle automatique

for (auto& f : fs)

{

f();

}

Résumé :

Nous avons appris comment définir des fonctions delegates comme celle disponibles en C#.

Références :

– http://fr.cppreference.com/w/cpp/utility/functional/function

– http://fr.cppreference.com/w/cpp/utility/functional/bind

– http://oopscenities.net/2012/02/24/c11-stdfunction-and-stdbind/

– http://openclassrooms.com/courses/introduction-a-c-2011-c-0x

Un Performance Timer pour synchroniser vos entités

Intro :

Dans un jeu, il peut être utile de calculer le temps entre chaque affichage pour synchroniser la mise à jour de certaines entités.

En effet la vitesse de calcul fait par votre processeur peut rendre la vitesse de ces entités trop rapide.

Par exemple la vitesse de déplacement d’un modèle peut être plus rapide sur la machine d’un PC avec un processeur plus rapide que le vôtre, parce que la boucle de rendu est appelée plus fréquemment que chez vous.

Un mécanisme de calcul du temps passé entre chaque rendu d’affichage permet de pallier ce problème.

Prérequis :

– Savoir lire du C++.

Explications :

Nous allons utiliser la fonction QueryPerformanceCounter qui donne le temps présent en « count ».

#include <windows.h>

__int64 A = 0;
QueryPerformanceCounter((LARGE_INTEGER*)&A);

/* Instructions */

__int64 B = 0;
QueryPerformanceCounter((LARGE_INTEGER*)&B);

#include <windows.h>

__int64 A = 0;

QueryPerformanceCounter((LARGE_INTEGER*)&A);

/* Instructions */

__int64 B = 0;

QueryPerformanceCounter((LARGE_INTEGER*)&B);

On fait la soustraction : B – A, et on a le temps passé (en count) entre l’exécution de ces instructions !

D’autre part il nous faut le temps en seconde (et non en count !)

Dond avec la fonction QueryPerformanceFrequency on obtient le count par seconde.
On aura donc le temps escompté en seconde !

__int64 cntsPerSec = 0;
QueryPerformanceFrequency((LARGE_INTEGER*)&cntsPerSec);

1 2	__int64 cntsPerSec = 0; QueryPerformanceFrequency((LARGE_INTEGER*)&cntsPerSec);

Le nombre de secondes escompté en un count est calculé par :

// Secondes par count :
float secsPerCnt = 1.0f / (float)cntsPerSec;

// Temps en secondes :
valueInSecs = valueInCounts * secsPerCnt;

// Secondes par count :

float secsPerCnt = 1.0f / (float)cntsPerSec;

// Temps en secondes :

valueInSecs = valueInCounts * secsPerCnt;

Temps passé entre chaque affichage :

On peut calculer le temps passé entre chaque rendu d’affichage. Notons t le temps passé ;
et \(t _{i} \) le temps passé depuis le ième affichage et \(t _{i-1} \) le temps passé depuis le précédent affichage.

\(\Delta t = t _{i} { – } t_{i-1} \)

On calcule ainsi le temps passé entre chaque affichage. On utilise cette valeur de temps afin de synchroniser la mise à jour de nos entités dans la boucle de rendu :

void MaBoucleDeRendu()
{
    /* Instructions */
    
    __int64 currTimeStamp = 0;
    QueryPerformanceCounter((LARGE_INTEGER*)&currTimeStamp);
    
    float fTimeSinceLastFrame = (currTimeStamp - prevTimeStamp) * cntsPerSec;

    UpdateScene(fTimeSinceLastFrame);
    DrawScene();
    
    prevTimeStamp = currTimeStamp;
    
    /* Instructions */
}

void MaBoucleDeRendu()

{

/* Instructions */

__int64 currTimeStamp = 0;

QueryPerformanceCounter((LARGE_INTEGER*)&currTimeStamp);

float fTimeSinceLastFrame = (currTimeStamp - prevTimeStamp) * cntsPerSec;

UpdateScene(fTimeSinceLastFrame);

DrawScene();

prevTimeStamp = currTimeStamp;

/* Instructions */

}

Voici un exemple de mise à jour d’une entité en utilisant la valeur fTimeSinceLastFrame (toujours changeante) :

Résumé :

Nous avons vu de quelle façon synchroniser la mise à jour de vos entités de façon à ce qu’elles varient dans le temps à la même vitesse sur toutes les machines.

Génération procédurale d’un labyrinthe 3D

Intro :

La génération procédurale d’un contenu par un quelconque algorithme permet de le créer de manière intelligente !

Dans cet article nous allons voir comment générer à la volée un labyrinthe en 3D.

Prérequis :

– Savoir lire du C++.

– Savoir ce qu’est un vertex buffer et un index buffer.

– Savoir manipuler un tableau à deux dimensions.

Explications :

Nous allons utiliser une classe Array2D qui nous permettra de manipuler un tableau à deux dimensions.

Voilà le code pour ce tableau spécial et simple d’utilisation (Array2D.h) :

#ifndef ARRAY_2D_H
#define ARRAY_2D_H

// Classe pour gérer facilement un tableau à deux dimensions.
template<typename T>
class Array2D
{
public:
    // Constructeur.
    Array2D(int iWidth = 0, int iHeight = 0) :
    m_iWidth(iWidth),
    m_iHeight(iHeight),
    m_vArray(iWidth*iHeight)
    {
    }

    // Redimensionner.
    void resize(int iWidth, int iHeight)
    {
        m_iWidth = iWidth;
        m_iHeight = iHeight ;
        m_vArray.resize(iWidth*iHeight);
    }

    inline T& operator() (unsigned int x, unsigned int y)
    {
        assert(((y*m_iWidth) + x) < m_vArray.size());
        return m_vArray[ (y*m_iWidth) + x ];
    }

    inline T& operator[] (int pos)
    {
        return m_vArray[pos];
    }

    inline const T& operator() (unsigned int x, unsigned int y) const
    {
        assert(((y*m_iWidth) + x) < m_vArray.size());
        return m_vArray[ (y*m_iWidth) + x ];
    }

    inline const T& operator[] (int x) const
    {
        return m_vArray[pos];
    }   

    inline int getWidth() const { return m_iWidth; }
    inline int getHeight() const { return m_iHeight; }

private:
    int m_iWidth; // Largeur.
    int m_iHeight; // Hauteur.
    std::vector<T> m_vArray; // Le vecteur qui va servir de tableau à deux dimensions.
};

#endif

#ifndef ARRAY_2D_H

#define ARRAY_2D_H

// Classe pour gérer facilement un tableau à deux dimensions.

template<typename T>

class Array2D

{

public:

// Constructeur.

Array2D(int iWidth = 0, int iHeight = 0) :

m_iWidth(iWidth),

m_iHeight(iHeight),

m_vArray(iWidth*iHeight)

{

}

// Redimensionner.

void resize(int iWidth, int iHeight)

{

m_iWidth = iWidth;

m_iHeight = iHeight ;

m_vArray.resize(iWidth*iHeight);

}

inline T& operator() (unsigned int x, unsigned int y)

{

assert(((y*m_iWidth) + x) < m_vArray.size());

return m_vArray[ (y*m_iWidth) + x ];

}

inline T& operator[] (int pos)

{

return m_vArray[pos];

}

inline const T& operator() (unsigned int x, unsigned int y) const

{

assert(((y*m_iWidth) + x) < m_vArray.size());

return m_vArray[ (y*m_iWidth) + x ];

}

inline const T& operator[] (int x) const

{

return m_vArray[pos];

}

inline int getWidth() const { return m_iWidth; }

inline int getHeight() const { return m_iHeight; }

private:

int m_iWidth; // Largeur.

int m_iHeight; // Hauteur.

std::vector<T> m_vArray; // Le vecteur qui va servir de tableau à deux dimensions.

};

#endif

Voici le fichier d’en-tête MazeGenerator.h

#ifndef MAZE_GENERATOR_H
#define MAZE_GENERATOR_H

#include "Array2D.h"

class MazeGenerator
{
public:
    MazeGenerator();
    virtual ~MazeGenerator() {};

    void generate(const int iRowCellNumber, const int iColumnCellNumber);

    void computeNeighbourgsCeils();

    void createMazeNode(scene::ISceneManager* pSceneManager, NewtonWrapper::CollisionManager* pCollisionManager);

    int generateRandomCellNumber()
    {
        assert(m_iRowCellNumber && m_iColumnCellNumber);

        return rand() % m_iCellNumber;
    }

    scene::CDynamicMeshBuffer* createMeshBuffer();

private:
    Array2D<MazeCell*> m_aMaze;
    int m_iRowCellNumber;
    int m_iColumnCellNumber;
    int m_iCellNumber;
};

#endif

#ifndef MAZE_GENERATOR_H

#define MAZE_GENERATOR_H

#include "Array2D.h"

class MazeGenerator

{

public:

MazeGenerator();

virtual ~MazeGenerator() {};

void generate(const int iRowCellNumber, const int iColumnCellNumber);

void computeNeighbourgsCeils();

void createMazeNode(scene::ISceneManager* pSceneManager, NewtonWrapper::CollisionManager* pCollisionManager);

int generateRandomCellNumber()

{

assert(m_iRowCellNumber && m_iColumnCellNumber);

return rand() % m_iCellNumber;

}

scene::CDynamicMeshBuffer* createMeshBuffer();

private:

Array2D<MazeCell*> m_aMaze;

int m_iRowCellNumber;

int m_iColumnCellNumber;

int m_iCellNumber;

};

#endif

Références :

– http://www.mazeworks.com/mazegen/mazetut/

RAII (Resource Acquisition Is Initialization)

Intro :

Parfois on a besoin simplement d’utiliser une variable ou un objet de manière temporaire, pour ensuite le ou la détruire facilement après son utilisation.

En C++, les objets résidant sur la pile sont automatiquement détruits lors de la sortie d’un bloc de portée, y compris dans le cas d’une levée d’exception ^; leur destructeur est appelé avant que l’exception ne se propage.

On peut alors se servir de ce mécanisme pour détruire automatiquement un objet une fois effectué son utilisation.

Prérequis :

– Avoir quelques notions de C++

Explications :

Il s’agit de manipuler un objet local qui sera utilisé dans la portée d’un bout de code et qui sera ensuite libérée lors de sa destruction.

Système de profiling :

Exemple :

void ExempleAvecRAII()
{
  // On acquiert une ressource (un fichier)
  Fichier logFile("Log.txt");
 
  logFile.Write("Bonjour!");

  // Le fichier logFile sera automatiquement détruit
  // après avoir atteint la fin de ce bloc de code.

  // On n'a pas besoin d'appeler une quelconque fonction
  // close()

  /* On peut lever aussi une exception juste ici. */
  if (logFile.writeHasFailed())
  {
      throw std::exception("Erreur!");
  }
}

void ExempleAvecRAII()

{

// On acquiert une ressource (un fichier)

Fichier logFile("Log.txt");

logFile.Write("Bonjour!");

// Le fichier logFile sera automatiquement détruit

// après avoir atteint la fin de ce bloc de code.

// On n'a pas besoin d'appeler une quelconque fonction

// close()

/* On peut lever aussi une exception juste ici. */

if (logFile.writeHasFailed())

{

throw std::exception("Erreur!");

}

Résumé :

Nous avons présenté le principe du RAII. Ce principe permet de simplifier les initialisation du constructeur d’un objet, sans avoir à appeler le destructeur.

Récapitulatif C++

Intro :

Le langage C++ est le langage le plus utilisé dans le monde du développement de jeu-vidéo.

Ce petit tutoriel à pour but de vous faire réviser certaines notions de C++.

Prérequis :

– Avoir quelques notions de C++

Explications :

Le C++ est un langage orienté objet. C’est-à-dire que l’on manipule des objets en déclarant des classes au sein du code.

Qu’est-ce qu’une déclaration de fonction / classe ?

Une déclaration indique l’identificateur d’une variable et sa nature (c’est-à-dire respectivement son nom et sa nature).

Qu’est-ce qu’une définition de fonction / classe ?

Une définition implémente la structure d’une fonction ou d’une classe afin de pouvoir l’utiliser.

Commentaires :

/* Ceci est un commentaire
sur plusieurs lignes */

// Ceci est un commentaire en une seule ligne

/* Ceci est un commentaire

sur plusieurs lignes */

// Ceci est un commentaire en une seule ligne

Qu’est-ce qu’une classe ?

Une classe permet de regrouper dans une même entité des données et des fonctions membres (appelées aussi méthodes) permettant de manipuler ces données.

Créer un objet à partir d’une classe :

Les opérateurs new et delete permettent de créer un objet en allouant sa quantité de mémoire.
A chaque new doit correspondre un delete, sinon il risque d’avoir une fuite de mémoire (memory leak) !
L’opérateur delete appelle le constructeur à détruire de la classe.

Qu’est-ce qu’un objet ?

Un objet est l’instance d’une certaine classe.

L’héritage :

En C++, les classes peuvent hériter d’autres classes et la relation d’héritage est exprimée à l’aide de l’opérateur de dérivation « : ».

class Chat : public Animal
{
public:
private:
};

class Chat : public Animal

{

public:

private:

};

L’encapsulation :

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

protected:

private:
    int m_iVariable;
};

class Sprite2D

{

public:

Sprite2D();

virtual ~Sprite2D();

protected:

private:

int m_iVariable;

};

– les déclarations en dessous de « public: » seront accessibles depuis n’importe quelle fonction.
– en dessous de « protected: » : pareil que private mais accessible depuis les classes
filles.
– en dessous de « private: » : accessible que depuis les fonctions de la classes.

L’opérateur sizeof :

Sert à calculer la taille de n’importe quel type de données.
On note que sizeof(char) = 1.

sizeof(x) = 1 ssi x est un byte. (Un byte est la plus petite unité adressable d’un ordinateur)

Opérateurs d’entrées-sorties :

On peut écrire dans la console avec l’instruction suivante :

#include <iostream>

std::cout << "Une phrase." << std:endl;

#include <iostream>

std::cout << "Une phrase." << std:endl;

On peut écrire du code UTF-8 aussi :

#include <iostream>

std::wcout << "Une phrase en français." << std:endl;

#include <iostream>

std::wcout << "Une phrase en français." << std:endl;

Les pointeurs :

Un pointeur désigne une adresse d’une variable d’un certain type.

int* pEntier; // Déclare un pointeur de type int

int iEntier;

&iEntier // permet d'obtenir l'adresse de iEntier

pEntier = &iEntier; // Affectation du pointeur

int* pEntier; // Déclare un pointeur de type int

int iEntier;

&iEntier // permet d'obtenir l'adresse de iEntier

pEntier = &iEntier; // Affectation du pointeur

Le références :

Une référence peut être vue comme un alias d’une variable. C’est un « synonyme » d’une autre variable. Une modification de l’une modifiera l’autre.

int i = 3;
int& i; // Un référence à la variable i

1 2	int i = 3; int& i; // Un référence à la variable i

Valeur par défaut des paramètres d’une fonction :

// Déclaration d'une fonction à paramètres par défaut
void print(long valeur, int base = 10);

1 2	// Déclaration d'une fonction à paramètres par défaut void print(long valeur, int base = 10);

Fonctions inline :

Les fonction inline fonctionnent comme les macros.

Surcharge de fonctions :

Tas et Pile :

Tas :

Pile :

Instanciation d’une classe :

Avion avion; // Sur la pile
Avion* pAvion = new Avion(); // Sur le tas

1 2	Avion avion; // Sur la pile Avion* pAvion = new Avion(); // Sur le tas

Fonctions membres statiques :

– existent même s’il n’y a aucune instance de classe.

– ne peuvent accéder qu’aux membres statiques de la classe.

Exceptions :

Moyen de gérer les erreurs dans un programme C++.

Throw : // Le mot-clé pour lever une exception.

/* Bloc try d'une gestion d'exception */
try
{
    // instructions pouvant déclencher des exceptions
    // dérivant de std::exception
}
catch ( const std::exception & e )
{
    std::cerr << e.what();
}

Throw : // Le mot-clé pour lever une exception.

/* Bloc try d'une gestion d'exception */

try

{

// instructions pouvant déclencher des exceptions

// dérivant de std::exception

}

catch ( const std::exception & e )

{

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

}

Caméra à la 3ème personne trigonométrique

Intro :

Pour se déplacer dans la scène 3D il faut mouvoir une caméra.

Dans cet article nous allons implémenter une caméra qui tourne autour d’un joueur (ou autour d’une position)

Prérequis :

– Comprendre un minimum de notions trigonométriques

Explications :

Déclarer ces trois variables dans un fichier quelconque :

float m_fCameraSpeed;
float m_fDistance;
D3DXVECTOR2 m_v2CameraAngle;

float m_fCameraSpeed;

float m_fDistance;

D3DXVECTOR2 m_v2CameraAngle;

Voilà les fonctions d’initialisation et de mise à jour de la caméra à la 3ème personne :

void CameraManager::Initialize()
{
    m_v2CameraAngle = D3DXVECTOR2(0.0f, 0.0f);
}

void CameraManager::UpdateThirdPersonCamera()
{
    // C'est deux fonctions retournent simplement la quantité de mouvement
    // du pointeur de la souris
    // Voir l'article sur le InputManager
    float fX = InputManager::getSingletonPtr()->getMouseRelativePos().x;
    float fY = InputManager::getSingletonPtr()->getMouseRelativePos().y;

#define CAMERA_SPEED_ROTATE_AROUND 0.0037f
    // Normalement il faut utiliser le temps passé depuis le dernier affichage
    // (voir l'article sur la variable fTimeSinceLastFrame "Performance Timer")
    m_v2CameraAngle.x += fX * CAMERA_SPEED_ROTATE_AROUND;
    m_v2CameraAngle.y -= fY * CAMERA_SPEED_ROTATE_AROUND;
    // Clamp : une fonction qui permet de garder le résultat
    // passé entre un intervalle donné
    m_v2CameraAngle.y = Clamp(camAngle.y, 0.003f, Ogre::Math::PI - 0.003f);

    // Usage de la trigonométrie pour faire en sorte que la caméra
    // fasse une rotation autour d'un point
    float cosX = cos(m_v2CameraAngle.x);
    float cosY = cos(m_v2CameraAngle.y);
    float sinY = sin(m_v2CameraAngle.y);
    float sinX = sin(m_v2CameraAngle.x);

    float xf = cosX * sinY;
    float yf = cosY;
    float zf = sinX * sinY;

    D3DXVECTOR3 finalPos(xf, yf, zf);

    /* Position du joueur (où de l'objet auquel vous voulez tourner autour !*/
    D3DXVECTOR3 playerPos = GAME->getPlayer()->getSceneNode()->getPosition();

    // Votre objet caméra utilisé
    m_pCamera->setPosition(finalPos * m_fDistance + playerPos);
    m_pCamera->lookAt(GAME->getPlayer()->getSceneNode()->getPosition());

    /** Pour centrer le curseur de ma souris */
    centerCursorPos();
}

void CameraManager::Initialize()

{

m_v2CameraAngle = D3DXVECTOR2(0.0f, 0.0f);

}

void CameraManager::UpdateThirdPersonCamera()

{

// C'est deux fonctions retournent simplement la quantité de mouvement

// du pointeur de la souris

// Voir l'article sur le InputManager

float fX = InputManager::getSingletonPtr()->getMouseRelativePos().x;

float fY = InputManager::getSingletonPtr()->getMouseRelativePos().y;

#define CAMERA_SPEED_ROTATE_AROUND 0.0037f

// Normalement il faut utiliser le temps passé depuis le dernier affichage

// (voir l'article sur la variable fTimeSinceLastFrame "Performance Timer")

m_v2CameraAngle.x += fX * CAMERA_SPEED_ROTATE_AROUND;

m_v2CameraAngle.y -= fY * CAMERA_SPEED_ROTATE_AROUND;

// Clamp : une fonction qui permet de garder le résultat

// passé entre un intervalle donné

m_v2CameraAngle.y = Clamp(camAngle.y, 0.003f, Ogre::Math::PI - 0.003f);

// Usage de la trigonométrie pour faire en sorte que la caméra

// fasse une rotation autour d'un point

float cosX = cos(m_v2CameraAngle.x);

float cosY = cos(m_v2CameraAngle.y);

float sinY = sin(m_v2CameraAngle.y);

float sinX = sin(m_v2CameraAngle.x);

float xf = cosX * sinY;

float yf = cosY;

float zf = sinX * sinY;

D3DXVECTOR3 finalPos(xf, yf, zf);

/* Position du joueur (où de l'objet auquel vous voulez tourner autour !*/

D3DXVECTOR3 playerPos = GAME->getPlayer()->getSceneNode()->getPosition();

// Votre objet caméra utilisé

m_pCamera->setPosition(finalPos * m_fDistance + playerPos);

m_pCamera->lookAt(GAME->getPlayer()->getSceneNode()->getPosition());

/** Pour centrer le curseur de ma souris */

centerCursorPos();

}

Résumé :

Nous avons présenté un moyen d’implémenter une caméra trigonométrique qui opère une révolution autour de la position du joueur !

Principe du Z-buffer

Intro :

L’utilisation du Z-buffer est une méthode consistant à afficher dans le bon ordre de profondeur les primitives géométriques envoyées au rendu 3D.

Prérequis :

– Comprendre les principales étapes de rendu de DirectX : voir cet article

Explications :

La technique du Z-buffer consiste à enregistrer pour chaque pixel une valeur de profondeur dans un tampon dédié (en l’occurrence le Z-buffer). Ce tampon a la même dimension que celui du frame buffer. Ces valeurs dans le tampon varient de 0.0f à 1.0f.

Lors de la transformation du repère 3D (celui des meshes / modèles) vers le repère 2D (celui de l’écran) nous avons bien les pixels sur les coordonnées (x, y) conservées mais nous avons perdu l’information sur la profondeur (z) ; il faut la recalculer par un algorithme adjacent.

1) Comment ça fonctionne ?

Avant qu’un pixel est affiché dans le tampon de rendu, sa valeur de profondeur est comparée
par sa valeur correspondante actuelle dans le Z-buffer. Si le pixel a sa valeur de profondeur inférieure ou égale alors le pixel est affiché et cette valeur est enregistrée dans le Z-buffer ; autrement le pixel est ignoré.

La carte graphique compare deux profondeurs (Z) une à une, et n’affiche que le pixel le plus proche de la caméra. Ensuite DirectX va automatiquement ignorer l’affichage des triangles cachés par d’autres triangles.

2) Comment le paramétrer ?

Le calcul effectué par le Z-buffer peut être ignoré et désactiver par un appel de l’API DirectX (voir cet article). Lorsqu’il est ignoré par DirectX, les derniers éléments dessinés seront affiché par dessus tous les autres.

Il faut noter aussi qu’à chaque tour de boucle le Z-buffer est réinitialisé et recalculé par cet appel :

m_pDevice->Clear(...)

1	m_pDevice->Clear(...)

Résumé :

Nous avons expliqué quel est le rôle du tampon de profondeur (le Z-buffer) dans le rendu 3D.
En effet cette étape permet de cacher les triangles placés à l’arrière d’autres triangles moins proches de la caméra.

Références :

– http://fr.wikipedia.org/wiki/Z-buffer

– http://www.toymaker.info/Games/html/z-buffer.html

Les principales fonctions de la bibliothèque D3DX (DirectX 10)

Intro :

La bibliothèque D3DX (D3DX utility library) implémente plusieurs fonctions courantes afin de faciliter certaines tâches d’utilisation de l’API 3D DirectX 10.

Nous verrons les objets de cette bibliothèque suivant :

– ID3DX10Sprite

– ID3DX10Font

– ID3DX10Mesh

Prérequis :

– Savoir comment initialiser correctement DirectX 10 (voir ces articles)

Explications :

ID3DX10Sprite :

Permet de simplifier l’affichage d’images 2D.

On créé cet objet avec la fonction : D3DX10CreateSprite()

J’ai déjà expliqué son utilisation dans cet article (dans la première méthode)

ID3DX10Font :

Permet d’afficher du texte à l’écran avec une police de font donnée.

On déclare les objets ID3DX10Font et ID3DX10Sprite :

ID3DX10Font* m_pFont;
ID3DX10Sprite* m_pSprite;

1 2	ID3DX10Font* m_pFont; ID3DX10Sprite* m_pSprite;

On initialise plus loin ces objets comme suit :

// Il faut créer un objet ID3DX10Sprite
D3DX10CreateSprite(m_pd3dDevice, 0, &m_pSprite);

/* Détaille les attributs de cette police d'affichage */
D3DX10_FONT_DESC fd;

// Définit la hauteur d'un caractère de cette police
fd.Height = 30;
// Définit la largeur d'un caractère de cette police
fd.Width = 18;
fd.Weight = 0;
fd.MipLevels = 4;
// En italique ou non
fd.Italic = false;
fd.CharSet = OUT_DEFAULT_PRECIS;
fd.Quality = DEFAULT_QUALITY;
fd.PitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
// Définit le nom de la police à utiliser
wcscpy(fd.FaceName, L"Impact");
 
D3DX10CreateFontIndirect(m_pd3dDevice, &fd, &m_pFont);

// Il faut créer un objet ID3DX10Sprite

D3DX10CreateSprite(m_pd3dDevice, 0, &m_pSprite);

/* Détaille les attributs de cette police d'affichage */

D3DX10_FONT_DESC fd;

// Définit la hauteur d'un caractère de cette police

fd.Height = 30;

// Définit la largeur d'un caractère de cette police

fd.Width = 18;

fd.Weight = 0;

fd.MipLevels = 4;

// En italique ou non

fd.Italic = false;

fd.CharSet = OUT_DEFAULT_PRECIS;

fd.Quality = DEFAULT_QUALITY;

fd.PitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;

// Définit le nom de la police à utiliser

wcscpy(fd.FaceName, L"Impact");

D3DX10CreateFontIndirect(m_pd3dDevice, &fd, &m_pFont);

Dans la boucle de rendu on ajoute :

EnableZBuffer(false);

m_pSprite->Begin(D3DX10_SPRITE_SAVE_STATE);
     m_pFont->DrawText(m_pSprite, L"Hello World!", -1, &rectangle, DT_NOCLIP, color);
m_pSprite->End();

EnableZBuffer(true);

EnableZBuffer(false);

m_pSprite->Begin(D3DX10_SPRITE_SAVE_STATE);

m_pFont->DrawText(m_pSprite, L"Hello World!", -1, &rectangle, DT_NOCLIP, color);

m_pSprite->End();

EnableZBuffer(true);

Le paramètre D3DX10_SPRITE_SAVE_STATE permet de restaurer les états du rendu 3D après l’appel End() comme ils étaient configurés avant l’appel Begin().

On désactive l’écriture sur le Z-Buffer pour préserver la profondeur de ce qui est affiché avant l’appel à m_pFontText().

ID3DX10Mesh :

Bien configurer un projet Visual C++

[rajouter utf-8]

Intro :

Les débutants en C++ sous Windows ont souvent du mal à compiler leur premier programme.
En effet pour compiler un programme il faut indiquer au compilateur où chercher ses dépendances (répertoires de fichiers d’en-têtes et de bibliothèques)

Prérequis :

– Savoir un peu écrire et lire du C++

Explications :

1) Ouvrez votre projet C++

2) Allez dans les propriétés du projet (ALT+F7)

3) Allez dans la partie « Répertoires C++ »

Vous verrez deux champs qui sont là pour indiquer où chercher vos fichiers #include et bibliothèques .lib des dépendances de votre projet.

4) Il vous reste plus qu’à sélectionner le répertoire de votre dépendance !

5) Compilez pour tester si votre projet est bien configuré !

Résumé :

Dans cet article nous avons configuré Visual C++ de façon à ce qu’il trouve les dépendances externes à votre projet afin de le compiler sans erreurs apparentes.

Les fichiers d’en-têtes précompilés (Visual C++)

Intro :

Parfois, étant donné le nombre faramineux de fichiers d’en-tête nécessaires pour compiler un fichier source .cpp, il peut etre nécessaire de tous les regrouper en seul fichier afin de le compiler en une seule fois.
Cette compilation accélère immédiatement la compilation des autres fichiers .cpp.

Prérequis :

– Savoir un peu lire du C++

Explications :

1) Ouvrez votre projet VC ++

2) Créez un fichier Stdafx.h où vous mettrez tous vos fichiers .h les uns à la suite des autres (comme dans la première image).

3) Créez juste un fichier Stdafx.cpp où vous metterez :

#include "Stdafx.h"

1	#include "Stdafx.h"

4) Faite un clic droit sur ce dernier fichier :

5) Allez dans la partie « En-tête précompilés ». Choisissez « Création /Yc » et ajouter comme dans l’image « Stdafx.h »

6) Ensuite allez dans les propriétés du projet (ALT+F7)

7) Veillez à ce que « Stdafx.h » soit écrit et choisissez « Utilisation /Yu » :

8) Dans le fichier Stdafx.h, vous pouvez mettre tous vos fichier #include :

#include "BoundingVolumeTrigger.h"
#include "Mob.h"
#include "NPC.h"
#include "TextAnnouncer.h"
#include "EventManager.h"
#include "M2Importer.h"
#include "ComputerInfo.h"
#include "CommandsManager.h"
#include "DataParameters.h"
#include "Commands.h"
#include "Actor.h"
#include "GUIScrollBar.h"
#include "GUIManager.h"
#include "GUIButton.h"
#include "GUIDraggableWindow.h"

#include "BoundingVolumeTrigger.h"

#include "Mob.h"

#include "NPC.h"

#include "TextAnnouncer.h"

#include "EventManager.h"

#include "M2Importer.h"

#include "ComputerInfo.h"

#include "CommandsManager.h"

#include "DataParameters.h"

#include "Commands.h"

#include "Actor.h"

#include "GUIScrollBar.h"

#include "GUIManager.h"

#include "GUIButton.h"

#include "GUIDraggableWindow.h"

9) Il reste plus qu’à mettre dans tous vos fichiers .cpp une seule en-tête :

#include "Stdafx.h"

1	#include "Stdafx.h"

10) Compilez et admirez la vitesse !

Résumé :

Nous avons appris comment regrouper un grand nombre de fichiers d’en-tête (des #include) en un seul fichier afin de rendre la compilation beaucoup plus rapide.

Introduction à la programmation réseau (Sockets) – partie 1

Intro :

Pour concevoir un jeu vidéo multijoueur il vous faut utiliser dans le programme C++ des objets qu’on appelle sockets. Ceci afin de pouvoir faire communiquer des ordinateurs à distance.

Prérequis :

– savoir un peu lire et écrire du C++

– être sous Windows.

Explications :

Les sockets sont des objets représentants une interface de connexion liée à une machine afin de faire communiquer les ordinateurs à travers un réseau (a fortiori par Internet)

1 – Tout d’abord je vais vous présenter un petit programme qui affiche une page HTML dans la console à partir d’une URL web en utilisant les sockets. Rien ne vaut un bel exemple concret pour comprendre !

2 – Aussi, comme il est important de connaître de quoi l’on parle, je vais énumérer toutes les fonctions et mots-clés utilisés dans la programmation socket en C.

1 – Voici ce premier programme :

/** Inspirez-vous des commentaires pour comprendre **/

#include <winsock2.h>
#include <stdio.h>
#include <stdlib.h>

// Fonction qui permet d'afficher le contenu d'une page web
void FetchAndPrintPage(SOCKET socket, const char* sHost, const char* sPage)
{
    // Chaîne de caractère représentant la requête HTTP
    const char* sRequestFormat = "GET %s HTTP/1.0\r\nHost: %s\r\nUser-Agent: FetchAndPrint.c\r\n\r\n";
    char* sMsg = new char[4096];

    // On compose les paramètres dans une chaîne de caractères finale
    // représentant la requête HTTP à envoyer
    sprintf(sMsg, sRequestFormat, sPage, sHost);

    // La fonction send() permet d'envoyer des informations vers
    // l'ordinateur distant (le serveur) ; ici on envoit la requête HTTP
    if (send(socket, sMsg, strlen(sMsg), 0) != SOCKET_ERROR)
    {
        // Comme la fonction recv(), qui suit, ne réceptionne qu'une partie du message
        // reçu, il faut l'invoquer en boucle jusqu'à ce que le message
        // est entièrement réceptionné.
        while (true)
        {
            // Le nombre d'octet reçu
            int iBytes;
            // Le tampon de caractères stockant le contenu de la page web
            char sBuffer[4096];

            // La fonction recv() ne réceptionne qu'une partie du message
            // reçu ; elle retourne le nombre d'octets reçu et stocke ce contenu
            // dans la variable tampon sBuffer
            iBytes = recv(socket, sBuffer, 4096, 0);

            // On sort de la boucle s'il n'y a plus de message à receptionner ou
            // qu'une erreur a eu lieu !
            if (iBytes == 0 && iBytes == -1)
            {
                break;
            }

            // Pour finaliser la chaîne on doit rajouter le caractère nul à celle-ci
            sBuffer[iBytes-1] = '\0';

            // On affiche le contenu de la page web dans la console
            printf("\n\n%s\n", sBuffer);
            // On met en pause le programme afin de lire la portion du texte reçu
            system("pause");
        }
    }
    else
    {
        printf("Socket Error Code = %i\n", WSAGetLastError());
    }

    delete sMsg;
}

int main()
{
    // Ces deux suivantes instructions initialisent
    // l'utilisation des sockets sous Windows
    WSADATA WSAData;
    WSAStartup(MAKEWORD(2,2), &WSAData);

    // Structure utilisée afin de stocker les informations d'un socket
    in_addr addr;

    const char* sHost = "anthroponaute.fr";

    // Cette fonction créé un socket
    SOCKET s = socket(AF_INET, SOCK_STREAM, 0);

    if (s == INVALID_SOCKET)
    {
        // Affiche la signification de l'erreur
        printf("Socket Error Code = %i\n", WSAGetLastError());

        system("pause");

        exit(EXIT_FAILURE);
    }
    
    // Pour obtenir des informations socket sur cette adresse web
    hostent* pHost = gethostbyname(sHost);

    if (pHost != nullptr)
    {
        printf("Adress Name = %s\n", pHost->h_name);

        addr.s_addr = *(u_long*) pHost->h_addr_list[0];

        printf("IP Address = %s\n", inet_ntoa(addr));
    }
    else
    {
        printf("Socket Error Code = %i", WSAGetLastError());

        system("pause");

        exit(EXIT_FAILURE);
    }

    // On remplit cette structure afin de configurer et situer notre socket
    SOCKADDR_IN adress_in;
    adress_in.sin_family = AF_INET;
    adress_in.sin_addr = addr;
    adress_in.sin_port = htons(80);

    /*************/

    // On se connecte sur le serveur web
    if (connect(s, (SOCKADDR*)&adress_in, sizeof(adress_in)) == SOCKET_ERROR)
    {
        printf("Socket Error Code = %i\n", WSAGetLastError());

        system("pause");

        exit(EXIT_FAILURE);
    }
    else
    {
        printf("Connected !\n");
    }
    // On affiche la page du site en spécifiant son répertoire
    FetchAndPrintPage(s, sHost, "/blog-informatique/");

    WSACleanup();

    return 0;
}

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

/** Inspirez-vous des commentaires pour comprendre **/

#include <winsock2.h>

#include <stdio.h>

#include <stdlib.h>

// Fonction qui permet d'afficher le contenu d'une page web

void FetchAndPrintPage(SOCKET socket, const char* sHost, const char* sPage)

{

// Chaîne de caractère représentant la requête HTTP

const char* sRequestFormat = "GET %s HTTP/1.0\r\nHost: %s\r\nUser-Agent: FetchAndPrint.c\r\n\r\n";

char* sMsg = new char[4096];

// On compose les paramètres dans une chaîne de caractères finale

// représentant la requête HTTP à envoyer

sprintf(sMsg, sRequestFormat, sPage, sHost);

// La fonction send() permet d'envoyer des informations vers

// l'ordinateur distant (le serveur) ; ici on envoit la requête HTTP

if (send(socket, sMsg, strlen(sMsg), 0) != SOCKET_ERROR)

{

// Comme la fonction recv(), qui suit, ne réceptionne qu'une partie du message

// reçu, il faut l'invoquer en boucle jusqu'à ce que le message

// est entièrement réceptionné.

while (true)

{

// Le nombre d'octet reçu

int iBytes;

// Le tampon de caractères stockant le contenu de la page web

char sBuffer[4096];

// La fonction recv() ne réceptionne qu'une partie du message

// reçu ; elle retourne le nombre d'octets reçu et stocke ce contenu

// dans la variable tampon sBuffer

iBytes = recv(socket, sBuffer, 4096, 0);

// On sort de la boucle s'il n'y a plus de message à receptionner ou

// qu'une erreur a eu lieu !

if (iBytes == 0 && iBytes == -1)

{

break;

}

// Pour finaliser la chaîne on doit rajouter le caractère nul à celle-ci

sBuffer[iBytes-1] = '\0';

// On affiche le contenu de la page web dans la console

printf("\n\n%s\n", sBuffer);

// On met en pause le programme afin de lire la portion du texte reçu

system("pause");

}

else

{

printf("Socket Error Code = %i\n", WSAGetLastError());

}

delete sMsg;

}

int main()

{

// Ces deux suivantes instructions initialisent

// l'utilisation des sockets sous Windows

WSADATA WSAData;

WSAStartup(MAKEWORD(2,2), &WSAData);

// Structure utilisée afin de stocker les informations d'un socket

in_addr addr;

const char* sHost = "anthroponaute.fr";

// Cette fonction créé un socket

SOCKET s = socket(AF_INET, SOCK_STREAM, 0);

if (s == INVALID_SOCKET)

{

// Affiche la signification de l'erreur

printf("Socket Error Code = %i\n", WSAGetLastError());

system("pause");

exit(EXIT_FAILURE);

}

// Pour obtenir des informations socket sur cette adresse web

hostent* pHost = gethostbyname(sHost);

if (pHost != nullptr)

{

printf("Adress Name = %s\n", pHost->h_name);

addr.s_addr = *(u_long*) pHost->h_addr_list[0];

printf("IP Address = %s\n", inet_ntoa(addr));

}

else

{

printf("Socket Error Code = %i", WSAGetLastError());

system("pause");

exit(EXIT_FAILURE);

}

// On remplit cette structure afin de configurer et situer notre socket

SOCKADDR_IN adress_in;

adress_in.sin_family = AF_INET;

adress_in.sin_addr = addr;

adress_in.sin_port = htons(80);

/*************/

// On se connecte sur le serveur web

if (connect(s, (SOCKADDR*)&adress_in, sizeof(adress_in)) == SOCKET_ERROR)

{

printf("Socket Error Code = %i\n", WSAGetLastError());

system("pause");

exit(EXIT_FAILURE);

}

else

{

printf("Connected !\n");

}

// On affiche la page du site en spécifiant son répertoire

FetchAndPrintPage(s, sHost, "/blog-informatique/");

WSACleanup();

return 0;

}

Copiez / collez et compilez !

2 – Voici maintenant tous les principes, concepts et fonctions de la programmation de sockets :

Voici les fichiers d’en-tête nécessaires :

#include <winsock2.h>
#include <stdio.h>
#include <stdlib.h>

#include <winsock2.h>

#include <stdio.h>

#include <stdlib.h>

Voici les #define préétablis :

SOCKET pour l'utilisation de socket (à la place de int)
SOCKADDR_IN pour struct sockaddr_in
SOCKADDR pour struct sockaddr
IN_ADDR pour struct in_addr
INVALID_SOCKET -1
SOCKET_ERROR -1

SOCKET pour l'utilisation de socket (à la place de int)

SOCKADDR_IN pour struct sockaddr_in

SOCKADDR pour struct sockaddr

IN_ADDR pour struct in_addr

INVALID_SOCKET -1

SOCKET_ERROR -1

Voici la structure principale à utiliser :

struct sockaddr_in
{
    short              sin_family;
    unsigned short     sin_port;
    struct   in_addr   sin_addr;
    char               sin_zero[8];
};

struct sockaddr_in

{

short sin_family;

unsigned short sin_port;

struct in_addr sin_addr;

char sin_zero[8];

};

Elle est utilisée pour configurer la socket.

Voici comment l’utiliser :

SOCKADDR_IN sin;
sin.sin_addr.s_addr = htonl(INADDR_ANY);   
sin.sin_family = AF_INET;
sin.sin_port = htons(23);

SOCKADDR_IN sin;

sin.sin_addr.s_addr = htonl(INADDR_ANY);

sin.sin_family = AF_INET;

sin.sin_port = htons(23);

– sin.sin_addr.s_addr : c’est l’adresse qu’on affecte à cette configuration de socket (c’est peut-être l’adresse représentant un client ou un serveur, cela dépend du rôle de notre socket)

– INADDR_ANY : adresse IP automatique

Pour spécifier une adresse manuellement on peut utiliser la fonction inet_addr()

sin.sin_addr.s_addr = inet_addr("127.0.0.1");

1	sin.sin_addr.s_addr = inet_addr("127.0.0.1");

– sin.sin_family = AF_INET : spécifie que l’on passe la socket en mode Internet

– sin.sin_port : spécifie le numéro de port de la socket à utiliser

En occurrence, qu’est-ce qu’un port ?

Un port sert à spécifier à quel service d’application les informations doivent être envoyées.

En effet sur le réseau Internet global, chaque ordinateur est représenté par un numéro d’IP, mais cette adresse IP ne spécifie pas à quelle application de l’ordinateur l’information doit être envoyé.

En conséquence les applications / services sont identifiés par des numéros de port (ex : port 80 pour
le service HTTP)

Ces deux fonctions doivent être appelées pour initialiser ou clôturer l’utilisation des sockets :

// Au début du programme :
WSADATA WSAData;
WSAStartup(MAKEWORD(2,2), &WSAData);

// A la fin du programme :
WSACleanup();

// Au début du programme :

WSADATA WSAData;

WSAStartup(MAKEWORD(2,2), &WSAData);

// A la fin du programme :

WSACleanup();

Pour initialiser une socket :

SOCKET sock = socket(AF_INET, SOCK_STREAM, 0);

1	SOCKET sock = socket(AF_INET, SOCK_STREAM, 0);

Voici les différents paramètres de cette fonction :

AF_INET // Spéficie que l'on va utiliser le mode Internet

1	AF_INET // Spéficie que l'on va utiliser le mode Internet

Types de socket :

SOCK_STREAM  // Spéficie que l'on va utiliser le protocole TCP/IP. 

SOCK_DGRAM // Spéficie que l'on va utiliser le protocole UDP/IP.

SOCK_STREAM // Spéficie que l'on va utiliser le protocole TCP/IP.

SOCK_DGRAM // Spéficie que l'on va utiliser le protocole UDP/IP.

– Le protocole TCP est un protocole dit connecté. Il contrôle si le paquet
est arrivé à destination si ce n’est pas le cas il le renvoie.

– Le procotole UDP est un protocole dit non connecté. A l’inverse du protocole TCP
il ne contrôle pas si le paquet est arrivé à destination.

Cette fonction permet de convertir une addresse IP (en char*) afin d’être
affectée à la structure IN_ADDR.

inet_addr("127.0.0.1");

1	inet_addr("127.0.0.1");

inet_ntoa()

1	inet_ntoa()

int connect(int socket, struct sockaddr* addr, socklen_t addrlen);

1	int connect(int socket, struct sockaddr* addr, socklen_t addrlen);

int bind(int socket, const struct sockaddr* addr, socklen_t addrlen);

1	int bind(int socket, const struct sockaddr* addr, socklen_t addrlen);

int listen(int socket, int backlog);

1	int listen(int socket, int backlog);

int accept(int socket, struct sockaddr* addr, socklen_t* addrlen);

1	int accept(int socket, struct sockaddr* addr, socklen_t* addrlen);

Résumé :

Nous avons créé un programme qui affiche une page web afin de comprendre la programmation sockets.

Au final nous avons énuméré tous les concepts liés à la programmation sockets.

Références :

– http://pub.phyks.me/sdz/sdz/les-sockets.html

Intégration de Newton Dynamics dans Irrlicht 3D

Intro :

Un moteur physique dans un jeu vidéo permet de simuler les phénomènes physiques du monde réél. Il fait bouger les objets dans le jeu par des mouvements réalistes.

Ici nous allons utiliser le moteur physique Newton Dynamics pour l’intégrer dans le moteur 3D Irrlicht.

Site web de Newton Dynamics : www.newtondynamics.com

Prérequis :

Savoir lire un peu du C++.

Explications :

Mettez dans un fichier PhysicsManager.h le code suivant :

#ifndef PHYSICS_MANAGER_H
#define PHYSICS_MANAGER_H

#include <irrlicht.h>
#include <Newton.h>

#include <string>
#include <iostream>
#include <fstream>

#define GAME_CUBE_MASS 15.0f

using namespace irr;

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

    // Lance un cube depuis la position de la caméra
    void LaunchCube(scene::ISceneNode* pCubeSceneNode, const core::vector3df& direction);

    // Analyse un mesh et construit un objet de collision Newton correspondant
    NewtonCollision* CreateCollisionFromMesh(scene::IMesh* pIrrlichtMesh, const core::vector3df& v3Scale);

    // Créé un objet de collision Newton d'une forme englobante et correspondante avec la forme complexe du mesh passé
    // en paramètre
    NewtonCollision* CreateCollisionConvexHullFromMesh(scene::IMesh* pIrrlichtMesh);

    // Prépare un objet Newton Body pour la gestion physique
    void InitializeRigidBody(const scene::ISceneNode* pSceneNode, NewtonBody* pBody);

    // Retourne vrai si le fichier cache de collision Newton existe
    bool PhysicsManager::CollisionCacheFileExist(const std::string& sCacheFileName);

    /* Callbacks */
    static void SetTransform(const NewtonBody* pBody, const float* matrix, int threadIndex);
    static void ApplyGravity(const NewtonBody* pBody, float timestep, int threadIndex);

    // Rafraichit le moteur physique Newton
    void Update(float fValue);

    // Ajoute un objet à traiter au moteur 3D
    void CreateDynamicBody(scene::IMeshSceneNode* pMeshNode, float fMass,
                           bool bUseCache, const std::string& sCacheName);

    static void SerializeCollision(void* serializeHandle, const void* buffer, int size);
    static void DeSerializeCollision(void* serializeHandle, void* buffer, int size);

private:
    // L'objet principale de la librairie Newton
    NewtonWorld* m_pNewtonWorld;
};

#endif

#ifndef PHYSICS_MANAGER_H

#define PHYSICS_MANAGER_H

#include <irrlicht.h>

#include <Newton.h>

#include <string>

#include <iostream>

#include <fstream>

#define GAME_CUBE_MASS 15.0f

using namespace irr;

class PhysicsManager

{

public:

PhysicsManager();

virtual ~PhysicsManager();

// Lance un cube depuis la position de la caméra

void LaunchCube(scene::ISceneNode* pCubeSceneNode, const core::vector3df& direction);

// Analyse un mesh et construit un objet de collision Newton correspondant

NewtonCollision* CreateCollisionFromMesh(scene::IMesh* pIrrlichtMesh, const core::vector3df& v3Scale);

// Créé un objet de collision Newton d'une forme englobante et correspondante avec la forme complexe du mesh passé

// en paramètre

NewtonCollision* CreateCollisionConvexHullFromMesh(scene::IMesh* pIrrlichtMesh);

// Prépare un objet Newton Body pour la gestion physique

void InitializeRigidBody(const scene::ISceneNode* pSceneNode, NewtonBody* pBody);

// Retourne vrai si le fichier cache de collision Newton existe

bool PhysicsManager::CollisionCacheFileExist(const std::string& sCacheFileName);

/* Callbacks */

static void SetTransform(const NewtonBody* pBody, const float* matrix, int threadIndex);

static void ApplyGravity(const NewtonBody* pBody, float timestep, int threadIndex);

// Rafraichit le moteur physique Newton

void Update(float fValue);

// Ajoute un objet à traiter au moteur 3D

void CreateDynamicBody(scene::IMeshSceneNode* pMeshNode, float fMass,

bool bUseCache, const std::string& sCacheName);

static void SerializeCollision(void* serializeHandle, const void* buffer, int size);

static void DeSerializeCollision(void* serializeHandle, void* buffer, int size);

private:

// L'objet principale de la librairie Newton

NewtonWorld* m_pNewtonWorld;

};

#endif

Mettez dans un fichier PhysicsManager.cpp le code suivant :

Cette fonction s’occupe de lancer un cube dans la direction spécifiée.

void PhysicsManager::LaunchCube(scene::ISceneNode* pCubeSceneNode, const core::vector3df& direction)
{
    NewtonCollision* pNewtonCollisionBox = nullptr;  
    NewtonBody* pBody = nullptr;

    // Calcule la taille englobante de la scene node
    core::vector3df size(pCubeSceneNode->getBoundingBox().MaxEdge - pCubeSceneNode->getBoundingBox().MinEdge);

    // En effet un objet NewtonCollision doit être agrandi ou réduit par rapport à la véritable échelle de la SceneNode
    pNewtonCollisionBox = NewtonCreateBox(m_pNewtonWorld, size.X, size.Y, size.Z, 0, 0);
        
    // Créé l'objet NewtonBody
    const float* matrix = core::IdentityMatrix.pointer();
    pBody = NewtonCreateDynamicBody(m_pNewtonWorld, pNewtonCollisionBox, matrix);
    
    // On détruit l'objet collision dont on n'a plus besoin
    NewtonDestroyCollision(pNewtonCollisionBox);    
    
    // On lui envoit les transformations de la scène node (position, rotation).
    NewtonBodySetMatrix(pBody, pCubeSceneNode->getRelativeTransformation().pointer());

    // On envoit un pointeur de la scène node pour pouvoir le récupérer plus tard.
    NewtonBodySetUserData(pBody, pCubeSceneNode);

    // Prépare l'objet pour le traitement physique 3D
    InitializeRigidBody(pCubeSceneNode, pBody);

    float directionArray[3];

    directionArray[0] = direction.X;
    directionArray[1] = direction.Y;
    directionArray[2] = direction.Z;

    // On lui impulse un mouvement dans la direction directionArray
    NewtonBodySetVelocity(pBody, directionArray);
}

void PhysicsManager::LaunchCube(scene::ISceneNode* pCubeSceneNode, const core::vector3df& direction)

{

NewtonCollision* pNewtonCollisionBox = nullptr;

NewtonBody* pBody = nullptr;

// Calcule la taille englobante de la scene node

core::vector3df size(pCubeSceneNode->getBoundingBox().MaxEdge - pCubeSceneNode->getBoundingBox().MinEdge);

// En effet un objet NewtonCollision doit être agrandi ou réduit par rapport à la véritable échelle de la SceneNode

pNewtonCollisionBox = NewtonCreateBox(m_pNewtonWorld, size.X, size.Y, size.Z, 0, 0);

// Créé l'objet NewtonBody

const float* matrix = core::IdentityMatrix.pointer();

pBody = NewtonCreateDynamicBody(m_pNewtonWorld, pNewtonCollisionBox, matrix);

// On détruit l'objet collision dont on n'a plus besoin

NewtonDestroyCollision(pNewtonCollisionBox);

// On lui envoit les transformations de la scène node (position, rotation).

NewtonBodySetMatrix(pBody, pCubeSceneNode->getRelativeTransformation().pointer());

// On envoit un pointeur de la scène node pour pouvoir le récupérer plus tard.

NewtonBodySetUserData(pBody, pCubeSceneNode);

// Prépare l'objet pour le traitement physique 3D

InitializeRigidBody(pCubeSceneNode, pBody);

float directionArray[3];

directionArray[0] = direction.X;

directionArray[1] = direction.Y;

directionArray[2] = direction.Z;

// On lui impulse un mouvement dans la direction directionArray

NewtonBodySetVelocity(pBody, directionArray);

}

La fonction suivante s’occupe de créer un objet Newton Body complètement statique et muni d’une collision solide.

NewtonCollision* PhysicsManager::CreateCollisionFromMesh(scene::IMesh* pIrrlichtMesh, const core::vector3df& v3Scale)
{
    // On prépare un certain type d'objet de collision
    NewtonCollision* pNewtonCollision = NewtonCreateTreeCollision(m_pNewtonWorld, 0);

    NewtonTreeCollisionBeginBuild(pNewtonCollision);

    scene::IMeshBuffer* pMeshBuffer = nullptr;
    int index1, index2, index3;

    /** Faire attention au format des vertex !! **/
    /** Si vous utilisez une autre déclaration de vertex, changez la ici ! **/
    const video::S3DVertex2TCoords* pVertices = nullptr;
    const u16* pIndices = nullptr;
    float floatArray[9] = {0};

    for (unsigned int iMeshBufferNumber = 0; iMeshBufferNumber < pIrrlichtMesh->getMeshBufferCount() ; ++iMeshBufferNumber)
    {
        pMeshBuffer = pIrrlichtMesh->getMeshBuffer(iMeshBufferNumber);

        pIndices = pMeshBuffer->getIndices();
        pVertices = (video::S3DVertex2TCoords*) pMeshBuffer->getVertices();

        for (unsigned int j = 0; j < pMeshBuffer->getIndexCount(); j += 3)
        {
            index1 = pIndices[j + 0];
            index2 = pIndices[j + 1];
            index3 = pIndices[j + 2];

            floatArray[0] = pVertices[index1].Pos.X * v3Scale.X;
            floatArray[1] = pVertices[index1].Pos.Y * v3Scale.Y;
            floatArray[2] = pVertices[index1].Pos.Z * v3Scale.Z;

            floatArray[3] = pVertices[index2].Pos.X * v3Scale.X;
            floatArray[4] = pVertices[index2].Pos.Y * v3Scale.Y;
            floatArray[5] = pVertices[index2].Pos.Z * v3Scale.Z;

            floatArray[6] = pVertices[index3].Pos.X * v3Scale.X;
            floatArray[7] = pVertices[index3].Pos.Y * v3Scale.Y;
            floatArray[8] = pVertices[index3].Pos.Z * v3Scale.Z;

            NewtonTreeCollisionAddFace(pNewtonCollision, 3, floatArray, sizeof(float)*3, 0);
        }
    }
    
    // Finalise la contrustion de l'objet collision
    NewtonTreeCollisionEndBuild(pNewtonCollision, 1);
    
    return pNewtonCollision;
}

NewtonCollision* PhysicsManager::CreateCollisionFromMesh(scene::IMesh* pIrrlichtMesh, const core::vector3df& v3Scale)

{

// On prépare un certain type d'objet de collision

NewtonCollision* pNewtonCollision = NewtonCreateTreeCollision(m_pNewtonWorld, 0);

NewtonTreeCollisionBeginBuild(pNewtonCollision);

scene::IMeshBuffer* pMeshBuffer = nullptr;

int index1, index2, index3;

/** Faire attention au format des vertex !! **/

/** Si vous utilisez une autre déclaration de vertex, changez la ici ! **/

const video::S3DVertex2TCoords* pVertices = nullptr;

const u16* pIndices = nullptr;

float floatArray[9] = {0};

for (unsigned int iMeshBufferNumber = 0; iMeshBufferNumber < pIrrlichtMesh->getMeshBufferCount() ; ++iMeshBufferNumber)

{

pMeshBuffer = pIrrlichtMesh->getMeshBuffer(iMeshBufferNumber);

pIndices = pMeshBuffer->getIndices();

pVertices = (video::S3DVertex2TCoords*) pMeshBuffer->getVertices();

for (unsigned int j = 0; j < pMeshBuffer->getIndexCount(); j += 3)

{

index1 = pIndices[j + 0];

index2 = pIndices[j + 1];

index3 = pIndices[j + 2];

floatArray[0] = pVertices[index1].Pos.X * v3Scale.X;

floatArray[1] = pVertices[index1].Pos.Y * v3Scale.Y;

floatArray[2] = pVertices[index1].Pos.Z * v3Scale.Z;

floatArray[3] = pVertices[index2].Pos.X * v3Scale.X;

floatArray[4] = pVertices[index2].Pos.Y * v3Scale.Y;

floatArray[5] = pVertices[index2].Pos.Z * v3Scale.Z;

floatArray[6] = pVertices[index3].Pos.X * v3Scale.X;

floatArray[7] = pVertices[index3].Pos.Y * v3Scale.Y;

floatArray[8] = pVertices[index3].Pos.Z * v3Scale.Z;

NewtonTreeCollisionAddFace(pNewtonCollision, 3, floatArray, sizeof(float)*3, 0);

}

// Finalise la contrustion de l'objet collision

NewtonTreeCollisionEndBuild(pNewtonCollision, 1);

return pNewtonCollision;

}

La fonction suivante créée un objet collision englobant la forme du mesh passé en paramètre.

// Créée un objet collision avec la forme englobante d'un mesh
NewtonCollision* PhysicsManager::CreateCollisionConvexHullFromMesh(scene::IMesh* pIrrlichtMesh)
{
    unsigned int iMeshBufferNumber = 0;
    scene::IMeshBuffer* pMeshBuffer = nullptr;
    float* afVertices = nullptr;

    unsigned int iTotalVertices = 0;

    for (iMeshBufferNumber = 0; iMeshBufferNumber < pIrrlichtMesh->getMeshBufferCount() ; ++iMeshBufferNumber)
    {
        iTotalVertices += pIrrlichtMesh->getMeshBuffer(iMeshBufferNumber)->getVertexCount();
    }

    afVertices = new float[iTotalVertices * 3];
    u32 iTmpCounter = 0;

    for (iMeshBufferNumber = 0 ; iMeshBufferNumber < pIrrlichtMesh->getMeshBufferCount() ; ++iMeshBufferNumber)
    {
        pMeshBuffer = pIrrlichtMesh->getMeshBuffer(iMeshBufferNumber);

        video::S3DVertex2TCoords* S3vertices = (video::S3DVertex2TCoords*)pMeshBuffer->getVertices();

        for(unsigned int i = 0; i < pMeshBuffer->getVertexCount(); ++i)
        {
            afVertices[iTmpCounter++] = S3vertices[i].Pos.X;
            afVertices[iTmpCounter++] = S3vertices[i].Pos.Y;
            afVertices[iTmpCounter++] = S3vertices[i].Pos.Z;
        }
    }

    NewtonCollision* pNewtonCollision = NewtonCreateConvexHull(m_pNewtonWorld, iTotalVertices, afVertices,
        sizeof(float)*3, 0.1f, 0, nullptr);

    delete [] afVertices;

    return pNewtonCollision;
}

// Créée un objet collision avec la forme englobante d'un mesh

NewtonCollision* PhysicsManager::CreateCollisionConvexHullFromMesh(scene::IMesh* pIrrlichtMesh)

{

unsigned int iMeshBufferNumber = 0;

scene::IMeshBuffer* pMeshBuffer = nullptr;

float* afVertices = nullptr;

unsigned int iTotalVertices = 0;

for (iMeshBufferNumber = 0; iMeshBufferNumber < pIrrlichtMesh->getMeshBufferCount() ; ++iMeshBufferNumber)

{

iTotalVertices += pIrrlichtMesh->getMeshBuffer(iMeshBufferNumber)->getVertexCount();

}

afVertices = new float[iTotalVertices * 3];

u32 iTmpCounter = 0;

for (iMeshBufferNumber = 0 ; iMeshBufferNumber < pIrrlichtMesh->getMeshBufferCount() ; ++iMeshBufferNumber)

{

pMeshBuffer = pIrrlichtMesh->getMeshBuffer(iMeshBufferNumber);

video::S3DVertex2TCoords* S3vertices = (video::S3DVertex2TCoords*)pMeshBuffer->getVertices();

for(unsigned int i = 0; i < pMeshBuffer->getVertexCount(); ++i)

{

afVertices[iTmpCounter++] = S3vertices[i].Pos.X;

afVertices[iTmpCounter++] = S3vertices[i].Pos.Y;

afVertices[iTmpCounter++] = S3vertices[i].Pos.Z;

}

NewtonCollision* pNewtonCollision = NewtonCreateConvexHull(m_pNewtonWorld, iTotalVertices, afVertices,

sizeof(float)*3, 0.1f, 0, nullptr);

delete [] afVertices;

return pNewtonCollision;

}

Les fonctions suivantes sont des callbacks (c’est-à-dire des fonctions appelées de manière
interne à Newton Dynamics).
La première sert à Irrlicht, elle permet de savoir comment doivent être mis en mouvement les SceneNode enregistrées.
La deuxième indique à Newton comment doivent être configuré la pesanteur.

void PhysicsManager::SetTransform(const NewtonBody* const pBody, const float* matrix, int threadIndex)
{
    scene::ISceneNode* pSceneNode = (scene::ISceneNode*) NewtonBodyGetUserData(pBody);

    if (pSceneNode)
    {
        core::matrix4 transform;
        transform.setM(matrix);
        pSceneNode->setPosition(transform.getTranslation());
        pSceneNode->setRotation(transform.getRotationDegrees());
    }    
}

void PhysicsManager::ApplyGravity(const NewtonBody* pBody, float timestep, int threadIndex)
{
   /* Cette fonction est une fonction Callback. Elle sera appelée à chaque fois
   qu'une modification aura lieu sur le corps. */

   // On récupère en premier lieu la masse ainsi que l'inertie
   float masse; // Contiendra la masse de l'objet pris en paramètre par la fonction
   float inertieX, inertieY, inertieZ; // Contiendra l'inertie du corps
   float force[3]; // Spécifiera la force appliquée sur le corps

   NewtonBodyGetMassMatrix(pBody, &masse, &inertieX, &inertieY, &inertieZ);
    
   force[0] = 0.0f; // X
   force[1] = -masse * 9.81f; /// timestep; // 9.81 est l'attraction gravitationnelle de la Terre (Y)
   force[2] = 0.0f; // Z

   NewtonBodyAddForce(pBody, force); // On ajoute la force au corps
}

void PhysicsManager::SetTransform(const NewtonBody* const pBody, const float* matrix, int threadIndex)

{

scene::ISceneNode* pSceneNode = (scene::ISceneNode*) NewtonBodyGetUserData(pBody);

if (pSceneNode)

{

core::matrix4 transform;

transform.setM(matrix);

pSceneNode->setPosition(transform.getTranslation());

pSceneNode->setRotation(transform.getRotationDegrees());

}

void PhysicsManager::ApplyGravity(const NewtonBody* pBody, float timestep, int threadIndex)

{

/* Cette fonction est une fonction Callback. Elle sera appelée à chaque fois

qu'une modification aura lieu sur le corps. */

// On récupère en premier lieu la masse ainsi que l'inertie

float masse; // Contiendra la masse de l'objet pris en paramètre par la fonction

float inertieX, inertieY, inertieZ; // Contiendra l'inertie du corps

float force[3]; // Spécifiera la force appliquée sur le corps

NewtonBodyGetMassMatrix(pBody, &masse, &inertieX, &inertieY, &inertieZ);

force[0] = 0.0f; // X

force[1] = -masse * 9.81f; /// timestep; // 9.81 est l'attraction gravitationnelle de la Terre (Y)

force[2] = 0.0f; // Z

NewtonBodyAddForce(pBody, force); // On ajoute la force au corps

}

Cette fonction ajoute une MeshSceneNode au traitement de Newton Dynamics.
Elle fait appel à CreateCollisionFromMesh(…) pour créer l’objet de collision.
Elle s’occupe aussi de sauvegarder dans un fichier .cache les données de collisions. Cela permettra d’accélérer le calcul et le traitement de la structure de collision du Mesh si un fichier .cache à été trouvé.

void PhysicsManager::CreateDynamicBody(scene::IMeshSceneNode* pMeshNode, float fMass,
                                       bool bUseCache, const std::string& sCacheName)
{    
    std::string sCacheFileName = "";
    NewtonCollision* pNewtonCollision = nullptr;
    FILE* pCacheFile = nullptr;
    
    if (sCacheName == "")
        sCacheFileName = pMeshNode->getName(); // On utilise le nom de la scene node pour nommer le fichier cache

    if (sCacheName != "")
        sCacheFileName = sCacheName; // On utilise un cache spécifique

    if (!sCacheFileName.empty())
        sCacheFileName += ".cache";

    // On utilise le cache si le fichier existe déjà
    if (bUseCache && CollisionCacheFileExist(sCacheFileName))
    {
        pCacheFile = fopen(sCacheFileName.c_str(), "rb");
        // On créér un objet collision directement depuis un cache précédemment créé
        pNewtonCollision = NewtonCreateCollisionFromSerialization(m_pNewtonWorld, DeSerializeCollision, pCacheFile);
    }
    else
    {
        // On créér un objet collision directement depuis le ou les meshbuffers de la SceneNode
        pNewtonCollision = CreateCollisionFromMesh(pMeshNode->getMesh(), pMeshNode->getScale());

        // On créé le cache
        if(!sCacheFileName.empty()) // ... si le fichier n'existe pas déjà
        {
            pCacheFile = fopen(sCacheFileName.c_str(), "wb");        
            // On sérialize l'objet NewtonCollision vers un fichier
            NewtonCollisionSerialize(m_pNewtonWorld, pNewtonCollision, SerializeCollision, pCacheFile);
        }
    }
    
    if (pCacheFile)
    {
        fclose(pCacheFile);
        pCacheFile = nullptr;    
    }

    // On met la bonne échelle
    NewtonCollisionSetScale(pNewtonCollision, pMeshNode->getScale().X, pMeshNode->getScale().Y, pMeshNode->getScale().Z);

    const float* matrix = core::IdentityMatrix.pointer();
    NewtonBody* pBody = NewtonCreateDynamicBody(m_pNewtonWorld, pNewtonCollision, matrix);

    NewtonDestroyCollision(pNewtonCollision);    

    // On remet la matrice des correctes transformations
    core::matrix4 transformation;
    transformation.setTranslation(pMeshNode->getPosition());     
    transformation.setScale(pMeshNode->getScale()); 

    NewtonBodySetMatrix(pBody, transformation.pointer());

    // On envoit un pointeur de la scène node pour pouvoir le récupérer plus tard.
    NewtonBodySetUserData(pBody, pMeshNode);
    // On lui envoit les transformations de la scène node (position, rotation).
    NewtonBodySetMatrix(pBody, pMeshNode->getRelativeTransformation().pointer());

    InitializeRigidBody(pMeshNode, pBody);
}

void PhysicsManager::CreateDynamicBody(scene::IMeshSceneNode* pMeshNode, float fMass,

bool bUseCache, const std::string& sCacheName)

{

std::string sCacheFileName = "";

NewtonCollision* pNewtonCollision = nullptr;

FILE* pCacheFile = nullptr;

if (sCacheName == "")

sCacheFileName = pMeshNode->getName(); // On utilise le nom de la scene node pour nommer le fichier cache

if (sCacheName != "")

sCacheFileName = sCacheName; // On utilise un cache spécifique

if (!sCacheFileName.empty())

sCacheFileName += ".cache";

// On utilise le cache si le fichier existe déjà

if (bUseCache && CollisionCacheFileExist(sCacheFileName))

{

pCacheFile = fopen(sCacheFileName.c_str(), "rb");

// On créér un objet collision directement depuis un cache précédemment créé

pNewtonCollision = NewtonCreateCollisionFromSerialization(m_pNewtonWorld, DeSerializeCollision, pCacheFile);

}

else

{

// On créér un objet collision directement depuis le ou les meshbuffers de la SceneNode

pNewtonCollision = CreateCollisionFromMesh(pMeshNode->getMesh(), pMeshNode->getScale());

// On créé le cache

if(!sCacheFileName.empty()) // ... si le fichier n'existe pas déjà

{

pCacheFile = fopen(sCacheFileName.c_str(), "wb");

// On sérialize l'objet NewtonCollision vers un fichier

NewtonCollisionSerialize(m_pNewtonWorld, pNewtonCollision, SerializeCollision, pCacheFile);

}

if (pCacheFile)

{

fclose(pCacheFile);

pCacheFile = nullptr;

}

// On met la bonne échelle

NewtonCollisionSetScale(pNewtonCollision, pMeshNode->getScale().X, pMeshNode->getScale().Y, pMeshNode->getScale().Z);

const float* matrix = core::IdentityMatrix.pointer();

NewtonBody* pBody = NewtonCreateDynamicBody(m_pNewtonWorld, pNewtonCollision, matrix);

NewtonDestroyCollision(pNewtonCollision);

// On remet la matrice des correctes transformations

core::matrix4 transformation;

transformation.setTranslation(pMeshNode->getPosition());

transformation.setScale(pMeshNode->getScale());

NewtonBodySetMatrix(pBody, transformation.pointer());

// On envoit un pointeur de la scène node pour pouvoir le récupérer plus tard.

NewtonBodySetUserData(pBody, pMeshNode);

// On lui envoit les transformations de la scène node (position, rotation).

NewtonBodySetMatrix(pBody, pMeshNode->getRelativeTransformation().pointer());

InitializeRigidBody(pMeshNode, pBody);

}

Ces fonctions suivantes indiquent à Newton Dynamics comment charger ou sauvegarder
un fichier de collision .cache.

void PhysicsManager::SerializeCollision(void* serializeHandle, const void* buffer, int size)
{
    fwrite(buffer, size, 1, (FILE*)serializeHandle);
}

void PhysicsManager::DeSerializeCollision(void* serializeHandle, void* buffer, int size)
{
    fread(buffer, size, 1, (FILE*)serializeHandle);
}

void PhysicsManager::SerializeCollision(void* serializeHandle, const void* buffer, int size)

{

fwrite(buffer, size, 1, (FILE*)serializeHandle);

}

void PhysicsManager::DeSerializeCollision(void* serializeHandle, void* buffer, int size)

{

fread(buffer, size, 1, (FILE*)serializeHandle);

}

Voici les autres fonctions du fichier PhysicsManager.cpp :

PhysicsManager::PhysicsManager()
{
    m_pNewtonWorld = NewtonCreate();

    NewtonSetSolverModel(m_pNewtonWorld, 1);
}

PhysicsManager::~PhysicsManager()
{
    NewtonDestroyAllBodies(m_pNewtonWorld);
    NewtonDestroy(m_pNewtonWorld);
}

void PhysicsManager::Update(float fValue)
{
    // Rafraichit le moteur Newton
    NewtonUpdate(m_pNewtonWorld, fValue);
}

PhysicsManager::PhysicsManager()

{

m_pNewtonWorld = NewtonCreate();

NewtonSetSolverModel(m_pNewtonWorld, 1);

}

PhysicsManager::~PhysicsManager()

{

NewtonDestroyAllBodies(m_pNewtonWorld);

NewtonDestroy(m_pNewtonWorld);

}

void PhysicsManager::Update(float fValue)

{

// Rafraichit le moteur Newton

NewtonUpdate(m_pNewtonWorld, fValue);

}

Pour utiliser Newton dans Irrlicht, nous proposons le programme suivant :

#include <Irrlicht.h>
#include <Newton.h>

#include <Windows.h>
#include <iostream>

#include "PhysicsManager.h"

using namespace irr;
using namespace core;
using namespace scene;

/* Il faut intégrer la librairie d'Irrlicht dans les propriété du projet */
#pragma comment(lib, "Irrlicht.lib")

/* J'ai aussi joint dans l'archive .zip plusieurs fichier .lib et .dll  de la libraire de Newton */
#pragma comment(lib, "newton_d.lib")

PhysicsManager *m_pPhysicsManager = nullptr;
ICameraSceneNode* cam = nullptr;
ISceneManager* smgr = nullptr;
video::IVideoDriver* driver = nullptr;

class MyEventReceiver : public IEventReceiver
{
public:
    virtual bool OnEvent(const SEvent& event)
    {
        /** Launch cube **/
        if (event.KeyInput.Key == KEY_SPACE)
        {
            IMeshSceneNode* node = smgr->addCubeSceneNode(24, nullptr, -1, cam->getAbsolutePosition());
            core::vector3df vect = cam->getTarget() - cam->getAbsolutePosition();

            node->setMaterialTexture(0, driver->getTexture("box.jpg"));
            node->setMaterialFlag(video::EMF_LIGHTING, false);

            m_pPhysicsManager->LaunchCube(node, vect);
        }

        return false;
    }
    
    MyEventReceiver()
    {
    }

private:
};

int main()
{
    m_pPhysicsManager = new PhysicsManager();
    MyEventReceiver receiver;

    IrrlichtDevice *device =
        createDevice(video::EDT_OPENGL, dimension2d<u32>(1280, 1024), 16,
            false, false, false, &receiver);
 
    if (!device)
        return 1;
 
    device->setWindowCaption(L"Implémentation Newton Dynamics");
 
    driver = device->getVideoDriver();
    smgr = device->getSceneManager();
    gui::IGUIEnvironment* guienv = device->getGUIEnvironment();
 
    device->getFileSystem()->addZipFileArchive("map-20kdm2.pk3");
    scene::IAnimatedMesh* mesh = smgr->getMesh("20kdm2.bsp");
    IMeshSceneNode* node = 0;

    if (mesh)
        node = smgr->addOctreeSceneNode(mesh->getMesh(0), 0, -1, 1024);

    node->setPosition(core::vector3df(-1300,-144,-1249));

     cam = smgr->addCameraSceneNodeFPS();
    
    // On créé l'objet collision du niveau Quake3 pour Newton Dynamics
    m_pPhysicsManager->CreateDynamicBody(node, 10.0f, true, "Collision");

    device->getCursorControl()->setVisible(false);

    while(device->run())
    {
        driver->beginScene(true, true, video::SColor(255,100,101,140));
 
        smgr->drawAll();
        guienv->drawAll();

        m_pPhysicsManager->Update(1/120.0f);
    
        driver->endScene();
    }
 
    device->drop();

    delete m_pPhysicsManager;
 
    return 0;
}

100

101

102

#include <Irrlicht.h>

#include <Newton.h>

#include <Windows.h>

#include <iostream>

#include "PhysicsManager.h"

using namespace irr;

using namespace core;

using namespace scene;

/* Il faut intégrer la librairie d'Irrlicht dans les propriété du projet */

#pragma comment(lib, "Irrlicht.lib")

/* J'ai aussi joint dans l'archive .zip plusieurs fichier .lib et .dll de la libraire de Newton */

#pragma comment(lib, "newton_d.lib")

PhysicsManager *m_pPhysicsManager = nullptr;

ICameraSceneNode* cam = nullptr;

ISceneManager* smgr = nullptr;

video::IVideoDriver* driver = nullptr;

class MyEventReceiver : public IEventReceiver

{

public:

virtual bool OnEvent(const SEvent& event)

{

/** Launch cube **/

if (event.KeyInput.Key == KEY_SPACE)

{

IMeshSceneNode* node = smgr->addCubeSceneNode(24, nullptr, -1, cam->getAbsolutePosition());

core::vector3df vect = cam->getTarget() - cam->getAbsolutePosition();

node->setMaterialTexture(0, driver->getTexture("box.jpg"));

node->setMaterialFlag(video::EMF_LIGHTING, false);

m_pPhysicsManager->LaunchCube(node, vect);

}

return false;

}

MyEventReceiver()

{

}

private:

};

int main()

{

m_pPhysicsManager = new PhysicsManager();

MyEventReceiver receiver;

IrrlichtDevice *device =

createDevice(video::EDT_OPENGL, dimension2d<u32>(1280, 1024), 16,

false, false, false, &receiver);

if (!device)

return 1;

device->setWindowCaption(L"Implémentation Newton Dynamics");

driver = device->getVideoDriver();

smgr = device->getSceneManager();

gui::IGUIEnvironment* guienv = device->getGUIEnvironment();

device->getFileSystem()->addZipFileArchive("map-20kdm2.pk3");

scene::IAnimatedMesh* mesh = smgr->getMesh("20kdm2.bsp");

IMeshSceneNode* node = 0;

if (mesh)

node = smgr->addOctreeSceneNode(mesh->getMesh(0), 0, -1, 1024);

node->setPosition(core::vector3df(-1300,-144,-1249));

cam = smgr->addCameraSceneNodeFPS();

// On créé l'objet collision du niveau Quake3 pour Newton Dynamics

m_pPhysicsManager->CreateDynamicBody(node, 10.0f, true, "Collision");

device->getCursorControl()->setVisible(false);

while(device->run())

{

driver->beginScene(true, true, video::SColor(255,100,101,140));

smgr->drawAll();

guienv->drawAll();

m_pPhysicsManager->Update(1/120.0f);

driver->endScene();

}

device->drop();

delete m_pPhysicsManager;

return 0;

}

Résumé :

Nous avons intégrer le moteur physique Newton Dynamics dans le moteur 3D Irrlicht.

Obtenir le taux d’occupation du CPU

Intro :

Dans cet article nous verrons comment obtenir le taux de consommation total du CPU de votre système et puis comment obtenir le taux de consommation du CPU du processus de votre application.

Pour info, j’ai déjà rédigé un article sur un sujet adjacent : les informations système.

Prérequis :

Savoir lire un peu du C++.

Explications :

Créez un fichier CPUTimer.h :

#ifndef CPU_TIMER_H
#define CPU_TIMER_H

#include <pdh.h>

#pragma comment(lib, "pdh.lib")

class CPUTimer
{
public:
    CPUTimer();

    virtual ~CPUTimer();

    void Initialize();
    void Frame();

    int GetCpuTotalPercentage();
    int GetCpuProcessPercentage();

private:

    /* Consommation CPU total du système */
    HQUERY m_queryHandle;
    HCOUNTER m_counterHandle;
    unsigned long m_lastSampleTime;
    double m_cpuTotalUsage;
    double m_cpuProcessUsage;

    /* Consommation CPU de l'application */
    ULARGE_INTEGER lastCPU, lastSysCPU, lastUserCPU;
    int numProcessors;
    HANDLE self;
};

#endif

#ifndef CPU_TIMER_H

#define CPU_TIMER_H

#include <pdh.h>

#pragma comment(lib, "pdh.lib")

class CPUTimer

{

public:

CPUTimer();

virtual ~CPUTimer();

void Initialize();

void Frame();

int GetCpuTotalPercentage();

int GetCpuProcessPercentage();

private:

/* Consommation CPU total du système */

HQUERY m_queryHandle;

HCOUNTER m_counterHandle;

unsigned long m_lastSampleTime;

double m_cpuTotalUsage;

double m_cpuProcessUsage;

/* Consommation CPU de l'application */

ULARGE_INTEGER lastCPU, lastSysCPU, lastUserCPU;

int numProcessors;

HANDLE self;

};

#endif

On accède aux pourcentages de consommation du CPU par le biais des fonctions :

GetCpuTotalPercentage();
GetCpuProcessPercentage();

1 2	GetCpuTotalPercentage(); GetCpuProcessPercentage();

Créez un fichier CPUTimer.cpp :

#include "CPUTimer.h"

CPUTimer::CPUTimer()
{
}

CPUTimer::~CPUTimer()
{
    PdhCloseQuery(m_queryHandle);
}

void CPUTimer::Initialize()
{
    m_cpuTotalUsage = 0;
    m_cpuProcessUsage = 0;

    /* Consommation CPU total du système */

    PDH_STATUS status;

    status = PdhOpenQuery(NULL, NULL, &m_queryHandle);

    status = PdhAddEnglishCounter(m_queryHandle, TEXT("\\Processor(_Total)\\% processor time"), NULL, &m_counterHandle);

    /***************************************/

    /* Consommation CPU de l'application */

    SYSTEM_INFO sysInfo;
    FILETIME ftime, fsys, fuser;
    
    GetSystemInfo(&sysInfo);
    numProcessors = sysInfo.dwNumberOfProcessors;
    
    GetSystemTimeAsFileTime(&ftime);
    memcpy(&lastCPU, &ftime, sizeof(FILETIME));
    
    self = GetCurrentProcess();

    GetProcessTimes(self, &ftime, &ftime, &fsys, &fuser);

    memcpy(&lastSysCPU, &fsys, sizeof(FILETIME));
    memcpy(&lastUserCPU, &fuser, sizeof(FILETIME));

    m_lastSampleTime = GetTickCount();
}

void CPUTimer::Frame()
{
    // On met à jour les informations toutes les secondes
    if ((m_lastSampleTime + 1000) < GetTickCount())
    {    
        m_lastSampleTime = GetTickCount(); 

        /* Consommation CPU total du système */

        PDH_FMT_COUNTERVALUE value; 

        PdhCollectQueryData(m_queryHandle);
        
        PdhGetFormattedCounterValue(m_counterHandle, PDH_FMT_LONG, NULL, &value);

        m_cpuTotalUsage = value.longValue;

        /* Consommation CPU de l'application */

        FILETIME ftime, fsys, fuser;
        ULARGE_INTEGER now, sys, user;
        double percent;
    
        GetSystemTimeAsFileTime(&ftime);
        memcpy(&now, &ftime, sizeof(FILETIME));
    
        GetProcessTimes(self, &ftime, &ftime, &fsys, &fuser);

        memcpy(&sys, &fsys, sizeof(FILETIME));
        memcpy(&user, &fuser, sizeof(FILETIME));

        percent = (sys.QuadPart - lastSysCPU.QuadPart) +
            (user.QuadPart - lastUserCPU.QuadPart);

        percent /= (now.QuadPart - lastCPU.QuadPart);

        percent /= numProcessors;
        lastCPU = now;

        lastUserCPU = user;
        lastSysCPU = sys;

        m_cpuProcessUsage = percent * 100;
    }
}

int CPUTimer::GetCpuTotalPercentage()
{
    return m_cpuTotalUsage;
}

int CPUTimer::GetCpuProcessPercentage()
{
    return m_cpuProcessUsage;
}

100

101

102

#include "CPUTimer.h"

CPUTimer::CPUTimer()

{

}

CPUTimer::~CPUTimer()

{

PdhCloseQuery(m_queryHandle);

}

void CPUTimer::Initialize()

{

m_cpuTotalUsage = 0;

m_cpuProcessUsage = 0;

/* Consommation CPU total du système */

PDH_STATUS status;

status = PdhOpenQuery(NULL, NULL, &m_queryHandle);

status = PdhAddEnglishCounter(m_queryHandle, TEXT("\\Processor(_Total)\\% processor time"), NULL, &m_counterHandle);

/***************************************/

/* Consommation CPU de l'application */

SYSTEM_INFO sysInfo;

FILETIME ftime, fsys, fuser;

GetSystemInfo(&sysInfo);

numProcessors = sysInfo.dwNumberOfProcessors;

GetSystemTimeAsFileTime(&ftime);

memcpy(&lastCPU, &ftime, sizeof(FILETIME));

self = GetCurrentProcess();

GetProcessTimes(self, &ftime, &ftime, &fsys, &fuser);

memcpy(&lastSysCPU, &fsys, sizeof(FILETIME));

memcpy(&lastUserCPU, &fuser, sizeof(FILETIME));

m_lastSampleTime = GetTickCount();

}

void CPUTimer::Frame()

{

// On met à jour les informations toutes les secondes

if ((m_lastSampleTime + 1000) < GetTickCount())

{

m_lastSampleTime = GetTickCount();

/* Consommation CPU total du système */

PDH_FMT_COUNTERVALUE value;

PdhCollectQueryData(m_queryHandle);

PdhGetFormattedCounterValue(m_counterHandle, PDH_FMT_LONG, NULL, &value);

m_cpuTotalUsage = value.longValue;

/* Consommation CPU de l'application */

FILETIME ftime, fsys, fuser;

ULARGE_INTEGER now, sys, user;

double percent;

GetSystemTimeAsFileTime(&ftime);

memcpy(&now, &ftime, sizeof(FILETIME));

GetProcessTimes(self, &ftime, &ftime, &fsys, &fuser);

memcpy(&sys, &fsys, sizeof(FILETIME));

memcpy(&user, &fuser, sizeof(FILETIME));

percent = (sys.QuadPart - lastSysCPU.QuadPart) +

(user.QuadPart - lastUserCPU.QuadPart);

percent /= (now.QuadPart - lastCPU.QuadPart);

percent /= numProcessors;

lastCPU = now;

lastUserCPU = user;

lastSysCPU = sys;

m_cpuProcessUsage = percent * 100;

}

int CPUTimer::GetCpuTotalPercentage()

{

return m_cpuTotalUsage;

}

int CPUTimer::GetCpuProcessPercentage()

{

return m_cpuProcessUsage;

}

Résumé :

Dans cet article nous avons appris comment obtenir le taux d’occupation du CPU de votre système mais aussi de votre application !

Introduction à DirectX 10 – Rendu 2D – partie 5

Intro :

Dans cette cinquième partie, nous allons apprendre comment afficher une image 2D à l’écran.
Nous proposerons deux façon d’implémenter cet affichage.

Prérequis :

Avoir suivi la cinquième partie de ce tutoriel.

Quatrième partie :

Afficher une image 2D à l’écran.

Explications (1ère façon plus simple, sans utiliser de shader) :

Voici le fichier Sprite2D.h :

#ifndef SPRITE_2D_H
#define SPRITE_2D_H

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

class Sprite2D
{
public:
    Sprite2D(ID3D10Device* pDevice, WCHAR* sTextureFilename, int iImageWidth, int iImageHeight);
    virtual ~Sprite2D();

    bool Initialize();
    void Render();

    void SetPosition(int iPosX, int iPosY);

private:    
    bool Update();

    ID3D10Device* m_pDevice;

    int m_iImageWidth;
    int m_iImageHeight;

    int m_iPosX;
    int m_iPosY;

    ID3D10ShaderResourceView* m_pTextureRessourceView;
    
    std::wstring m_sTextureFilename;

    D3DX10_SPRITE m_pSpriteDesc;
    ID3DX10Sprite* m_pSprite;

    ID3D10Texture2D* m_pTexture;;

    D3DXMATRIX m_matProjection;
};

#endif

#ifndef SPRITE_2D_H

#define SPRITE_2D_H

#include <d3dx10.h>

#include <string>

class Sprite2D

{

public:

Sprite2D(ID3D10Device* pDevice, WCHAR* sTextureFilename, int iImageWidth, int iImageHeight);

virtual ~Sprite2D();

bool Initialize();

void Render();

void SetPosition(int iPosX, int iPosY);

private:

bool Update();

ID3D10Device* m_pDevice;

int m_iImageWidth;

int m_iImageHeight;

int m_iPosX;

int m_iPosY;

ID3D10ShaderResourceView* m_pTextureRessourceView;

std::wstring m_sTextureFilename;

D3DX10_SPRITE m_pSpriteDesc;

ID3DX10Sprite* m_pSprite;

ID3D10Texture2D* m_pTexture;;

D3DXMATRIX m_matProjection;

};

#endif

Voici le constructeur de la classe Sprite2D :

Sprite2D::Sprite2D(ID3D10Device* pDevice, WCHAR* sTextureFilename,
     int iImageWidth, int iImageHeight) :
m_pSprite(nullptr),
m_pTexture(nullptr),
m_pTextureRessourceView(nullptr),
m_sTextureFilename(sTextureFilename),
m_pDevice(pDevice),
m_iPosX(0),
m_iPosY(0),
m_iImageWidth(iImageWidth),
m_iImageHeight(iImageHeight)
{
    if (!Initialize())
    {
        MessageBoxA(NULL, "Erreur d'initialisation d'un Sprite !", "Erreur",
                    MB_ICONHAND | MB_OK);
    }
}

Sprite2D::Sprite2D(ID3D10Device* pDevice, WCHAR* sTextureFilename,

int iImageWidth, int iImageHeight) :

m_pSprite(nullptr),

m_pTexture(nullptr),

m_pTextureRessourceView(nullptr),

m_sTextureFilename(sTextureFilename),

m_pDevice(pDevice),

m_iPosX(0),

m_iPosY(0),

m_iImageWidth(iImageWidth),

m_iImageHeight(iImageHeight)

{

if (!Initialize())

{

MessageBoxA(NULL, "Erreur d'initialisation d'un Sprite !", "Erreur",

MB_ICONHAND | MB_OK);

}

Voici la méthode d’initialisation :

bool Sprite2D::Initialize()
{
    HRESULT hr = D3DX10CreateTextureFromFile(m_pDevice, m_sTextureFilename.c_str(), nullptr, nullptr, (ID3D10Resource**)&m_pTexture, nullptr);

    if (FAILED(hr))
    {
         return false;
    }

    hr = m_pDevice->CreateShaderResourceView((ID3D10Resource*)m_pTexture, nullptr, &m_pTextureRessourceView);

    if (FAILED(hr))
    {
         return false;
    }

    ZeroMemory(&m_pSpriteDesc, sizeof(D3DX10_SPRITE));

    m_pSpriteDesc.pTexture = m_pTextureRessourceView;
    m_pSpriteDesc.TexCoord.x = 0;
    m_pSpriteDesc.TexCoord.y = 0;
    m_pSpriteDesc.TexSize.x = 1.0f;
    m_pSpriteDesc.TexSize.y = 1.0f;
    m_pSpriteDesc.TextureIndex = 0;
    m_pSpriteDesc.ColorModulate = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);

    hr = D3DX10CreateSprite(m_pDevice, 0, &m_pSprite);

    if (FAILED(hr))
    {
         return false;
    }

    D3DXMatrixOrthoOffCenterLH(&m_matProjection, 0.0f, D3D10_RENDERER->GetViewportWidth(), 0.0f,
        D3D10_RENDERER->GetViewportHeight(), 0.1f, 10);

    hr = m_pSprite->SetProjectionTransform(&m_matProjection);

    if (FAILED(hr))
    {
         return false;
    }

    Update();

    return true;
}

bool Sprite2D::Initialize()

{

HRESULT hr = D3DX10CreateTextureFromFile(m_pDevice, m_sTextureFilename.c_str(), nullptr, nullptr, (ID3D10Resource**)&m_pTexture, nullptr);

if (FAILED(hr))

{

return false;

}

hr = m_pDevice->CreateShaderResourceView((ID3D10Resource*)m_pTexture, nullptr, &m_pTextureRessourceView);

if (FAILED(hr))

{

return false;

}

ZeroMemory(&m_pSpriteDesc, sizeof(D3DX10_SPRITE));

m_pSpriteDesc.pTexture = m_pTextureRessourceView;

m_pSpriteDesc.TexCoord.x = 0;

m_pSpriteDesc.TexCoord.y = 0;

m_pSpriteDesc.TexSize.x = 1.0f;

m_pSpriteDesc.TexSize.y = 1.0f;

m_pSpriteDesc.TextureIndex = 0;

m_pSpriteDesc.ColorModulate = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);

hr = D3DX10CreateSprite(m_pDevice, 0, &m_pSprite);

if (FAILED(hr))

{

return false;

}

D3DXMatrixOrthoOffCenterLH(&m_matProjection, 0.0f, D3D10_RENDERER->GetViewportWidth(), 0.0f,

D3D10_RENDERER->GetViewportHeight(), 0.1f, 10);

hr = m_pSprite->SetProjectionTransform(&m_matProjection);

if (FAILED(hr))

{

return false;

}

Update();

return true;

}

Voici les autres méthodes :

void Sprite2D::Render()
{
    m_pSprite->Begin(D3DX10_SPRITE_SORT_TEXTURE | D3DX10_SPRITE_SAVE_STATE);

        m_pSprite->DrawSpritesImmediate(&m_pSpriteDesc, 1, 0, 0);

    m_pSprite->End();
}

bool Sprite2D::Update()
{
    float fSpritePosX = m_iPosX;
    float fSpritePosY = m_iPosY;
    float fSpriteWidth = m_iImageWidth;
    float fSpriteHeight = m_iImageHeight;

    D3DXMATRIX matTranslation;
    D3DXMatrixTranslation(&matTranslation, (fSpriteWidth / 2) + fSpritePosX, (fSpriteHeight / 2) + fSpritePosY, 0.1);

    D3DXMATRIX matScaling;
    D3DXMatrixScaling(&matScaling, fSpriteWidth, fSpriteHeight, 1.0f);

    m_pSpriteDesc.matWorld = matScaling * matTranslation;

    return true;
}

void Sprite2D::SetPosition(int iPosX, int iPosY)
{
    m_iPosX = iPosX;
    m_iPosY = iPosY;

    Update();
}

void Sprite2D::Render()

{

m_pSprite->Begin(D3DX10_SPRITE_SORT_TEXTURE | D3DX10_SPRITE_SAVE_STATE);

m_pSprite->DrawSpritesImmediate(&m_pSpriteDesc, 1, 0, 0);

m_pSprite->End();

}

bool Sprite2D::Update()

{

float fSpritePosX = m_iPosX;

float fSpritePosY = m_iPosY;

float fSpriteWidth = m_iImageWidth;

float fSpriteHeight = m_iImageHeight;

D3DXMATRIX matTranslation;

D3DXMatrixTranslation(&matTranslation, (fSpriteWidth / 2) + fSpritePosX, (fSpriteHeight / 2) + fSpritePosY, 0.1);

D3DXMATRIX matScaling;

D3DXMatrixScaling(&matScaling, fSpriteWidth, fSpriteHeight, 1.0f);

m_pSpriteDesc.matWorld = matScaling * matTranslation;

return true;

}

void Sprite2D::SetPosition(int iPosX, int iPosY)

{

m_iPosX = iPosX;

m_iPosY = iPosY;

Update();

}

Explications (2ème façon plus compliquée, en utilisant un shader) :

Mettre dans un fichier Sprite2D.h :

#ifndef SPRITE_2D
#define SPRITE_2D

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

class Sprite2D
{
public:
    // La structure du rectangle à afficher
    struct VertexType
    {
        D3DXVECTOR3 position;
        D3DXVECTOR2 texture;
    };

    Sprite2D(ID3D10Device* pDevice, WCHAR* sTextureFilename, int iImageWidth, int iImageHeight);
    virtual ~Sprite2D();

    bool Initialize();
    void Render();

    void SetPosition(int iPosX, int iPosY);

private:    
    // Met à jour la dimension du quad texturé
    bool Update();

    ID3D10Device* m_pDevice;

    ID3D10Buffer* m_pVertexBuffer;
    ID3D10Buffer* m_pIndexBuffer;

    int m_iVertexCount;
    int m_iIndexCount;

    int m_iScreenWidth;
    int m_iScreenHeight;

    int m_iImageWidth;
    int m_iImageHeight;

    /* Position de l'image */
    int m_iPosX;
    int m_iPosY;

    int m_iPreviousPosX;
    int m_iPreviousPosY;

    ID3D10ShaderResourceView* m_pTexture;
    ID3D10EffectShaderResourceVariable* m_pTextureVariable;

    ID3D10Effect* m_pEffect;
    ID3D10EffectTechnique* m_pTechnique;
    ID3D10InputLayout* m_pLayout;

    ID3D10EffectMatrixVariable* m_pWorldVariable;
    ID3D10EffectMatrixVariable* m_pViewVariable;
    ID3D10EffectMatrixVariable* m_pProjectionVariable;

    D3DXMATRIX m_worldMatrix;
    D3DXMATRIX m_viewMatrix;
    D3DXMATRIX m_orthoMatrix;
    
    // Le nom de la texture de l'image à afficher
    std::wstring m_sTextureFilename;
};

#endif

#ifndef SPRITE_2D

#define SPRITE_2D

#include <d3dx10.h>

#include <string>

class Sprite2D

{

public:

// La structure du rectangle à afficher

struct VertexType

{

D3DXVECTOR3 position;

D3DXVECTOR2 texture;

};

Sprite2D(ID3D10Device* pDevice, WCHAR* sTextureFilename, int iImageWidth, int iImageHeight);

virtual ~Sprite2D();

bool Initialize();

void Render();

void SetPosition(int iPosX, int iPosY);

private:

// Met à jour la dimension du quad texturé

bool Update();

ID3D10Device* m_pDevice;

ID3D10Buffer* m_pVertexBuffer;

ID3D10Buffer* m_pIndexBuffer;

int m_iVertexCount;

int m_iIndexCount;

int m_iScreenWidth;

int m_iScreenHeight;

int m_iImageWidth;

int m_iImageHeight;

/* Position de l'image */

int m_iPosX;

int m_iPosY;

int m_iPreviousPosX;

int m_iPreviousPosY;

ID3D10ShaderResourceView* m_pTexture;

ID3D10EffectShaderResourceVariable* m_pTextureVariable;

ID3D10Effect* m_pEffect;

ID3D10EffectTechnique* m_pTechnique;

ID3D10InputLayout* m_pLayout;

ID3D10EffectMatrixVariable* m_pWorldVariable;

ID3D10EffectMatrixVariable* m_pViewVariable;

ID3D10EffectMatrixVariable* m_pProjectionVariable;

D3DXMATRIX m_worldMatrix;

D3DXMATRIX m_viewMatrix;

D3DXMATRIX m_orthoMatrix;

// Le nom de la texture de l'image à afficher

std::wstring m_sTextureFilename;

};

#endif

Créer un fichier Sprite2D.cpp où vous metterez :

bool Sprite2D::Initialize()
{
    // On prépare la matrice orthogonale, spécialement conçue pour
    // le rendu 2D.
    D3DXMatrixOrthoLH(&m_orthoMatrix, (float)m_iScreenWidth,
                      (float)m_iScreenHeight, 1.0f, 20.0f);

    VertexType* arVertices;
    unsigned long* indices;

    D3D10_BUFFER_DESC vertexBufferDesc;
    D3D10_BUFFER_DESC indexBufferDesc;

    D3D10_SUBRESOURCE_DATA vertexData;
    D3D10_SUBRESOURCE_DATA indexData;

    HRESULT hr;

    m_iVertexCount = 6;
    m_iIndexCount = m_iVertexCount;
    arVertices = new VertexType[m_iVertexCount];
    indices = new unsigned long[m_iIndexCount];

    memset(arVertices, 0, (sizeof(VertexType) * m_iVertexCount));
    for (unsigned int i = 0; i < m_iIndexCount; i++)
    {
        indices[i] = i;
    }

    vertexBufferDesc.Usage = D3D10_USAGE_DYNAMIC;
    vertexBufferDesc.ByteWidth = sizeof(VertexType) * m_iVertexCount;
    vertexBufferDesc.BindFlags = D3D10_BIND_VERTEX_BUFFER;
    vertexBufferDesc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;
    vertexBufferDesc.MiscFlags = 0;

    vertexData.pSysMem = arVertices;

    // Créér le vertex buffer
    hr = m_pDevice->CreateBuffer(&vertexBufferDesc, &vertexData, &m_pVertexBuffer);

    if (FAILED(hr))
    {
        return false;
    }

    indexBufferDesc.Usage = D3D10_USAGE_DEFAULT;
    indexBufferDesc.ByteWidth = sizeof(unsigned long) * m_iIndexCount;
    indexBufferDesc.BindFlags = D3D10_BIND_INDEX_BUFFER;
    indexBufferDesc.CPUAccessFlags = 0;
    indexBufferDesc.MiscFlags = 0;

    indexData.pSysMem = indices;

    // Créér l'index buffer
    hr = m_pDevice->CreateBuffer(&indexBufferDesc, &indexData, &m_pIndexBuffer);

    if (FAILED(hr))
    {
        return false;
    }

    delete [] arVertices;
    arVertices = 0;

    delete [] indices;
    indices = 0;

    /********* Partie préparation du shader *********/

    unsigned int numElements;
    D3D10_PASS_DESC passDesc;

    hr = D3DX10CreateEffectFromFile(L"Texture.fx", NULL, NULL, "fx_4_0",
                                    D3D10_SHADER_ENABLE_STRICTNESS, 0,
                                    m_pDevice, NULL, NULL, &m_pEffect, NULL, NULL);
    if (FAILED(hr))
    {
        return false;
    }

    m_pTechnique = m_pEffect->GetTechniqueByName("TextureTechnique");
    if (!m_pTechnique)
    {
        return false;
    }

    D3D10_INPUT_ELEMENT_DESC polygonLayout[] =
    {
        { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0 },
        { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D10_APPEND_ALIGNED_ELEMENT, D3D10_INPUT_PER_VERTEX_DATA, 0 },
    };
    numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);

    m_pTechnique->GetPassByIndex(0)->GetDesc(&passDesc);

    // Créér le vertex input layout
    hr = m_pDevice->CreateInputLayout(polygonLayout, numElements, passDesc.pIAInputSignature, passDesc.IAInputSignatureSize, &m_pLayout);
    if (FAILED(hr))
    {
        return false;
    }

    m_pWorldVariable = m_pEffect->GetVariableByName("worldMatrix")->AsMatrix();
    m_pViewVariable = m_pEffect->GetVariableByName("viewMatrix")->AsMatrix();
    m_pProjectionVariable = m_pEffect->GetVariableByName("projectionMatrix")->AsMatrix();
    m_pTextureVariable = m_pEffect->GetVariableByName("shaderTexture")->AsShaderResource();

    // Créée la texture
    hr = D3DX10CreateShaderResourceViewFromFile(m_pDevice, m_sTextureFilename.c_str(), NULL, NULL, &m_pTexture, NULL);

    if (FAILED(hr))
    {
        return false;
    }

    return true;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

bool Sprite2D::Initialize()

{

// On prépare la matrice orthogonale, spécialement conçue pour

// le rendu 2D.

D3DXMatrixOrthoLH(&m_orthoMatrix, (float)m_iScreenWidth,

(float)m_iScreenHeight, 1.0f, 20.0f);

VertexType* arVertices;

unsigned long* indices;

D3D10_BUFFER_DESC vertexBufferDesc;

D3D10_BUFFER_DESC indexBufferDesc;

D3D10_SUBRESOURCE_DATA vertexData;

D3D10_SUBRESOURCE_DATA indexData;

HRESULT hr;

m_iVertexCount = 6;

m_iIndexCount = m_iVertexCount;

arVertices = new VertexType[m_iVertexCount];

indices = new unsigned long[m_iIndexCount];

memset(arVertices, 0, (sizeof(VertexType) * m_iVertexCount));

for (unsigned int i = 0; i < m_iIndexCount; i++)

{

indices[i] = i;

}

vertexBufferDesc.Usage = D3D10_USAGE_DYNAMIC;

vertexBufferDesc.ByteWidth = sizeof(VertexType) * m_iVertexCount;

vertexBufferDesc.BindFlags = D3D10_BIND_VERTEX_BUFFER;

vertexBufferDesc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;

vertexBufferDesc.MiscFlags = 0;

vertexData.pSysMem = arVertices;

// Créér le vertex buffer

hr = m_pDevice->CreateBuffer(&vertexBufferDesc, &vertexData, &m_pVertexBuffer);

if (FAILED(hr))

{

return false;

}

indexBufferDesc.Usage = D3D10_USAGE_DEFAULT;

indexBufferDesc.ByteWidth = sizeof(unsigned long) * m_iIndexCount;

indexBufferDesc.BindFlags = D3D10_BIND_INDEX_BUFFER;

indexBufferDesc.CPUAccessFlags = 0;

indexBufferDesc.MiscFlags = 0;

indexData.pSysMem = indices;

// Créér l'index buffer

hr = m_pDevice->CreateBuffer(&indexBufferDesc, &indexData, &m_pIndexBuffer);

if (FAILED(hr))

{

return false;

}

delete [] arVertices;

arVertices = 0;

delete [] indices;

indices = 0;

/********* Partie préparation du shader *********/

unsigned int numElements;

D3D10_PASS_DESC passDesc;

hr = D3DX10CreateEffectFromFile(L"Texture.fx", NULL, NULL, "fx_4_0",

D3D10_SHADER_ENABLE_STRICTNESS, 0,

m_pDevice, NULL, NULL, &m_pEffect, NULL, NULL);

if (FAILED(hr))

{

return false;

}

m_pTechnique = m_pEffect->GetTechniqueByName("TextureTechnique");

if (!m_pTechnique)

{

return false;

}

D3D10_INPUT_ELEMENT_DESC polygonLayout[] =

{

{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0 },

{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D10_APPEND_ALIGNED_ELEMENT, D3D10_INPUT_PER_VERTEX_DATA, 0 },

};

numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);

m_pTechnique->GetPassByIndex(0)->GetDesc(&passDesc);

// Créér le vertex input layout

hr = m_pDevice->CreateInputLayout(polygonLayout, numElements, passDesc.pIAInputSignature, passDesc.IAInputSignatureSize, &m_pLayout);

if (FAILED(hr))

{

return false;

}

m_pWorldVariable = m_pEffect->GetVariableByName("worldMatrix")->AsMatrix();

m_pViewVariable = m_pEffect->GetVariableByName("viewMatrix")->AsMatrix();

m_pProjectionVariable = m_pEffect->GetVariableByName("projectionMatrix")->AsMatrix();

m_pTextureVariable = m_pEffect->GetVariableByName("shaderTexture")->AsShaderResource();

// Créée la texture

hr = D3DX10CreateShaderResourceViewFromFile(m_pDevice, m_sTextureFilename.c_str(), NULL, NULL, &m_pTexture, NULL);

if (FAILED(hr))

{

return false;

}

return true;

}

La fonction de rendu / d’affichage :

void Sprite2D::Render()
{
    Update();

    // On désactive le ZBuffer pour que l'image soit affichée devant
    // tous les rendus
    D3D10_RENDERER->EnableZBuffer(false);

    unsigned int stride = sizeof(VertexType);
    unsigned int offset = 0;
   
    // On prépare les matrices de transformation
    D3DXMatrixIdentity(&m_worldMatrix);
    D3DXMatrixIdentity(&m_viewMatrix);

    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);

    // Initialise les variables du shader
    m_pWorldVariable->SetMatrix((float*) &m_worldMatrix);
    m_pViewVariable->SetMatrix((float*) &m_viewMatrix);
    m_pProjectionVariable->SetMatrix((float*) &m_orthoMatrix);

    m_pTextureVariable->SetResource(m_pTexture);

    // Prépare le vertex input layout
    m_pDevice->IASetInputLayout(m_pLayout);

    // Prépare les vertex et index buffers pour être affichés
    m_pDevice->IASetVertexBuffers(0, 1, &m_pVertexBuffer, &stride, &offset);
    m_pDevice->IASetIndexBuffer(m_pIndexBuffer, DXGI_FORMAT_R32_UINT, 0);
    m_pDevice->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);

    // Affiche le quad texturé
    D3D10_TECHNIQUE_DESC techniqueDesc;
    m_pTechnique->GetDesc(&techniqueDesc);
    for(unsigned int i = 0; i < techniqueDesc.Passes; i++)
    {
        m_pTechnique->GetPassByIndex(i)->Apply(0);
        m_pDevice->DrawIndexed(m_iIndexCount, 0, 0);
    }

    D3D10_RENDERER->EnableZBuffer(true);
}

void Sprite2D::Render()

{

Update();

// On désactive le ZBuffer pour que l'image soit affichée devant

// tous les rendus

D3D10_RENDERER->EnableZBuffer(false);

unsigned int stride = sizeof(VertexType);

unsigned int offset = 0;

// On prépare les matrices de transformation

D3DXMatrixIdentity(&m_worldMatrix);

D3DXMatrixIdentity(&m_viewMatrix);

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);

// Initialise les variables du shader

m_pWorldVariable->SetMatrix((float*) &m_worldMatrix);

m_pViewVariable->SetMatrix((float*) &m_viewMatrix);

m_pProjectionVariable->SetMatrix((float*) &m_orthoMatrix);

m_pTextureVariable->SetResource(m_pTexture);

// Prépare le vertex input layout

m_pDevice->IASetInputLayout(m_pLayout);

// Prépare les vertex et index buffers pour être affichés

m_pDevice->IASetVertexBuffers(0, 1, &m_pVertexBuffer, &stride, &offset);

m_pDevice->IASetIndexBuffer(m_pIndexBuffer, DXGI_FORMAT_R32_UINT, 0);

m_pDevice->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);

// Affiche le quad texturé

D3D10_TECHNIQUE_DESC techniqueDesc;

m_pTechnique->GetDesc(&techniqueDesc);

for(unsigned int i = 0; i < techniqueDesc.Passes; i++)

{

m_pTechnique->GetPassByIndex(i)->Apply(0);

m_pDevice->DrawIndexed(m_iIndexCount, 0, 0);

}

D3D10_RENDERER->EnableZBuffer(true);

}

Ici la fonction de mise à jour de la position de l’image :

bool Sprite2D::Update()
{
    float left, right, top, bottom;
    VertexType* arVertices;
    void* pVerticesPtr;
    HRESULT hr;

    // On calcul les coordonnées du quad en fonction de la position
    // de l'image
    left = (float)((m_iScreenWidth / 2) * -1) + (float)m_iPosX;
    right = left + (float)m_iImageWidth;

    top = (float)(m_iScreenHeight / 2) - (float)m_iPosY;
    bottom = top - (float)m_iImageHeight;

    arVertices = new VertexType[m_iVertexCount];

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

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

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

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

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

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

    hr = m_pVertexBuffer->Map(D3D10_MAP_WRITE_DISCARD, 0, (void**)&pVerticesPtr);

    if (FAILED(hr))
    {
        return false;
    }

    memcpy(pVerticesPtr, (void*)arVertices, (sizeof(VertexType) * m_iVertexCount));

    m_pVertexBuffer->Unmap();

    delete [] arVertices;
    arVertices = 0;

    return true;
}

bool Sprite2D::Update()

{

float left, right, top, bottom;

VertexType* arVertices;

void* pVerticesPtr;

HRESULT hr;

// On calcul les coordonnées du quad en fonction de la position

// de l'image

left = (float)((m_iScreenWidth / 2) * -1) + (float)m_iPosX;

right = left + (float)m_iImageWidth;

top = (float)(m_iScreenHeight / 2) - (float)m_iPosY;

bottom = top - (float)m_iImageHeight;

arVertices = new VertexType[m_iVertexCount];

// Premier triangle

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

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

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

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

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

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

// Deuxième triangle

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

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

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

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

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

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

hr = m_pVertexBuffer->Map(D3D10_MAP_WRITE_DISCARD, 0, (void**)&pVerticesPtr);

if (FAILED(hr))

{

return false;

}

memcpy(pVerticesPtr, (void*)arVertices, (sizeof(VertexType) * m_iVertexCount));

m_pVertexBuffer->Unmap();

delete [] arVertices;

arVertices = 0;

return true;

}

Créez un fichier Texture.fx, où vous mettrez :

matrix worldMatrix;
matrix viewMatrix;
matrix projectionMatrix;
Texture2D shaderTexture;

SamplerState SampleType
{
    Filter = MIN_MAG_MIP_LINEAR;
    AddressU = Wrap;
    AddressV = Wrap;
};

struct VertexInputType
{
    float4 position : POSITION;
    float2 tex : TEXCOORD0;
};

struct PixelInputType
{
    float4 position : SV_POSITION;
    float2 tex : TEXCOORD0;
};

PixelInputType TextureVertexShader(VertexInputType input)
{
    PixelInputType output;
  
    input.position.w = 1.0f;

    output.position = mul(input.position, worldMatrix);
    output.position = mul(output.position, viewMatrix);
    output.position = mul(output.position, projectionMatrix);
    
    output.tex = input.tex;
    
    return output;
}

float4 TexturePixelShader(PixelInputType input) : SV_Target
{
    float4 textureColor;

    textureColor = shaderTexture.Sample(SampleType, input.tex);

    return textureColor;
}

technique10 TextureTechnique
{
    pass pass0
    {
        SetVertexShader(CompileShader(vs_4_0, TextureVertexShader()));
        SetPixelShader(CompileShader(ps_4_0, TexturePixelShader()));
        SetGeometryShader(NULL);
    }
}

matrix worldMatrix;

matrix viewMatrix;

matrix projectionMatrix;

Texture2D shaderTexture;

SamplerState SampleType

{

Filter = MIN_MAG_MIP_LINEAR;

AddressU = Wrap;

AddressV = Wrap;

};

struct VertexInputType

{

float4 position : POSITION;

float2 tex : TEXCOORD0;

};

struct PixelInputType

{

float4 position : SV_POSITION;

float2 tex : TEXCOORD0;

};

PixelInputType TextureVertexShader(VertexInputType input)

{

PixelInputType output;

input.position.w = 1.0f;

output.position = mul(input.position, worldMatrix);

output.position = mul(output.position, viewMatrix);

output.position = mul(output.position, projectionMatrix);

output.tex = input.tex;

return output;

}

float4 TexturePixelShader(PixelInputType input) : SV_Target

{

float4 textureColor;

textureColor = shaderTexture.Sample(SampleType, input.tex);

return textureColor;

}

technique10 TextureTechnique

{

pass pass0

{

SetVertexShader(CompileShader(vs_4_0, TextureVertexShader()));

SetPixelShader(CompileShader(ps_4_0, TexturePixelShader()));

SetGeometryShader(NULL);

}

Résumé :

Nous avons expliquées deux façon d’afficher du rendu 2D avec DirectX.

Nous nous servirons de cet affichage 2D pour implémenter une UI (Interface Utilisateur).

Références :

– http://mscerts.programming4.us/programming/directx%2010%20game%20programming%20%20%20the%202d%20resurgence%20-%20sprites.aspx

Introduction à DirectX 10 – Lumière – partie 4

Intro :

Dans cette quatrième partie, nous allons apprendre à intégrer une lumière afin d’éclairer notre cube.

Prérequis :

Avoir suivi la troisième partie de ce tutoriel.

Quatrième partie :

Afficher un petit cube éclairé d’une lumière.

Explications :

Nous allons utiliser cette structure de vertex :

struct SimpleVertex
{
    D3DXVECTOR3 Pos;
    D3DXVECTOR2 Tex;
    D3DXVECTOR3 Normal;
};

struct SimpleVertex

{

D3DXVECTOR3 Pos;

D3DXVECTOR2 Tex;

D3DXVECTOR3 Normal;

};

Elle contient un attribut supplémentaire par rapport à la partie 3 : la normale.

La normale d’un vertex est un vecteur perpendiculaire à celui-ci ; nous l’utiliserons afin de calculer le degré de nuance de lumière à cet endroit.
C’est par ce principe que nous effectuerons globalement le calcul lumineux.

Voir cet article pour comprendre comment modéliser la lumière dans un rendu 3D.

Nous allons utiliser ce programme HLSL – partie4.fx :

//--------------------------------------------------------------------------------------
// Constant Buffer Variables
//--------------------------------------------------------------------------------------
matrix World;
matrix View;
matrix Projection;
float4 vLightDir;
Texture2D txDiffuse;

SamplerState samLinear
{
    Filter = MIN_MAG_MIP_LINEAR;
    AddressU = Wrap;
    AddressV = Wrap;
};

//--------------------------------------------------------------------------------------
struct VS_INPUT
{
    float4 Pos : POSITION;
    float2 Tex : TEXCOORD;
    float3 Norm : NORMAL;
};

struct PS_INPUT
{
    float4 Pos : SV_POSITION;
    float2 Tex : TEXCOORD0;
    float3 Norm : TEXCOORD1;
};

//--------------------------------------------------------------------------------------
// Vertex Shader
//--------------------------------------------------------------------------------------
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.Norm = mul( input.Norm, World );
    output.Tex = input.Tex;
    
    return output;
}

//--------------------------------------------------------------------------------------
// Pixel Shader
//--------------------------------------------------------------------------------------
float4 PS( PS_INPUT input) : SV_Target
{
    float4 finalColor = (saturate( dot( (float3)vLightDir, input.Norm) )
    * txDiffuse.Sample( samLinear, input.Tex ));
    finalColor.a = 1;
    return finalColor;
}

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

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

// Constant Buffer Variables

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

matrix World;

matrix View;

matrix Projection;

float4 vLightDir;

Texture2D txDiffuse;

SamplerState samLinear

{

Filter = MIN_MAG_MIP_LINEAR;

AddressU = Wrap;

AddressV = Wrap;

};

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

struct VS_INPUT

{

float4 Pos : POSITION;

float2 Tex : TEXCOORD;

float3 Norm : NORMAL;

};

struct PS_INPUT

{

float4 Pos : SV_POSITION;

float2 Tex : TEXCOORD0;

float3 Norm : TEXCOORD1;

};

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

// Vertex Shader

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

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.Norm = mul( input.Norm, World );

output.Tex = input.Tex;

return output;

}

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

// Pixel Shader

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

float4 PS( PS_INPUT input) : SV_Target

{

float4 finalColor = (saturate( dot( (float3)vLightDir, input.Norm) )

* txDiffuse.Sample( samLinear, input.Tex ));

finalColor.a = 1;

return finalColor;

}

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

technique10 Render

{

pass P0

{

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

SetGeometryShader( NULL );

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

}

Si vous ne comprenez rien à ce programme : consulter cet article.

Il faut aussi connaître la notion de matrices et le principe de transformations de coordonnées
pour comprendre ce code : voir cet article.

Dans votre fichier D3D10Renderer.h, rajoutez :

// Variables matrices en cours
ID3D10EffectMatrixVariable* m_pWorldVariable;
ID3D10EffectMatrixVariable* m_pViewVariable;
ID3D10EffectMatrixVariable* m_pProjectionVariable;

ID3D10EffectVectorVariable* m_pLightDirVariable;
ID3D10EffectVectorVariable* m_pLightColorVariable; 

// Variable texture en cours
ID3D10EffectShaderResourceVariable* m_pDiffuseVariable;

// Variables matrices en cours

ID3D10EffectMatrixVariable* m_pWorldVariable;

ID3D10EffectMatrixVariable* m_pViewVariable;

ID3D10EffectMatrixVariable* m_pProjectionVariable;

ID3D10EffectVectorVariable* m_pLightDirVariable;

ID3D10EffectVectorVariable* m_pLightColorVariable;

// Variable texture en cours

ID3D10EffectShaderResourceVariable* m_pDiffuseVariable;

Ce sont les variables que l’on enverra au shader HLSL.

Ensuite dans votre fichier D3D10Renderer.cpp à la fonction Initialize(bool bFullScreen), rajoutez :

/******************** Partie 2 & 3 & 4 ********************/

DWORD dwShaderFlags = D3D10_SHADER_ENABLE_STRICTNESS;

#if defined( DEBUG ) || defined( _DEBUG )
// Permet d'afficher les éventuelles erreurs de la compilation d'un shader
dwShaderFlags |= D3D10_SHADER_DEBUG;
#endif

// Pour la création du shader, on le compile
hr = D3DX10CreateEffectFromFile(L"Partie4.fx", NULL, NULL, "fx_4_0", dwShaderFlags, 0, m_pd3dDevice, NULL,
                                NULL, &m_pEffect, NULL, NULL);
if (FAILED(hr))
    return false;

// On acquiert la technique du shader HLSL
m_pTechnique = m_pEffect->GetTechniqueByName("Render");

// On acquiert les variables du shader HLSL
// cela permettra de faire le lien avec l'application et le programme shader HLSL
m_pWorldVariable = m_pEffect->GetVariableByName("World")->AsMatrix();
m_pViewVariable = m_pEffect->GetVariableByName("View")->AsMatrix();
m_pProjectionVariable = m_pEffect->GetVariableByName("Projection")->AsMatrix();
m_pLightDirVariable = m_pEffect->GetVariableByName( "vLightDir" )->AsVector();
m_pDiffuseVariable = m_pEffect->GetVariableByName("txDiffuse")->AsShaderResource();

/******************/ 

// On définit la structure d'un vertex, ici 3 attributs sont déclarés
D3D10_INPUT_ELEMENT_DESC layout[] =
{
    { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0 },
    { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D10_INPUT_PER_VERTEX_DATA, 0 },
    { "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 20, D3D10_INPUT_PER_VERTEX_DATA, 0 },
};
UINT numElements = sizeof( layout ) / sizeof( layout[0] );

D3D10_PASS_DESC PassDesc;
m_pTechnique->GetPassByIndex(0)->GetDesc(&PassDesc);
hr = m_pd3dDevice->CreateInputLayout(layout, numElements, PassDesc.pIAInputSignature,
                                     PassDesc.IAInputSignatureSize, &m_pVertexLayout);
if (FAILED(hr))
    return false;

m_pd3dDevice->IASetInputLayout(m_pVertexLayout);

/******************** Partie 2 & 3 & 4 ********************/

DWORD dwShaderFlags = D3D10_SHADER_ENABLE_STRICTNESS;

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

// Permet d'afficher les éventuelles erreurs de la compilation d'un shader

dwShaderFlags |= D3D10_SHADER_DEBUG;

#endif

// Pour la création du shader, on le compile

hr = D3DX10CreateEffectFromFile(L"Partie4.fx", NULL, NULL, "fx_4_0", dwShaderFlags, 0, m_pd3dDevice, NULL,

NULL, &m_pEffect, NULL, NULL);

if (FAILED(hr))

return false;

// On acquiert la technique du shader HLSL

m_pTechnique = m_pEffect->GetTechniqueByName("Render");

// On acquiert les variables du shader HLSL

// cela permettra de faire le lien avec l'application et le programme shader HLSL

m_pWorldVariable = m_pEffect->GetVariableByName("World")->AsMatrix();

m_pViewVariable = m_pEffect->GetVariableByName("View")->AsMatrix();

m_pProjectionVariable = m_pEffect->GetVariableByName("Projection")->AsMatrix();

m_pLightDirVariable = m_pEffect->GetVariableByName( "vLightDir" )->AsVector();

m_pDiffuseVariable = m_pEffect->GetVariableByName("txDiffuse")->AsShaderResource();

/******************/

// On définit la structure d'un vertex, ici 3 attributs sont déclarés

D3D10_INPUT_ELEMENT_DESC layout[] =

{

{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0 },

{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D10_INPUT_PER_VERTEX_DATA, 0 },

{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 20, D3D10_INPUT_PER_VERTEX_DATA, 0 },

};

UINT numElements = sizeof( layout ) / sizeof( layout[0] );

D3D10_PASS_DESC PassDesc;

m_pTechnique->GetPassByIndex(0)->GetDesc(&PassDesc);

hr = m_pd3dDevice->CreateInputLayout(layout, numElements, PassDesc.pIAInputSignature,

PassDesc.IAInputSignatureSize, &m_pVertexLayout);

if (FAILED(hr))

return false;

m_pd3dDevice->IASetInputLayout(m_pVertexLayout);

On créé le vertex buffer d’un cube : il est composé de la position, des coordonées de la texture et des normales de chaque vertex.

Les voici :

// Déclaration des vertices
SimpleVertex vertices[] =
{
    { D3DXVECTOR3( -1.0f, 1.0f, -1.0f ), D3DXVECTOR2( 0.0f, 0.0f ), D3DXVECTOR3( 0.0f, 1.0f, 0.0f ) },
    { D3DXVECTOR3( 1.0f, 1.0f, -1.0f ), D3DXVECTOR2( 1.0f, 0.0f ), D3DXVECTOR3( 0.0f, 1.0f, 0.0f ) },
    { D3DXVECTOR3( 1.0f, 1.0f, 1.0f ), D3DXVECTOR2( 1.0f, 1.0f ), D3DXVECTOR3( 0.0f, 1.0f, 0.0f ) },
    { D3DXVECTOR3( -1.0f, 1.0f, 1.0f ), D3DXVECTOR2( 0.0f, 1.0f ), D3DXVECTOR3( 0.0f, 1.0f, 0.0f ) },

    { D3DXVECTOR3( -1.0f, -1.0f, -1.0f ), D3DXVECTOR2( 0.0f, 0.0f ), D3DXVECTOR3( 0.0f, -1.0f, 0.0f ) },
    { D3DXVECTOR3( 1.0f, -1.0f, -1.0f ), D3DXVECTOR2( 1.0f, 0.0f ), D3DXVECTOR3( 0.0f, -1.0f, 0.0f ) },
    { D3DXVECTOR3( 1.0f, -1.0f, 1.0f ), D3DXVECTOR2( 1.0f, 1.0f ),  D3DXVECTOR3( 0.0f, -1.0f, 0.0f ) },
    { D3DXVECTOR3( -1.0f, -1.0f, 1.0f ), D3DXVECTOR2( 0.0f, 1.0f ),  D3DXVECTOR3( 0.0f, -1.0f, 0.0f ) },

    { D3DXVECTOR3( -1.0f, -1.0f, 1.0f ), D3DXVECTOR2( 0.0f, 0.0f ),  D3DXVECTOR3( -1.0f, 0.0f, 0.0f ) },
    { D3DXVECTOR3( -1.0f, -1.0f, -1.0f ), D3DXVECTOR2( 1.0f, 0.0f ), D3DXVECTOR3( -1.0f, 0.0f, 0.0f ) },
    { D3DXVECTOR3( -1.0f, 1.0f, -1.0f ), D3DXVECTOR2( 1.0f, 1.0f ),  D3DXVECTOR3( -1.0f, 0.0f, 0.0f ) },
    { D3DXVECTOR3( -1.0f, 1.0f, 1.0f ), D3DXVECTOR2( 0.0f, 1.0f ),  D3DXVECTOR3( -1.0f, 0.0f, 0.0f ) },

    { D3DXVECTOR3( 1.0f, -1.0f, 1.0f ), D3DXVECTOR2( 0.0f, 0.0f ), D3DXVECTOR3( 1.0f, 0.0f, 0.0f ) },
    { D3DXVECTOR3( 1.0f, -1.0f, -1.0f ), D3DXVECTOR2( 1.0f, 0.0f ), D3DXVECTOR3( 1.0f, 0.0f, 0.0f ) },
    { D3DXVECTOR3( 1.0f, 1.0f, -1.0f ), D3DXVECTOR2( 1.0f, 1.0f ), D3DXVECTOR3( 1.0f, 0.0f, 0.0f ) },
    { D3DXVECTOR3( 1.0f, 1.0f, 1.0f ), D3DXVECTOR2( 0.0f, 1.0f ),    D3DXVECTOR3( 1.0f, 0.0f, 0.0f ) },

    { D3DXVECTOR3( -1.0f, -1.0f, -1.0f ), D3DXVECTOR2( 0.0f, 0.0f ), D3DXVECTOR3( 0.0f, 0.0f, -1.0f ) },
    { D3DXVECTOR3( 1.0f, -1.0f, -1.0f ), D3DXVECTOR2( 1.0f, 0.0f ),  D3DXVECTOR3( 0.0f, 0.0f, -1.0f ) },
    { D3DXVECTOR3( 1.0f, 1.0f, -1.0f ), D3DXVECTOR2( 1.0f, 1.0f ),  D3DXVECTOR3( 0.0f, 0.0f, -1.0f ) },
    { D3DXVECTOR3( -1.0f, 1.0f, -1.0f ), D3DXVECTOR2( 0.0f, 1.0f ),  D3DXVECTOR3( 0.0f, 0.0f, -1.0f ) },

    { D3DXVECTOR3( -1.0f, -1.0f, 1.0f ), D3DXVECTOR2( 0.0f, 0.0f ), D3DXVECTOR3( 0.0f, 0.0f, 1.0f ) },
    { D3DXVECTOR3( 1.0f, -1.0f, 1.0f ), D3DXVECTOR2( 1.0f, 0.0f ),  D3DXVECTOR3( 0.0f, 0.0f, 1.0f ) },
    { D3DXVECTOR3( 1.0f, 1.0f, 1.0f ), D3DXVECTOR2( 1.0f, 1.0f ),     D3DXVECTOR3( 0.0f, 0.0f, 1.0f ) },
    { D3DXVECTOR3( -1.0f, 1.0f, 1.0f ), D3DXVECTOR2( 0.0f, 1.0f ),  D3DXVECTOR3( 0.0f, 0.0f, 1.0f ) },
};
// Déclaration des indices
DWORD indices[] =
{
    3,1,0,
    2,1,3,

    6,4,5,
    7,4,6,

    11,9,8,
    10,9,11,

    14,12,13,
    15,12,14,

    19,17,16,
    18,17,19,

    22,20,21,
    23,20,22
};

// Déclaration des vertices

SimpleVertex vertices[] =

{

{ D3DXVECTOR3( -1.0f, 1.0f, -1.0f ), D3DXVECTOR2( 0.0f, 0.0f ), D3DXVECTOR3( 0.0f, 1.0f, 0.0f ) },

{ D3DXVECTOR3( 1.0f, 1.0f, -1.0f ), D3DXVECTOR2( 1.0f, 0.0f ), D3DXVECTOR3( 0.0f, 1.0f, 0.0f ) },

{ D3DXVECTOR3( 1.0f, 1.0f, 1.0f ), D3DXVECTOR2( 1.0f, 1.0f ), D3DXVECTOR3( 0.0f, 1.0f, 0.0f ) },

{ D3DXVECTOR3( -1.0f, 1.0f, 1.0f ), D3DXVECTOR2( 0.0f, 1.0f ), D3DXVECTOR3( 0.0f, 1.0f, 0.0f ) },

{ D3DXVECTOR3( -1.0f, -1.0f, -1.0f ), D3DXVECTOR2( 0.0f, 0.0f ), D3DXVECTOR3( 0.0f, -1.0f, 0.0f ) },

{ D3DXVECTOR3( 1.0f, -1.0f, -1.0f ), D3DXVECTOR2( 1.0f, 0.0f ), D3DXVECTOR3( 0.0f, -1.0f, 0.0f ) },

{ D3DXVECTOR3( 1.0f, -1.0f, 1.0f ), D3DXVECTOR2( 1.0f, 1.0f ), D3DXVECTOR3( 0.0f, -1.0f, 0.0f ) },

{ D3DXVECTOR3( -1.0f, -1.0f, 1.0f ), D3DXVECTOR2( 0.0f, 1.0f ), D3DXVECTOR3( 0.0f, -1.0f, 0.0f ) },

{ D3DXVECTOR3( -1.0f, -1.0f, 1.0f ), D3DXVECTOR2( 0.0f, 0.0f ), D3DXVECTOR3( -1.0f, 0.0f, 0.0f ) },

{ D3DXVECTOR3( -1.0f, -1.0f, -1.0f ), D3DXVECTOR2( 1.0f, 0.0f ), D3DXVECTOR3( -1.0f, 0.0f, 0.0f ) },

{ D3DXVECTOR3( -1.0f, 1.0f, -1.0f ), D3DXVECTOR2( 1.0f, 1.0f ), D3DXVECTOR3( -1.0f, 0.0f, 0.0f ) },

{ D3DXVECTOR3( -1.0f, 1.0f, 1.0f ), D3DXVECTOR2( 0.0f, 1.0f ), D3DXVECTOR3( -1.0f, 0.0f, 0.0f ) },

{ D3DXVECTOR3( 1.0f, -1.0f, 1.0f ), D3DXVECTOR2( 0.0f, 0.0f ), D3DXVECTOR3( 1.0f, 0.0f, 0.0f ) },

{ D3DXVECTOR3( 1.0f, -1.0f, -1.0f ), D3DXVECTOR2( 1.0f, 0.0f ), D3DXVECTOR3( 1.0f, 0.0f, 0.0f ) },

{ D3DXVECTOR3( 1.0f, 1.0f, -1.0f ), D3DXVECTOR2( 1.0f, 1.0f ), D3DXVECTOR3( 1.0f, 0.0f, 0.0f ) },

{ D3DXVECTOR3( 1.0f, 1.0f, 1.0f ), D3DXVECTOR2( 0.0f, 1.0f ), D3DXVECTOR3( 1.0f, 0.0f, 0.0f ) },

{ D3DXVECTOR3( -1.0f, -1.0f, -1.0f ), D3DXVECTOR2( 0.0f, 0.0f ), D3DXVECTOR3( 0.0f, 0.0f, -1.0f ) },

{ D3DXVECTOR3( 1.0f, -1.0f, -1.0f ), D3DXVECTOR2( 1.0f, 0.0f ), D3DXVECTOR3( 0.0f, 0.0f, -1.0f ) },

{ D3DXVECTOR3( 1.0f, 1.0f, -1.0f ), D3DXVECTOR2( 1.0f, 1.0f ), D3DXVECTOR3( 0.0f, 0.0f, -1.0f ) },

{ D3DXVECTOR3( -1.0f, 1.0f, -1.0f ), D3DXVECTOR2( 0.0f, 1.0f ), D3DXVECTOR3( 0.0f, 0.0f, -1.0f ) },

{ D3DXVECTOR3( -1.0f, -1.0f, 1.0f ), D3DXVECTOR2( 0.0f, 0.0f ), D3DXVECTOR3( 0.0f, 0.0f, 1.0f ) },

{ D3DXVECTOR3( 1.0f, -1.0f, 1.0f ), D3DXVECTOR2( 1.0f, 0.0f ), D3DXVECTOR3( 0.0f, 0.0f, 1.0f ) },

{ D3DXVECTOR3( 1.0f, 1.0f, 1.0f ), D3DXVECTOR2( 1.0f, 1.0f ), D3DXVECTOR3( 0.0f, 0.0f, 1.0f ) },

{ D3DXVECTOR3( -1.0f, 1.0f, 1.0f ), D3DXVECTOR2( 0.0f, 1.0f ), D3DXVECTOR3( 0.0f, 0.0f, 1.0f ) },

};

// Déclaration des indices

DWORD indices[] =

{

3,1,0,

2,1,3,

6,4,5,

7,4,6,

11,9,8,

10,9,11,

14,12,13,

15,12,14,

19,17,16,

18,17,19,

22,20,21,

23,20,22

};

Toujours dans votre fichier D3D10Renderer.cpp à la fonction Initialize(bool bFullScreen), rajoutez :

D3DXMatrixIdentity(&m_worldMatrix);

D3DXVECTOR3 Eye(0.0f, 3.0f, -6.0f);
D3DXVECTOR3 At(0.0f, 0.0f, 0.0f);
D3DXVECTOR3 Up(0.0f, 1.0f, 0.0f);

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

// Initialize the projection matrix
D3DXMatrixPerspectiveFovLH( &m_projectionMatrix, ( float )D3DX_PI * 0.25f, width / ( FLOAT )height, 0.1f, 100.0f );

// Update Variables that never change
m_pViewVariable->SetMatrix( ( float* )&m_viewMatrix );
m_pProjectionVariable->SetMatrix( ( float* )&m_projectionMatrix );
m_pDiffuseVariable->SetResource( m_pTextureRV );

D3DXMatrixIdentity(&m_worldMatrix);

D3DXVECTOR3 Eye(0.0f, 3.0f, -6.0f);

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

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

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

// Initialize the projection matrix

D3DXMatrixPerspectiveFovLH( &m_projectionMatrix, ( float )D3DX_PI * 0.25f, width / ( FLOAT )height, 0.1f, 100.0f );

// Update Variables that never change

m_pViewVariable->SetMatrix( ( float* )&m_viewMatrix );

m_pProjectionVariable->SetMatrix( ( float* )&m_projectionMatrix );

m_pDiffuseVariable->SetResource( m_pTextureRV );

Toujours dans votre fichier D3D10Renderer.cpp :

void D3D10Renderer::Render()
{
    // Couleur du fond de rendu
    static float afClearColor[4] = {0.0f, 0.125f, 0.3f, 1.0f}; 

    // Efface la surface de rendu
    m_pd3dDevice->ClearRenderTargetView(m_pRenderTargetView, afClearColor);
    
    /*********** Donnée d'une variable de temps ***********/
 
    static float t = 0.0f;
    static DWORD dwTimeStart = 0;
    DWORD dwTimeCur = GetTickCount();
    if( dwTimeStart == 0 )
        dwTimeStart = dwTimeCur;
    t = ( dwTimeCur - dwTimeStart ) / 1000.0f;
    
    /*******************************************************/
    
    // Direction de la lumière
    D3DXVECTOR4 vLightDirs( -1.577f, 0.577f, -0.577f, 1.0f );

    D3DXMATRIX mRotate;
    D3DXVECTOR4 vOutDir;
    D3DXMatrixRotationZ( &mRotate, -2.0f * t );
    D3DXVec3Transform( &vLightDirs, ( D3DXVECTOR3* )&vLightDirs, &mRotate );

    // On met à jour les variables du shader HLSL
    m_pWorldVariable->SetMatrix((float*)&m_worldMatrix);
    m_pLightDirVariable->SetFloatVectorArray((float*)vLightDirs, 0, 2);

    /**********************/

    // Affiche le cube
    D3D10_TECHNIQUE_DESC techDesc;
    m_pTechnique->GetDesc(&techDesc);
    for (UINT p = 0; p < techDesc.Passes; ++p)
    {
        m_pTechnique->GetPassByIndex( p )->Apply( 0 );
        m_pd3dDevice->DrawIndexed( 36, 0, 0 );
    }

    /**********************/

    // On affiche le front buffer
    m_pSwapChain->Present( 0, 0 );
}

void D3D10Renderer::Render()

{

// Couleur du fond de rendu

static float afClearColor[4] = {0.0f, 0.125f, 0.3f, 1.0f};

// Efface la surface de rendu

m_pd3dDevice->ClearRenderTargetView(m_pRenderTargetView, afClearColor);

/*********** Donnée d'une variable de temps ***********/

static float t = 0.0f;

static DWORD dwTimeStart = 0;

DWORD dwTimeCur = GetTickCount();

if( dwTimeStart == 0 )

dwTimeStart = dwTimeCur;

t = ( dwTimeCur - dwTimeStart ) / 1000.0f;

/*******************************************************/

// Direction de la lumière

D3DXVECTOR4 vLightDirs( -1.577f, 0.577f, -0.577f, 1.0f );

D3DXMATRIX mRotate;

D3DXVECTOR4 vOutDir;

D3DXMatrixRotationZ( &mRotate, -2.0f * t );

D3DXVec3Transform( &vLightDirs, ( D3DXVECTOR3* )&vLightDirs, &mRotate );

// On met à jour les variables du shader HLSL

m_pWorldVariable->SetMatrix((float*)&m_worldMatrix);

m_pLightDirVariable->SetFloatVectorArray((float*)vLightDirs, 0, 2);

/**********************/

// Affiche le cube

D3D10_TECHNIQUE_DESC techDesc;

m_pTechnique->GetDesc(&techDesc);

for (UINT p = 0; p < techDesc.Passes; ++p)

{

m_pTechnique->GetPassByIndex( p )->Apply( 0 );

m_pd3dDevice->DrawIndexed( 36, 0, 0 );

}

/**********************/

// On affiche le front buffer

m_pSwapChain->Present( 0, 0 );

}

Résumé :

Nous avons intégré une lumière près de notre cube afin de l’éclairer.

Voici l’archive du code complet pour cette partie : DirectX 10 Tutoriel – Partie 4.zip

Blog de développement de jeux vidéo

Apprenez à programmer des jeux vidéos

Archives de l’auteur : cezium

Les pointeurs intelligents

Debugguez vos fichiers .FX avec l’interface ID3D10Blob

Théorie sur les lumières

Les propriétés d’un matériau donnée (or, glace, bois, métal, etc…) déterminent comment un modèle est affiché :

Les propriétés d’une lumière donnée déterminent comment la scène est affichée :

Lumière ambiante :

La réflexion diffuse :

Nouveautés C++11

Mémoire locale pour un thread :

Sizeof sur les attributs de classes :

Mettre en surbrillance l’icone de la barre des tâches

Fonctions delegates avec std::function et std::bind

Un Performance Timer pour synchroniser vos entités

Génération procédurale d’un labyrinthe 3D

RAII (Resource Acquisition Is Initialization)

Récapitulatif C++

Caméra à la 3ème personne trigonométrique

Principe du Z-buffer

Les principales fonctions de la bibliothèque D3DX (DirectX 10)

Bien configurer un projet Visual C++

Les fichiers d’en-têtes précompilés (Visual C++)

Introduction à la programmation réseau (Sockets) – partie 1

Intégration de Newton Dynamics dans Irrlicht 3D

Obtenir le taux d’occupation du CPU

Introduction à DirectX 10 – Rendu 2D – partie 5

Quatrième partie :

Introduction à DirectX 10 – Lumière – partie 4

Quatrième partie :