Article Discussion Modifier Historique Forums Salon IRC

OpenGL:Camera à la première personne

Un article de Games Creators Network.

Aperçu du résultat de notre caméra

La classe de caméra utilisée (et adaptée) dans cet article est celle de l'article "Développer un RPG en C++ avec OpenGL". Vous pourrez aussi trouver ces sources dans l'article connexe intitulé "Caméra à la troisième personne".

[modifier] Concept

Pour réaliser notre caméra à la première personne, nous allons donc réutiliser une classe de caméra existante, mais spécialisée dans les vue à la troisième personne. Le principe de cette classe, est qu'à partir d'un point de focalisation, il soit possible de faire tourner la caméra autour de ce point, comme si son champs d'action était une sphère. Le point de focalisation est donc fixe et la caméra se déplace autour.

Pour réaliser une caméra à la première personne, nous allons donc utiliser le même principe, mais en inversant la focalisation et la position. Ainsi, notre caméra se situera au centre d'une sphère, ou le point de focalisation pourra se déplacer.

Pour déplacer la caméra, il suffira d'effectuer une translation sur le vecteur de position et de focalisation.

[modifier] Mise en oeuvre

[modifier] Ne pas oublier

Cette fois, nous allons devoir créer un objet Focalisation, et non pas juste récupérer l'adresse de la position d'un objet. Il faudra donc penser à détruire notre mémoire allouée dans le destructeur de la classe TCamera.

TCamera::~TCamera( void ) {
     delete Focalisation;
}

[modifier] La méthode Focalise

Voici notre nouvelle méthode Focaliser(), rien de plus simple.

void TCamera::TCamera::Focalise(void) {
     gluLookAt( Focalisation->x,
                Focalisation->y,
                Focalisation->z,
                Position.x,
                Position.y,
                Position.z,
                Orientation.x,
                Orientation.y,
                Orientation.z );
}

[modifier] Déplacement de la caméra

Pour pouvoir déplacer notre caméra, encore une fois cela reste simple, il suffit de translater notre point de Position de x vers le point de Focalisation, et de translater le point de Focalisation de x aussi, a l'opposé du point de Position. Nous obtenons donc la méthode suivante :

void TCamera::Distance(float distance) {
     float norme;
     Point3D* C = new Point3D;
     norme = sqrt( (Focalisation->x-Position.x)*
                   (Focalisation->x-Position.x)+
                   (Focalisation->y-Position.y)*
                   (Focalisation->y-Position.y)+
                   (Focalisation->z-Position.z)*
                   (Focalisation->z-Position.z));
 
     C->x = (distance/norme)*(Position.x-Focalisation->x)
            +Focalisation->x;
     C->y = (distance/norme)*(Position.y-Focalisation->y)
            +Focalisation->y;
     C->z = (distance/norme)*(Position.z-Focalisation->z)
            +Focalisation->z;
 
     delete Focalisation;
     Focalisation = C; 
 
     Point3D D;
     norme = sqrt( (Focalisation->x-Position.x)*
                   (Focalisation->x-Position.x)+
                   (Focalisation->y-Position.y)*
                   (Focalisation->y-Position.y)+
                   (Focalisation->z-Position.z)*
                   (Focalisation->z-Position.z));
 
     D.x = (distance/norme)*(Position.x-Focalisation->x)+Position.x;
     D.y = (distance/norme)*(Position.y-Focalisation->y)+Position.y;
     D.z = (distance/norme)*(Position.z-Focalisation->z)+Position.z;
 
     Position = D; 
}