Historique des modifications - Message

Message #11498

Sujet: C++ Autre Camera 3ieme personne


Type Date Auteur Contenu
Correction refusée 15-03-2014 07:54:50 jonath313
Texte original:
Bonjour tout les monde,

Pour ceux que çà intéresse, j'ai pris un peut de mon temps pour faire une camera à la troisième personne, la plus simple possible et en m'inspirant d'autres codes trouvé sur le net.

Tout d'abord une petite classe camera pour accueillir notre unique fonction :S (camera.h)

Code c++ :

#ifndef CAMERA_H
#define CAMERA_H

#include <stdlib.h>
#include <stdio.h>
#include <cstdio>
#include <string>
#include <iostream>
#include <direct.h>
#include <windows.h>
#include <time.h>

#include <irr/irrlicht.h>

/** Déclarations anticipées **/
using namespace std;
using namespace irrklang;
using namespace irr;
using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;


class Camera
{
    public:

        //! constructeur
        Camera();
        //! destructeur
        ~Camera();

        void moveCameraControl(ICameraSceneNode *camera,
                               ISceneManager *smgr,
                               IAnimatedMeshSceneNode* Node,
                               float Horizontal,float Vertical,float VitesseCamera);

    private:

        float direction;
        float zdirection;

    protected:

};

#endif // CAMERA_H

En suite le fichier camera.cpp qui va avec :

Code c++ :

#include <stdlib.h>
#include <stdio.h>
#include <cstdio>
#include <string>
#include <iostream>
#include <direct.h>
#include <windows.h>
#include <time.h>
#include <cstring>
#include <sstream>

#include <irr/irrlicht.h>
#include <irrklang/irrKlang.h>
#include "Camera.h"

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

enum    ///***Enumeration des ID
{
};

//! constructeur
Camera::Camera():direction(0), zdirection(0)
{
//ctor
}

//! destructeur
Camera::~Camera()
{
}

void Camera::moveCameraControl(ICameraSceneNode *camera,           //-----> camera crée dans le scene
                                                   ISceneManager *smgr,                      //-----> sceneManager
                                                   IAnimatedMeshSceneNode* Node,      //-----> Node du personnage
                                                   float Horizontal,float Vertical,float VitesseCamera) //--------> Pour choisir mouvement horizontal en envoi 1.0, 0.0, 0.5 -> le dernier est la vitesse
{

     core::vector3df cameraPos = camera->getAbsolutePosition();

     direction = direction + VitesseCamera *(Horizontal);
     zdirection = zdirection - VitesseCamera * (Vertical);

     if( zdirection <- 90 )
         zdirection = -90;
     else
     if( zdirection > 90 )
         zdirection = 90;

     core::vector3df playerPos = Node->getPosition();

     float xf = playerPos.X - cos( direction * PI / 180.0f ) * 64.0f;
     float yf = playerPos.Y - sin( zdirection * PI / 180.0f ) * 64.0f;
     float zf = playerPos.Z + sin( direction * PI / 180.0f ) * 64.0f;

     camera->setPosition( core::vector3df( xf, yf, zf ) );
     camera->setTarget( core::vector3df( playerPos.X, playerPos.Y+25.0f, playerPos.Z ) );
     //Node->setRotation( core::vector3df( 0, direction, 0 ) ); // -> Pour que le personnage suive la direction de la camera
}

Maintenant il faut juste mettre a jour la camera dans la partie jeux :
Moi j'ai fais comme çà mais après il y a surement d'autres solutions ...

Code c++ :

#ifndef APPLICATION_H
#define APPLICATION_H
#include "IRR/IEventReceiver.h"
#include "IRR/irrArray.h"
#include <stdlib.h>
#include <stdio.h>
#include <cstdio>
#include <string>
#include <iostream>
#include <direct.h>
#include <windows.h>
#include <time.h>

#include <irr/irrlicht.h>


#include "Camera.h" // -------------------------------> A ne pas oublier

/** Déclarations anticipées **/
using namespace std;
using namespace irrklang;
using namespace irr;
using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;


class Application : public irr::IEventReceiver // On dérive la classe Application pour gérer les événements
{
    public:

        //! constructeur
        Application();
        //! destructeur
        virtual ~Application();

        //! créé l'environnement Irrlicht
        bool run();

        //! Boucle de rendu
        void rendu();

        //! gestion des événements
        bool OnEvent(const irr::SEvent& event);


        //! Mouvement de la camera
        void UpdateCameraMovement();  //-------------------------> Pour mettre a jour la position de la camera


    protected:
        //! MEMBRES
        irr::IrrlichtDevice *device;
        irr::video::IVideoDriver *driver;
        irr::scene::ISceneManager *smgr;
        irr::gui::IGUIEnvironment *env;


        //cameras
        ICameraSceneNode *camera[2]={0,0};  //----> Deux camera mais une seule suffit ;)

        IAnimatedMeshSceneNode *model_node; //----> le personnage

        bool cameraH_Positif;    //-------------------> Pour les Evénements on va pouvoir déterminer quel mouvement de camera réaliser
        bool cameraH_Negatif;
        bool cameraV_Positif;
        bool cameraV_Negatif;

        Camera came;   // ---------------------------> On cree un objet camera

    private:

};

#endif // APPLICATION_H

Et pour finir la partie du jeux .cpp

Code c++ :

 void Application::UpdateCameraMovement(){
     if(cameraV_Positif == true){
        came.moveCameraControl(camera[0],smgr,model_node,0,1,0.5);
     }
     if(cameraV_Negatif == true){
        came.moveCameraControl(camera[0],smgr,model_node,0,-1,0.5);
     }
     if(cameraH_Positif == true){
        came.moveCameraControl(camera[0],smgr,model_node,1,0,0.5);
     }
     if(cameraH_Negatif == true){
        came.moveCameraControl(camera[0],smgr,model_node,-1,0,0.5);
     }
     if(cameraV_Positif == false || cameraV_Negatif == false || cameraH_Positif == false || cameraH_Negatif == false){
        came.moveCameraControl(camera[0],smgr,model_node,0,0,0);

     }

 }



bool  Application::OnEvent(const SEvent& event){
switch(event.EventType)
    {
        case EET_KEY_INPUT_EVENT:
        {
            // si on appuie sur echap
            if(event.KeyInput.Key == KEY_ESCAPE && event.KeyInput.PressedDown)
            {
                // on ferme l'application
                printf("FERMETURE");
                device->closeDevice();
                return true;
            }

            if(event.KeyInput.Key == irr::KEY_KEY_Z)
                {
                    if(event.KeyInput.PressedDown == true)          //Si il s'agit d'un appui
                        cameraV_Positif = true; //-------------------------------------------------> Mouvement vertical positif
                    //Sinon c'est un relachement
                       else cameraV_Positif = false;
                    return true;
                }
            if(event.KeyInput.Key == irr::KEY_KEY_S)
                {
                    if(event.KeyInput.PressedDown == true)
                        cameraV_Negatif = true; //-------------------------------------------------> Mouvement vertical negatif
                    else cameraV_Negatif = false;
                    return true;
                }
             if(event.KeyInput.Key == irr::KEY_KEY_Q)
                {
                    if(event.KeyInput.PressedDown == true)          //Si il s'agit d'un appui
                        cameraH_Positif = true; //-------------------------------------------------> Mouvement horizontal positif
                    //Sinon c'est un relachement
                    else cameraH_Positif = false;
                    return true;
                }
            if(event.KeyInput.Key == irr::KEY_KEY_D)
                {
                    if(event.KeyInput.PressedDown == true)
                        cameraH_Negatif = true; //-------------------------------------------------> Mouvement horizontal negatif
                    else cameraH_Negatif = false;
                    return true;
                }
        }
        break;
        default: break;
    }
}

Puis dans la boucle de rendu :
UpdateCameraMovement();

Voila même si c'est pas grand chose, j’espère que çà sera utile...

Bonne continuation.
Correction proposée:
Bonjour tout les monde,

Pour ceux que çà intéresse, j'ai pris un peut de mon temps pour faire une camera à la troisième personne, la plus simple possible et en m'inspirant d'autres codes trouvé sur le net.

Tout d'abord une petite classe camera pour accueillir notre unique fonction :S (camera.h)

Code c++ :

#ifndef CAMERA_H
#define CAMERA_H
#include <irr/irrlicht.h>

/** Déclarations anticipées **/
using namespace std;
using namespace irrklang;
using namespace irr;
using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;


class Camera
{
    public:

        //! constructeur
        Camera();
        //! destructeur
        ~Camera();

        void moveCameraControl(ICameraSceneNode *camera,
                               ISceneManager *smgr,
                               IAnimatedMeshSceneNode* Node,
                               float Horizontal,float Vertical,float VitesseCamera);

    private:

        float direction;
        float zdirection;

    protected:

};

#endif // CAMERA_H

En suite le fichier camera.cpp qui va avec :

Code c++ :


#include "Camera.h"

//using namespace ...

//! constructeur
Camera::Camera():direction(0), zdirection(0)
{
//ctor
}

//! destructeur
Camera::~Camera()
{
}

void Camera::moveCameraControl(ICameraSceneNode *camera,           //-----> camera crée dans le scene
                                                   ISceneManager *smgr,                      //-----> sceneManager
                                                   IAnimatedMeshSceneNode* Node,      //-----> Node du personnage
                                                   float Horizontal,float Vertical,float VitesseCamera) //--------> Pour choisir mouvement horizontal en envoi 1.0, 0.0, 0.5 -> le dernier est la vitesse
{

     core::vector3df cameraPos = camera->getAbsolutePosition();

     direction = direction + VitesseCamera *(Horizontal);
     zdirection = zdirection - VitesseCamera * (Vertical);

     if( zdirection <- 90 )
         zdirection = -90;
     else
     if( zdirection > 90 )
         zdirection = 90;

     core::vector3df playerPos = Node->getPosition();

     float xf = playerPos.X - cos( direction * PI / 180.0f ) * 64.0f;
     float yf = playerPos.Y - sin( zdirection * PI / 180.0f ) * 64.0f;
     float zf = playerPos.Z + sin( direction * PI / 180.0f ) * 64.0f;

     camera->setPosition( core::vector3df( xf, yf, zf ) );
     camera->setTarget( core::vector3df( playerPos.X, playerPos.Y+25.0f, playerPos.Z ) );
     //Node->setRotation( core::vector3df( 0, direction, 0 ) ); // -> Pour que le personnage suive la direction de la camera
}

Maintenant il faut juste mettre a jour la camera dans la partie jeux :
Moi j'ai fais comme çà mais après il y a surement d'autres solutions ...
[Code=cpp]#ifndef APPLICATION_H
#define APPLICATION_H
#include "IRR/IEventReceiver.h"
#include "IRR/irrArray.h"
#include <irr/irrlicht.h>
#include "Camera.h" // --------------------------
Correction refusée 15-03-2014 07:52:23 jonath313
Texte original:
Bonjour tout les monde,

Pour ceux que çà intéresse, j'ai pris un peut de mon temps pour faire une camera à la troisième personne, la plus simple possible et en m'inspirant d'autres codes trouvé sur le net.

Tout d'abord une petite classe camera pour accueillir notre unique fonction :S (camera.h)

Code c++ :

#ifndef CAMERA_H
#define CAMERA_H

#include <stdlib.h>
#include <stdio.h>
#include <cstdio>
#include <string>
#include <iostream>
#include <direct.h>
#include <windows.h>
#include <time.h>

#include <irr/irrlicht.h>

/** Déclarations anticipées **/
using namespace std;
using namespace irrklang;
using namespace irr;
using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;


class Camera
{
    public:

        //! constructeur
        Camera();
        //! destructeur
        ~Camera();

        void moveCameraControl(ICameraSceneNode *camera,
                               ISceneManager *smgr,
                               IAnimatedMeshSceneNode* Node,
                               float Horizontal,float Vertical,float VitesseCamera);

    private:

        float direction;
        float zdirection;

    protected:

};

#endif // CAMERA_H

En suite le fichier camera.cpp qui va avec :

Code c++ :

#include <stdlib.h>
#include <stdio.h>
#include <cstdio>
#include <string>
#include <iostream>
#include <direct.h>
#include <windows.h>
#include <time.h>
#include <cstring>
#include <sstream>

#include <irr/irrlicht.h>
#include <irrklang/irrKlang.h>
#include "Camera.h"

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

enum    ///***Enumeration des ID
{
};

//! constructeur
Camera::Camera():direction(0), zdirection(0)
{
//ctor
}

//! destructeur
Camera::~Camera()
{
}

void Camera::moveCameraControl(ICameraSceneNode *camera,           //-----> camera crée dans le scene
                                                   ISceneManager *smgr,                      //-----> sceneManager
                                                   IAnimatedMeshSceneNode* Node,      //-----> Node du personnage
                                                   float Horizontal,float Vertical,float VitesseCamera) //--------> Pour choisir mouvement horizontal en envoi 1.0, 0.0, 0.5 -> le dernier est la vitesse
{

     core::vector3df cameraPos = camera->getAbsolutePosition();

     direction = direction + VitesseCamera *(Horizontal);
     zdirection = zdirection - VitesseCamera * (Vertical);

     if( zdirection <- 90 )
         zdirection = -90;
     else
     if( zdirection > 90 )
         zdirection = 90;

     core::vector3df playerPos = Node->getPosition();

     float xf = playerPos.X - cos( direction * PI / 180.0f ) * 64.0f;
     float yf = playerPos.Y - sin( zdirection * PI / 180.0f ) * 64.0f;
     float zf = playerPos.Z + sin( direction * PI / 180.0f ) * 64.0f;

     camera->setPosition( core::vector3df( xf, yf, zf ) );
     camera->setTarget( core::vector3df( playerPos.X, playerPos.Y+25.0f, playerPos.Z ) );
     //Node->setRotation( core::vector3df( 0, direction, 0 ) ); // -> Pour que le personnage suive la direction de la camera
}

Maintenant il faut juste mettre a jour la camera dans la partie jeux :
Moi j'ai fais comme çà mais après il y a surement d'autres solutions ...

Code c++ :

#ifndef APPLICATION_H
#define APPLICATION_H
#include "IRR/IEventReceiver.h"
#include "IRR/irrArray.h"
#include <stdlib.h>
#include <stdio.h>
#include <cstdio>
#include <string>
#include <iostream>
#include <direct.h>
#include <windows.h>
#include <time.h>

#include <irr/irrlicht.h>


#include "Camera.h" // -------------------------------> A ne pas oublier

/** Déclarations anticipées **/
using namespace std;
using namespace irrklang;
using namespace irr;
using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;


class Application : public irr::IEventReceiver // On dérive la classe Application pour gérer les événements
{
    public:

        //! constructeur
        Application();
        //! destructeur
        virtual ~Application();

        //! créé l'environnement Irrlicht
        bool run();

        //! Boucle de rendu
        void rendu();

        //! gestion des événements
        bool OnEvent(const irr::SEvent& event);


        //! Mouvement de la camera
        void UpdateCameraMovement();  //-------------------------> Pour mettre a jour la position de la camera


    protected:
        //! MEMBRES
        irr::IrrlichtDevice *device;
        irr::video::IVideoDriver *driver;
        irr::scene::ISceneManager *smgr;
        irr::gui::IGUIEnvironment *env;


        //cameras
        ICameraSceneNode *camera[2]={0,0};  //----> Deux camera mais une seule suffit ;)

        IAnimatedMeshSceneNode *model_node; //----> le personnage

        bool cameraH_Positif;    //-------------------> Pour les Evénements on va pouvoir déterminer quel mouvement de camera réaliser
        bool cameraH_Negatif;
        bool cameraV_Positif;
        bool cameraV_Negatif;

        Camera came;   // ---------------------------> On cree un objet camera

    private:

};

#endif // APPLICATION_H

Et pour finir la partie du jeux .cpp

Code c++ :

 void Application::UpdateCameraMovement(){
     if(cameraV_Positif == true){
        came.moveCameraControl(camera[0],smgr,model_node,0,1,0.5);
     }
     if(cameraV_Negatif == true){
        came.moveCameraControl(camera[0],smgr,model_node,0,-1,0.5);
     }
     if(cameraH_Positif == true){
        came.moveCameraControl(camera[0],smgr,model_node,1,0,0.5);
     }
     if(cameraH_Negatif == true){
        came.moveCameraControl(camera[0],smgr,model_node,-1,0,0.5);
     }
     if(cameraV_Positif == false || cameraV_Negatif == false || cameraH_Positif == false || cameraH_Negatif == false){
        came.moveCameraControl(camera[0],smgr,model_node,0,0,0);

     }

 }



bool  Application::OnEvent(const SEvent& event){
switch(event.EventType)
    {
        case EET_KEY_INPUT_EVENT:
        {
            // si on appuie sur echap
            if(event.KeyInput.Key == KEY_ESCAPE && event.KeyInput.PressedDown)
            {
                // on ferme l'application
                printf("FERMETURE");
                device->closeDevice();
                return true;
            }

            if(event.KeyInput.Key == irr::KEY_KEY_Z)
                {
                    if(event.KeyInput.PressedDown == true)          //Si il s'agit d'un appui
                        cameraV_Positif = true; //-------------------------------------------------> Mouvement vertical positif
                    //Sinon c'est un relachement
                       else cameraV_Positif = false;
                    return true;
                }
            if(event.KeyInput.Key == irr::KEY_KEY_S)
                {
                    if(event.KeyInput.PressedDown == true)
                        cameraV_Negatif = true; //-------------------------------------------------> Mouvement vertical negatif
                    else cameraV_Negatif = false;
                    return true;
                }
             if(event.KeyInput.Key == irr::KEY_KEY_Q)
                {
                    if(event.KeyInput.PressedDown == true)          //Si il s'agit d'un appui
                        cameraH_Positif = true; //-------------------------------------------------> Mouvement horizontal positif
                    //Sinon c'est un relachement
                    else cameraH_Positif = false;
                    return true;
                }
            if(event.KeyInput.Key == irr::KEY_KEY_D)
                {
                    if(event.KeyInput.PressedDown == true)
                        cameraH_Negatif = true; //-------------------------------------------------> Mouvement horizontal negatif
                    else cameraH_Negatif = false;
                    return true;
                }
        }
        break;
        default: break;
    }
}

Puis dans la boucle de rendu :
UpdateCameraMovement();

Voila même si c'est pas grand chose, j’espère que çà sera utile...

Bonne continuation.
Correction proposée:
Bonjour tout les monde,

Pour ceux que çà intéresse, j'ai pris un peut de mon temps pour faire une camera à la troisième personne, la plus simple possible et en m'inspirant d'autres codes trouvé sur le net.

Tout d'abord une petite classe camera pour accueillir notre unique fonction :S (camera.h)

Code c++ :

#ifndef CAMERA_H
#define CAMERA_H
#include <irr/irrlicht.h>

/** Déclarations anticipées **/
using namespace std;
using namespace irrklang;
using namespace irr;
using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;


class Camera
{
    public:

        //! constructeur
        Camera();
        //! destructeur
        ~Camera();

        void moveCameraControl(ICameraSceneNode *camera,
                               ISceneManager *smgr,
                               IAnimatedMeshSceneNode* Node,
                               float Horizontal,float Vertical,float VitesseCamera);

    private:

        float direction;
        float zdirection;

    protected:

};

#endif // CAMERA_H

En suite le fichier camera.cpp qui va avec :

Code c++ :


#include "Camera.h"

//using namespace ...

//! constructeur
Camera::Camera():direction(0), zdirection(0)
{
//ctor
}

//! destructeur
Camera::~Camera()
{
}

void Camera::moveCameraControl(ICameraSceneNode *camera,           //-----> camera crée dans le scene
                                                   ISceneManager *smgr,                      //-----> sceneManager
                                                   IAnimatedMeshSceneNode* Node,      //-----> Node du personnage
                                                   float Horizontal,float Vertical,float VitesseCamera) //--------> Pour choisir mouvement horizontal en envoi 1.0, 0.0, 0.5 -> le dernier est la vitesse
{

     core::vector3df cameraPos = camera->getAbsolutePosition();

     direction = direction + VitesseCamera *(Horizontal);
     zdirection = zdirection - VitesseCamera * (Vertical);

     if( zdirection <- 90 )
         zdirection = -90;
     else
     if( zdirection > 90 )
         zdirection = 90;

     core::vector3df playerPos = Node->getPosition();

     float xf = playerPos.X - cos( direction * PI / 180.0f ) * 64.0f;
     float yf = playerPos.Y - sin( zdirection * PI / 180.0f ) * 64.0f;
     float zf = playerPos.Z + sin( direction * PI / 180.0f ) * 64.0f;

     camera->setPosition( core::vector3df( xf, yf, zf ) );
     camera->setTarget( core::vector3df( playerPos.X, playerPos.Y+25.0f, playerPos.Z ) );
     //Node->setRotation( core::vector3df( 0, direction, 0 ) ); // -> Pour que le personnage suive la direction de la camera
}

Maintenant il faut juste mettre a jour la camera dans la partie jeux :
Moi j'ai fais comme çà mais après il y a surement d'autres solutions ...

Code c++ :

#ifndef APPLICATION_H
#define APPLICATION_H
#include "IRR/IEventReceiver.h"
#include "IRR/irrArray.h"
#include <irr/irrlicht.h>
#include "Camera.h" // -------------------------------> A ne pas oublier

/** Déclarations anticipées **/
//using namespace ...

class Application : public irr::IEventReceiver // On dérive la classe Application pour gérer les événements
{
    public:

        //! constructeur
        Application();
        //! destructeur
        virtual ~Application();

        //! créé l'environnement Irrlicht
        bool run();

        //! Boucle de rendu
        void rendu();

        //! gestion des événements
        bool OnEvent(const irr::SEvent& event);


        //! Mouvement de la camera
        void UpdateCameraMovement();  //-------------------------> Pour mettre a jour la position de la camera


    protected:
        //! MEMBRES
        irr::IrrlichtDevice *device;
        irr::video::IVideoDriver *driver;
        irr::scene::ISceneManager *smgr;
        irr::gui::IGUIEnvironment *env;


        //cameras
        ICameraSceneNode *camera[2]={0,0};  //----> Deux camera mais une seule suffit ;)

        IAnimatedMeshSceneNode *model_node; //----> le personnage

        bool cameraH_Positif;    //-------------------> Pour les Evénements on va pouvoir déterminer quel mouvement de camera réaliser
        bool cameraH_Negatif;
        bool cameraV_Positif;
        bool cameraV_Negatif;

        Camera came;   // ---------------------------> On cree un objet camera

    private:

};

#endif // APPLICATION_H

Et pour finir la partie du jeux application.cpp

[Code=cpp] void Application::UpdateCameraMovement(){
if(cameraV_Positif == true){
came.moveCameraControl(camera[0],smgr,model_node,0,1,0.5);
}
if(cameraV_Negatif == true){
came.moveCameraControl(camera[0],smgr,model_node,0,-1,0.5);
}
if(cameraH_Positif == true){
came.moveCameraControl(camera[0],smgr,model_node,1,0,0.5);
}
if(cameraH_Negatif == true){
came.moveCameraControl(camera[0],smgr,model_node,-1,0,0.5);
}
if(cameraV_Positif == false || cameraV_Negatif == false || cameraH_Positif == false || cameraH_Negatif == false){
came.moveCameraControl(camera[0],smgr,model_node,0,0,0);

}

}



bool Application::OnEvent(const SEvent& event){
switch(event.EventType)
{
case EET_KEY_INPUT_EVENT:
{
// si on appuie sur echap
if(event.KeyInput.Key == KEY_ESCAPE && event.KeyInput.PressedDown)
{
// on ferme l'application
printf("FERMETURE");
device->closeDevice();
return true;
}

if(event.KeyInput.Key == irr::KEY_KEY_Z)
{
if(event.KeyInput.PressedDown == true) //Si il s'agit d'un appui
cameraV_Positif = true; //-------------------------------------------------> Mouvement vertical positif
//Sinon c'est un relachement
else cameraV_Positif = false;
%
Création du message 13-03-2014 15:01:52 jonath313
Bonjour tout les monde,

Pour ceux que çà intéresse, j'ai pris un peut de mon temps pour faire une camera à la troisième personne, la plus simple possible et en m'inspirant d'autres codes trouvé sur le net.

Tout d'abord une petite classe camera pour accueillir notre unique fonction :S (camera.h)

Code c++ :

#ifndef CAMERA_H
#define CAMERA_H

#include <stdlib.h>
#include <stdio.h>
#include <cstdio>
#include <string>
#include <iostream>
#include <direct.h>
#include <windows.h>
#include <time.h>

#include <irr/irrlicht.h>

/** Déclarations anticipées **/
using namespace std;
using namespace irrklang;
using namespace irr;
using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;


class Camera
{
    public:

        //! constructeur
        Camera();
        //! destructeur
        ~Camera();

        void moveCameraControl(ICameraSceneNode *camera,
                               ISceneManager *smgr,
                               IAnimatedMeshSceneNode* Node,
                               float Horizontal,float Vertical,float VitesseCamera);

    private:

        float direction;
        float zdirection;

    protected:

};

#endif // CAMERA_H

En suite le fichier camera.cpp qui va avec :

Code c++ :

#include <stdlib.h>
#include <stdio.h>
#include <cstdio>
#include <string>
#include <iostream>
#include <direct.h>
#include <windows.h>
#include <time.h>
#include <cstring>
#include <sstream>

#include <irr/irrlicht.h>
#include <irrklang/irrKlang.h>
#include "Camera.h"

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

enum    ///***Enumeration des ID
{
};

//! constructeur
Camera::Camera():direction(0), zdirection(0)
{
//ctor
}

//! destructeur
Camera::~Camera()
{
}

void Camera::moveCameraControl(ICameraSceneNode *camera,           //-----> camera crée dans le scene
                                                   ISceneManager *smgr,                      //-----> sceneManager
                                                   IAnimatedMeshSceneNode* Node,      //-----> Node du personnage
                                                   float Horizontal,float Vertical,float VitesseCamera) //--------> Pour choisir mouvement horizontal en envoi 1.0, 0.0, 0.5 -> le dernier est la vitesse
{

     core::vector3df cameraPos = camera->getAbsolutePosition();

     direction = direction + VitesseCamera *(Horizontal);
     zdirection = zdirection - VitesseCamera * (Vertical);

     if( zdirection <- 90 )
         zdirection = -90;
     else
     if( zdirection > 90 )
         zdirection = 90;

     core::vector3df playerPos = Node->getPosition();

     float xf = playerPos.X - cos( direction * PI / 180.0f ) * 64.0f;
     float yf = playerPos.Y - sin( zdirection * PI / 180.0f ) * 64.0f;
     float zf = playerPos.Z + sin( direction * PI / 180.0f ) * 64.0f;

     camera->setPosition( core::vector3df( xf, yf, zf ) );
     camera->setTarget( core::vector3df( playerPos.X, playerPos.Y+25.0f, playerPos.Z ) );
     //Node->setRotation( core::vector3df( 0, direction, 0 ) ); // -> Pour que le personnage suive la direction de la camera
}

Maintenant il faut juste mettre a jour la camera dans la partie jeux :
Moi j'ai fais comme çà mais après il y a surement d'autres solutions ...

Code c++ :

#ifndef APPLICATION_H
#define APPLICATION_H
#include "IRR/IEventReceiver.h"
#include "IRR/irrArray.h"
#include <stdlib.h>
#include <stdio.h>
#include <cstdio>
#include <string>
#include <iostream>
#include <direct.h>
#include <windows.h>
#include <time.h>

#include <irr/irrlicht.h>


#include "Camera.h" // -------------------------------> A ne pas oublier

/** Déclarations anticipées **/
using namespace std;
using namespace irrklang;
using namespace irr;
using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;


class Application : public irr::IEventReceiver // On dérive la classe Application pour gérer les événements
{
    public:

        //! constructeur
        Application();
        //! destructeur
        virtual ~Application();

        //! créé l'environnement Irrlicht
        bool run();

        //! Boucle de rendu
        void rendu();

        //! gestion des événements
        bool OnEvent(const irr::SEvent& event);


        //! Mouvement de la camera
        void UpdateCameraMovement();  //-------------------------> Pour mettre a jour la position de la camera


    protected:
        //! MEMBRES
        irr::IrrlichtDevice *device;
        irr::video::IVideoDriver *driver;
        irr::scene::ISceneManager *smgr;
        irr::gui::IGUIEnvironment *env;


        //cameras
        ICameraSceneNode *camera[2]={0,0};  //----> Deux camera mais une seule suffit ;)

        IAnimatedMeshSceneNode *model_node; //----> le personnage

        bool cameraH_Positif;    //-------------------> Pour les Evénements on va pouvoir déterminer quel mouvement de camera réaliser
        bool cameraH_Negatif;
        bool cameraV_Positif;
        bool cameraV_Negatif;

        Camera came;   // ---------------------------> On cree un objet camera

    private:

};

#endif // APPLICATION_H

Et pour finir la partie du jeux .cpp

Code c++ :

 void Application::UpdateCameraMovement(){
     if(cameraV_Positif == true){
        came.moveCameraControl(camera[0],smgr,model_node,0,1,0.5);
     }
     if(cameraV_Negatif == true){
        came.moveCameraControl(camera[0],smgr,model_node,0,-1,0.5);
     }
     if(cameraH_Positif == true){
        came.moveCameraControl(camera[0],smgr,model_node,1,0,0.5);
     }
     if(cameraH_Negatif == true){
        came.moveCameraControl(camera[0],smgr,model_node,-1,0,0.5);
     }
     if(cameraV_Positif == false || cameraV_Negatif == false || cameraH_Positif == false || cameraH_Negatif == false){
        came.moveCameraControl(camera[0],smgr,model_node,0,0,0);

     }

 }



bool  Application::OnEvent(const SEvent& event){
switch(event.EventType)
    {
        case EET_KEY_INPUT_EVENT:
        {
            // si on appuie sur echap
            if(event.KeyInput.Key == KEY_ESCAPE && event.KeyInput.PressedDown)
            {
                // on ferme l'application
                printf("FERMETURE");
                device->closeDevice();
                return true;
            }

            if(event.KeyInput.Key == irr::KEY_KEY_Z)
                {
                    if(event.KeyInput.PressedDown == true)          //Si il s'agit d'un appui
                        cameraV_Positif = true; //-------------------------------------------------> Mouvement vertical positif
                    //Sinon c'est un relachement
                       else cameraV_Positif = false;
                    return true;
                }
            if(event.KeyInput.Key == irr::KEY_KEY_S)
                {
                    if(event.KeyInput.PressedDown == true)
                        cameraV_Negatif = true; //-------------------------------------------------> Mouvement vertical negatif
                    else cameraV_Negatif = false;
                    return true;
                }
             if(event.KeyInput.Key == irr::KEY_KEY_Q)
                {
                    if(event.KeyInput.PressedDown == true)          //Si il s'agit d'un appui
                        cameraH_Positif = true; //-------------------------------------------------> Mouvement horizontal positif
                    //Sinon c'est un relachement
                    else cameraH_Positif = false;
                    return true;
                }
            if(event.KeyInput.Key == irr::KEY_KEY_D)
                {
                    if(event.KeyInput.PressedDown == true)
                        cameraH_Negatif = true; //-------------------------------------------------> Mouvement horizontal negatif
                    else cameraH_Negatif = false;
                    return true;
                }
        }
        break;
        default: break;
    }
}

Puis dans la boucle de rendu :
UpdateCameraMovement();

Voila même si c'est pas grand chose, j’espère que çà sera utile...

Bonne continuation.

Retour

Options Liens officiels Caractéristiques Statistiques Communauté
Préférences cookies
Corrections
 irrlicht
irrklang
irredit
irrxml
 Propulsé par Django
xhtml 1.0
css 2.1
 884 membres
1440 sujets
11337 messages
 Dernier membre inscrit: Saidov17
149 invités en ligne
membre en ligne: -
RSS Feed