Bienvenue sur le forum !

Si vous souhaitez rejoindre la communauté, cliquez sur l'un de ces boutons !

Qt 5 : 5.7.1 - Qt Creator : 4.2.0 - Qt Installer : 2.0.3 - JOM : 1.1.2 - Qt Build suite : 1.7.0 - VS Qt 5 : 2.0.0

opengl deplacement et rotation de camera

16 Mar modifié dans Qt / Langage C++
Bonsoir a tous,
je viens demander votre aide pour realser une classe Camera correcte,
pour les déplacements j'y arrive bien mais pas les rotations et point cible.
Merci d'avance
Je met mon code Camera
Camera.h

#ifndef CAMERA_H
#define CAMERA_H

#include<QVector3D>
#include<QKeyEvent>
#include<QMouseEvent>

class Camera
{

public:

Camera();
Camera(QVector3D position, QVector3D pointCible, QVector3D axeVertical,float sensibilite, float vitesse);
~Camera();

void orienter(int xRel, int yRel);
void setPointcible(QVector3D pointCible);
void lookAt(QMatrix4x4 &modelview);
void setPosition(QVector3D position);

void keyPressEvent(QKeyEvent *event);
// void mouseMoveEvent(QMouseEvent * event);
void keyUp();
void keyDown();
void keyLeft();
void keyRight();
void positionSouris(int px, int py);

float sensibilite() const;

float vitesse() const;

void setSensibilite(float sensibilite);

void setVitesse(float vitesse);


QVector3D m_orientation;
QVector3D m_axeVertical;
QVector3D m_deplacementLateral;

QVector3D m_position;
QVector3D m_pointCible;

private:
float m_phi;
float m_theta;

float m_sensibilite;
float m_vitesse;

};

#endif // CAMERA_H
Camera.cpp

#include <qmath.h>
#include <QDebug>
#include <iostream>

#include <QMatrix4x4>

#include "camera.h"


Camera::Camera() : m_phi(0.0), m_theta(0.0), m_orientation(), m_axeVertical(0, 1, 0),
m_deplacementLateral(), m_position(), m_pointCible(),
m_sensibilite(0.0), m_vitesse(0.0)

{

}

Camera::Camera(QVector3D position, QVector3D pointCible, QVector3D axeVertical,float sensibilite, float vitesse) :
m_phi(0.0), m_theta(0.0), m_orientation(),
m_axeVertical(axeVertical), m_deplacementLateral(),
m_position(position), m_pointCible(pointCible),
m_sensibilite(sensibilite), m_vitesse(vitesse)

{
// Actualisation du point ciblé
setPointcible(pointCible);
}

Camera::~Camera()
{

}
void Camera::orienter(int xRel, int yRel)
{
// Modification des angles
m_phi += -yRel * m_sensibilite;
m_theta += -xRel * m_sensibilite;

// Limitation de l'angle phi
if(m_phi > 89.0)
m_phi = 89.0;

else if(m_phi < -89.0)
m_phi = -89.0;

// Conversion des angles en radian
float phiRadian = m_phi * M_PI / 180;
float thetaRadian = m_theta * M_PI / 180;

//------à

//passage des coordonnées sphériques aux coordonnées cartésiennes

double r_temp = qCos(phiRadian);

m_orientation.setZ(qSin(phiRadian));

m_orientation.setX(r_temp*qCos(thetaRadian));

m_orientation.setY(r_temp*qSin(thetaRadian));
//--------
// // Si l'axe vertical est l'axe X
// if(m_axeVertical.x() == 1.0)
// {
// // Calcul des coordonnées sphériques

// m_orientation.setX(qSin(phiRadian));
// m_orientation.setY(qCos(phiRadian) * qCos(thetaRadian));
// m_orientation.setZ(qCos(phiRadian) * qSin(thetaRadian));

// }
//// Si c'est l'axe Y
// else if(m_axeVertical.y() == 1.0)
// {
// Calcul des coordonnées sphériques
// m_orientation.setX(qCos(phiRadian) * qSin(thetaRadian));
// m_orientation.setY(qSin(phiRadian));
// m_orientation.setZ(qCos(phiRadian) * qCos(thetaRadian));
// }

// // qSoson c'est l'axe Z
// else
// {
// Calcul des coordonnées sphériques
// m_orientation.setX(qCos(phiRadian) * qCos(thetaRadian));
// m_orientation.setY(qCos(phiRadian) * qSin(thetaRadian));
// m_orientation.setZ(qSin(phiRadian));
// }

// Calcul de la normale
m_deplacementLateral = (m_deplacementLateral.crossProduct(m_axeVertical, m_orientation));
m_deplacementLateral.normalized();

// Calcul du point ciblé pour OpenGL

m_pointCible = m_position + m_orientation;
}

void Camera::setPointcible(QVector3D pointCible)
{
// Calcul du vecteur orientation
// m_orientation = m_pointCible - m_position; revoir ici
m_orientation = pointCible - m_position;
m_orientation.normalize();

// Si l'axe vertical est l'axe X
if(m_axeVertical.x() == 1.0)
{
// Calcul des angles
m_phi = qAsin(m_orientation.x());
m_theta = qAcos(m_orientation.y() / qCos(m_phi));

if(m_orientation.y() < 0)
m_theta *= -1;
}

// Si c'est l'axe Y
else if(m_axeVertical.y() == 1.0)
{
// Calcul des angles
m_phi = qAsin(m_orientation.y());
m_theta = qAcos(m_orientation.z() / qCos(m_phi));

if(m_orientation.z() < 0)
m_theta *= -1;

}
// Sinon c'est l'axe Z
else
{
// Calcul des angles
m_phi = qAsin(m_orientation.x());
m_theta = qAcos(m_orientation.z() / qCos(m_phi));

if(m_orientation.z() < 0)
m_theta *= -1;
}

// Conversion en degrés
m_phi = m_phi * 180 / M_PI;
m_theta = m_theta * 180 / M_PI;
}

void Camera::lookAt(QMatrix4x4 &modelview)
{
modelview.lookAt(m_position, m_pointCible, m_axeVertical);
}

void Camera::setPosition(QVector3D position)
{
// Mise à jour de la position
m_position = position;
// Actualisation du point ciblé
m_pointCible = m_position + m_orientation;
}


void Camera::keyPressEvent(QKeyEvent *event)
{

if((event->key() == Qt::Key_Up))
{
m_position.setZ(m_position.z()+0.1);
}
if((event->key() == Qt::Key_Down))
{
m_position.setZ(m_position.z()-0.1);
}
if((event->key() == Qt::Key_Left))
{
m_position.setX(m_position.x()+0.1);
}
if((event->key() == Qt::Key_Right))
{
m_position.setX(m_position.x()-0.1);
}
}


void Camera::keyUp()
{

// m_position += m_orientation * m_vitesse;
// m_pointCible = m_position + m_orientation;

m_position = m_position + m_orientation * 0.5f;
m_pointCible = m_position + m_orientation;
}

void Camera::keyDown()
{

// m_position -=m_orientation *m_vitesse;
// m_pointCible = m_position + m_orientation;
m_position = m_position - m_orientation * 0.5f;
m_pointCible = m_position + m_orientation;
}

void Camera::keyLeft()
{
// m_position += m_deplacementLateral * m_vitesse;
// m_pointCible = m_position + m_orientation;
m_position = m_position + m_deplacementLateral * 0.5f;
m_pointCible = m_position + m_orientation;

}

void Camera::keyRight()
{
m_position = m_position - m_deplacementLateral * 0.5f;
m_pointCible = m_position + m_orientation;

// m_position -= m_deplacementLateral * m_vitesse;
// m_pointCible = m_position + m_orientation;
}

void Camera::positionSouris(int px, int py)
{
// QPoint positionSouris = event->pos();

this->orienter(px, py);

// qDebug() <<"x"<<px <<endl;
}

float Camera::sensibilite() const
{
return m_sensibilite;
}

float Camera::vitesse() const
{
return m_vitesse;
}

void Camera::setSensibilite(float sensibilite)
{
m_sensibilite = sensibilite;
}

void Camera::setVitesse(float vitesse)
{
m_vitesse = vitesse;
}

Réponses

  • 17 Mar modifié
    La classe camera est correcte, c'est juste quand je rentre le position x et y de la souris le model ne fait que tourner sur le point d'origine alors que normalement je dois l'explorer en free fly
    void Scene3D::mouseMoveEvent(QMouseEvent *event)
    {
    QPoint pSouris = event->pos();

    cam1->positionSouris(pSouris.x(), pSouris.y());// objet camera

    }
    je serai heureux si quelqun pourai poster un code basique pour gerer la souris sous opengl
Connectez-vous ou Inscrivez-vous pour répondre.