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
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.