Game Developers

void Affichage::afficherMaison()
{
     /* Affichage de la maison créer sous blender */
    maMaison = maSceneManager->getMesh("media/house2.3ds"); // defaut  : house.3ds
    nMaMaison= maSceneManager->addAnimatedMeshSceneNode(maMaison);    //nMaMaison= maSceneManager->addMeshSceneNode(maMaison -> getMesh(0));
    //nMaMaison->setMaterialFlag(video::EMF_LIGHTING,false);
    nMaMaison->setPosition(core::vector3df(4000, 0, 3000));   // -30
    nMaMaison->setScale(core::vector3df(100,100,100));
    maSceneManager->getMeshManipulator()->makePlanarTextureMapping(maMaison->getMesh(0), 0.3f);
    nMaMaison->setMaterialTexture(0, driver -> getTexture("media/metal.jpg"));   // Ou carrelage.jpg :)
    nMaMaison->addShadowVolumeSceneNode();
}

#ifndef AFFICHAGE_H_INCLUDED
#define AFFICHAGE_H_INCLUDED
 
#include <iostream>
#include <windows.h>
#include <irrlicht.h>
 
using namespace irr;
class Affichage
{
    public:
        Affichage();
        void menuConsole();
        int initialiserIrrlicht(int);
        void afficherCamera();
        int boucleRendu();
        int afficherCube();
        int afficherTerrain();
        void afficherMaison();
        int afficherFeu();
 
    private:
        IrrlichtDevice *device;
        scene::ISceneManager *maSceneManager;
        video::IVideoDriver *driver;
        scene::ICameraSceneNode *maCamera;
        scene::ISceneNode *monCube, *monCube2;
        scene::ITerrainSceneNode *monTerrain;
        scene::ILightSceneNode *monSoleil;
        scene::IAnimatedMesh *maMaison;
        scene::IAnimatedMeshSceneNode *nMaMaison ;  // IMeshSceneNode
};
 
#endif // AFFICHAGE_H_INCLUDED

#include "Affichage.h"
 
using namespace std;
 
Affichage::Affichage()
{
 
}
void Affichage::menuConsole()
{
    int choixMenu;
    cout << "Hello world ;) " << endl;
    cout << "Choisissez votre resolution graphique ci-dessous : " << endl;
    cout << "1. 640*480 en 32bits couleurs" << endl;
    cout << "2. 800*600 en 32 bits couleurs" << endl;
    cout << "Votre choix : " ;
    cin >> choixMenu;
    // Appel de la fonction initialiserIrrlicht pour définir la résolution de la fenêtre.
    initialiserIrrlicht(choixMenu);
    // Appel de la fonction :
}
 
int Affichage::initialiserIrrlicht(int choixResolution)
{
    switch(choixResolution)
    {
        case 1:
            cout << "choix 1" << endl;
            device = createDevice(video::EDT_OPENGL, core::dimension2d<u32>(800,600), 32, false, true);   // 32, true pour le plein ecran
        break;
        case 2:
            cout << "Choix 2" << endl;
            device = createDevice(video::EDT_OPENGL, core::dimension2d<u32>(1366,768), 32, true, true);   // 32, true pour le plein ecran
        break;
        default:
            cout << "Choix entre 1 et 2. Merci" << endl;
            system("cls");
            menuConsole();
        break;
    }
    // Récupération du gestionnaire de scene :
    maSceneManager = device->getSceneManager();
    // Récupération du pilote video :
    driver = device->getVideoDriver();
    // Titre pour la fenêtre :
    device->setWindowCaption(L"Mon jeu 3D sous Irrlicht");
    return 0;
}
 
void Affichage::afficherCamera()
{
    maCamera = maSceneManager->addCameraSceneNodeFPS();
    maCamera->setPosition(core::vector3df(50, 3, 50));   // Default : 100.f,100.f,100.f et mtn : 5000, 300, 5000
    maCamera->setTarget(irr::core::vector3df(0.f,0.f,0.f));
    maCamera->setFarValue(10000.0f);
    device->getCursorControl()->setVisible(false);
}
 
int Affichage::boucleRendu()
{
    while(device->run())
    {
        driver->beginScene(true, true, video::SColor(255,128,128,255));
        maSceneManager->drawAll();
        driver->endScene();
    }
    device->drop();
    return 0;
}
 
int Affichage::afficherCube(int posX, int posY, int posZ)
{
    /* Créations d'une boucle FOR pour afficher plusieurs cube, histoire de créer genre un mur, ou une maison ? */
    // Création du cube :
    monCube = maSceneManager->addCubeSceneNode(1.f);
    monCube->setPosition(core::vector3df(posX, posY, posZ));
    // Affichage de la texture :
    monCube->setMaterialTexture(0, driver->getTexture("media/metal.jpg"));
 
    //monCube->addShadowVolumeSceneNode();
    return 0;
}
 
int Affichage::afficherTerrain()
{
    /* Modifier le prototype de cette fonction pour mettre les 3 paramètres suivant : */
    unsigned char chemin_texture[30] = "media/snow.jpg";
    unsigned char chemin_skydom[30] = "media/skydome.jpg";
    unsigned char chemin_heighMap[30] = "media/map.png";
 
    // Réglage de la lumière ici :
    maSceneManager->setAmbientLight(video::SColorf(0.5f,0.5f,0.5f,1.f));    // 0.5f,0.5f,0.5f,1.f
    // Création d'une lumière diffuse :
    monSoleil = maSceneManager->addLightSceneNode();
    // On spécifie la distance que l'on peut atteindre avec la lumière :
    monSoleil->setRadius(1000);
    // Position de la lumière sur la scene :
    monSoleil->setPosition(core::vector3df(40, 20, 40));
    //monSoleil->getLightData().CastShadows = true;
    // Ajout de la SkyDome (Ciel, nuage, etc.) :
    scene::ISceneNode *monCiel = maSceneManager->addSkyDomeSceneNode(driver->getTexture(chemin_skydom));
    // Code ci-dessous pour afficher le terrain ainsi que la texture de celui-ci :
    monTerrain = maSceneManager->addTerrainSceneNode(
		chemin_heighMap,
		0,
		-1,
		core::vector3df(0.f, 0.f, 0.f),
		core::vector3df(0.f, 0.f, 0.f),
		core::vector3df(0.4f, 0.044f, 0.4f),
		video::SColor ( 255, 255, 255, 255 ),
		5//,
		//scene::ETPS_17,
		//3
		);
    monTerrain->setMaterialTexture(0, driver->getTexture(chemin_texture));
    //monTerrain->scaleTexture(10.f, 10.f); // Par défaut 10f, 10f
 
    afficherMaison(40, 0, 35);
    afficherMaison(100, 0, 80);
    return 0;
}
 
void Affichage::afficherMaison(int posX, int posY, int posZ)
{
     /* Affichage de la maison créer sous blender */
    maMaison = maSceneManager->getMesh("media/house2.3ds"); // defaut  : house.3ds
    nMaMaison= maSceneManager->addAnimatedMeshSceneNode(maMaison);    //nMaMaison= maSceneManager->addMeshSceneNode(maMaison -> getMesh(0));
    //nMaMaison->setMaterialFlag(video::EMF_LIGHTING,false);
    nMaMaison->setPosition(core::vector3df(posX, posY, posZ));   // -30
    nMaMaison->setScale(core::vector3df(1,1,1));
    maSceneManager->getMeshManipulator()->makePlanarTextureMapping(maMaison->getMesh(0), 0.3f);
    nMaMaison->setMaterialTexture(0, driver -> getTexture("media/wall.jpg"));   // Ou carrelage.jpg :)
    nMaMaison->addShadowVolumeSceneNode();
}
 
int Affichage::afficherFeu(int posX, int posY, int posZ)
{
    scene::IParticleSystemSceneNode *particuleFeu = maSceneManager->addParticleSystemSceneNode(false);
    scene::IParticleEmitter *emetteur = particuleFeu->createBoxEmitter(core::aabbox3d<f32>(-7,0,-7,7,1,7),
                                                                       core::vector3df(0.0f, 0.06f, 0.0f),
                                                                       0.8, 1,
                                                                       video::SColor(0,255,255,255),
                                                                       video::SColor(0,255,255,255),
                                                                       8,20,7,
                                                                       core::dimension2df(0.1f,0.1f),
                                                                       core::dimension2df(0.2f,0.2f)
                                                                       );
    particuleFeu->setEmitter(emetteur);
    particuleFeu->setPosition(core::vector3df(posX, posY, posZ));  // position du feu :
    emetteur->drop();
 
    scene::IParticleAffector* paf = particuleFeu->createFadeOutParticleAffector();
    particuleFeu->addAffector(paf);
    paf->drop();
    particuleFeu->setMaterialFlag(video::EMF_LIGHTING, false);
    particuleFeu->setMaterialFlag(video::EMF_ZWRITE_ENABLE, false);
    particuleFeu->setMaterialTexture(0, driver->getTexture("media/fire.bmp"));
    particuleFeu->setMaterialType(video::EMT_TRANSPARENT_VERTEX_ALPHA);
    return 0;
}
 

#include <irrlicht.h>
#include "Affichage.h"
 
Affichage monAffichage;
using namespace std;
//using namespace irr;
 
int main(int argv, char *argc[])
{
    monAffichage.menuConsole();
    // Fonction pour la boucle de rendu :
    monAffichage.afficherCamera();
    monAffichage.afficherTerrain();
    // Affichage des deux cubes :
    monAffichage.afficherCube(40, 0.5, 40);
    monAffichage.afficherCube(39, 0.5, 40);
    // Affichage des deux particules de feu :
    monAffichage.afficherFeu(38, 0, 40);
    monAffichage.afficherFeu(41, 0, 40);
    // Affichage de la boucle de rendu :
    monAffichage.boucleRendu();
    return 0;
}