D3D Initialisation (174 Ko)

   Le module D3DApp contient la classe CD3DApplication. Cette classe publie l'interface des programmes d'exemple, dans le fichier D3Dapp.h, comme illustré ci-dessous :

// -------------------------------------------------------------
// Fonctions remplaçables pour la scène en 3D créée par l'application
// -------------------------------------------------------------

virtual HRESULT OneTimeSceneInit()        { return S_OK; }
virtual HRESULT InitDeviceObjects()       { return S_OK; }
virtual HRESULT RestoreDeviceObjects()    { return S_OK; }
virtual HRESULT FrameMove()               { return S_OK; }
virtual HRESULT Render()                  { return S_OK; }
virtual HRESULT InvalidateDeviceObjects() { return S_OK; }
virtual HRESULT DeleteDeviceObjects()     { return S_OK; }
virtual HRESULT FinalCleanup()            { return S_OK; }

  Pour créer une nouvelle application D3D en utilisant la structure d'exemple, il suffit de créer un nouveau projet et de nouvelles implémentations de ces fonctions ; appelons-les "l'interface publique" d'un exemple D3Dframe. C'est exactement ce que font les exemples du kit de développement D3D.

  OneTimeSceneInit permet à l'exemple d'effectuer une tâche d'initialisation unique, comme le chargement de textures et de x-files, de définir des valeurs calculées, de créer des géométries procédurales, et des opérations similaires. Fondamentalement, toute allocation de ressource unique devrait être exécutée ici. OneTimeSceneInit est appelée une fois par cycle d'exécution de l'application.

  InitDeviceObjects donne à l'exemple la possibilité d'initialiser des objets par dispositif. En général, les programmes effectuent des opérations telles que le chargement de textures binaires sur la surface d'un dispositif, la définition de matrices, la configuration de sources lumineuses, et le remplissage de tampons de sommets. La fonction InitDeviceObjects est appelée lors de l'initialisation du premier dispositif, et à chaque modification d'un dispositif.

  RestoreDeviceObjects permet à l'exemple de tester les surfaces et les objets perdus et de les restaurer, de sorte que l'application peut continuer d'être exécutée. RestoreDeviceObjects est appelée lorsque des surfaces et les objets ont été perdus à la suite du passage d'une application à une autre.

  FrameMove est une façon pratique de réunir des tâches d'animation par trame. La mise à jour des matrices, des coordonnées de texture, des coordonnées d'objets, et d'autres activités dépendant du temps se produisent toutes dans FrameMove.  FrameMove est appelée une fois par trame.

  Render est là où s'effectuent tous les rendus. Vous pouvez y effacer le tampon de trame et appeler tout le code de rendu entre la paire BeginScene/EndScene. Render est appelée une fois par trame.

  InvalidateDeviceObjects permet de supprimer les objets dépendants de dispositif qui sont sur le point d'être perdus. InvalidateDeviceObjects est appelée lorsque un changement de résolution de l'écran à été demandé ou détecté par exemple.

  DeleteDeviceObjects contient le code utilisé par l'exemple pour supprimer les objets créés avec la fonction InitDeviceObjects. Ces deux fonctions constituent des ensembles correspondants ; veillez à ce que les allocations de ressource des dispositifs correspondent aux suppressions, faute de quoi vous risqueriez de manquer de mémoire dès qu'une modification se produit sur un dispositif.  La fonction DeleteDeviceObjects est appelée chaque fois qu'un dispositif est détruit.

  FinalCleanup est l'équivalent de OneTimeSceneInit et fournit un temps pour détruire des objets par application. Veillez à ce que votre code de nettoyage corresponde à votre code d'initialisation pour éviter le manque de mémoire.

   Avant d'entrer dans le détail, observons ce que devient WinMain en utilisant CD3DApplication. Dans cet exemple, WinMain finit par ressembler à :

  INT WINAPI WinMain(HINSTANCE hInst, HINSTANCE, LPSTR, INT)
  {
    CMyD3DApplication d3dApp;

    if(FAILED(d3dApp.Create(hInst)))
      return 0;

    return d3dApp.Run();
  }

   Create utilise le support à partir des strctures D3DModeInfo, D3DDeviceInfo et D3DAdapterInfo pour énumérer le support du pilote, du périphérique et du mode pour le matériel en cours ; une valeur par défaut est également sélectionnée. Puis l'interface publique OneTimeSceneInit est appelée. Lorsque les objets de l'utilisateur sont créés le module cré l'environnement du nouveau dispositif.

   Run effectue deux tâches importantes : la gestion des messages en boucle de Windows et l'appel de Render3DEnvironment. Run prévoit également le message WM_QUIT et la sortie.

   À présent, tout ce qu'il vous reste à faire pour créer un nouvel exemple est d'implémenter une classe, telle que CMyD3Dapplication illustrée ci-dessous :

// -------------------------------------------------------------
// Name: class CMyD3DApplication
// Desc: Class de l'application. La classe de base (CD3DApplication)
//		fournit les fonctionnalités génériques nécessaires
//		dans tous les exemples Direct3D. CMyD3DApplication
//		ajoute les fonctionnalités spécifiques à cet exemple.
// -------------------------------------------------------------

class CMyD3DApplication : public CD3DApplication
{
  HRESULT ConfirmDevice(D3DCAPS8*, DWORD, D3DFORMAT);

protected:
  HRESULT OneTimeSceneInit();
  HRESULT InitDeviceObjects();
  HRESULT RestoreDeviceObjects();
  HRESULT InvalidateDeviceObjects();
  HRESULT DeleteDeviceObjects();
  HRESULT FinalCleanup();
  HRESULT Render();
  HRESULT FrameMove();

public:
  CMyD3DApplication();
};