Tourner autour d'un centre

Invité · 04/12/2013, 21h49

Bonsoir,

Cela fait plusieurs jours que je bloque dedans quelque chose qui peut paraître simple, j'ai essayé énormément de trucs amis sans succès.

Ce que j'aimerais faire, c'est tourner à 360 degré autour de moi même, comme dans un jeu ou l'on peut regarder autour de soi.

Voici mon code pour l'instant ( j'essaie de faire cela avec la souris )

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
#include <OpenGL/glu.h>
#include <QApplication>
#include <QGLWidget>
#include <cmath>
#include <QtGui>
 
using namespace std;
class MyGLWindow : public QGLWidget{
private :
    int width;
    int height;
    float z, x, y,xView, yView, zView;
public:
    MyGLWindow(unsigned int width,unsigned int height,QString title){
        resize(width,height);
        setWindowTitle(title);
        this->width = width;
        this->height = height;
        z = 3.0f;
        x = 3.0f;
        y = 3.0f;
 
        xView=0.0f;
        yView=0.0f;
        zView=0.0f;
}
 
protected:
    void initializeGL(void){
 
        glClear (GL_COLOR_BUFFER_BIT);
        glClearColor (0.0f, 0.0f, 0.0f, 0.0f);
        glEnable(GL_DEPTH_TEST);
 
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        setMouseTracking(true);
        gluPerspective(100.0f, (double)(width/height), 0.1f, 1000.0f);
        glMatrixMode(GL_MODELVIEW);
 
    }
 
    void resizeGL(int w, int h){
        glViewport(0, 0, (GLint)w, (GLint)h);
    }
 
    void paintGL(void){
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) ;
 
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(0.0,0.0,0.0,xView,yView,zView,0.0f,1.0f,0.0f);
 
 
   glBegin(GL_LINES);
        glColor3f (1.0f, 0.0f, 0.0f);
        glVertex3f (0.0f, 0.0f, 0.0f);
        glVertex3f (0.0f, 0.0f, 5.0f);
   glEnd();
   glBegin(GL_LINES);
        glColor3f (0.0f, 1.0f, 0.0f);
        glVertex3f (0.0f, 0.0f, 0.0f);
        glVertex3f (0.0f, 5.0f, 0.0f);
   glEnd();
   glBegin(GL_LINES);
        glColor3f (0.0f, 0.0f, 1.0f);
        glVertex3f (0.0f, 0.0f, 0.0f);
        glVertex3f (5.0f, 0.0f, 0.0f);
   glEnd();
   glBegin(GL_QUADS);
   glColor3ub(255,0,0); //face rouge
   glVertex3d(0.2,0.2,0.2);
   glVertex3d(0.2,0.2,-0.2);
   glVertex3d(-0.2,0.2,-0.2);
   glVertex3d(-0.2,0.2,0.2);
 
   glColor3ub(0,255,0); //face verte
   glVertex3d(0.2,-0.2,0.2);
   glVertex3d(0.2,-0.2,-0.2);
   glVertex3d(0.2,0.2,-0.2);
   glVertex3d(0.2,0.2,0.2);
 
   glColor3ub(0,0,255); //face bleue
   glVertex3d(-0.2,-0.2,0.2);
   glVertex3d(-0.2,-0.2,-0.2);
   glVertex3d(0.2,-0.2,-0.2);
   glVertex3d(0.2,-0.2,0.2);
 
   glColor3ub(255,255,0); //face jaune
   glVertex3d(-0.2,0.2,0.2);
   glVertex3d(-0.2,0.2,-0.2);
   glVertex3d(-0.2,-0.2,-0.2);
   glVertex3d(-0.2,-0.2,0.2);
 
   glColor3ub(0,255,255); //face cyan
   glVertex3d(0.2,0.2,-0.2);
   glVertex3d(0.2,-0.2,-0.2);
   glVertex3d(-0.2,-0.2,-0.2);
   glVertex3d(-0.2,0.2,-0.2);
 
   glColor3ub(255,0,255); //face magenta
   glVertex3d(0.2,-0.2,0.2);
   glVertex3d(0.2,0.2,0.2);
   glVertex3d(-0.2,0.2,0.2);
   glVertex3d(-0.2,-0.2,0.2);
 
   glEnd();
    }
 
    void mouseMoveEvent(QMouseEvent *event){
 
        qDebug() << "X : " << xView << "Y : " << yView << "Z : " << zView;
 
          xView = xView + sin(-(event->x())*M_PI/180) * cos(-(event->y())*M_PI/180);
          yView = yView + sin((event->x())*M_PI/180) * sin((event->y())*M_PI/180);
          zView = zView + cos((event->x())*M_PI/180);
 
          updateGL();
     }
 
    void keyPressEvent(QKeyEvent *event)
    {
        switch (event->key()){
            case Qt::Key_Up : // APPUYER SUR LA TOUCHE A
                z+=1.0;
                qDebug() << "z : " << z;
            break;
            case Qt::Key_Down : // APPUYER SUR LA TOUCHE Z
                z-=1.0;
                qDebug() << "z : " << z;
            break;
 
            case Qt::Key_Left : // APPUYER SUR LA TOUCHE GAUCHE
                x+=1.0;
                qDebug() << "x : " << x;
            break;
            case Qt::Key_Right : // APPUYER SUR LA TOUCHE DROITE
                x-=1.0;
                qDebug() << "x : " << x;
            break;
            case Qt::Key_A : // APPUYER SUR LA TOUCHE HAUT
                qDebug() << "y : " << y;
            break;
            case Qt::Key_Z : // APPUYER SUR LA TOUCHE BAS
                qDebug() << "y : " << y;
            break;
 
        }
        updateGL();
    }
};
 
int main(int argc, char** argv){
    QApplication app(argc,argv);
    MyGLWindow myglwin(350, 350,"TP1 OpenGL : hello_world_OpenGL");
    myglwin.show();
    return app.exec();
}

On est à l'intérieur d'un cube, et je test donc de pouvoir regarder tout autour de moi, sauf que bien sûr ça bloque ..

J'espère que certains seront me guider !

Bonne soirée

**LittleWhite** · 05/12/2013, 07h02

Bonjour,

En effet, il ne faut pas récupérer de manière brute les coordonnées x/y de la souris, car celles ci sont en position écran.
À la place, il faut regarder le décalage de la souris sur les deux aces, entre chaque update. Suivant ce décalage, vous mettez à jour vos angles de rotation. Et grâce à vos angles de rotation, vous calculer xView/yView/zView, comme vous le faites actuellement.

Invité · 06/12/2013, 18h37

Bonsoir,

Merci du retour.
J'avais déjà essayé de mettre dans des variables et de faire des conditions en m'inspirant d'autres fonctions que je vais citer après, mais sans succès.. ( surement un soucis de normal )
Je ne comprends pas leurs façons de faire, et surtout où mettre cela dans mon gluLookAt ..
Je suppose que theta correspond à x de la souris, et phi au y ?

Voici ce que j'ai pu trouvé sur le net :

Fonction 1 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
float r = viewDist;
	  float x = r*cos((45.+viewPhi)*M_PI/180)*cos(viewTheta*M_PI/180);  
      float y = r*sin((45.+viewPhi)*M_PI/180)*cos(viewTheta*M_PI/180);
      float z = r*sin(viewTheta*M_PI/180.0);
      gluLookAt(widthBox+x, widthBox+y, z, 0.0, 0.0, depthBox/2.0, 0.0, 0.0, 1.0);

Fonction 2 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
theta -= _vTheta;
	_phi -= _vPhi;
	if (_phi >= 90.0) {
		_phi = 89.9;
	}
	if (_phi <= -90.0) {
		_phi = -89.9;
	}
 
	if (_orbit < _orbitMin) {
		_orbit = _orbitMin;
	}
 
	// Convert camera angles to positions
	float y = _orbit * sin(_phi * M_PI / 180);
	float l = _orbit * cos(_phi * M_PI / 180);
	float x = l * sin(_theta * M_PI / 180);
	float z = l * cos(_theta * M_PI / 180);

Fonction 3

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
vector3df sphericalXYZ(f32 compassAngle, f32 elevationAngle, f32 radius){
 
   compassAngle = compassAngle * -1;
   elevationAngle = elevationAngle * -1;
 
   elevationAngle = elevationAngle + 90;
 
   f32 x = radius * cos(compassAngle * PI/180.0f ) * sin(elevationAngle * PI/180.0f );
   f32 z = radius * sin(compassAngle * PI/180.0f ) * sin(elevationAngle * PI/180.0f );
   f32 y = radius * cos(elevationAngle * PI/180.0f );
 
   vector3df result;
   result.X = x;
   result.Y = y;
   result.Z = z;
   return result;
}

Fonction 4 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
position.z = distance * sin(phi*(M_PI/180));
position.y = distance * cos(teta*(M_PI/180)) * cos(phi*(M_PI/180));
position.x = distance * sin(teta*(M_PI/180)) * cos(phi*(M_PI/180));

Je n'ai bien sûr pas réussi à les réimplanter par manque d'informations sur leurs variables..

**plegat** · 09/12/2013, 16h33

Salut,

Envoyé par tchoumo

Je suppose que theta correspond à x de la souris, et phi au y ?

Non, du tout... theta et phi sont des angles, donc rien à voir avec les x et y de la souris.
Et comme l'a souligné LittleWhite, il ne faut pas utiliser les x/y de l'évènement souris directement brut de fonderie... mais les ramener à des valeurs utilisables dans ton environnement 3D.

Il faut penser à ce que tu veux que ton programme fasse... passer de ta fenêtre 2D à ton monde 3D, et de ton monde 3D à ton programme.

J'ai l'impression que tu récupères du code sur le net et que tu essaies d'assembler les briques sans réellement savoir ce que tu fais...

Ton gluLookAt à besoin d'une position, d'une cible, et d'une orientation. Quelle partie modifies-tu quand tu fais un clic souris? la position? la cible?
Ton évènement souris modifie ta cible (xview,yview,zview), alors que ton évènement clavier modifie ta position (x,y,z... même si ils ne sont pas utilisés dans le gluLookAt!).

Quetion: comment gères-tu ta caméra dans ton programme? Parce que tourner à 360 dans un espace 3D, c'est vague...

Invité · 10/12/2013, 11h34

Bonjour,

Concernant la caméra, j'étais partie du fait que j'allais pas utilisé une classe Caméra implémenté par mon prof mais plutôt faire la mienne pour arriver au final à ce que je veux faire ( tourner autour de soi )

J'ai déjà une classe caméra que j'ai pas encore implémenté dans mon programme de test.
Je viens de mettre un exemple de test/implémentation de la caméra de notre prof
sur un simple triangle.

Voici la classe :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#ifndef CAMERA_H
#define CAMERA_H
 
#include "point.h"
 
class Camera {
public :
    point position;
    point visee;
    point verticale;
 
    float planProche, planLointain;
    float ratio;
    float ouverture;
 
    Camera();
    ~Camera();
    Camera(const Camera&);
 
    //accesseurs
    float getPositionX();
    float getPositionY();
    float getPositionZ();
 
    float getViseeX();
    float getViseeY();
    float getViseeZ();
 
    float getVerticaleX();
    float getVerticaleY();
    float getVerticaleZ();
 
    point getPosition();
    point getVisee();
    point getVerticale();
    float getRatio();
    float getPlanProche();
    float getPlanLointain();
    float getOuverture();
 
    void setPosition(const point &);
    void setVisee(const point &);
    void setVerticale(const point&);
 
    void setPlanLointain(const float &);
    void setPlanProche(const float  &);
    void setRatio(const float &);
    void setOuverture(const float &);
};
 
 
#endif // CAMERA_H

Et le .cpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
#include "camera.h"
Camera::Camera() {
    position = point(0.0f ,0.0f, 50.0f);\
    visee = point(0.0f, 0.0f, 0.0f);\
    verticale = point(0.0, 1.0, 0.0);\
    planProche = 1.0f; planLointain = 1000.0f;\
    ratio = 1.0f; ouverture = 100.0f;
}
 
Camera::~Camera() {///rien pour l'instant
}
 
Camera::Camera(const Camera& _cam) {
    position = _cam.position; visee = _cam.visee ; verticale = _cam.verticale;\
    planProche = _cam.planProche; planLointain = _cam.planLointain;\
    ratio = _cam.ratio; ouverture = _cam.ouverture;
}
 
 
    //accesseurs
float Camera::getPositionX() {return position.x;}
    float Camera::getPositionY() {return position.y;}
    float Camera::getPositionZ() {return position.z;}
 
    float Camera::getViseeX() {return visee.x;}
    float Camera::getViseeY() {return visee.y;}
    float Camera::getViseeZ() {return visee.z;}
 
    float Camera::getVerticaleX() {return verticale.x;}
    float Camera::getVerticaleY() {return verticale.y;}
    float Camera::getVerticaleZ() {return verticale.z;}
 
    point Camera::getPosition() {return position;}
    point Camera::getVisee() {return visee;}
    point Camera::getVerticale() {return verticale;}
    float Camera::getRatio() {return ratio;}
    float Camera:: getPlanProche() {return planProche;}
    float Camera::getPlanLointain() {return planLointain;}
    float Camera::getOuverture() {return ouverture;}
 
    void Camera::setPosition(const point & _p) {position = _p;}
    void Camera::setVisee(const point & _v) {visee = _v;}
    void Camera::setVerticale(const point & _v) {verticale = _v;}
 
    void Camera::setPlanLointain(const float & _f) {planLointain = _f;}
    void Camera::setPlanProche(const float  & _f) {planProche = _f;}
    void Camera::setRatio(const float & _r) {ratio = _r;}
    void Camera::setOuverture(const float & _o) {ouverture = _o;}

C'est une classe que j'ai utilisé lors de certains de mes tp ( étudiant )

Et sinon, un simple exemple en utilisant un simple triangle comme figure.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
#include <glu.h>
 
#include "myglwindow.h"
 
 
 // Constructeur
 MyGLWindow::MyGLWindow(unsigned int width,unsigned int height,QString title)
 {
 
 myCamera = new Camera();
 myCamera -> setRatio((float) width / (float) height);
 myCamera -> setPosition(point(0.0, 0.0, -10.0));
 myCamera -> setOuverture(130.0);
 
 xRot = 0.0f;
 yRot = 0.0f;
 zRot = 0.0f;
 
 //Options OpenGL
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_CULL_FACE);
    glShadeModel(GL_SMOOTH);
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    glEnable(GL_MULTISAMPLE);
 
    static GLfloat lightPosition[4] = { 0.5, 5.0, 7.0, 1.0 };
    glLightfv(GL_LIGHT0, GL_POSITION, lightPosition);
 
 resize(width,height);
 
 setWindowTitle(title);
 }
 
 MyGLWindow::~MyGLWindow()
 {
     if (!myCamera)
    delete myCamera;
 }
 
 //
 //fonction appelée (une seule fois) au lancement du moteur OpenGL.
 //
 void MyGLWindow::initializeGL(void)
  {
     setMouseTracking(true);
 
    //choix de la couleur de fond
    glClearColor (0.6f, 0.6f, 0.6f, 0.0f); //(R, G, B, transparence), donc vert
 
    //les paramètres de projection
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
 
    glOrtho(-10.0, 10.0, -10.0, 10.0, -10.0, 10.0);
     gluPerspective(myCamera -> ouverture, myCamera -> ratio, myCamera -> getPlanProche(), myCamera->getPlanLointain() );
  }
 
 //
 //fonction qui est appelée à chaque changement de taille de la fenêtre.
 //
 void MyGLWindow::resizeGL(int w, int h)
  {
   // modifie le Viewport pour que ça colle aux dimensions de la fenêtre.
   glViewport(0, 0, (GLint)w, (GLint)h);
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();
    glOrtho(-10.0, 10.0, -10.0, 10.0, -10.0, 10.0);
   myCamera -> setRatio((float)w/(float)h);
 }
 
 
 void MyGLWindow::myScene() {
     //tous nos objets seront en rouge
    glColor3f (1.0f, 0.0f, 0.0f); //(R, G, B)
 
    glRotatef(xRot, 1.0, 0.0, 0.0);
    glRotatef(yRot, 0.0, 1.0, 0.0);
    glRotatef(zRot, 0.0, 0.0, 1.0);
 
    //on commence à décrire un objet géométrique (TRIANGLE -> 3 sommets)
    glBegin(GL_TRIANGLES);
        glVertex3f (-1.0f, -1.0f, 0.0f);
        glVertex3f (1.0f, -1.0f, 2.0f);
        glVertex3f (0.0f, 1.0f, 0.0f);
    glEnd(); //on termine là la description de notre objet
 
 }
 
 //
 //fonction qui est appelée à chaque image
 //
 void MyGLWindow::paintGL(void)
  {
     glMatrixMode(GL_MODELVIEW);
     glLoadIdentity();
 
     gluLookAt(myCamera -> getPositionX(), myCamera -> getPositionY(), myCamera -> getPositionZ(),
       myCamera -> getViseeX(), myCamera -> getViseeY(), myCamera -> getViseeZ(),
       myCamera -> getVerticaleX(), myCamera -> getVerticaleY(), myCamera -> getVerticaleZ());
 
 
    //on met le fond de l'image à la couleur par défaut
    glClear (GL_COLOR_BUFFER_BIT);
    glColor3f(1.0, 0.0, 0.0);
   myScene();
    // Les tracés sont terminés et seront automatiquement portés à l'écran avec
    // un appel à swapBuffers();
}
 
void MyGLWindow::mousePressEvent(QMouseEvent *event) {
    lastPos = event -> pos();
}
 
void MyGLWindow::mouseMoveEvent(QMouseEvent *event)
  {
      int dx = event->x() - lastPos.x();
      int dy = event->y() - lastPos.y();
 
      if (event->buttons() & Qt::LeftButton) {
      setxRotation(xRot + 8 * dy);
      setyRotation(yRot + 8 * dx);
      } else if (event->buttons() & Qt::RightButton) {
      setxRotation(xRot + 8 * dy);
      setzRotation(zRot + 8 * dx);
      }
      lastPos = event->pos();
 }
 
void MyGLWindow::setxRotation(int angle)
 {
     if (angle != xRot) {
     xRot = angle;
     updateGL();
     }
 }
 
void MyGLWindow::setyRotation(int angle)
 {
     if (angle != yRot) {
     yRot = angle;
     updateGL();
     }
 }
 
void MyGLWindow::setzRotation(int angle)
 {
     if (angle != zRot) {
     zRot = angle;
     updateGL();
     }
 }

Pour éviter de demander des réponses, est-ce que vous pensez qu'il est possible d'arriver à mon but en partant de cette base ?

Car la caméra du prof ne fait que tourner l'objet , pas moi même..

**plegat** · 10/12/2013, 11h53

Envoyé par tchoumo

Car la caméra du prof ne fait que tourner l'objet , pas moi même..

Tu sais que ça ne veut rien dire cette phrase?

La caméra de ton prof ne fait pas tourner l'objet. Du tout. L'objet tourne, certes, mais ce n'est pas la caméra qui s'en occupe...

Dans ton cas, le but du jeu est uniquement d'arriver à gérer la position de ta caméra, et le point qu'elle vise. Ca se fait très bien, d'ailleurs c'est ce que fait la classe caméra de ton prof. La tienne aussi d'ailleurs.

Ta seule difficulté, c'est de réussir à modifier le point de visée. On t'a dit précédemment qu'il ne fallait pas utiliser les x/y de l'évènement souris directement, c'est tout ce qu'il y a à savoir. Il faut juste passer de l'espace 2D, à l'espace 3D... par exemple en disant que si la souris se déplace de 5 pixels en x (de la fenêtre 2D), ça correspond à une rotation de 5° autour de l'axe z (de l'espace 3D)... c'est tout...

Tourner autour d'un centre

OpenGL

Vue hybride

Discussions similaires

Partager

Partager