Total controle d'une camera 3D

Salut,
Je suis en train de developper un jeu en 3D et j'ai un soucis (entre autres) de camera dans un environnement 3D
une camera en 3D dans OpenGL (comme dans game maker) est defini avec ces 9 composantes :

• px, py, pz : la position de la camera
  

• pCx, pCy, pCz : le point cible de la camera (là ou elle regarde)
  

• nx, ny, nz : le vecteur "haut" de la camera
  

Pour calculer le point cible en prenant en compte la souris, je prend deux angle theta (en X) et phi (en Y) que je transforme ensuite en coordonnées sphérique.
Pour faire une camera simple avec comme vecteur normal (haut) (0,0,1), les coordonnées point cible sont defini ainsi :

Code:

m_pC.setX(cos(phiRadian) * cos(thetaRadian));
m_pC.setY(cos(phiRadian) * sin(thetaRadian));
m_pC.setZ(sin(phiRadian));

et pour un vecteur normal (0,1,0), c'est comme ca

Code:

m_pC.setX(cos(phiRadian) * sin(thetaRadian));
m_pC.setY(sin(phiRadian));
m_pC.setZ(cos(phiRadian) * cos(thetaRadian));

(evidement il existe d'autre methode )

Le probleme se pose lorsque le vecteur normal est variable, que ce vecteur n'est pas aligné avec les axe unitaire. Je n'arrive pas a trouver un moyen de calculer ce point cible en fonction des angles donnée avec la souris et et la normal de la camera.
J'ai essayer avec les coordonnées plan qui prend pour normal celle de la camera (ce qui aurait pu me donner les coordonnées correct pour l'angle theta) mais j'ai abouti à rien  

Pourriez vous m'aider pour trouver comment calculer ce point cible ?

J'ai du mal à saisir pourquoi tu veux obtenir le point cible à partir de la verticale...
Si le but est de faire pencher la caméra, il s'agit bien toujours de déterminer la verticale.
Chose que j'ai galéré un bon moment à essayer de faire (sans succès) avec des fonctions trigo, et qui est infiniment plus simple avec des vecteurs.

En fait, j'ai deja mon verteur vertical (dans mon cas, c'est la position d'un point - la position de la camera, et normalisé)
Ce qui fait que le vecteur vertical de la camera n'est plus sur l'un des axe unitaire. Donc il faut que je repositionne le point cible en fonction du vecteur vertical.

Si j'ai bien compris le problème, tu devrais regarder du coté des quaternions nan?

J'ai demandé une solution pour mon problème à un prof a l'université et ma clairement répondu sur la façon de trouver ce point.
Si quelq'un ça interresse, voici un croquis sur comment procéder :

J'enverrai le code une fois fait

La solution que j'explique est à la fois simple mais il requiert quand même de bonnes connaissance.
(J'espère que j'ai compris ta question)


Solution 2: (Si tu ne comprend rien et/ou que tu ne veux pas t'embetter)
Il y a la fonction GluUnproject qui fait ce que tu veux.

(ps, j'espère que tu veux pas faire cela avec Game Maker ^^)

Solution 1)  (Si tu programme tout "from scratch" et que tu comprend tout ce que tu fais)

Tu possède la position de la souris et tu veux le vecteur3D directeur du rayon tracé par ta souris.
Par exemple pour sélectionner un bloc dans minecraft, on peut avoir besoin de cela.
Supposons tu ais une matrice de projection P et une matrice de modelview M définissant la position-orientation de ta caméra

Donc pour un point sur ta scene 3D
(x,y,z,1)   (on utilise la représentation 4d)

pour avoir le point du l'écran:
on calcul:
(ax,ay,az,aw) = P * M * (x,y,z,1)

puis la coordonée de ton point a l'écran (écran en [-1,1]*[-1,1] )
devient:
px=ax/aw;
py=ay/aw;
depth=az/aw;

Pour obtenir la droite que "sélectionne" ta souris, il faut partir de px et py et donner les points. C'est le problème inverse.

on cherche x,y,z tel que:
(px*w,py*w,depth*w,w) = P * M (x,y,z,1)

On inverse le système :
(x,y,z,1) = (P * M) ^ (-1) (px*w, py*w, depth*w, w)
(x,y,z,1) = w * (P*M)^(-1) * (px,py,depth,1)

Ainsi, il "suffit" de calculer:
(bx,by,bz,bw) = (P*M)^(-1) * (px,py,depth,1)

puis (x,y,z) = (bx/bw, by/bw, bz/bw)

Le paramètre depth paramètre ta droite 3d (la droite caméra-souris)


Si tu peux récupérer le paramètre depth dans le depthBuffer, tu peux récupéré le point 3D que clic ta souris. (Et non une droite)


(Comprenne qui pourra, désolé)

Ce que tu mets ici est vraiment bien détaillé mais je l'ai déjà fait, et ce n'est pas ce que je voulais avoir ^^.

Ce que je voulais avoir c'était "le vecteur direction" en fonction de phi, theta et le vecteur vertical, que je n'ai jamais traité auparavant que par simple coordonnées sphérique.

Je crois que j'ai compris:

Tu as la vertical (vx,vy,vz)
On suppose que la vertical est normalisé (sinon, et bien on la normalise)

On la suppose non horizontale.
On prend le vecteur (1,0,0)
Puis on va perturbé ce vecteur pour le rendre perpendiculaire à la verticale.

Cela donne.
(ax,ay,az) = (1,0,0) - <(1,0,0),(vx,vy,vz)> (vx,vy,vz)

On normalise (ax,ay,az)

Puis on prend (bx,by,bz) pour formé une base orthonormé.
(bx,by,bz) = (vx,vy,vz) ^ (ax,ay,az)

Voila tu as ta base orthonormé [(ax,ay,az),(bx,by,bz),(vx,vy,vz)] de vertical (vx,vy,vz)

maintenant ton vecteur est: ( (On note A,B,V) les 3 vecteurs de ta base)
cos(phi) ( cos(theta) A + sin(theta) B )  + sin(phi) V


(J'espère que là je suis dans les clous)