#include "stdafx.h"
#include <irrlicht.h>
#include <iostream>
#include <windows.h>
#include <tchar.h>
#include <vector>
#include <exception>
#include <fstream>
#include <string>
#include "Drone.h"

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

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

#define DRONE nsSimulateur::Drone

DRONE::Drone (char * FichierDrone /*= "drone.x"*/, ISceneManager * Smgr /*=0*/,
    const vector3df PositionInitiale /*= vector3df(0,0,0)*/ )
{
    m_FichierDrone = FichierDrone ;
    m_MeshDrone = Smgr->getMesh(FichierDrone) ;
    m_Drone = Smgr-> addAnimatedMeshSceneNode (m_MeshDrone) ;
    m_Drone->setMaterialFlag(EMF_LIGHTING, false) ; 
    m_Drone->setPosition (PositionInitiale) ;
    m_Drone->setScale (vector3df (0.05f, 0.1f, 0.05f)) ;
    m_Drone->setAnimationSpeed (100.0f) ;
    m_Drone->setFrameLoop (1, 13) ;

    m_Camera = Smgr->addCameraSceneNodeFPS(0, 0, 0);
    m_Camera->setPosition(vector3df (PositionInitiale.X, PositionInitiale.Y + 1.0f, PositionInitiale.Z + 7.0f ));

    m_Angle = 0 ;
    m_Zoom = 1 ;

} // Drone ()

void DRONE::MoveDrone (float RotationX /*=0*/, float RotationY /*=0*/, float RotationZ /*=0*/, 
    float PositionX /*=0*/, float PositionY /*=0*/, float PositionZ /*=0*/)
{
        m_Drone->setPosition (vector3df(PositionX, PositionY, PositionZ) );
        m_Drone->setRotation (vector3df(RotationX, RotationY, RotationZ) );


        float vrRadY = -RotationY / 180 * 3.141592654f;
        float CosTargetX = cos (vrRadY + (3.14f/2.0f));
        float SinTargetZ = sin (vrRadY + (3.14f/2.0f));
        float PasX = (CosTargetX * 7.0f) ;
        float PasZ = (SinTargetZ * 7.0f) ;

        MoveCamera (RotationX, RotationY, RotationZ, m_Angle, PositionX + PasX, PositionY + 1.0f, PositionZ + PasZ);        
} // MoveDrone ()


IAnimatedMeshSceneNode * DRONE::GetDrone (void) const
{
    return m_Drone ;
} // GetDrone ()

void DRONE::MoveCamera (float RotationX /*=0*/, float RotationY /*=0*/, float RotationZ /*=0*/, float RotationInterne /*=0*/,
    float PositionX /*=0*/, float PositionY /*=0*/, float PositionZ /*=0*/)
{
        m_Camera->setPosition(vector3df (PositionX, PositionY, PositionZ));

        vector3df rotation = vector3df(RotationInterne, 0, 0); 
        m_Camera->getAbsoluteTransformation().rotateVect(rotation);
        m_Camera->setRotation(vector3df(RotationX + RotationInterne, RotationY , RotationZ) );

        m_Angle = RotationInterne ;
} // MoveCamera ()

ICameraSceneNode * DRONE::GetCamera (void) const
{
    return m_Camera ;
} // GetCamera ()

void DRONE::Zoom (float CoeffGrossissement) 
{
        m_Camera->setFOV (m_Camera->getFOV() / CoeffGrossissement) ;
        m_Zoom += (CoeffGrossissement > 1) ? CoeffGrossissement : -1/CoeffGrossissement ;
} // Zoom ()

float DRONE::GetAngle (void)
{
    return m_Angle ;
} // GetAngle ()

IAnimatedMesh * DRONE::GetMeshDrone (void) const
{
    return m_MeshDrone ;
} // GetMeshDrone ()