DirectX Camera à la sourisRésolu

Question

Bonjour,

Je voudrais que la souris gère les rotations de la camera mais je n'y arrive pas.
J'arrive à gerer le deplacement en translation de celle-ci.
J'utilise les vecteurs pour les deplacements.
Merci.

THEwarrior333 · Accepted Answer

+1 pour QueryPerformanceCounter

"avec cette méthode" -> c'est à dire la différence de temps? C'est ce que tu fais avec temps1 - temps2.

Sinon regardes à cette adresse: http://www.codesampler.com/dx9src/dx9src_5.htm#dx9_fps_controls

cs_rt15 · Answer

Salut,

Je n'ai pas mes sources ici, mais je crois que j'ai fait ça très simplement avec D3DXMatrixRotationYawPitchRoll.

seb2086 · Answer

Merci de ta réponse,

mais en fait il faudrait que je recupere la variation de l'angle dans une variable de type float.
par exemple dans float CameraAngleY je voudrait recuperer la valeur de l'angle.

Donc je sais pas si peux avec cette fonction.

En fait moi je faisait comme ca :

CameraAngleX -= EtatSouris.lX *0.002;

J'ai l'angle de la camera egal à la position X de la souris * par une valeur.

Mais quand je fais ca la camera part dans tout les sens.
Donc si tu a une idée ;)

Merci

THEwarrior333 · Answer

Regardes dans le SDK, tu as de bons exemples sur la gestion de la
camera. Tu as même DXUT qui propose des classes de gestion de camera:
regardes comment ils font.

Sinon une méthode est de bouger ton vecteur directeur selon l'écart de
position de la souris. Ensuite tu mets à jour ta matrice de vue
D3DMatView.

seb2086 · Answer

Oui j'avais deja regardé mais j'ai pas reussi à comprendre leur code.

Par contre je voudrais bien que tu m'explique comment faire en bougeant le vecteur selon l'ecart de position de la souris.
Je pense que cette méthode se rapproche bien de ce que j'ai commencé à coder pour le clavier.

Si tu pouvais m'espliquer en détail.

Merci

seb2086 · Answer

Merci pour votre aide mais en fait c'est bon je vais utiliser ce que j'avais fait.

En fait mon problème c'et que ca tournait beaucoup trop vite et que je ne voyait rien.

Pour tester la camera j'ai juste charger un cube mais le probleme je pense c'est que le cube etait vraiment tout petit et comme je n'ai pas regler la camera en fonction de la taille de l'objet ca tourne beaucoup trop vite.

Donc j'ai reduit la vitesse de rotation CameraAngleY -= EtatSouris.lY *0.000000000002f et la ca tourne à une vitesse correcte.

Voila encore désolé de vous avoir embêter avec ca.

Merci en tout cas pour votre aide.

THEwarrior333 · Answer

Tu ne nous embêtes pas :)

En fait ton problème vient du fait que tu ne bases pas tes mouvements sur le temps. Toutes tes animations doivent évoluer en fonction du temps. Donc tu définis une vitesse pour la souris et tu calcules le nouvel angle par:

angleX +=vitesse / (temps_écoulé) * ecart_sourisX;

seb2086 · Answer

Merci,

Je le recupere comment le temps écoulé ?
Et ecart_sourisX correspond à quoi ?

Merci de ta réponse.

THEwarrior333 · Answer

Pour le temps ecoule c'est tres simple (cf DXUT par ex). C'est la
différence entre les temps mesurés à chaque frame (chaque rendu).

Je ne sais pas comment tu obtiens l'état de la souris mais dans le
chunk de la souris, ecart_sourisX et ecart_sourisY sont inclus.

seb2086 · Answer

J'ai fait ca :

        int temps1, temps2, difference ;
        temps1 = GetTickCount() ;
        difference = temps1 - temps2 ;

        CameraAngleX += 0.0000000000002f / difference * EtatSouris.lX ;
        temps2 = temps1 ;

Mais ca fait la même chose qu'avant.
en fait la rotation se fait mais elle ne s'arrête plus.
En fait dés que la souris fait un mouvement la rotation ne s'arrête plus alors que moi je voudrais que la rotation s'arrête lorsque la souris ne bouge plus.

THEwarrior333 · Answer

Qu'est-ce que EtatSouris? Car s'il s'agit de la position de la
souris alors il est normal que ca ne s'arrete plus de tourner. Ton
mouvement doit être relatif à l'écart de position et non à la position
de la souris.

seb2086 · Answer

Oui Etat souris c'est l'etat de la souris DIMOUSESTATE EtatSouris ;
Je fait comment alors pour obtenir l'ecart de position ?

Encore Merci ;)

THEwarrior333 · Answer

OK DIMOUSESTATE ne donne pas directement les écarts de position
mais les positions absolues (etat.lX, etat.lY). Qu'à cela ne tienne, tu
peux les calculer toi-même ^^: tu procèdes de la même manière que pour
le temps écoulé. D'ailleurs n'oublies pas d'initialiser tes variables
temps1 et temps2 à zéro avant de les utiliser!

seb2086 · Answer

J'ai fait ca mais ca ne deplace pas la caméra :

        int temps1, temps2, difference ;
        temps1 = 0 ;
        temps2 = 0 ;
        temps1 = GetTickCount() ;
        difference = temps1 - temps2 ;
        EtatSourisDifference.lX = EtatSouris.lX - EtatSourisSave.lX ;
     
            
        CameraAngleX += 0.002f / difference * EtatSourisDifference.lX ;
        temps2 = temps1 ;
        EtatSourisSave.lX = EtatSouris.lX ;

Encore merci ;)

THEwarrior333 · Answer

Peut-etre as-tu fait temps1 = 0; et temps2 = 0; dans ta boucle de rendu, auquel cas forcement ca ne peut pas marcher.

Sinon postes un bout de code directement comme ca on verra mieux.

seb2086 · Answer

/*---------------------------------------------------------------------------------------
    Nom : NEC_Camera.cpp
    Description : Classe permettant de gerer la camera
---------------------------------------------------------------------------------------*/

#include "NEF_Camera.h"

#define KEYDOWN(name, key) (name[key] & 0x80)    // Macro permettant de tester l'appui ou non sur un touche

// Variables Globales
D3DXMATRIX  CameraMatriceProjection ;        // Matrice de projection
D3DXMATRIX  CameraMatriceVision ;            // Matrice de vision

NEC_Clavier *TestClavier = NEC_Clavier :: NE_GetInstanceClavier() ;
char BufferEtatClavier[256] ;

NEC_Souris *TestSouris = NEC_Souris :: NE_GetInstanceSouris() ;
DIMOUSESTATE EtatSouris ;
DIMOUSESTATE EtatSourisSave ;
DIMOUSESTATE EtatSourisDifference ;

int temps1, temps2, difference ;

/*---------------------------------------------------------------------------------------
    Nom : NEC_Camera(void)
    Description : Constructeur de la classe
---------------------------------------------------------------------------------------*/
NEC_Camera :: NEC_Camera(void)
{
    CameraAngleX = 0.0f ;
    CameraAngleY = 0.0f ;
}

/*---------------------------------------------------------------------------------------
    Nom : ~NEC_Camera(void)
    Description : Destructeur de la classe
---------------------------------------------------------------------------------------*/
NEC_Camera :: ~NEC_Camera(void)
{

}

/*---------------------------------------------------------------------------------------
    Nom : void NE_CreerCamera(LPDIRECT3DDEVICE9 D3DDevice)
    Description : Creation de la camera
---------------------------------------------------------------------------------------*/
void NEC_Camera :: NE_CreerCamera(LPDIRECT3DDEVICE9 D3DDevice)
{
    // Creation de la matrice de projection : 
    // Angle d'ouverture de la camera : 45° , plan le proche : 0.1f , plan le plus eloigne : 1000.0f
    D3DXMatrixPerspectiveFovLH(&CameraMatriceProjection, D3DXToRadian(45.0f), 640.0f / 480.0f, 0.1f, 100.0f) ;

    // On applique la matrice
    D3DDevice -> SetTransform(D3DTS_PROJECTION, &CameraMatriceProjection) ;

    CameraAngleX = D3DX_PI/2.0f ;
    CameraAngleY = 0.0f ;

    // Initialisation des vecteurs
    CameraVecteurPosition = D3DXVECTOR3(0.0f, 0.0f, -30.0f) ; 
    CameraVecteurCible.x = CameraVecteurPosition.x + cosf(CameraAngleY) * cosf(CameraAngleX) ;
    CameraVecteurCible.y = CameraVecteurPosition.y + sinf(CameraAngleY) ;
    CameraVecteurCible.z = CameraVecteurPosition.z + cosf(CameraAngleY) * sinf(CameraAngleX) ;
    CameraVecteurOrientation = D3DXVECTOR3(0.0f, 1.0f, 0.0f);

    // Creation de la matrice de vision 
    D3DXMatrixLookAtLH(&CameraMatriceVision, &CameraVecteurPosition, &CameraVecteurCible, &CameraVecteurOrientation) ;    

    // On applique la matrice
     D3DDevice -> SetTransform(D3DTS_VIEW, &CameraMatriceVision) ;    

    temps1 = 0 ;
    temps2 = 0 ;
    EtatSourisSave.lX = 0 ;
}

/*---------------------------------------------------------------------------------------
    Nom : void NE_DeplacerCamera(LPDIRECT3DDEVICE9 D3DDevice)
    Description : Deplacement de la camera
---------------------------------------------------------------------------------------*/
void NEC_Camera :: NE_DeplacerCamera(LPDIRECT3DDEVICE9 D3DDevice)
{
    HRESULT hr ;
    
    TestSouris -> NE_AcquisitionSouris(true) ;
    hr = TestSouris -> NE_GetEtatSouris(EtatSouris) ;

    if(hr == S_OK)
    {
        
        temps1 = GetTickCount() ;
        difference = temps1 - temps2 ;
        EtatSourisDifference.lX = EtatSouris.lX - EtatSourisSave.lX ;
        //Variation de l'angle de la camera en fonction de la souris
        //Regard à droite ou à gauche
        //if(EtatSouris.lX & 0x80)
        //{    
            //CameraAngleX -= EtatSouris.lX *0.0000000000002f ;
            //CameraAngleX -= EtatSouris.lX *0.0000000000002f ;    
            
            CameraAngleX += 0.000000002f / difference * EtatSourisDifference.lX ;
            temps2 = temps1 ;
            EtatSourisSave.lX = EtatSouris.lX ;
        //}

        /*if(-EtatSouris.lX & 0x80)
        {
            CameraAngleX += EtatSouris.lX *0.000000000002f ;

        }*/

        // Regard en haut ou en bas
        /*if(EtatSouris.lY & 0x80)
        {
            CameraAngleY -= EtatSouris.lY *0.00000000000002f ;
        }*/

        if(EtatSouris.rgbButtons[0] & 0x80)
        {
            MessageBox(NULL,"Quitter l'application","Test Souris",MB_OK) ;
            PostQuitMessage(0) ; 
        }
    }

    // Coefficient pour regler la vitesse de la camera
    VitesseCamera = 0.02f ;
    
    hr = TestClavier -> NE_AcquisitionClavier(true) ;
    hr = TestClavier -> NE_GetEtatClavier(BufferEtatClavier) ;
    
    if(hr == S_OK)
    { 
        //Deplacement de la camera en fonction du clavier
        //Reculer
        if (KEYDOWN(BufferEtatClavier, DIK_DOWN))
        {
            CameraVecteurPosition.x -= cosf(CameraAngleY) * cosf(CameraAngleX) * VitesseCamera ;
            CameraVecteurPosition.y -= sinf(CameraAngleY) * VitesseCamera ;
            CameraVecteurPosition.z -= cosf(CameraAngleY) * sinf(CameraAngleX) * VitesseCamera ;
        }
        // Avancer
        if (KEYDOWN(BufferEtatClavier, DIK_UP))
        {
            CameraVecteurPosition.x += cosf(CameraAngleY) * cosf(CameraAngleX) * VitesseCamera ;
            CameraVecteurPosition.y += sinf(CameraAngleY) * VitesseCamera ;
            CameraVecteurPosition.z += cosf(CameraAngleY) * sinf(CameraAngleX) * VitesseCamera ;
        }
        // Déplacement sur la gauche
        if (KEYDOWN(BufferEtatClavier, DIK_LEFT))
        {
            CameraVecteurPosition.x -= sinf(CameraAngleX) * VitesseCamera ;
            CameraVecteurPosition.z += cosf(CameraAngleX) * VitesseCamera ;
        }
        // Déplacement sur la droite
        if (KEYDOWN(BufferEtatClavier, DIK_RIGHT))
        {
            CameraVecteurPosition.x += sinf(CameraAngleX) * VitesseCamera ;
            CameraVecteurPosition.z -= cosf(CameraAngleX) * VitesseCamera ;
        }

        if(KEYDOWN(BufferEtatClavier, DIK_ESCAPE))
        {    
            MessageBox(NULL,"Quitter l'application","Test Clavier",MB_OK) ;
            PostQuitMessage(0) ; 
        }
    }

    // Calcul du vecteur cible en fonction des angles X et Y
    CameraVecteurCible.x = CameraVecteurPosition.x + cosf(CameraAngleY) * cosf(CameraAngleX) ;
    CameraVecteurCible.y = CameraVecteurPosition.y + sinf(CameraAngleY) ;
    CameraVecteurCible.z = CameraVecteurPosition.z + cosf(CameraAngleY) * sinf(CameraAngleX) ;

    //// Creation de la matrice de vision en fonction des vecteurs
    D3DXMatrixLookAtLH(&CameraMatriceVision, &CameraVecteurPosition, &CameraVecteurCible, &CameraVecteurOrientation) ;

    // On applique la matrice
    D3DDevice -> SetTransform(D3DTS_VIEW, &CameraMatriceVision) ;
}

Voila j'espere que ca pourra t'aider à m'aider ;)

THEwarrior333 · Answer

EtatSourisSave.lX = 0 n'est pas bon: tu n'as pas a modifier un
champs d'une structure que tu n'as pas créée toi-même. Tu dois utiliser
ta propre variable. Pareil pour EtatSourisDifference.lX.


Donc:

LONG X, diffX;

X = 0;

diffX = 0;


Dans NE_DeplacerCamera:

TestSouris -> NE_AcquisitionSouris(true);

hr = TestSouris -> NE_GetEtatSouris(EtatSouris);


 if(hr == S_OK)

{        

    temps1 = GetTickCount() ;

    difference = temps1 - temps2 ;

    temps2 = temps1 ;


    diffX = EtatSouris.lX - X ;

    X = EtatSouris.lX ;

     

    CameraAngleX += 0.000000002f / difference * diffX ;   


    ...

seb2086 · Answer

Je peux pas te dire si ca marche car ej ne trouve plus mon objet dans l'espace 3D.
on dirait qu'il a disparu :S

THEwarrior333 · Answer

LOL ben je sais plus quoi dire. Je regarderai mes codes ce soir
au retour du boulot (je suis au canada) mais je me souviens avoir pas
mal pompé sur DXUT.

seb2086 · Answer

Ok beh j'attends ton post avec impatience.
Merci de t'occuper de mon probleme ;)

DirectX Camera à la souris

28 réponses

Votre réponse