Mouvement souris et clavier

Signaler
Messages postés
23
Date d'inscription
lundi 15 avril 2002
Statut
Membre
Dernière intervention
1 mars 2007
-
Messages postés
23
Date d'inscription
lundi 15 avril 2002
Statut
Membre
Dernière intervention
1 mars 2007
-
Bonjour, avant de me mettre à direct input, j'aimerai faire un tout petit truc avec directement les messages windows.
J'ai un problème avec les mouvement de souris qui sont très très saccader et j'ai un problème avec les mouvements clavier c'est à dire que avant-arrière c'ets niquel mais gauche droite fonctionne mais toujours par rapport au même axe. Si qqun peut m'aider j'aimerail ui envoyer rapidement mes sources car pour qqun d'expérimenter ça prendra 5 minutes.

Merci bcp

19 réponses

Messages postés
23
Date d'inscription
lundi 15 avril 2002
Statut
Membre
Dernière intervention
1 mars 2007

voici les sources :


 Camera.h
#pragma once


class CCamera
{
public:


 CCamera();


 enum ECamMoveDir
 {
  eForward,
  eBack,
  eLeft,
  eRight
 };


 void Reset();


 void Move(ECamMoveDir dir);


 void Yaw(float angle);
 void Pitch(float angle);
 void Roll(float angle);


 void SetEye(const D3DVECTOR &eyePos) { eye = eyePos; }


 D3DVECTOR GetTarget();


 D3DVECTOR GetEye() const { return eye; }
 D3DVECTOR GetCamForward() const { return forward; }
 D3DVECTOR GetCamUp() const { return up; }
 D3DVECTOR GetCamRight() const { return right; }


private:


 D3DVECTOR right;
 D3DVECTOR up;
 D3DVECTOR forward;


 D3DVECTOR eye;    
};

Camera.cpp
#include <d3d9.h>
#include <d3dx9.h>
#include "Camera.h"


// Constructeur
CCamera::CCamera()
{
 Reset();
}


// Place la camera sur les axes
// Place l'oeil &#224; -5 sur Z
void CCamera::Reset()
{
 right.x   = 1.0f;
 right.y   = 0.0f;
 right.z   = 0.0f;
 up.x   = 0.0f;
 up.y   = 1.0f;
 up.z   = 0.0f;
 forward.x = 0.0f;
 forward.y = 0.0f;
 forward.z = 1.0f;


 eye.x   = 0.0f;
 eye.y   = 0.0f;
 eye.z   = -5.0f;
}


// Bouges la camera dans la direction "dir"
void CCamera::Move(ECamMoveDir dir)
{
 switch(dir)
 {
  case eForward: // Bouge devant
   eye.x += forward.x;
   eye.y += forward.y;
   eye.z += forward.z;   
  break;


  case eBack: // Bouge derri&#232;re
   eye.x -= forward.x;
   eye.y -= forward.y;
   eye.z -= forward.z;      
  break;


  case eLeft: // Bouge &#224; gauche
   eye.x -= right.x;
   eye.y -= right.y;
   eye.z -= right.z;
  break;


  case eRight: // Bouge &#224; droite
   eye.x += right.x;
   eye.y += right.y;
   eye.z += right.z;   
  break;
 }
}


void CCamera::Yaw(float angle)
{
 D3DXMATRIX matRotation;
 D3DXMatrixRotationAxis(&amp;matRotation, (D3DXVECTOR3*)&amp;up/*&amp;D3DXVECTOR3(0,1,0)*/, angle);
 //D3DXVec3TransformCoord((D3DXVECTOR3*)&amp;eye, (D3DXVECTOR3*)&amp;eye, &amp;matRotation);
 D3DXVec3TransformCoord((D3DXVECTOR3*)&amp;forward, (D3DXVECTOR3*)&amp;forward, &amp;matRotation);
}


void CCamera::Pitch(float angle)
{
 D3DXMATRIX matRotation;
 D3DXMatrixRotationAxis(&amp;matRotation, (D3DXVECTOR3*)&amp;right, angle);
 //D3DXVec3TransformCoord((D3DXVECTOR3*)&amp;eye, (D3DXVECTOR3*)&amp;eye, &amp;matRotation);
 D3DXVec3TransformCoord((D3DXVECTOR3*)&amp;forward, (D3DXVECTOR3*)&amp;forward, &amp;matRotation);
}


void CCamera::Roll(float angle)
{


}



D3DVECTOR CCamera::GetTarget()
{
 D3DVECTOR tmp;
 tmp.x = eye.x + forward.x;
 tmp.y = eye.y + forward.y;
 tmp.z = eye.z + forward.z;


 return tmp; 
}

Code principale
#define WIN32_LEAN_AND_MEAN // Optimise la taille et la vitesse (non MFC)
#define D3D_DEBUG_INFO // Informations compl&#233;mentaires pour debug


#include <d3d9.h>   // Ent&#234;te Direct3D
#include <d3dx9.h>   // Ent&#234;te Extension D3D
#include <windows.h>  // Ent&#234;te API Windows


#include "DrawFPS.h"  // Afficheur de FPS
#include "Camera.h"   // Camera


//----------------------------------------------------
//--------------------  Macros  ----------------------
//----------------------------------------------------
#define SAFE_DELETE(p)       { if(p) { delete (p);     (p)=NULL; } }
#define SAFE_DELETE_ARRAY(p) { if(p) { delete[] (p);   (p)=NULL; } }
#define SAFE_RELEASE(p)      { if(p) { (p)->Release(); (p)=NULL; } }


//----------------------------------------------------
//--------------------  Globals  ---------------------
//----------------------------------------------------
HWND              g_hWnd        = NULL;  // Handle pour la fen&#234;tre
LPDIRECT3D9       g_pD3D        = NULL;  // Pointer sur l'interface IDirect3D9
LPDIRECT3DDEVICE9 g_pd3dDevice  = NULL;  // Pointer sur l'interface IDirect3DDevice9
D3DPRESENT_PARAMETERS g_d3dpp;       // Param&#232;tres D3D
D3DDISPLAYMODE    g_d3ddm;        // Mode d'affichage
LPDIRECT3DVERTEXBUFFER9 g_pVB   = NULL;  // Vertex Buffer
LPDIRECT3DVERTEXBUFFER9 g_pGridVB = NULL;// Grid Vertex Buffer
LPDIRECT3DINDEXBUFFER9 g_pIB    = NULL;  // Index Buffer
LPDIRECT3DTEXTURE9 g_pTexture   = NULL;  // Texture
CCamera    * g_Camera;    // Camera
ID3DXFont*    g_pFont_x     = NULL;  // Font pour x
ID3DXFont*    g_pFont_y     = NULL;  // Font pour y


bool     g_bFullScreen = false; // Plein &#233;cran ?
bool     g_bDrawFPS    = true;  // Affichage ou non des FPS
int      g_iwSx     = 800;   // Dimension de la fen&#234;tre
int      g_iwSy     = 600;   // Dimension de la fen&#234;tre
bool     g_bDeviceLost = false; // Perte du device
POINT     g_ptCurrentMousePos;  // Position actuelle de la souris


// Structure pour format de vertex
struct CUSTOMVERTEX
{
 D3DVECTOR points; // Position du vertex  x,y,z
 D3DVECTOR normal; // Normale
 D3DCOLOR  color;    // Couleur
 float   tu,tv; // Coordonn&#233;e texture
};
// Le FVF (flexible vertex format), d&#233;crit la structure du vertex
#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_DIFFUSE | D3DFVF_TEX1)


// Structure pour format de vertex
struct GRIDVERTEX
{
 D3DVECTOR points; // Position du vertex  x,y,z
 D3DCOLOR  color;    // Couleur
};
// Le FVF (flexible vertex format), d&#233;crit la structure du vertex
#define D3DFVF_GRIDVERTEX (D3DFVF_XYZ | D3DFVF_DIFFUSE)



//----------------------------------------------------
//-------------------  Prototypes  -------------------
//----------------------------------------------------
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
                   LPSTR CmdLine, int CmdShow);
LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
HRESULT Init(void);
void ShutDown(void);
void ReleaseObject(void);
void Render(void);
void ToggleFullScreen(void);
HRESULT InitVB(void);
HRESULT InitGridVB(void);
HRESULT InitView(void);
HRESULT InitTransform(void);
HRESULT LoadTextures(void);
void SetView(void);
void DrawCube(void);
void DrawGrid(void);
void CenterCursor();


//----------------------------------------------------
//-----------  Point d'entr&#233;e du programme  ----------
//----------------------------------------------------
int WINAPI WinMain(HINSTANCE hInstance,   // Handle de l'instance de l'appli
       HINSTANCE hPrevInstance,  // Obsol&#232;te, toujours NULL
       LPSTR CmdLine,   // Param&#232;tre (ligne de commande)
       int CmdShow)    // Flag pour l'&#233;tat de la fen&#234;tre
{ 
 MSG uMsg;        // Message de la fen&#234;tre
 WNDCLASSEX winClass;     // Classe de la fen&#234;tre (param&#232;tres)


 winClass.cbSize        = sizeof(WNDCLASSEX); // Taille de la structure 
 winClass.style     = CS_CLASSDC;   // Style de la fen&#234;tre     
 winClass.lpfnWndProc   = WindowProc;   // Fonction de traitement des messages
    winClass.cbClsExtra    = 0;      // Nombre d'octets en plus pour la structure
    winClass.cbWndExtra    = 0;      // Nombre d'octets en plus pour l'instance
 winClass.hInstance    = hInstance;     // Handle de l'appli
    winClass.hIcon         = LoadIcon(NULL, IDI_APPLICATION); // Pas d'icone    
    winClass.hCursor       = LoadCursor(NULL, IDC_ARROW); // Curseur standard
 winClass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH); // Fond, NULL pour D3D
    winClass.lpszMenuName  = NULL;     // Menu
 winClass.lpszClassName = "MY_WINDOWS_CLASS"; // Nom de la classe de la fen&#234;tre
 winClass.hIconSm       = LoadIcon(NULL, IDI_APPLICATION); // Pas d'icone    
        
 if(!RegisterClassEx(&amp;winClass)) return E_FAIL; // Enregistre la fen&#234;tre


 // Creation de la fen&#234;tre
 g_hWnd = CreateWindowEx(NULL,        // Styles &#233;tendus      
            "MY_WINDOWS_CLASS",     // Nom de la classe de la fen&#234;tre
          "Plom 3D",       // Titre de la fen&#234;tre
          WS_OVERLAPPEDWINDOW | WS_VISIBLE, // Style de la fen&#234;tre
          0, 0,        // x, y point d'origine
          g_iwSy, g_iwSy,      // Taille
          NULL,        // Handle fen&#234;tre parent
          NULL,        // Handle du menu
          hInstance,       // Handle de l'appli
          NULL);        // Param&#232;tres suppl&#233;mentaires
          
 if(g_hWnd == NULL) return E_FAIL; // Si la fen&#234;tre n'est pas cr&#233;&#233;e


 ShowWindow(g_hWnd, CmdShow);  // Affiche la fen&#234;tre hWnd suivant le param&#232;tre CmdShow
 UpdateWindow(g_hWnd);    // Mise &#224; jour contenu fen&#234;tre 
 CenterCursor();      // Centre le curseur
 //ShowCursor(FALSE);     // Cache le curseur


    ZeroMemory(&amp;uMsg, sizeof(uMsg));  // Initialise &#224; z&#233;ro les messages        
  
 if(SUCCEEDED(Init()))      // Initialise Direct3D
    { 
  while(uMsg.message != WM_QUIT)   // Tant que le message n'est pas QUIT
  {
   if(PeekMessage(&amp;uMsg, NULL, 0, 0, PM_REMOVE)) // Dispatche les msg de la file
   {
    TranslateMessage(&amp;uMsg);  // Traduit le msg
    DispatchMessage(&amp;uMsg);   // Transmet &#224; la fonction de traitement (WindowProc)
   }
   else
   {
    Render();      // Ex&#233;cute le rendu 3D
    CenterCursor();        // Centre le curseur
   }
  }
 }
 ShutDown();        // Stoppe le rendu 3D et vide la m&#233;moire


    UnregisterClass("MY_WINDOWS_CLASS", winClass.hInstance ); // Si on quitte, lib&#232;re la fen&#234;tre


    return uMsg.wParam;      // Rentourne le wParam du message WM_QUIT
}



//----------------------------------------------------
//--------------  Gestion des messages  --------------
//----------------------------------------------------
LRESULT CALLBACK WindowProc(HWND   hWnd,    // Handle de la fen&#234;tre
                            UINT   uMsg,    // Identifiant du message
                            WPARAM wParam,  // Premier param&#232;tre du message
                            LPARAM lParam)  // deuxi&#232;e param&#232;tre du message
{
    switch( uMsg )       // Suivant le msg
    {
        case WM_KEYDOWN:     // Si touche enfonc&#233;e
        {
            switch( wParam )    // Suivant le param&#232;tre touche
            {
    case VK_F1:
    {
     g_bDrawFPS = !g_bDrawFPS;
    }
    break;
    case VK_UP: case 'Z': case 'z':
    {
     g_Camera->Move(CCamera::eForward);     
    }    
    break;
    case VK_DOWN: case 'S': case 's':
    {
     g_Camera->Move(CCamera::eBack);     
    }    
    break;
    case VK_RIGHT: case 'D': case 'd':
    {
     g_Camera->Move(CCamera::eRight);     
    }
    break;
    case VK_LEFT: case 'Q': case 'q':
    {
     g_Camera->Move(CCamera::eLeft);
    }
    break;
            }
        }
        break;


  case WM_SYSKEYDOWN:
  {
   // ALT + ENTER    
   if(wParam == VK_RETURN &amp;&amp; (lParam &amp; (1 << 29)))
   {
    ToggleFullScreen();   // Plein Ecran
   }
   // ALT + F4    
   if(wParam == VK_F4 &amp;&amp; (lParam &amp; (1 << 29)))
   {
    PostQuitMessage(0);   // Quitte
   }   
  }
  break;


  case WM_MOUSEMOVE:     // Si la souris bouge
  { 
   GetCursorPos(&amp;g_ptCurrentMousePos);     // R&#233;cup&#232;re la position du curseur ...
   ScreenToClient(g_hWnd, &amp;g_ptCurrentMousePos); // ... par rapport &#224; la fen&#234;tre


   // Droite
   if(g_ptCurrentMousePos.x > g_iwSx/2 + 2)
   {
    float nXDiff = (1.0f - (float)(g_ptCurrentMousePos.x) / (float)g_iwSx) * 20;
    g_Camera->Yaw(D3DXToRadian(nXDiff));
   }
   // Gauche
   if(g_ptCurrentMousePos.x < g_iwSx/2 - 2)
   {
    float nXDiff = (1.0f - (float)(g_ptCurrentMousePos.x) / (float)g_iwSx) * 20;
    g_Camera->Yaw(D3DXToRadian(-nXDiff));
   }
   // Bas
   if(g_ptCurrentMousePos.y > g_iwSy/2 + 2)
   {
    float nYDiff = (1.0f - (float)(g_ptCurrentMousePos.y) / (float)g_iwSy) * 20;
    g_Camera->Pitch(D3DXToRadian(-nYDiff));
   }
   // Haut
   if(g_ptCurrentMousePos.y < g_iwSy/2 - 2)
   {
    float nYDiff = (1.0f - (float)(g_ptCurrentMousePos.y) / (float)g_iwSy) * 20;
    g_Camera->Pitch(D3DXToRadian(nYDiff));
   }
  }
  break;


        case WM_CLOSE:
        {
            // Ferme l'application en envoyant WM_QUIT
            PostQuitMessage(0);
        }


        case WM_DESTROY:
        {
            // Ferme l'application en envoyant WM_QUIT
            PostQuitMessage(0);
        }
        break;


        default:
        {
            // La fonction DefWindowProc() traitera les messages intrait&#233;s            
            return DefWindowProc( hWnd, uMsg, wParam, lParam );
        }
        break;
    }
    return 0;
}


//----------------------------------------------------
//----------------  Centre le curseur  ---------------
//----------------------------------------------------
void CenterCursor()
{
 POINT pt = { g_iwSx / 2, g_iwSy / 2 }; // Point central ...  
 ClientToScreen(g_hWnd, &amp;pt);     // ... par rapport &#224; la fen&#234;tre
 SetCursorPos(pt.x, pt.y);      // Place le curseur au centre de la fen&#234;tre
}


//----------------------------------------------------
//------------  Initialisation Direct 3D  ------------
//----------------------------------------------------
HRESULT Init(void)
{
 g_pD3D = Direct3DCreate9(D3D_SDK_VERSION);  // Cr&#233;e l'interface et renvoie un pointeur sur IDIRECT3D9
 
 ZeroMemory(&amp;g_d3ddm, sizeof(g_d3ddm));   // Met tout &#224; z&#233;ro
 ZeroMemory(&amp;g_d3dpp, sizeof(g_d3dpp));   // Met tout &#224; z&#233;ro
 Sleep(100);


 g_d3dpp.hDeviceWindow = g_hWnd;     // Handle sur la fen&#234;tre
 g_d3dpp.SwapEffect   = D3DSWAPEFFECT_DISCARD; // Remplitle back buffer de bruit
 g_d3dpp.PresentationInterval   = D3DPRESENT_INTERVAL_IMMEDIATE; // N'attend pas la V-Sync
 g_d3dpp.EnableAutoDepthStencil = TRUE;   // Active le depth buffer
 g_d3dpp.AutoDepthStencilFormat = D3DFMT_D16; // Format du depth buffer


 // En Plein Ecran
 if(g_bFullScreen)
 {  
  g_d3ddm.Format = D3DFMT_X8R8G8B8;   // Format du display
  g_d3ddm.Width  = g_iwSx;     // Taille du display
  g_d3ddm.Height = g_iwSy;     // Taille du display
  g_pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &amp;g_d3ddm);
    
  g_d3dpp.Windowed         = FALSE;   // Pas en fen&#234;tr&#233; (pas n&#233;cessaire)
  g_d3dpp.BackBufferWidth  = g_d3ddm.Width; // Taille back buffer
  g_d3dpp.BackBufferHeight = g_d3ddm.Height; // Taille back buffer  g_d3dpp.BackBufferFormat g_d3ddm.Format; // Format back buffer format display 
 }
 // En Fen&#234;tr&#233;
 else if(!g_bFullScreen)
 {
  g_pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &amp;g_d3ddm);
  
  g_d3dpp.Windowed   = TRUE;   // Fen&#234;tr&#233;  g_d3dpp.BackBufferFormat D3DFMT_UNKNOWN; // Format back buffer format bureau
 } 


 if(FAILED(g_pD3D->CreateDevice(D3DADAPTER_DEFAULT,     // Utilise l'affichage principal
           D3DDEVTYPE_HAL,      // Utilise l'acc&#233;l&#233;ration mat&#233;riel 
           g_hWnd,        // Handle sur la fen&#234;tre
           D3DCREATE_HARDWARE_VERTEXPROCESSING, // Traitement de vertex (sommets) en hardware
           &amp;g_d3dpp,       // Pointeur sur les param&#232;tres
           &amp;g_pd3dDevice)))      // Pointeur sur l'interface IDirect3DDevice9
 {
  return E_FAIL;
 }
 
 g_Camera = new CCamera(); // Creation camera 


 InitTimer();       // Initialisation des Timers (FPS)
 if FAILED(InitFont()) return E_FAIL; // Initialisation de la Font (FPS)
 if FAILED(InitVB()) return E_FAIL;  // Initialisation du vertex buffer
 if FAILED(InitGridVB()) return E_FAIL; // Initialisation du vertex buffer
 if FAILED(InitTransform()) return E_FAIL; // Initialisation de la vue et de la perspective 
 SetView();        // Initialise camera
 if FAILED(LoadTextures()) return E_FAIL;// Chargements des textures


 g_pd3dDevice->SetRenderState(D3DRS_LIGHTING, FALSE); // D&#233;sactive les lumi&#232;res


 D3DXCreateFont(g_pd3dDevice,     // Pointeur sur IDirect3DDevice9
       20,        // Hauteur des caract&#232;res
       0,        // Largeur des caract&#232;res
       FW_BOLD,       // Type
       0,        // Nombre de niveaux de mipmap
       FALSE,       // TRUE pour Italic
       DEFAULT_CHARSET,     // Charset
                   OUT_DEFAULT_PRECIS,       // TrueType ou pas
       DEFAULT_QUALITY,     // Qualit&#233;
       DEFAULT_PITCH | FF_DONTCARE,  // Famille et pitch de la police
                   TEXT("Arial"),     // Nom de la police
       &amp;g_pFont_x);      // Pointeur sur Font
 D3DXCreateFont(g_pd3dDevice,     // Pointeur sur IDirect3DDevice9
       20,        // Hauteur des caract&#232;res
       0,        // Largeur des caract&#232;res
       FW_BOLD,       // Type
       0,        // Nombre de niveaux de mipmap
       FALSE,       // TRUE pour Italic
       DEFAULT_CHARSET,     // Charset
                   OUT_DEFAULT_PRECIS,       // TrueType ou pas
       DEFAULT_QUALITY,     // Qualit&#233;
       DEFAULT_PITCH | FF_DONTCARE,  // Famille et pitch de la police
                   TEXT("Arial"),     // Nom de la police
       &amp;g_pFont_y);      // Pointeur sur Font


 return S_OK;
}


//----------------------------------------------------
//---------------  Arr&#234;t de Direct 3D  ---------------
//----------------------------------------------------
void ShutDown(void)
{
 ReleaseObject();         // Lib&#232;re la Font (FPS)
 SAFE_RELEASE(g_pVB);        // Lib&#232;re le vertex buffer
 SAFE_RELEASE(g_pIB);        // Lib&#232;re l'index buffer
 SAFE_RELEASE(g_pGridVB);       // Lib&#232;re le vertex buffer
 SAFE_RELEASE(g_pd3dDevice);       // Lib&#232;re le Device
 SAFE_RELEASE(g_pD3D);        // Lib&#232;re l'interface
}


//----------------------------------------------------
//---------------  Lib&#232;re les objets  ----------------
//----------------------------------------------------
void ReleaseObject(void)
{
 ReleaseFont(); // Lib&#232;re la Font (FPS)
 SAFE_RELEASE(g_pTexture); // Lib&#232;re la texture
 SAFE_DELETE(g_Camera);   // Lib&#232;re la camera
 SAFE_RELEASE(g_pFont_x);  // Lib&#232;re la font du texte
 SAFE_RELEASE(g_pFont_y);  // Lib&#232;re la font du texte
}


//----------------------------------------------------
//----------  Initialise et remplit le VB  -----------
//----------------------------------------------------
HRESULT InitVB(void)
{
 // Liste des points
 D3DVECTOR P0 = { 1.0f,  1.0f, -1.0f},
     P1 = { 1.0f, -1.0f, -1.0f},   
     P2 = {-1.0f, -1.0f, -1.0f},           
     P3 = {-1.0f,  1.0f, -1.0f},
     P4 = {-1.0f,  1.0f,  1.0f},
     P5 = {-1.0f, -1.0f,  1.0f},   
     P6 = { 1.0f, -1.0f,  1.0f},           
     P7 = { 1.0f,  1.0f,  1.0f};
 
 // Liste des normales
 D3DVECTOR N0 = {  0.0f,  0.0f, -1.0f},
     N1 = { -1.0f,  0.0f,  0.0f},
     N2 = {  0.0f,  0.0f,  1.0f},
     N3 = {  1.0f,  0.0f,  0.0f},
     N4 = {  0.0f, -1.0f,  0.0f},
     N5 = {  0.0f,  1.0f,  0.0f};
 
 // Liste des couleurs
 D3DCOLOR C0 = D3DCOLOR_XRGB(255,0,0),
    C1 = D3DCOLOR_XRGB(255,255,0),
    C2 = D3DCOLOR_XRGB(255,0,255),
    C3 = D3DCOLOR_XRGB(255,128,128),
    C4 = D3DCOLOR_XRGB(0,255,255),
    C5 = D3DCOLOR_XRGB(128,128,128);


 // Liste des vertex
 CUSTOMVERTEX vertices[] =
 {
  {P0, N0, C0, 1.0f,0.0f}, {P1, N0, C0, 1.0f,1.0f}, {P3, N0, C0, 0.0f,0.0f}, {P2, N0, C0, 0.0f,1.0f}, // 1 face
  {P2, N1, C1, 1.0f,1.0f}, {P5, N1, C1, 0.0f,1.0f}, {P3, N1, C1, 1.0f,0.0f}, {P4, N1, C1, 0.0f,0.0f}, // 2 face
  {P4, N2, C2, 1.0f,0.0f}, {P5, N2, C2, 1.0f,1.0f}, {P7, N2, C2, 0.0f,0.0f}, {P6, N2, C2, 0.0f,1.0f}, // 3 face
  {P7, N3, C3, 1.0f,0.0f}, {P6, N3, C3, 1.0f,1.0f}, {P0, N3, C3, 0.0f,0.0f}, {P1, N3, C3, 0.0f,1.0f}, // 4 face
  {P6, N4, C4, 1.0f,1.0f}, {P5, N4, C4, 0.0f,1.0f}, {P1, N4, C4, 1.0f,0.0f}, {P2, N4, C4, 0.0f,0.0f}, // 5 face
  {P7, N5, C5, 1.0f,0.0f}, {P0, N5, C5, 1.0f,1.0f}, {P4, N5, C5, 0.0f,0.0f}, {P3, N5, C5, 0.0f,1.0f}  // 6 face
 }; 


 // Tableau d'indices  
 short unsigned int index_vertices[] = {  0, 1, 2, 3,   // Face 1
            4, 5, 6, 7,   // Face 2
            8, 9,10,11,   // Face 3
           12,13,14,15,   // Face 4
           16,17,18,19,   // Face 5
           20,21,22,23 }; // Face 6


 size_t verticesSize = sizeof(vertices); // Taille du tableau de sommets (vertex)
 size_t index_verticesSize = sizeof(index_vertices); // Taille du tableau d'index
 
 // Cr&#233;ation d'un objet IDirect3DVertexBuffer9 (tableau de N sommets)
 g_pd3dDevice->CreateVertexBuffer(verticesSize,   // Taille de m&#233;moire &#224; r&#233;server
          0,      // 0 ou flag sur utilisation du buffer
          D3DFVF_CUSTOMVERTEX, // Format
          D3DPOOL_MANAGED,  // Gestion m&#233;moire
          &amp;g_pVB,    // Pointeur sur IDirect3DVertexBuffer9
          NULL);                 // Toujours NULL                  


 // V&#233;rouille l'objet (&#233;vite qu'il "bouge" en m&#233;moire)
 VOID* pVertices;
 g_pVB->Lock(0,        // Offset, d&#233;calage depuis le d&#233;but du VertexBuffer
       verticesSize, // Taille &#224; v&#233;rouiller
       &amp;pVertices,   // Adresse m&#233;moire (temporaire) pour effectuer les op&#233;rations
       0);     // Type de verrou
 memcpy(pVertices, vertices, verticesSize);   // Effectue la copie
 g_pVB->Unlock();    // D&#233;v&#233;rouille


 // Cr&#233;ation d'un Index Buffer
 g_pd3dDevice->CreateIndexBuffer(index_verticesSize, // Taille de m&#233;omire &#224; r&#233;server
         0,     // 0 ou flag
         D3DFMT_INDEX16,  // Format
         D3DPOOL_MANAGED, // Gestion m&#233;moire
         &amp;g_pIB,    // Pointeur sur l'IndexBuffer
         NULL);    // Toujours NULL
 g_pIB->Lock(0, index_verticesSize, &amp;pVertices, 0);
 memcpy(pVertices, index_vertices, index_verticesSize);
 g_pIB->Unlock();


 return S_OK;
}


//----------------------------------------------------
//----------  Initialise et remplit le VB  -----------
//----------------------------------------------------
HRESULT InitGridVB(void)
{ int i 0, j 0;
 D3DCOLOR Color = D3DCOLOR_XRGB(255,0,200);
 D3DVECTOR pos = { 0.0f, -2.0f, 0.0f };
 GRIDVERTEX gridvertices[260];


 for(i = -32; i <= 32; ++i)
 {
  gridvertices[j].color = Color;
  gridvertices[j].points.x = pos.x - 32;
  gridvertices[j].points.y = pos.y; 
  gridvertices[j].points.z = pos.z + i;
  ++j;
  
  gridvertices[j].color = Color;
  gridvertices[j].points.x = pos.x + 32;
  gridvertices[j].points.y = pos.y; 
  gridvertices[j].points.z = pos.z + i;
  ++j;


  gridvertices[j].color = Color;
  gridvertices[j].points.x = pos.x + i;
  gridvertices[j].points.y = pos.y; 
  gridvertices[j].points.z = pos.z - 32;
  ++j;  


  gridvertices[j].color = Color;
  gridvertices[j].points.x = pos.x + i;
  gridvertices[j].points.y = pos.y; 
  gridvertices[j].points.z = pos.z + 32;
  ++j;
 }


 size_t verticesSize = sizeof(gridvertices); // Taille du tableau de sommets (vertex) 
 
 // Cr&#233;ation d'un objet IDirect3DVertexBuffer9 (tableau de N sommets)
 g_pd3dDevice->CreateVertexBuffer(verticesSize,   // Taille de m&#233;moire &#224; r&#233;server
          0,      // 0 ou flag sur utilisation du buffer
          D3DFVF_GRIDVERTEX,  // Format
          D3DPOOL_MANAGED,  // Gestion m&#233;moire
          &amp;g_pGridVB,   // Pointeur sur IDirect3DVertexBuffer9
          NULL);                 // Toujours NULL                  


 // V&#233;rouille l'objet (&#233;vite qu'il "bouge" en m&#233;moire)
 VOID* pVertices;
 g_pGridVB->Lock(0,        // Offset, d&#233;calage depuis le d&#233;but du VertexBuffer
     verticesSize, // Taille &#224; v&#233;rouiller
     &amp;pVertices,   // Adresse m&#233;moire (temporaire) pour effectuer les op&#233;rations
     0);     // Type de verrou
 memcpy(pVertices, gridvertices, verticesSize);   // Effectue la copie
 g_pGridVB->Unlock();    // D&#233;v&#233;rouille


 return S_OK;
}


//----------------------------------------------------
//------------  Initialise la perspective  -----------
//----------------------------------------------------
HRESULT InitTransform(void)
{
    D3DXMATRIX matProjection; // D&#233;claration des matrices


 // D&#233;fini le c&#244;ne de vision (perspective)
 D3DXMatrixPerspectiveFovLH(&amp;matProjection,  // Matrice &#224; cr&#233;er
          D3DX_PI/3.f,   // Largeur de champ de vision (radian)
          640.0f / 480.0f,  // Aspect ratio
          1.0f,    // z min visible
          8192.0f);   // z max visible
    g_pd3dDevice->SetTransform(D3DTS_PROJECTION, &amp;matProjection);


 return S_OK;
}


//----------------------------------------------------
//----------------  Initialise la vue  ---------------
//----------------------------------------------------
void SetView(void)
{
    D3DXMATRIX matVue; // D&#233;claration matrice


 D3DXVECTOR3 Voeil = g_Camera->GetEye(),   // Place l'oeil de la camera
    Vvers = g_Camera->GetTarget(),  // Place la direction de la camera
    //Vdirhaut(0.0f, 1.0f, 0.0f);   // Direction
    Vdirhaut = g_Camera->GetCamUp();


 // D&#233;fini d'ou on regarde et dans quel direction
 D3DXMatrixLookAtLH(&amp;matVue,    // Matrice &#224; cr&#233;er
        &amp;Voeil,    // L&#224; ou est notre oeil
        &amp;Vvers,    // Direction qu'il regarde
        &amp;Vdirhaut); // Direction du haut
    g_pd3dDevice->SetTransform(D3DTS_VIEW, &amp;matVue); 
}


//----------------------------------------------------
//-------------  Initialise les Textures  ------------
//----------------------------------------------------
HRESULT LoadTextures(void)
{
 D3DXCreateTextureFromFile(g_pd3dDevice, "rabbit.jpg", &amp;g_pTexture); // Chargement de la texture dans g_pTexture


 g_pd3dDevice->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR); // Filtre bilin&#233;aire pour zoom arri&#232;re
 g_pd3dDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR); // Filtre bilin&#233;aire pour zoom avant


 return S_OK;
}
//----------------------------------------------------
//-------------  Passe en Plein Ecran  ---------------
//----------------------------------------------------
void ToggleFullScreen(void)
{
 static RECT winRect = {0};       // Rectangle
 
 ZeroMemory(&amp;g_d3dpp, sizeof(g_d3dpp));    // Efface les param&#232;tres du device
 g_pd3dDevice->Reset(&amp;g_d3dpp);      // Reset du device
 
 
 if(!g_bFullScreen) GetWindowRect(g_hWnd, &amp;winRect); // Recup&#232;re taille fen&#234;tre
 
 g_bFullScreen = !g_bFullScreen;      // Passe de l'un &#224; l'autre
 
 // Si fen&#234;tr&#233;, redimensionne la fen&#234;tre
 if(!g_bFullScreen) SetWindowPos(g_hWnd, HWND_NOTOPMOST, winRect.left, winRect.top, winRect.right - winRect.left,
            winRect.bottom - winRect.top, SWP_SHOWWINDOW);
 
 Init();            // R&#233;initialise
}


//----------------------------------------------------
//---------------  Affichage du cube  ----------------
//----------------------------------------------------
void DrawCube(void)
{
 // Chargement de la texture
 g_pd3dDevice->SetTexture(0, g_pTexture);


 // D&#233;finit le FVF du Device
 g_pd3dDevice->SetFVF(D3DFVF_CUSTOMVERTEX);
    // Charge l'index
 g_pd3dDevice->SetIndices(g_pIB);
 // Charge les VertexBuffer dans le flux de sommets
 g_pd3dDevice->SetStreamSource(0,       // Place dans le flux
          g_pVB,      // Pointeur sur le VertexBuffer
          0,       // Offset dans le tableau de sommets
          sizeof(CUSTOMVERTEX));  // Taille de la structure


 // Affiche la primitive
 g_pd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLESTRIP, 0, 0, 24,  0, 2); // Premi&#232;re face
    g_pd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLESTRIP, 0, 0, 24,  4, 2); // Deuxi&#232;me face (d&#233;marre indice 4)
    g_pd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLESTRIP, 0, 0, 24,  8, 2); // 3&#232;me face (d&#233;marre indice 8)
    g_pd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLESTRIP, 0, 0, 24, 12, 2); // 4&#232;me face
    g_pd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLESTRIP, 0, 0, 24, 16, 2); // Dessous
    g_pd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLESTRIP, 0, 0, 24, 20, 2); // Dessus
}


//----------------------------------------------------
//---------------  Affichage du cube  ----------------
//----------------------------------------------------
void DrawGrid(void)
{
 g_pd3dDevice->SetFVF(D3DFVF_GRIDVERTEX);
 // Charge les VertexBuffer dans le flux de sommets
 g_pd3dDevice->SetStreamSource(0,       // Place dans le flux
          g_pGridVB,     // Pointeur sur le VertexBuffer
          0,       // Offset dans le tableau de sommets
          sizeof(GRIDVERTEX));    // Taille de la structure
 // Affiche la primitive
 g_pd3dDevice->DrawPrimitive(D3DPT_LINELIST, 0, 130); // Premi&#232;re face  
}


//----------------------------------------------------
//--------------------  Rendu 3D  --------------------
//----------------------------------------------------
void Render(void)
{
 HRESULT hr;
    if(g_bDeviceLost == true) // Si le device est lost
    {
        Sleep(100); // Laisse 100 milliseconds pour autres processus


  // Teste du cooperative level, on analyse l'erreur pour d&#233;termin&#233; que faire
        if(FAILED(hr = g_pd3dDevice->TestCooperativeLevel()))
        {
            // Le device est perdu, on ne pas encore rien faire que attendre
   if(hr == D3DERR_DEVICELOST) return;


            // Le device est perdu mais on peut lancer un reset
            if(hr == D3DERR_DEVICENOTRESET)
            {
                ReleaseObject(); // On stope tous les objets


                // On lance un reset, seule methode qui peut &#234;tre utilise pendant un lost
                hr = g_pd3dDevice->Reset(&amp;g_d3dpp);
                if(FAILED(hr)) return;
    
                Init();    // On r&#233;initialise tout
            }
            return;
        }
        g_bDeviceLost = false;
    }


 g_pd3dDevice->Clear(0,           // Nombre de rectangle dans le tableau (voir param suivant)
      NULL,          // Pointeur sur tableau de D3DRECT
      D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,   // Surface &#224; effacer
                        D3DCOLOR_COLORVALUE(0.0f,0.0f,1.0f,1.0f),// Efface la surface par une couleur (bleu) 
      1.0f,          // Nouvelle valeur du depth buffer
      0);           // Nouvelle valeur du stencil buffer


    g_pd3dDevice->BeginScene();      // D&#233;marrage du rendu
 //-------------------------
 if(g_bDrawFPS == true) drawFPS();


 RECT rc_x; SetRect(&amp;rc_x, 2, 30, 0, 0);
 RECT rc_y; SetRect(&amp;rc_y, 2, 50, 0, 0);
 char str_x[80] = "souris x :";
 char str_y[80] = "souris y :";
 sprintf(str_x, "souris x : %.2lf\n", cur_fps);
 sprintf(str_y, "souris y : %.2lf\n", cur_fps);
 g_pFont_x->DrawText(NULL, str_x, -1, &amp;rc_x, DT_NOCLIP, D3DCOLOR_XRGB(255, 255, 255)); 
 g_pFont_y->DrawText(NULL, str_y, -1, &amp;rc_y, DT_NOCLIP, D3DCOLOR_XRGB(255, 255, 255)); 


 SetView();


 DrawCube();
 DrawGrid();


 //-------------------------
 g_pd3dDevice->EndScene();              // Arr&#234;t du rendu
 
    hr = g_pd3dDevice->Present(NULL, NULL, NULL, NULL);  // Donne au back buffer la sc&#232;ne &#224; afficher (ici rien pour vider)
    
 // Present renvoie une erreur si le device est lost if(hr D3DERR_DEVICELOST) g_bDeviceLost true;
}

Merci
Messages postés
202
Date d'inscription
dimanche 18 mai 2003
Statut
Membre
Dernière intervention
6 mars 2010

* pour faire les rotations autour des objet moi j'utilise plutot cette méthode :



D3DXMATRIX mat;



D3DXMatrixRotationY( &mat , Angle1 );

D3DXMatrixMultiply( &m , &mat , &m );



ou "m" est ma matrice de transformation et Angle1 mon angle en radian.



* mieux vaut faire un DrawPrimitive pour tout un objet.



* utilise plutot le deplacement souris que sa position. Pour avoir le
deplacement sauvegarde le dernier emplacement et soustrait le a
la nouvelle position.



*tu creer une fenetre 800 * 600 et dans ta structure D3DDISPLAYMODE
tu met un buffer de 800*600. or en mode fenetré la fenetre est plus
petit ce qui fait que les position souris sont interpolé. Pour être
précis récupere la vrai taille de ta fenetre ( zone client ) par la
fonction GetWindowInfo().

Voili,Voilou
Messages postés
23
Date d'inscription
lundi 15 avril 2002
Statut
Membre
Dernière intervention
1 mars 2007

Merci bcp mais se que je comprend pas c'est qu'en faisant "gauche-droite" je me déplace pas par rapport à la fenêtre mais par rapport à autre chsoe (le world je pense).
Messages postés
202
Date d'inscription
dimanche 18 mai 2003
Statut
Membre
Dernière intervention
6 mars 2010

en fait tu redefinis la position de l'observateur mais il regarde
toujours vers la meme direction donc tu dois tourner autour de ton
point d'observation.

Voili,Voilou
Messages postés
23
Date d'inscription
lundi 15 avril 2002
Statut
Membre
Dernière intervention
1 mars 2007

il me faudrai un peu plus d'explication ou alros des exemples s'il te plait.
Messages postés
202
Date d'inscription
dimanche 18 mai 2003
Statut
Membre
Dernière intervention
6 mars 2010

quand tu deplace
eye
il faut ausi deplacer ta direction de la camera soit Vvers. ansi quand
tu appellera la fonction pour calculer la matrice de la camera la
direction de ta vision restera parrallele a la precedent ça
donnera un effet de pas chasser sur le coté ( si j'ai bien
compris ce que tu voulait ? ).



Voeil.x += 10; // deplacement identique

vvers.x += 10;




D3DXMatrixLookAtLH(&matVue, // Matrice à créer
&Voeil, // Là ou est notre oeil
&Vvers, // Direction qu'il regarde
&Vdirhaut); // Direction du haut








Voili,Voilou
Messages postés
23
Date d'inscription
lundi 15 avril 2002
Statut
Membre
Dernière intervention
1 mars 2007

Oui c'est se que je chercher à faire, des côté des côtés.


Le problèmec'est que ma direction est calculée donc en bougeant mon oeil ma direction devrai bouger aussi.

J'ai poser mon projet sur http://www.sm2i.info/private/Camera_2.rarhttp://www.sm2i.info/private/camera2.rar


Je pense que le problème viens de mon objet caméra

Si tu pouvais m'expliquer sur en concret sur mon projet je te remercierai jamais assez :)
Et aussi pour la souris que je ne parviens pas à bouger convenablement.

Merci bcp
Messages postés
23
Date d'inscription
lundi 15 avril 2002
Statut
Membre
Dernière intervention
1 mars 2007

Dans ma fonction CenterCursor()
j'ai ajouter ceci comme tu me la conseillé mais là ça part dans tout les sens :)


WINDOWINFO winInfo;


winInfo.cbSize =
sizeof(WINDOWINFO);


GetWindowInfo(g_hWnd, &winInfo);


POINT pt = { (winInfo.rcClient.right-winInfo.rcClient.left)/2, (winInfo.rcClient.bottom-winInfo.rcClient.top)/2 };
Messages postés
202
Date d'inscription
dimanche 18 mai 2003
Statut
Membre
Dernière intervention
6 mars 2010

pour le WINDOWINFO c'est pour la taille du device.



g_d3ddm.Width = g_iwSx; // Taille du display

g_d3ddm.Height = g_iwSy; // Taille du display



changer g_iwSx , g_iwSy par la taille que tu recupere pour WINDOWINFO .



pour la souris remplace dans ton code au MOUSEMOVE par ça :



case WM_MOUSEMOVE: // Si la souris bouge

{

static int posXp = 0;

static int posYp = 0;

int posX = GET_X_LPARAM(lParam);

int posY = GET_Y_LPARAM(lParam);



// Droite - gauche

float nXDiff = posX-posXp;

g_Camera->Yaw(D3DXToRadian(nXDiff));



// Bas haut

float nYDiff = posY - posYp;

g_Camera->Pitch(D3DXToRadian(nYDiff));



posXp = posX;

posYp = posY;



}



n'oublie pas de rajoute #include <windowsx.h> pour pouvoir utiliser le GET_X_LPARAM



si la souris bouge trop vite il suffit de diviser nXDiff par 2 , 3 ....



j'ai utilisé les static pour aller plus vite mais tu devrai transformer
ce bout de code pour bien l'intégrer dans tes classe mais essaye déjà
comme ça ça marche sur ton code.

Voili,Voilou
Messages postés
23
Date d'inscription
lundi 15 avril 2002
Statut
Membre
Dernière intervention
1 mars 2007

Merci, ça fonctionne bien, cependant y a qq souci.
Déjà en faite je voulais recentrer le curseur à chaque fois parce que dans ton exemple la souris finie par sortir de l'écran. Et sinon faudrai que je bloque le descente/montée parce que sinon si je vais trop bah ça m'inverse tout.

En tout cas merci pour ton aide, maintenant il faut que je règle se problème avec mon gauche-droite, si tu as une idée, je suis prenneur.

Merci
Messages postés
202
Date d'inscription
dimanche 18 mai 2003
Statut
Membre
Dernière intervention
6 mars 2010

j'aurais une idée c'est de passer par des matrices de transformations
et non pas appeler la fonction D3DXMatrixLookAtLH() a chaque fois
mais seulement 1 seul fois a l'initialisation.

mais pour cela il faut que tu change complétement le fonctionnnement de ta camera.



J'ai pas trop le temps pour bien d'expliquer mais si tu veut j'ai une source qui utlise ce genre de truc ?

Voili,Voilou
Messages postés
23
Date d'inscription
lundi 15 avril 2002
Statut
Membre
Dernière intervention
1 mars 2007

Oui, je suis prenneur pour ta sources.
En fait je suis déjà parti d'une source tout fait qui fonctionnait avec le même principe, j'ai fait quasiement copier coller alors c'est ça que je comprend pas.
Messages postés
23
Date d'inscription
lundi 15 avril 2002
Statut
Membre
Dernière intervention
1 mars 2007

J'ai ajouté ça SetCapture(g_hWnd); pour que ça capture même en dehors de la fenêtre mais se qui est chiant c'est qu'il faut laisser le bouton gauche souris enfoncé
Messages postés
23
Date d'inscription
lundi 15 avril 2002
Statut
Membre
Dernière intervention
1 mars 2007

J'ai pratiquer qq améliorations.
J'ai remis le CenterCursor(); mais pas dans le while des messages mais à la fin du rendu. De se fait je capture le moindre mouvement de souris et je soustrait à la position centrale. Ainsi mon curseur et toujours au centre, il ne jamais de la fenêtre, le mouvement est très fluide.
Le seul hic pour le moment c'est en fenêtré, là ça bug un peu, mais en plein écran c'est niquel.
Messages postés
23
Date d'inscription
lundi 15 avril 2002
Statut
Membre
Dernière intervention
1 mars 2007

http://www.sm2i.info/private/Camera_2.rar

J'ai mis à jour, je te laisse jeter un coup d'oeilhttp://www.sm2i.info/private/camera2.rar
Messages postés
23
Date d'inscription
lundi 15 avril 2002
Statut
Membre
Dernière intervention
1 mars 2007

J'y suis aller un peu bourrin mais pour virer les problème en fenêtré j'ai fait -4 pour les X et -23 pour les Y et ça tourne niquel :)
Messages postés
23
Date d'inscription
lundi 15 avril 2002
Statut
Membre
Dernière intervention
1 mars 2007

Autre problème quand je compile en mode "Release" j'ai une erreur de buffer overrun. Comprend pas
Messages postés
202
Date d'inscription
dimanche 18 mai 2003
Statut
Membre
Dernière intervention
6 mars 2010

pour la taille fenetre avec -4 et -23 il faut que tu ajoute ça :



g_d3ddm.Width = g_iwSx; // Taille du display

g_d3ddm.Height = g_iwSy; // Taille du display



et tu remplace g_
iwSx et g_
iwSy par la taille que tu recupere avec
WINDOWINFO. Sa ce fait au début a l'initialisation du device.



pour ton probleme en debug et relesase c'est surement des
initialisation qui ne sont pas fait car en debug il initialise tout
seul ce que le mode release ne fait pas.



Pour ton code j'ai pas trop le temp de me pencher dessus mais essaye de passer par les matrice pour déplacer ta camera.


Voili,Voilou
Messages postés
23
Date d'inscription
lundi 15 avril 2002
Statut
Membre
Dernière intervention
1 mars 2007

g_d3ddm.Width = g_iwSx; // Taille du display
g_d3ddm.Height = g_iwSy; // Taille du display

Je ne suis pas sur que j'ai besoin de faire ta manip car si tu regarder bien j'exécute se code que lorsque je suis en plein écran, en mode fenêtrer je ne le fait pas, ça le fait tout seul apparemment. J'vais quand même tester avec ça pour voir parce que je trouve que la souris manque de précision...