Opengl: classe camera qui gère le glulookat

Soyez le premier à donner votre avis sur cette source.

Vue 10 097 fois - Téléchargée 783 fois

Description

Bonjour.

c'est une petite classe pour gérer la Camera qui se veut être suffisante pour tous les programmes opengl que j'aurais envie d'écrire

il manque principalement l'option Lock pour les rotations et les déplacement mais je pense que cette option s'implémente facilement au cas par cas

je me sers de la classe "vecteur 3d" NxVec3 du physx SDK d'ageia

Source / Exemple :


#define NxReal double

NxReal from[3] = {-10,0,0};
NxReal to[3] = {0,0,0};
NxReal up[3] = {0,1,0};
camera = new Camera(from,to,up);
camera->setModeLock(true,true,false);
camera->setMinMaxCurrentUpDown(-M_PI/6,M_PI/6,0);
camera->setMinMaxCurrentLeftRight(-M_PI/12,M_PI/12,0);

/************************************************************************/
switch ( key ) {
    case 'q':
    case 27:     // la touche Echappement
      exit( 0 );
      break;
     case 'o':
      camera->rotateUpLockSrc();
      break;
     case 'l':
      camera->rotateDownLockSrc();
      break;
     case 'i':
      camera->rotateUpLockDst();
      break;
     case 'k':
      camera->rotateDownLockDst();
      break;
     case 'u':
      camera->rotateSideLeft();
      break;
     case 'j':
      camera->rotateSideRight();
      break;
     case 'r':
      camera->moveFront(0.5);
      break;
     case 'f':
      camera->moveBack(0.5);
      break;
     case 'd':
      camera->moveLeft(0.5);
      break;
     case 'g':
      camera->moveRight(0.5);
      break;
     case 'w':
      camera->rotateLeftLockSrc();
      break;
     case 'x':
      camera->rotateRightLockSrc();
      break;
     case 'h':
      camera->rotateUpLockSrcKeepUpAndFront();
      break;
     case 'n':
      camera->rotateDownLockSrcKeepUpAndFront();
      break;
     case '+':
      camera->setDistanceFromToLockTo(camera->distanceFromTo/1.3);
      break;
     case '-':
      camera->setDistanceFromToLockTo(camera->distanceFromTo*1.3);
      break;
}
/************************************************************************/
class Camera {
   public:
    Camera(NxReal *_from, NxReal *_to, NxReal *_up);
    void lookAt();
    void moveFront();
    void moveBack();
    void moveUp();
    void moveDown();
    void moveLeft();
    void moveRight();
    void rotateUpLockSrc();
    void rotateDownLockSrc();
    void rotateUpLockSrcKeepUpAndFront();
    void rotateDownLockSrcKeepUpAndFront();
    void rotateLeftLockSrc();
    void rotateRightLockSrc();
    void rotateUpLockDst();
    void rotateDownLockDst();
    void rotateLeftLockDst();
    void rotateRightLockDst();
    void rotateSideLeft();
    void rotateSideRight();
    void move(NxReal *_direction);
    void moveFront(NxReal _distance);
    void moveBack(NxReal _distance);
    void moveUp(NxReal _distance);
    void moveDown(NxReal _distance);
    void moveLeft(NxReal _distance);
    void moveRight(NxReal _distance);
    void rotateUpLockSrc(NxReal _angle);
    void rotateDownLockSrc(NxReal _angle);
    void rotateUpLockSrcKeepUpAndFront(NxReal _angle);
    void rotateDownLockSrcKeepUpAndFront(NxReal _angle);
    void rotateLeftLockSrc(NxReal _angle);
    void rotateRightLockSrc(NxReal _angle);
    void rotateUpLockDst(NxReal _angle);
    void rotateDownLockDst(NxReal _angle);
    void rotateLeftLockDst(NxReal _angle);
    void rotateRightLockDst(NxReal _angle);
    void rotateSideLeft(NxReal _angle);
    void rotateSideRight(NxReal _angle);
    void setDistanceStep(NxReal _magnitudeStepUp, NxReal _magnitudeStepFront, NxReal _magnitudeStepLeft);
    void setAllAngleStep(NxReal _angle);
    void setAngleStep(NxReal _stepAngleUpDown, NxReal _stepAngleLeftRight, NxReal _stepAngleSide);
    void setFrom(NxReal *_from);
    void setTo(NxReal *_to);
    void setUp(NxReal *_up);
    void setFromToUp(NxReal *_from, NxReal *_to, NxReal *_up);
    void setDistanceFromToLockFrom(NxReal _distanceFromTo);
    void setDistanceFromToLockTo(NxReal _distanceFromTo);
    void setModeLock(bool _modeLockUpDown, bool _modeLockLeftRight, bool _modeLockSide);
    void setMinMaxCurrentUpDown(NxReal _minUpDown, NxReal _maxUpDown, NxReal _currentUpDown);
    void setMinMaxCurrentLeftRight(NxReal _minLeftRight, NxReal _maxLeftRight, NxReal _currentLeftRight);
    void setMinMaxCurrentSide(NxReal _minSide, NxReal _maxSide, NxReal _currentSide);
    void setAllMinMaxCurrent(NxReal _angle);
    void calculateStepVectors();
    NxVec3  // points:
            from,
            to,
            // normalized vectors:
            up,
            left,
            front,
            // balanced vectors:
            stepUp,
            stepLeft,
            stepFront;

    NxReal  sinUpDown,
            cosUpDown,
            stepAngleUpDown,
            sinLeftRight,
            cosLeftRight,
            stepAngleLeftRight,
            sinSide,
            cosSide,
            stepAngleSide;
            // distance and vector from - to :
    NxReal  distanceFromTo;
    NxVec3  fromTo;

    bool    modeLockUpDown,
            modeLockLeftRight,
            modeLockSide;

    NxReal  magnitudeStepUp,
            magnitudeStepFront,
            magnitudeStepLeft,
            maxUpDown,
            minUpDown,
            currentUpDown,
            maxLeftRight,
            minLeftRight,
            currentLeftRight,
            maxSide,
            minSide,
            currentSide;
};
/************************************************************************/
class NxVec3
{
	public:
	NxVec3  ();
	NxVec3  (NxReal a);
	NxVec3  (NxReal nx, NxReal ny, NxReal nz);
	NxVec3  (const NxReal v[]);
	NxVec3  (const NxReal v[], bool normalized);
	NxVec3  (const NxVec3& v);
	NxVec3  (const NxVec3& v, bool normalized);
	const   NxVec3& operator=(const NxVec3&);
	const   NxReal *get() const;
	NxReal* get();
	bool    operator< (const NxVec3&) const;
	bool    operator==(const NxVec3&) const;
	bool    operator!=(const NxVec3&) const;
	void    set(const NxVec3 &);
	void    setx(const NxReal & d);
	void    sety(const NxReal & d);
	void    setz(const NxReal & d);
	void    setNegative(const NxVec3 &a);
	void    setNegative();
	void    set(NxReal, NxReal, NxReal);
	void    set(NxReal);
	void    zero();
	void    setPlusInfinity();
	void    setMinusInfinity();
        void    add(const NxVec3 & a, const NxVec3 & b);
	void    subtract(const NxVec3 &a, const NxVec3 &b);
	void    multiply(NxReal s,  const NxVec3 & a);
	void    arrayMultiply(const NxVec3 &a, const NxVec3 &b);
	void    multiplyAdd(NxReal s, const NxVec3 & a, const NxVec3 & b);
	NxReal  normalize();
	void	setMagnitude(NxReal);
	bool    isFinite() const;
	NxReal  dot(const NxVec3 &other) const;
	bool    sameDirection(const NxVec3 &) const;
	NxReal  magnitude() const;
	NxReal  magnitudeSquared() const;
	NxReal  distance(const NxVec3 &) const;
	NxReal  distanceSquared(const NxVec3 &v) const;
	void    cross(const NxVec3 &left, const NxVec3 & right);
	void    cross(const NxVec3 &left, const NxVec3 & right, bool normalized);
	bool    equals(const NxVec3 &, NxReal epsilon) const;
	void    rotate (NxReal angle, const NxVec3 &axe);
	void    rotate (NxReal sin_angle, NxReal cos_angle, const NxVec3 &axe);
	void    rotate (const NxVec3 &axe);
	NxVec3  operator -() const;
	NxVec3  operator +(const NxVec3 & v) const;
	NxVec3  operator -(const NxVec3 & v) const;
	NxVec3  operator *(NxReal f) const;
	NxVec3  operator /(NxReal f) const;
	NxVec3  &operator +=(const NxVec3& v);
        NxVec3  &operator -=(const NxVec3& v);
	NxVec3  &operator *=(NxReal f);
	NxVec3  &operator /=(NxReal f);
	NxVec3  cross(const NxVec3& v) const;
	NxVec3  operator^(const NxVec3& v) const;
	NxReal  operator|(const NxVec3& v) const;
	NxReal  x,y,z;
};

Conclusion :


si quelqu'un a des commentaires sur pourquoi il faut tout refaire, ou encore mieux des idées pour l'améliorer... :)

merci

Codes Sources

A voir également

Ajouter un commentaire Commentaire
Messages postés
11
Date d'inscription
mercredi 29 octobre 2003
Statut
Membre
Dernière intervention
4 avril 2007

Rien à redire, ça me semble très bien, par contre j'ai une question...

Qu'est-ce qu'il se passe si le vecteur "Up" de la caméra a une valeur opposée à l'orientation de la caméra???

Par exemple,
si la caméra est placée aux coordonnées P : {0, 0, 0}
la cible se trouve en C : {0, -1, 0}
et le vecteur "Up" a les coordonnées : {0, 1, 0}

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.