Intro :

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

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

Explications :

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

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

Intro :

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

Prérequis :

– Savoir lire du C++

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

Explications :

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

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

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

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

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

 

Résumé :

Références :

Intro :

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

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

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

Prérequis :

– Savoir lire du C++

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

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

Explications :

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

Installation de Ogre3D dans Visual Studio C++ :

Voici le répertoire du SDK une fois extrait :

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

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

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

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

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

Copiage des fichiers DLL :

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

 

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

Voir ce tutoriel

Copiage des fichiers .cfg :

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

# Defines plugins to load

# Define plugin folder
PluginFolder=.

# Define plugins
Plugin=RenderSystem_Direct3D9_d
Plugin=RenderSystem_Direct3D11_d
Plugin=RenderSystem_GL_d

 

Résumé :

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

Références :

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

I

 

Intro :

Irrlicht 3D est un moteur 3D gratuit et open-source écrit en C++.
Son utilisation est facilité par le petit nombre de méthodes (fonctions) qu’il possède par rapport à Ogre3D qui quant à lui comporte beaucoup plus de fonctions. Irrlicht 3D est donc plutôt simple à utiliser.

Il gère aussi bien les APIs DirectX que OpenGL. Il peut être aussi utilisé sur Linux, Windows et OS X.

Version d’Irrlicht 3D utilisée : 1.8.1

Prérequis :

– Savoir lire les rudiments d’un programme C++ (pointeur, classe, etc…)
– Savoir configurer Visual Studio C++ Express (voir cet article)

Explications :

Il vous faut comprendre comment configurer les répertoires de dépendance dans Visual C++.

Télécharger Irrlicht :

http://irrlicht.sourceforge.net/downloads.html

Ce qu’il y a dans le repertoire extrait :

bin : les bibliothèques dynamiques et les binaires des exemples du SDK

include : les principaux headers du code source

lib : les bibliothèques statiques

Ce qu’il faut faire :

Dans le répertoire bin extrait : il vous suffit de choisir le dossier correspondant à votre configuration et de copier le fichier .dll quelque part.
Vous devrez le mettre dans le même dossier que vos fichiers exécutables (.exe) pour que ceux-ci fonctionnent.

Il faut configurer votre IDE (en l’occurence Visual Studio C++)
en paramétrant les dossiers include / et lib (suivre ce tutoriel pour le configurer [config_vc++]

Mettre dans votre fichier .cpp principal :

 

---

 

Exemple complet :

 // Définition de la bibliothèque 
Irrlicht.lib#pragma comment(lib, "Irrlicht.lib")

 // Déclaration du fichier d'en-tête d'Irrlicht
#include <irrlicht.h>

// Déclaration du namespace (espace de nom) d'Irrlicht
using namespace irr; 

int main()
{
    // Créée le device qui va gérer le moteur 3D
    IrrlichtDevice* device = createDevice(video::EDT_DIRECT3D8,
        core::dimension2d<u32>(640,480));

    // Système qui permet d'afficher du rendu à l'écran
    video::IVideoDriver* driver = device->getVideoDriver();
    scene::ISceneManager* scenemgr = device->getSceneManager();

    // On spécifie le titre de la fenêtre
    device->setWindowCaption(L"Hello World!");

    // On charge un fichier modèle .md2
    scene::ISceneNode* node = scenemgr->addAnimatedMeshSceneNode(
        scenemgr->getMesh("quake2model.md2"));

    // On ajoute à ce modèle, une texture et on désactive les lumières
    if (node)
    {
        node->setMaterialTexture(0, driver->getTexture("texture.bmp"));
        node->setMaterialFlag(video::EMF_LIGHTING, false);
    }

    // On ajoute une caméra de type FPS (Vue à la première personne)
    scenemgr->addCameraSceneNodeFPS();

    // On affiche le rendu !
    while (device->run() && driver)
    {
        driver->beginScene(true, true, video::SColor(255,0,0,255));
        scenemgr->drawAll();
        driver->endScene();
    }

    // On efface le device
    device->drop();
    return 0;
}

 

Fonction createDevice (…) :

irr::IrrlichtDevice* device =
             irr::createDevice(irr::video::EDT_OPENGL,
             irr::core::dimension2d<irr::u32>(800,600),
             32, false, true, false, 0);

 

Explication du bout de code :

Les arguments passés en paramètre sont dans l’ordre :

– device  : c’est un pointeur sur l’objet returné par irr:createDevice(…)

– deviceType : désigne l’API graphique avec laquelle va s’interfacer Irrlicht. Nous utiliserons OpenGL tout au long du tutoriel, mais on peut aussi choisir Direct3D par exemple en mettant la valeur EDT_DIRECT3D9.

– windowSize : la taille de la fenêtre. Tout est dit ! Avec le code indiqué plus haut, on crée une
fenêtre de 800 par 600 pixels.

– bits : détermine le nombre de bits par pixels.

– fullscreen : un booléen qui indique si on veut faire du plein écran ou pas. Pour la valeur true l’application
sera en plein écran, et pour false la fenêtre sera de la taille définie plus haut.

– stencilbuffer : un autre booléen qui indique lui si on active le stencil buffer ou pas. Il est actif pour true.

– vsync : toujours un booléen. Celui-ci sert à activer la synchronisation verticale. Pas de mystère, elle est active pour true.

– receiver : permet d’associer un capteur d’événements au device (0 signifie qu’on n’associe rien). Nous verrons de quoi il s’agit dans un prochain chapitre.

Résumé :

Dans cette première partie nous avons appris comment se servir de Irrlicht 3D.

Références :

– http://irrlicht.sourceforge.net/features/
– http://openclassrooms.com/courses/3d-temps-reel-avec-irrlicht
– http://irrlicht.sourceforge.net/docu/example001.html