#0 

09-04-2013 21:27:59

jonath313
Abonné
Date d'inscription: 28-12-2009
Messages: 240

Voici ma caméra 3éme personne :

CLEventReceiver .h

Code:

#include <irr/irrlicht.h>
#include <cstdlib>
#include <iostream>
#include <windows.h>

using namespace irr;
using namespace core;
using namespace gui;
using namespace video;
using namespace scene;

class CLEventReceiver : public irr::IEventReceiver//On créé une classe CEventReceiver , fille de la classe IEventReceiver
{
public ://dans la partie publique , on va mettre les prototypes de nos fonctions

    CLEventReceiver(irr::scene::IAnimatedMeshSceneNode* Nperso,
                    irr::scene::ICameraSceneNode* camera3);//On créé le constructeur , qui prend en parametre le node de notre modele(ici , Sydney , donc)

    virtual bool OnEvent(const irr::SEvent &event);//Cette fonction est lancée en cas d'évenement

    void majPosMesh();//On met à jour la position de notre mesh
    void majAnimMesh();//On met à jour l'animation du mesh , si besoin est

    void CameraTourneHorizontal(scene::ISceneNode *node, const core::vector3df &origin, const core::vector3df &angle);
    void CameraTourneVerticale(scene::ISceneNode *node, const core::vector3df &origin, const core::vector3df &angle);


private ://dans la partie privée , on met nos attributs

    irr::scene::IAnimatedMeshSceneNode* m_Nperso;//Le node que l'on va manipuler
    irr::scene::ICameraSceneNode* m_Ncamera3;//Le node que l'on va manipuler

    bool m_camGauche;
    bool m_camDroite;
    bool m_camHaut;
    bool m_camBas;
    bool m_PivoCamHorizontal;
    bool m_PivoCamVerticale;

};

CLEventReceiver .cpp

Code:

#include "CLEventReceiver.h"
#include <cstdlib>
#include <windows.h>
#include <iostream>


using namespace std;

CLEventReceiver::CLEventReceiver(irr::scene::IAnimatedMeshSceneNode* Nperso,
                                 irr::scene::ICameraSceneNode* camera3)//revoilà notre constructeur :)
{
    m_Nperso = Nperso;//On pointe le mesh passe en parametre.
    m_Ncamera3 = camera3;

    m_animrun = true;//et comme l'animation n'est du coup pas "courir" , on met notre booléen à false aussi


    m_isAvance = false;//Par défaut , le modele est immobile .Donc le booléen qui indique si l'on bouge est à false
    m_isRecule = false;
    m_isDroite = false;
    m_isGauche = false;
    m_isSauterAvant = false;
    m_isSauterArriere = false;
    m_isPivoterDroite = false;
    m_isPivoterGauche = false;

    m_camGauche = false;
    m_camDroite = false;
    m_camHaut   = false;
    m_camBas    = false;
    m_PivoCamHorizontal = false;
    m_PivoCamVerticale  = false;

    m_isCourrir = false;
    m_isMarcher = false;
}


bool CLEventReceiver::OnEvent(const irr::SEvent &event)//En cas d'évenement :
{

    if(m_Ncamera3 != 0  && event.EventType == irr::EET_KEY_INPUT_EVENT && event.KeyInput.Key == irr::KEY_LEFT)
    {
        if(event.KeyInput.PressedDown == true)
        m_camGauche = true;
        else
        m_camGauche = false;
        return true;
    }
    if(m_Ncamera3 != 0  && event.EventType == irr::EET_KEY_INPUT_EVENT && event.KeyInput.Key == irr::KEY_RIGHT)
    {
        if(event.KeyInput.PressedDown == true)
        m_camDroite = true;
        else
        m_camDroite = false;
        return true;
    }
    if(m_Ncamera3 != 0  && event.EventType == irr::EET_KEY_INPUT_EVENT && event.KeyInput.Key == irr::KEY_UP)
    {
        if(event.KeyInput.PressedDown == true)
        m_camHaut = true;
        else
        m_camHaut = false;
        return true;
    }
    if(m_Ncamera3 != 0  && event.EventType == irr::EET_KEY_INPUT_EVENT && event.KeyInput.Key == irr::KEY_DOWN)
    {
        if(event.KeyInput.PressedDown == true)
        m_camBas = true;
        else
        m_camBas = false;
        return true;
    }
    return false;
}



void CLEventReceiver::majPosMesh()//revoilà notre chère fonction de mise à jour de la position
{
int speedCamera = 2;


    if(m_Ncamera3 != 0 && m_camGauche == true){ //Rotation a gauche de la caméra
         m_PivoCamHorizontal = true;
         CLEventReceiver::CameraTourneHorizontal(m_Ncamera3, m_Nperso->getPosition()+250, core::vector3df(0,0.2*speedCamera,0)); // Fonction pour tourner la caméra 
        }
        if(m_Ncamera3 != 0 && m_camGauche == false){
         m_PivoCamHorizontal = false;
         CLEventReceiver::CameraTourneHorizontal(m_Ncamera3, m_Nperso->getPosition()+250, core::vector3df(0,0,0)); // On coupe la rotation de la caméra
        }
    if(m_Ncamera3 != 0 && m_camDroite == true){ //Rotation a droite de la caméra
         m_PivoCamHorizontal = true;
         CLEventReceiver::CameraTourneHorizontal(m_Ncamera3, m_Nperso->getPosition()+250, core::vector3df(0,-0.2*speedCamera,0));
        }
        if(m_Ncamera3 != 0 && m_camDroite == false){
         m_PivoCamHorizontal = false;
         CLEventReceiver::CameraTourneHorizontal(m_Ncamera3, m_Nperso->getPosition()+250, core::vector3df(0,0,0)); // On coupe la rotation de la caméra
        }
    if(m_Ncamera3 != 0 && m_camHaut == true){ //Rotation a droite de la caméra
         m_PivoCamVerticale = true;
         CLEventReceiver::CameraTourneVerticale(m_Ncamera3, m_Nperso->getPosition()+250, core::vector3df(-0.05*speedCamera,0,0));
        }
        if(m_Ncamera3 != 0 && m_camHaut == false){
         m_PivoCamVerticale = false;
         CLEventReceiver::CameraTourneVerticale(m_Ncamera3, m_Nperso->getPosition()+250, core::vector3df(0,0,0)); // On coupe la rotation de la caméra
        }
    if(m_Ncamera3 != 0 && m_camBas == true){ //Rotation a droite de la caméra
         m_PivoCamVerticale = true;
         CLEventReceiver::CameraTourneVerticale(m_Ncamera3, m_Nperso->getPosition()+250, core::vector3df(0.05*speedCamera,0,0));
        }
        if(m_Ncamera3 != 0 && m_camBas == false){
         m_PivoCamVerticale = false;
         CLEventReceiver::CameraTourneVerticale(m_Ncamera3, m_Nperso->getPosition()+250, core::vector3df(0,0,0)); // On coupe la rotation de la caméra
        }
}



void CLEventReceiver::majAnimMesh()//Ici , on met à jour l'animation
{
 ...
}


core::vector3df Rotation;

void CLEventReceiver::CameraTourneHorizontal(scene::ISceneNode *node, const core::vector3df &origin,
   const core::vector3df &angle)
{
   core::vector3df pos = node->getPosition() - origin; //position courante du node par rapport à l'origine
   Rotation += angle;                                   //Nouvelle rotation du node
   f32 distance = pos.getLength();                      // position were node is when unrotated
   core::vector3df newPos(0,0,distance);                 // this assumes Z axis points "forward"
   core::matrix4 m;                                        // now rotate position vector with new rotation // to find out new position of node
   m.setRotationDegrees(Rotation);
   m.rotateVect(newPos);
   newPos += origin;                                     // get it absolute
   node->setPosition(newPos);                           // position node
}

// this one allows rotation around all 3 axes, but rotation will be relative

void CLEventReceiver::CameraTourneVerticale(scene::ISceneNode *node, const core::vector3df &origin,
   const core::vector3df &angle)
{
        core::vector3df pos = node->getPosition() - origin; //position courante du node par rapport à l'origine
        Rotation += angle;                                  //Nouvelle rotation du node
        f32 distance = pos.getLength();                      // position were node is when unrotated
        core::vector3df newPos(0,0,distance);                 // this assumes Z axis points "forward"
        core::matrix4 m;                                        // now rotate position vector with new rotation // to find out new position of node
        m.setRotationDegrees(Rotation);
        m.rotateVect(newPos);
        newPos += origin;                                     // get it absolute
        node->setPosition(newPos);                           // position node
        //cout << "angle: " << pos.Y <<endl;
}

main.cpp

Code:

#include <iostream>
#include <cstdlib>
#include <irr/irrlicht.h>
#include "CLEventReceiver.h"

using namespace irr;
using namespace std;
using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;

////////////////////CREATION DE LA FENETRE//////////////////////////////

  irr::IrrlichtDevice* device = irr::createDevice(irr::video::EDT_OPENGL,irr::core::dimension2d<irr::u32>(1024,768),32);
  irr::video::IVideoDriver* driver = device->getVideoDriver ();
  irr::scene::ISceneManager* sceneManager = device->getSceneManager ();

int main(void) {

    /* PERSO*/
    irr::scene::IAnimatedMesh* perso;//Ici ...
    perso = (irr::scene::IAnimatedMesh*)sceneManager->getMesh("model/perso22.b3d");  /*testbox5.X*/ //ennemi12.b3d ennemi15.b3d
    irr::scene::IAnimatedMeshSceneNode* Nperso = sceneManager->addAnimatedMeshSceneNode(perso);
    Nperso->setMaterialTexture(0, driver->getTexture("images/skin6.jpg"));
    Nperso->setMaterialFlag(irr::video::EMF_LIGHTING, true);
    Nperso->setPosition(irr::core::vector3df(0.0,500.0,0.0)) ;
//////////////////////////////CAMERA////////////////////////////////////////////////////////////////////////////////////

    irr::scene::ICameraSceneNode *camera3 = sceneManager->addCameraSceneNode();
    camera3->setFarValue(camera3->getFarValue() + 40000.0f);
    camera3->setNearValue(0.3f); //0.03f
//////////////////////////////RECEPTEUR EVENNEMENTS/////////////////////////////

    CLEventReceiver receiver(Nperso,
                             camera3);//On créé un objet instance de la classe CEventReceiver : c'est notre capteur d'évènements

    device->setEventReceiver(&receiver);//on définit cet objet comme le capteur pour notre device
//////////////////////////////RENDU////////////////////////////////////////////////////////////////////////////////////
  while (device->run()) {

    driver->beginScene(true, true, irr::video::SColor(0,255,255,255));

    receiver.majPosMesh();//a chaque frame , on appelle la fonction qui met à jour la position du Mesh
    receiver.majAnimMesh();//a chaque frame , on appelle la fonction qui , si besoin est  , modifie l'animation du mesh

    sceneManager->drawAll ();
    driver->endScene ();

           camera3->setTarget(Nperso->getPosition());       //Actualisation de la camera
           camera3->setPosition(vector3df(Nperso->getPosition().X-500, Nperso->getPosition().Y, Nperso->getPosition().Z - 500));

  }
  device->drop ();
  return 0;
}

Hors ligne


#1 

10-04-2013 14:37:17

johnplayer
Habitué
Date d'inscription: 30-09-2007
Messages: 431

Sympa, mais à tout de même un défaut qui risque d'être handicapant. Ton code est présent partout dans le main et ce n'est pas top pour gérer proprement un projet (j'en ai fait l'expérience). Ce qui serait bien, c'est que tu fasses la gestion des événements dans une classe dérivée de ISceneNodeAnimator. Ainsi tu auras un code facilement réutilisable, qui fonctionnera en arrière-plan comme les cameras (FPS, MAYA...) d'Irrlicht.
Dans ton projet tu créés une camera, tu lui attaches ton animator(camera 3ème personne) et roule ma poule...


core i7 4970K @ 4GHz - 32GB ddr3 19200(2400MHz) - ssd samsung 840 evo 250GB - GTX1080Ti (4K) - Cooler master storm stryker blanc.
"L'alcool, c'est comme Activia, c'est actif à l'intérieur et ça se voit à l'extérieur."

Hors ligne


#2 

10-04-2013 23:04:53

jonath313
Abonné
Date d'inscription: 28-12-2009
Messages: 240

Oui je vois ce que tu veux dire mais j'ai un peux du mal avec la programmation objet et surtout avec les class (je suis modélisateur 3d lol)
En gros tu me dis de créer une class fille de ISceneNodeAnimator et après bin c'est floue ... (j'imagine que le but est de créer une fonction caméras 3iéme personne ).

Hors ligne


Options Liens officiels Caractéristiques Statistiques Communauté
Corrections
irrlicht
irrklang
irredit
irrxml
xhtml 1.0
css 2.1
Propulsé par FluxBB
Traduit par FluxBB.fr
Analysé par
880 membres
1424 sujets
11113 messages
Dernier membre inscrit: mandrifidy
22 invités en ligne
Aucun membre connecté
RSS Feed