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

};

#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;
}

#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;
}