Partager via

Sélection d’un appareil (Direct3D 9)

  • Article

Les applications peuvent interroger le matériel pour détecter les types d’appareils Direct3D pris en charge. Cette section contient des informations sur les tâches principales impliquées dans l’énumération des cartes d’affichage et la sélection des appareils Direct3D.

Une application doit effectuer une série de tâches pour sélectionner un appareil Direct3D approprié. Notez que les étapes suivantes sont destinées à une application en plein écran et que, dans la plupart des cas, une application fenêtré peut ignorer la plupart de ces étapes.

  1. Initialement, l’application doit énumérer les cartes d’affichage sur le système. Un adaptateur est un élément matériel physique. Notez que les graphiques carte peuvent contenir plusieurs cartes, comme c’est le cas avec un affichage à double tête. Les applications qui ne sont pas concernées par la prise en charge de plusieurs moniteurs peuvent ignorer cette étape et passer D3DADAPTER_DEFAULT à la méthode IDirect3D9::EnumAdapterModes à l’étape 2.

  2. Pour chaque adaptateur, l’application énumère les modes d’affichage pris en charge en appelant IDirect3D9::EnumAdapterModes.

  3. Si nécessaire, l’application vérifie la présence d’une accélération matérielle dans chaque mode d’affichage énuméré en appelant IDirect3D9::CheckDeviceType, comme indiqué dans l’exemple de code suivant. Notez qu’il ne s’agit que de l’une des utilisations possibles pour IDirect3D9::CheckDeviceType ; Pour plus d’informations, consultez Détermination de la prise en charge matérielle (Direct3D 9).

    D3DPRESENT_PARAMETERS Params;
// Initialize values for D3DPRESENT_PARAMETERS members. 

Params.BackBufferFormat = D3DFMT_X1R5G5B5; 

if(FAILED(m_pD3D->CheckDeviceType(Device.m_uAdapter, 
                  Device.m_DevType, 
                  Params.BackBufferFormat, Params.BackBufferFormat, 
                  FALSE))) 
    return E_FAIL;

  4. L’application vérifie le niveau de fonctionnalité souhaité pour l’appareil sur cette carte en appelant la méthode IDirect3D9::GetDeviceCaps . La fonctionnalité retournée par cette méthode est garantie constante pour un appareil dans tous les modes d’affichage, vérifiée par IDirect3D9::CheckDeviceType.

  5. Les appareils peuvent toujours effectuer un rendu sur des surfaces au format d’un mode d’affichage énuméré pris en charge par l’appareil. Si l’application doit effectuer un rendu sur une surface d’un autre format, elle peut appeler IDirect3D9::CheckDeviceFormat. Si l’appareil peut effectuer un rendu au format, il est garanti que toutes les fonctionnalités retournées par IDirect3D9::GetDeviceCaps sont applicables.

  6. Enfin, l’application peut déterminer si les techniques de multi-échantillonnage, telles que l’anticrénelage en scène complète, sont prises en charge pour un format de rendu à l’aide de la méthode IDirect3D9::CheckDeviceMultiSampleType .

Après avoir effectué les étapes précédentes, l’application doit disposer d’une liste de modes d’affichage dans lesquels elle peut fonctionner. La dernière étape consiste à vérifier que suffisamment de mémoire accessible par l’appareil est disponible pour prendre en charge le nombre requis de mémoires tampons et d’anti-ataliasing. Ce test est nécessaire, car la consommation de mémoire pour la combinaison mode et multi-échantillon est impossible à prédire sans la vérifier. En outre, certaines architectures d’adaptateurs d’affichage peuvent ne pas avoir une quantité constante de mémoire accessible par l’appareil. Cela signifie qu’une application doit être en mesure de signaler les défaillances de mémoire hors vidéo lors de la mise en mode plein écran. En règle générale, une application doit supprimer le mode plein écran de la liste des modes qu’elle propose à un utilisateur, ou elle doit essayer de consommer moins de mémoire en réduisant le nombre de mémoires tampons arrière ou en utilisant une technique de multi-échantillonnage moins complexe.

Une application fenêtré effectue un ensemble de tâches similaire.

  1. Il détermine le rectangle de bureau couvert par la zone cliente de la fenêtre.
  2. Il énumère les cartes, en recherchant l’adaptateur dont le moniteur couvre la zone cliente. Si la zone cliente appartient à plusieurs adaptateurs, l’application peut choisir de piloter chaque adaptateur indépendamment, ou de piloter un seul adaptateur et d’avoir Direct3D transférer des pixels d’un appareil à un autre lors de la présentation. L’application peut également ignorer deux étapes précédentes et utiliser l’adaptateur D3DADAPTER_DEFAULT. Notez que cela peut ralentir le fonctionnement lorsque la fenêtre est placée sur un moniteur secondaire.
  3. L’application doit appeler IDirect3D9::CheckDeviceType pour déterminer si l’appareil peut prendre en charge le rendu sur une mémoire tampon arrière au format spécifié en mode Bureau. IDirect3D9::GetAdapterDisplayMode peut être utilisé pour déterminer le format d’affichage du bureau, comme illustré dans l’exemple de code suivant. 
    D3DPRESENT_PARAMETERS Params;
// Initialize values for D3DPRESENT_PARAMETERS members. 

// Use the current display mode.
D3DDISPLAYMODE mode;

if(FAILED(m_pD3D->GetAdapterDisplayMode(Device.m_uAdapter , &mode)))
    return E_FAIL;

Params.BackBufferFormat = mode.Format;

if(FAILED(m_pD3D->CheckDeviceType(Device.m_uAdapter, Device.m_DevType, 
Params.BackBufferFormat, Params.BackBufferFormat, FALSE)))
    return E_FAIL;

Appareils Direct3D