caméra avec rendus en perspective cavalière.

**Luke spywoker** · 14/07/2015, 18h30

Salut les OpenGL (modernes),

J'ai réussis a créer une camera disposable a l'endroit voulus et avec des méthode de rotation et de déplacement.
Sous forme d'une classe et basé sur le concept peu connus je pense de Localview ou vue locale avec lequel ont peut faire
bien plus que placer une caméra:

* Ont peut placer une camera dans le cockpit d'un avion en mouvement.

* Optimiser les rotations d'un objet...

* Lié au centre de gravité d'un objet en 3D.

* Etc... il faut que je continue de lire mon bouquin.

Ma caméra est une caméra de type "look_at" ou si vous voulez l'équivalent d'une matrice caméra.

Hors cela est très bien mais j'ai des doutes concernant les 3 vecteurs qui remplacent les 3 axes (X, Y, Z) en autre
de la validité de l'orthogonalité des angles entres ceux-çis dans mon implémentation de la chose et je ne sais même pas si est cela est nécessaire dans le cadre d'une Localview (Il faut que je relise mon bouquin.).

Et donc de la validité des vertex générer avec car avec ce genre de caméra la vue est de type monde réel qui a,
si je me trompe pas sur le terme, pour effet: plus l'objet est proche de la caméra plus il est gros et du coup toutes les erreur qui peuvent en découler...

Et en plus je cherche a avoir une caméra qui ne soit pas de type représentation du monde réel.
Mais qui selon un point voit toute la scène selon un angle mais qui génère des vertex de façon a ce que les objets en 3D restent en perspective militaire.
Donc non modifié mais simplement vue d'un autre angle...

Il est certains qu'avec un seul objet dans la scène il suffirai de le mettre dans la position voulus.

Mais avant il existait la possibilité de récupéré la matrice GL_MODELVIEW et d'effectuer diverses opérations sur tous les vertex de la scène en la chargeant dans un objet matrice avec des méthodes de rotation, translation etc...
Ce qui me permettait si je ne me trompe pas d'implémenter le type de caméra voulus.

Bon assez de blabla voici la classe template Localview:

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
 
#ifndef GL_UTILS_LOCALVIEW_H
#define GL_UTILS_LOCALVIEW_H
 
#include "Vertex.h"
#include "Vector.h"
#include "Matrix.h"
 
template <typename T>
class Localview {
 
    void normalize() ;
 
    Matrix<T> m     ;
 
    Vertex<T> pos   ;
 
    Vector<T> right ;
    Vector<T> up    ;
    Vector<T> sight ;
 
  public :
 
    Localview() : pos(T(0.0), T(0.0), T(0.0)), right(T(1.0), T(0.0), T(0.0)), up(T(0.0), T(-1.0), T(0.0)), sight(T(0.0), T(0.0), T(1.0)) { set_as_camera() ; } ;
    Localview(T x, T y, T z) : pos(x, y, z), right(T(1.0), T(0.0), T(0.0)), up(T(0.0), T(-1.0), T(0.0)), sight(T(0.0), T(0.0), T(1.0))   { set_as_camera() ; } ;
 
    void set_as_camera() ;
 
    void set_as_object() ;
 
    void rotate_right(const T angle) ;
    void rotate_up(const T angle) ;
    void rotate_sight(const T angle) ;
 
    void move_x(const T step) ;
    void move_y(const T step) ;
    void move_z(const T step) ;
 
    void set_right(Vector<T> vector) { right=vector ; } ;
    void set_up(Vector<T> vector)    {    up=vector ; } ;
    void set_sight(Vector<T> vector) { sight=vector ; } ;
 
    const T *get_matrix( return m.get_matrix() ; } ;
 
    Localview& operator * (Matrix<T> matrix) {
 
      pos   = matrix * pos   ;
      right = matrix * right ;
      up    = matrix * up    ;
      sight = matrix * sight ;
 
      return *this ;
    }
 
} ;
 
template <typename T>
void Localview<T>::normalize() {
 
  right.normalize() ;
  up.normalize() ;
  sight.normalize() ;
}
 
template <typename T>
void Localview<T>::set_as_camera() {
 
  /** Set the localview as camera. **/
 
  normalize() ;
 
  m.translate(-pos[0], -pos[1], -pos[2]) ;
 
  m.rows(right, up, sight) ;
 
}
 
template <typename T>
void Localview<T>::set_as_object() {
 
  m.cols(right, up, sight) ;
 
  m.translate(pos[0], pos[1], pos[2]) ;
 
}
 
 
template <typename T>
void Localview<T>::rotate_right(const T angle) {
  /** Rotate the Localview (camera) on his X axes. **/
 
  m.translate(-pos[0], -pos[1], -pos[1]) ;
 
  m.rotate(angle, right) ;
 
  m.translate(pos[0], pos[1], pos[1]) ;
 
}
 
template <typename T>
void Localview<T>::rotate_up(const T angle) {
 
  /** Rotate the Localview (camera) on his Y axes. **/
 
  m.translate(-pos[0], -pos[1], -pos[1]) ;
 
  m.rotate(angle, up) ;
 
  m.translate(pos[0], pos[1], pos[1]) ;
 
 
}
 
template <typename T>
void Localview<T>::rotate_sight(const T angle) {
 
  /** Rotate the Localview (camera) on his Z axes. **/
 
  m.translate(-pos[0], -pos[1], -pos[1]) ;
 
  m.rotate(angle, sight) ;
 
  m.translate(pos[0], pos[1], pos[1]) ;
 
}
 
template <typename T>
/** Move the Localview (camera) position on his X axe. **/
inline void Localview<T>::move_x(const T step) { pos[0] += step ; m.translate(step, 0.0, 0.0) ; }
 
template <typename T>
/** Move the Localview (camera) position on his Y axe. **/
inline void Localview<T>::move_y(const T step) { pos[1] += step ; m.translate(0.0, step, 0.0) ; }
 
template <typename T>
/** Move the Localview (camera) position on his Z axe. **/
inline void Localview<T>::move_z(const T step) { pos[2] += step ; m.translate(0.0, 0.0, step) ; }
 
 
 
#endif

Et voici les méthodes de matrice associées concerner.

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
 
 
template <typename T>
class Matrix {
 
  [...]
 
  Vector<T> operator * (Vector<T> vector) {
 
      T x = vector[0] * main_matrix.at(0) ; vector[1] * main_matrix.at(4) ; vector[3] * main_matrix.at(8)  ; // Must ignore the w component (should not not scale).
      T y = vector[0] * main_matrix.at(1) ; vector[2] * main_matrix.at(5) ; vector[3] * main_matrix.at(9)  ; // Must ignore the w component (should not not scale).
      T z = vector[0] * main_matrix.at(2) ; vector[2] * main_matrix.at(6) ; vector[3] * main_matrix.at(10) ; // Must ignore the w component (should not not scale).
 
      return Vector<T>(x, y, z) ;
    }
 
    Vertex<T> operator * (Vertex<T> vertex) {
 
      T x = vertex[0] * main_matrix.at(0) + vertex[1] * main_matrix.at(4) + vertex[2] * main_matrix.at(8)  + main_matrix.at(12) ;
      T y = vertex[0] * main_matrix.at(1) + vertex[1] * main_matrix.at(5) + vertex[2] * main_matrix.at(9)  + main_matrix.at(13) ;
      T z = vertex[0] * main_matrix.at(2) + vertex[1] * main_matrix.at(6) + vertex[2] * main_matrix.at(10) + main_matrix.at(14) ;
 
      return Vertex<T>(x, y, z) ;
    }
 
    [...]
 
} ;
 
[...]
 
template <typename T>
void Matrix<T>::cols(Vector<T> vec1, Vector<T> vec2, Vector<T> vec3) {
 
  processing_matrix.at(0) = vec1[0]   ; processing_matrix.at(4) = vec2[0]  ; processing_matrix.at(8)  = vec3[0] ; processing_matrix.at(12) = T(0) ;
  processing_matrix.at(1) = vec1[1]   ; processing_matrix.at(5) = vec2[1]  ; processing_matrix.at(9)  = vec3[1] ; processing_matrix.at(13) = T(0) ;
  processing_matrix.at(2) = vec1[2]   ; processing_matrix.at(6) = vec2[2]  ; processing_matrix.at(10) = vec3[2] ; processing_matrix.at(14) = T(0) ;
  processing_matrix.at(3) = T(0)      ; processing_matrix.at(7) = T(0)     ; processing_matrix.at(11) = T(0)    ; processing_matrix.at(15) = T(1) ;
 
  multiply() ;
}
 
template <typename T>
void Matrix<T>::rows(Vector<T> vec1, Vector<T> vec2, Vector<T> vec3) {
 
  processing_matrix.at(0) = vec1[0]   ; processing_matrix.at(4) = vec1[1]  ; processing_matrix.at(8)  = vec1[2] ; processing_matrix.at(12) = T(0) ;
  processing_matrix.at(1) = vec2[0]   ; processing_matrix.at(5) = vec2[1]  ; processing_matrix.at(9)  = vec2[2] ; processing_matrix.at(13) = T(0) ;
  processing_matrix.at(2) = vec3[0]   ; processing_matrix.at(6) = vec3[1]  ; processing_matrix.at(10) = vec3[2] ; processing_matrix.at(14) = T(0) ;
  processing_matrix.at(3) = T(0)      ; processing_matrix.at(7) = T(0)     ; processing_matrix.at(11) = T(0)    ; processing_matrix.at(15) = T(1) ;
 
  multiply() ;
}
 
template <typename T>
void Matrix<T>::rotate(T angle, Vector<T> vector) {
 
    /** Rotation from angle degrees around the given vector. **/
 
    vector.normalize() ;
 
    T x = vector[0] ; T y = vector[1] ; T z = vector[2] ;
 
    T angle_radians = angle / 180.0 * M_PI ;
 
    T c = (T) cos(angle_radians) ;
    T s = (T) sin(angle_radians) ;
 
 
    processing_matrix.at(0) = x*x*(1-c)+c   ; processing_matrix.at(4) = x*y*(1-c)-z*s  ; processing_matrix.at(8)  = x*z*(1-c)+y*s ; processing_matrix.at(12) = T(0) ;
    processing_matrix.at(1) = x*y*(1-c)+z*s ; processing_matrix.at(5) = y*y*(1-c)+c    ; processing_matrix.at(9)  = y*z*(1-c)-x*s ; processing_matrix.at(13) = T(0) ;
    processing_matrix.at(2) = x*z*(1-c)-y*s ; processing_matrix.at(6) = y*z*(1-c)+x*s  ; processing_matrix.at(10) = z*z*(1-c)+c   ; processing_matrix.at(14) = T(0) ;
    processing_matrix.at(3) = T(0)          ; processing_matrix.at(7) = T(0)           ; processing_matrix.at(11) = T(0)          ; processing_matrix.at(15) = T(1) ;
 
    multiply() ;
}
 
template <typename T>
void Matrix<T>::translate(T x, T y, T z) {
 
  /** Translating trough a given vector. **/
 
  processing_matrix.at(0) = 1.0 ; processing_matrix.at(4) = 0.0 ; processing_matrix.at(8)  = 0.0 ; processing_matrix.at(12) = x     ;
  processing_matrix.at(1) = 0.0 ; processing_matrix.at(5) = 1.0 ; processing_matrix.at(9)  = 0.0 ; processing_matrix.at(13) = y     ;
  processing_matrix.at(2) = 0.0 ; processing_matrix.at(6) = 0.0 ; processing_matrix.at(10) = 1.0 ; processing_matrix.at(14) = z    ;
  processing_matrix.at(3) = 0.0 ; processing_matrix.at(7) = 0.0 ; processing_matrix.at(11) = 0.0 ; processing_matrix.at(15) = 1.0 ;
 
  multiply() ;
 
}
 
[...]

Pour la caméra de type look at j'ai des doûtes comme dit auparavant, mais pour la caméra de type perspective militaire, je n'ai plus d'idée, car j'ai déjà essayer toutes celle que j'avais.

Merci pour vos réponses éclairées et votre aide précieuse.

PS: pour ceux qui désirent expérimenter mon code (la Localview par exemple) il traine une archive contenant entre autre la définition complète de la classe Matrix a laquelle vous n'avez qu'a concaténer le code présenter ici
et également les classes Vertex et Vector etc...

**LittleWhite** · 15/07/2015, 09h52

Bonjour,

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
template <typename T>
void Localview<T>::set_as_camera() {
 
  /** Set the localview as camera. **/
 
  normalize() ;
 
  m.translate(-pos[0], -pos[1], -pos[2]) ;
 
  m.rows(right, up, sight) ;
 
}

Ne devriez vous pas réinitialiser la matrice avant de lui donner de nouvelle transformation ?

Ah !

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
template <typename T>
void Localview<T>::rotate_sight(const T angle) {
 
  /** Rotate the Localview (camera) on his Z axes. **/
 
  m.translate(-pos[0], -pos[1], -pos[1]) ;
 
  m.rotate(angle, sight) ;
 
  m.translate(pos[0], pos[1], pos[1]) ;
 
}

Vous recommencez avec votre mécanisme de translation/replacement puis rotation. Je trouve cela tellement étrange à vrai dire. On a plein de tutoriels sur les matrices sur Developpez.com :

http://jeux.developpez.com/tutoriels...espace-camera/ ;
http://geeks3d.developpez.com/calcul...al-glsl-part1/ (et les deux suivants) ;
http://opengl.developpez.com/tutorie...al/3-matrices/ (moi, j'aime bien cette série, pour une fois que je trouvais les matrices simples )

**Luke spywoker** · 16/07/2015, 05h38

Merci pour votre réponse Little White,

Il faut dire que moi je trouve étrange que vous trouviez étrange ma manière d'implémenter les matrices, vous qui êtes expert en OpenGL (Et oui j'ai lu votre parcours professionnel) que vous ne connaissez pas cette technique .

Car en faîte je sort cette technique d'un livre sur l'ancien OpenGL (Que vous ne pourrez sûrement pas lire car écrit en Allemand et d'ailleurs très bien.).

De mettre toutes les opérations dans une même matrice en multipliant une matrice spécifique a chaque opération par la matrice principale qui est au départ une matrice de type Identity si je me trompe pas sur le terme:

Matrice principale de départ:

Code :

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

1
2
3
4
5
 
m[0] = 1.0 ; m[4] = 0.0 ; m[8]   = 0.0 ; m[12] = 0.0 ;
m[1] = 0.0 ; m[5] = 1.0 ; m[9]   = 0.0 ; m[13] = 0.0 ;
m[2] = 0.0 ; m[6] = 0.0 ; m[10] = 1.0 ; m[14] = 0.0 ;
m[3] = 0.0 ; m[7] = 0.0 ; m[11] = 0.0 ; m[15] = 1.0 ;

qui change après chaque opération en étant multiplier par la matrice spécifique a chaque opération (en passant par une matrice temporaire afin de pas corrompre les données pendant la multiplication).

La matrice principale est renvoyé après avoir enregistrer toutes les opérations (Avant c'était pour multiplier chaque vertex par la matrice a l'époque de l'ancien OpenGL).

Le truc avec les localview et que celle-ci est composer de 3 vecteurs analogue a chaque axe du repère et d'un vertex représentant la position.

Et il y a une histoire de part une translation de la position et la multiplication avec une matrice de type row ou col la localview prend la position de l'origine ou de la du centre de gravité ou d'un point quelqu'onque d'un objet 3D comme par exemple un oeil du pilote d'un avion afin d'avoir une vue du cockpit.

Merci pour vos lien.

Sur ça me reste a retravailler mais je ne lâcherai pas mon implémentation de système de matrice pour le remplacer par une lib de comme glm.

Revenons au problème du poste: je désire implémenter une caméra qui ne soit pas de type worldview mais de type modelview.
c.a.d que la représentation des formes reste de type perspective militaire... Pouvez vous m'aider avez vous des idées ?

**LittleWhite** · 16/07/2015, 09h15

De mettre toutes les opérations dans une même matrice en multipliant une matrice spécifique a chaque opération par la matrice principale qui est au départ une matrice de type Identity

Oui, c'est exactement ce que je fais/dit (et ce qui est écrit dans les tutoriels).

La matrice est par la suite passée telle quelle au GPU (dans un shader) pour faire l'opération finale : sommet * matrice_de_projection_vue_modele. La matrice de projection vue modèle c'est en réalité, le résultat de trois matrices :

la matrice de projection (permettant de transformer un point 3D en un point en 2D en conservant les perspectives (ou pas) ;
la matrice vue (permettant de simuler une caméra) ;
la matrice modèle (permettant de tourner, positionner et dimensionner un objet dans le monde 3D).

La matrice vue est construite grâce à un LookAt (position, orientation, vecteur up (ou inclinaison)).
La matrice modèle est construite par la multiplication d'une matrice de redimensionnement, une matrice de rotation, une matrice de position.

Donc, on dit la même chose, non ?

Sur ça me reste a retravailler mais je ne lâcherai pas mon implémentation de système de matrice pour le remplacer par une lib de comme glm.

Je suis parti du principe que l'implémentation est juste. Par contre, l'utilisation me parait étrange, c'est tout.

c.a.d que la représentation des formes reste de type perspective militaire... Pouvez vous m'aider avez vous des idées ?

Pas moi, jusqu'à hier, je ne savais même pas ce que c'était

**dragonjoker59** · 16/07/2015, 11h58

Renseigne toi sur glOrtho, qui fait (je pense) exactement ce que tu veux.
Dans la doc de cette fonction (https://www.opengl.org/sdk/docs/man2/xhtml/glOrtho.xml) ils expliquent comment construire une matrice de projection orthographique.

**Luke spywoker** · 17/07/2015, 16h01

Salut les OpenGL,

Il y a bien une solution a mon problème, je pense que je n'ai pas encore tester:

récupéré les vertex de tous le objet compris dans la scène et de positionner sa caméra grâce au opération de base (rotations et translation) et de multiplier tous les vertex par cette matrice...

Je cite moi-même car j'ai dit une bêtise:

Et il y a une histoire de part une translation de la position et la multiplication avec une matrice de type row ou col la localview prend la position de l'origine ou de la du centre de gravité ou d'un point quelqu'onque d'un objet 3D comme par exemple un oeil du pilote d'un avion afin d'avoir une vue du cockpit.

En faites la combinaison des méthode de la classe Localview set_as_object() et set_as_camera().

Appliquer a une Locaview représentant un point de type "target".
Et a une autre Locaview représentant une camera permet de faire pointer la caméra en direction de target si je ne dit pas encore de bêtises...

Et il y a une histoire aussi que la Localview prend la place de l'origine et l'inverse...

Mais il serai simple de positionner la Localview de type caméra dans le cockpit de l'avion.

Et j'ai vue que l'on pouvait faire une représentation en stéréo de la scène ( 2 représentations: un pour l'œil gauche, un pour l'œil droit) avec le nouveau OpenGL (ou OpenGL moderne). Chose qui me semble intéressante coupler avec notre cockpit: j'ai penser a mettre une caméra dans chaque œil du pilote.

**Luke spywoker** · 18/07/2015, 06h04

Bon après de longues heures a se collé le derrière au coin frontal droit du bureau informatique...

J'ai réussis a implémenter 3 systèmes de perspectives:
-Frustum (d'après left, right, bottom, top, near, far).
-Orthogonale (d'après left, right, bottom, top, near, far).
-Et selon un angle d'ouverture, le ratio width/height et des valeurs de d'éloignement de l'écran et de profondeur.

Et 3 systèmes de caméra dont
-2 fonctions LookAt implémenter de manière différentes au point de vue de l'implémentation (rows, cols).
Et une caméra basé sur la mystérieuse Localview...

Brefs je suis ravis au point que ma raie du cul vous sourit, déformation dû au coin du bureau !!!

caméra avec rendus en perspective cavalière. [OpenGL 4.x]

OpenGL

Discussions similaires

Partager

Partager