Partager via

Résumé des fonctionnalités (Direct3D 9 pour Windows Vista)

  • Article

Cette documentation fait spécifiquement référence aux extensions Windows Vista pour les graphiques DirectX. Pour développer la puissance de DirectX pour Windows Vista, vous devez installer le Kit de développement logiciel (SDK) Windows Vista ainsi que le Kit de développement logiciel (SDK) DirectX. Les applications qui utilisent DirectX pour Windows Vista doivent utiliser du matériel qui utilise le pilote WDDM (modèle de pilote de périphérique Windows) par opposition au modèle XPDM (modèle de pilote XP) ; les pilotes qui n’implémentent pas wdDM ne peuvent pas instancier les interfaces graphiques Windows Vista DirectX.

Découvrez les nouvelles fonctionnalités graphiques DirectX dans Windows Vista dans l’une des sections suivantes :

Changements de comportement de l’appareil

Les appareils ne sont désormais perdus que dans deux circonstances ; lorsque le matériel est réinitialisé parce qu’il est suspendu et lorsque le pilote de périphérique est arrêté. Lorsque le matériel se bloque, l’appareil peut être réinitialisé en appelant ResetEx. Si le matériel se bloque, la mémoire de texture est perdue.

Une fois qu’un pilote est arrêté, l’objet IDirect9Ex doit être recréé pour reprendre le rendu.

Lorsque la zone de présentation est masquée par une autre fenêtre en mode fenêtré ou lorsqu’une application plein écran est réduite, PresentEx retourne S_D3DPRESENTATIONOCCLUDED. Les applications en plein écran peuvent reprendre le rendu lorsqu’elles reçoivent un message de rappel WM_ACTIVATEAPP .

Dans les versions précédentes de DirectX, lorsqu’une application a subi un changement de mode, la seule façon de récupérer était de réinitialiser l’appareil et de recréer toutes les ressources de mémoire vidéo et les chaînes d’échange. Maintenant, avec DirectX pour Windows Vista, l’appel à la réinitialisation après un changement de mode n’entraîne pas la perte de surfaces de mémoire de texture, de textures et d’informations d’état, et ces ressources n’ont pas besoin d’être recréées.

Désactivation du traitement du vertex logiciel multithread

Un nouveau bit de majuscules (D3DCREATE_DISABLE_PSGP_THREADING) a été ajouté pour désactiver le multithreading pour le traitement du vertex logiciel (swvp). Utilisez cette macro pour générer un indicateur de comportement pour IDirect3D9::CreateDevice.

#define D3DCREATE_DISABLE_PSGP_THREADING

Surfaces d’un bit

Il existe un nouveau type de format surface d’un bit qui peut être particulièrement utile pour le traitement des glyphes de texte. Le nouveau format est appelé D3DFMT_A1. Une surface un bit est conçue pour être utilisée comme texture par pixel ou comme sortie cible de rendu générée par ComposeRects ou ColorFill. Il n’y a pas de majuscules distinctes pour la largeur et la hauteur de la surface; une implémentation doit prendre en charge une surface de taille unique qui est 2K texels x 8K texels.

Une surface à un bit a un bit par texel; par conséquent, un signifie que tous les composants (r,g,b,a) d’un pixel sont 1, et zéro signifie que tous les composants sont égaux à 0. Vous pouvez utiliser des surfaces un bits avec les API suivantes : ColorFill, UpdateSurface et UpdateTexture.

Lorsqu’une surface un bits est lue, le runtime peut effectuer un filtrage d’exemple de points ou de convolution. Le filtre de convolution est réglable (voir SetConvolutionMonoKernel).

Il existe certaines restrictions pour les surfaces un bits :

  • Le mappage Mip n’est pas pris en charge
  • Les données sRGB ne peuvent pas être lues ou écrites sur une surface un bit.
  • Une surface un bit ne peut pas être utilisée comme texture de vertex ou pour le multi-échantillonnage.

Mémoires tampons profondeur/gabarit de lecture

Utilisez IDirect3DDevice9::UpdateSurface pour lire ou écrire des données de profondeur/gabarit à partir de surfaces obtenues à partir de IDirect3DDevice9::CreateDepthStencilSurface ou IDirect3DDevice9::GetDepthStencilSurface.

Tout d’abord, créez une surface verrouillable, de profondeur uniquement ou de gabarit uniquement à l’aide de IDirect3DDevice9::CreateOffscreenPlainSurface. Utilisez l'un des éléments suivants :

  • D3DFMT_D16_LOCKABLE
  • D3DFMT_D32F_LOCKABLE
  • D3DFMT_D32_LOCKABLE
  • D3DFMT_S8_LOCKABLE

Deuxièmement, transférez des données entre la mémoire tampon de profondeur/gabarit et la surface de profondeur verrouillable ou de gabarit nouvellement créée. Le transfert est effectué à l’aide de IDirect3DDevice9::UpdateSurface.

UpdateSurface échoue lorsque les deux surfaces sont au format LOCKABLE ou que les deux sont non verrouillables.

Le transfert de données inexistantes entraîne une erreur (par exemple, le transfert d’une surface de profondeur non verrouillable uniquement vers une surface D3DFMT_S8_LOCKABLE).

Les autres restrictions pour IDirect3DDevice9::UpdateSurface s’appliquent toujours.

Partage de ressources

Les ressources Direct3D peuvent désormais être partagées entre des appareils ou des processus. Cela s’applique à toutes les ressources Direct3D, y compris les textures, les tampons de vertex, les tampons d’index ou les surfaces (telles que les cibles de rendu, les tampons de gabarit de profondeur ou les surfaces simples hors écran). Pour être partagé, vous devez désigner une ressource à partager au moment de la création et localiser la ressource dans le pool par défaut (D3DPOOL_DEFAULT). Une fois qu’une ressource est créée pour le partage, elle peut être partagée entre les appareils au sein d’un processus ou partagée entre les processus.

Pour activer les ressources partagées, les API de création de ressources ont un paramètre de handle supplémentaire. Il s’agit d’un HANDLE qui pointe vers la ressource partagée. Dans les révisions précédentes de DirectX, cet argument a fait partie de la signature d’API, mais n’a pas été utilisé et doit être défini sur NULL. À compter de Windows Vista, utilisez pSharedHandle des manières suivantes :

  • Définissez le pointeur (pSharedHandle) sur NULL pour ne pas partager de ressource. C’est comme le comportement de DirectX avant Windows Vista.
  • Pour créer une ressource partagée, appelez une API de création de ressource (voir ci-dessous) avec un handle non initialisé (le pointeur lui-même n’est pas NULL (pSharedHandle != NULL), mais le pointeur pointe vers une valeur NULL (*pSharedHandle == NULL)). L’API génère une ressource partagée et retourne un handle valide.
  • Pour ouvrir et accéder à une ressource partagée précédemment créée à l’aide d’un handle de ressource partagée nonNULL, définissez pSharedHandle sur l’adresse de ce handle. Après avoir ouvert la ressource partagée créée précédemment de cette manière, vous pouvez utiliser l’interface retournée dans l’API Direct3D 9 ou Direct3D 9Ex comme si l’interface était une ressource classique de ce type.

Les API de création de ressources incluent : CreateTexture, CreateVolumeTexture, CreateCubeTexture, CreateRenderTarget, CreateVertexBuffer, CreateIndexBuffer, CreateDepthStencilSurface, CreateOffscreenPlainSurface, CreateDepthStencilSurfaceEx, CreateOffscreenPlainSurfaceEx et CreateRenderTargetEx.

Certaines restrictions s’appliquent à l’utilisation de ressources partagées. Il s’agit notamment des paramètres suivants :

  • L’API que vous utilisez pour ouvrir une ressource partagée doit correspondre à l’API que vous avez utilisée pour créer la ressource partagée. Par exemple, si vous avez utilisé CreateTexture pour créer une ressource partagée, vous devez utiliser CreateTexture pour ouvrir cette ressource partagée ; si vous avez utilisé CreateRenderTarget pour créer une ressource partagée, vous devez utiliser CreateRenderTarget pour ouvrir cette ressource partagée, et ainsi de suite.
  • Lorsque vous ouvrez une ressource partagée, vous devez spécifier D3DPOOL_DEFAULT.
  • Les ressources verrouillables (textures avec D3DUSAGE_DYNAMIC, tampons de vertex et mémoires tampons d’index, pour instance) peuvent connaître des performances médiocres lorsqu’elles sont partagées. Les cibles de rendu verrouillables ne pourront pas être partagées sur certains matériels.
  • Les références à une ressource partagée inter-processus doivent avoir les mêmes dimensions que la ressource d’origine. Lors du passage d’un handle entre les processus, incluez les informations de dimension afin que la référence puisse être créée de manière identique.
  • Les surfaces inter-processus partagées ne fournissent aucun mécanisme de synchronisation. Les modifications en lecture/écriture d’une surface partagée peuvent ne pas refléter l’affichage de la surface par un processus de référencement lorsque cela est attendu. Pour fournir la synchronisation, utilisez des requêtes d’événements ou verrouillez la texture.
  • Seul le processus qui crée initialement une ressource partagée peut la verrouiller (tout processus qui ouvre une référence à cette ressource partagée ne peut pas la verrouiller).
  • Si une ressource partagée est verrouillée, il n’existe aucune validation pour que d’autres processus sachent si la ressource est disponible.

Conversion sRGB avant fusion

Vous pouvez maintenant case activée pour voir si l’appareil peut convertir des données de pipeline en sRGB avant la fusion frame-buffer. Cela implique que l’appareil convertit les valeurs de la cible de rendu à partir de sRGB. Pour voir si la conversion est prise en charge par le matériel, case activée pour cette limite :

D3DPMISCCAPS_POSTBLENDSRGBCONVERT

Cette limite identifie le matériel qui prend en charge la conversion en sRGB avant la fusion. Cette fonctionnalité est importante pour le rendu de haute qualité à partir des mémoires tampons d’images fp16 dans le gestionnaire de fenêtres de bureau (DWM).

Améliorations de StretchRect

Dans les versions précédentes de DirectX, StretchRect a de nombreuses restrictions pour prendre en charge différents pilotes (voir IDirect3DDevice9::StretchRect). Windows Vista est basé sur le modèle de pilote de périphérique Windows (WDDM). Ce nouveau modèle de pilote est beaucoup plus robuste et permet aux pilotes de gérer des cas spéciaux dans le matériel.

En général, la seule restriction restante est que la cible de rendu doit avoir été créée avec l’utilisation de la cible de rendu (D3DUSAGE_RENDERTARGET). Cette restriction est levée si vous effectuez une copie simple (où la source et le dest ont le même format, la même taille et il n’y a pas de sous-rectangles).

Création de textures dans la mémoire système

Les applications qui ont besoin de plus de flexibilité sur l’utilisation, l’allocation et la suppression de la mémoire système peuvent désormais créer des textures à partir d’un pointeur de mémoire système. Par exemple, une application peut créer une texture Direct3D à partir d’un pointeur bitmap de mémoire système GDI.

Vous devez effectuer deux opérations pour créer une telle texture :

  • Allouez suffisamment de mémoire système pour contenir la surface de texture. Le nombre minimal d’octets est largeur x hauteur x octets par pixel.
  • Transmettez l’adresse d’un pointeur vers votre surface de mémoire système pour le paramètre HANDLE* à IDirect3DDevice9::CreateTexture.

Voici le prototype de fonction pour IDirect3DDevice9::CreateTexture :

STDMETHOD(CreateTexture)(THIS_ UINT Width, UINT Height, UINT Levels, 
    DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DTexture9** ppTexture, 
    HANDLE* pSharedHandle)

Une texture de mémoire système présente les restrictions suivantes :

  • La hauteur de texture doit être égale à la largeur de texture fois le nombre d’octets par pixel.
  • Lors de l’utilisation de formats compressés (formats DXT), l’application est responsable de l’allocation de la taille correcte.
  • Seules les textures avec un seul niveau mipmap sont prises en charge.
  • La valeur passée à CreateTexture pour l’argument Pool doit être D3DPOOL_SYSTEMMEM.
  • Cette API encapsule la mémoire fournie dans une texture. Ne libérez pas cette mémoire tant que vous n’en avez pas terminé.