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)

En suite le fichier camera.cpp qui va avec :

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

Puis dans la boucle de rendu :

UpdateCameraMovement();

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

Bonne continuation.

merci pour le partage

juste quelsque remarque:

organise t'est include pour que ce soit portable du premier coup
a savoir

non indispensable au comportement, pas nécessaire a reinclure dans les *.cpp s'il sont inclue dans le header

et éviter les using namespace dans les headers:

pensse a mettre t'est fonctions en virtual ça peut aider plus tard (pour ta class Camera)

sinon c'est plutot propre

si tu veut aller un peut plus loin tu peut regarder du coter de  ISceneNodeAnimator

Merci pour tes remarques je vais les prendres en compte pour améliorer mon code.

On ne peut vraiment pas utiliser les namespaces dans les header? En quoi cela est il néfaste? Il y a une autre façon de les annoncer peut être?

Qu'entend tu par fonction virtual? J'avais déjà cherché ce que c'était mais en ais pas vraiment comprit l'intérêt.

Et oui on Ma déjà proposé de regarder du côté des animators mais je suis limité à ce que je sais faire. Tu penses quil y a mieux à faire? Ma caméra est plutôt gourmande en terme de ressources non ?

le soucis de l'utilisation des namespaces dans les header c'est surtout que rien ne garantie qu'un namespace du même nom n'existe pas ailleur dans le projet host
par exemple core, video, scene, ... sont des nom asser usuel or si tu utilise <<using namespace irr>> il y a de forte probabiliter qu'il y est des conflits

les fonctions virtuel permette de pouvoir utiliser le polymorphisme
si tu dérive une class et que tu redefini une fonctions virtuel, peut import la déclaration que tu utilise (fils ou mère)
la fonction utiliser seras celle de l'instance de la class
si tu ne le fait pas c'est celle de la déclaration qui seras usé

(peut-être que je ne suis pas asser claire)
ça permet d'étendre ton code sans toucher au base

pour finir, l'interet de passer par un animator c'est de décharger le programmeur sur la mise a jours de la position de la camera et evenement
et de plus de pouvoir l'exporter simplement dans les scenes *.irr avec une class a deriver pour l'importation (irr::scene::ISceneUserDataSerializer)

il suffie alors de faire un code de ce style:

rien de plus



une dernier chose

equivalent a

Enfait par rapport à mon code il suffit que je declare ma class :

Je suis un peut perdu car vue que ma class camera avait une seule fonction je n'envoyai plus l'interet alors j'ai mis la fonction de la camera dans la classe de creation d'un joueur :

Comme çà je récupère directement la position du joueur.

Dans la boucle,la fonction est appelée si on a appui sur une touche.

Admettons que l'on ajoute le système d'animateur, çà reviendrait concrètement à recréer une class pour ma caméra, la mettre en ISceneNodeAnimator , et créer des  animateurs pour chacune des caméras.

Je me suis perdus dans ma question...