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 utilisant 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 à 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 :

Modifications du comportement de l’appareil

Les appareils ne sont maintenant perdus que dans deux circonstances, lorsque le matériel est réinitialisé en raison d'un blocage et quand 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 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 de réinitialisation après une modification du mode n’entraîne pas la perte des surfaces de mémoire de texture, des textures et des informations d’état, et ces ressources n’ont pas besoin d’être recréées.

Désactivation du traitement logiciel de sommet multithreadé

Un nouveau bit de capacités (D3DCREATE_DISABLE_PSGP_THREADING) a été ajouté afin de désactiver le multithreading pour le traitement des sommets par logiciel (swvp). Utilisez cette macro pour générer un indicateur de comportement pour IDirect3D9 ::CreateDevice.

#define D3DCREATE_DISABLE_PSGP_THREADING

Surfaces à 1 bit

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

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

Lorsqu’une surface à un bit est lue, l'environnement d'exécution peut effectuer un échantillonnage par points ou un filtrage de convolution. Le filtre de convolution est réglable (voir SetConvolutionMonoKernel).

Il existe certaines restrictions pour les surfaces à 1 bit :

  • Le mip-mapping 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 bits ne peut pas être utilisée comme texture de vertex ou pour l’échantillonnage multiple.

Lecture des tampons de profondeur/pochoir

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

Premièrement, créez une surface verrouillable dédiée uniquement à la profondeur ou uniquement au pochoir en utilisant IDirect3DDevice9::CreateOffscreenPlainSurface. Utilisez l’un des formats suivants :

  • D3DFMT_D16_LOCKABLE
  • D3DFMT_D32F_LOCKABLE
  • D3DFMT_D32_LOCKABLE
  • D3DFMT_S8_LOCKABLE

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

UpdateSurface échouera lorsque les deux surfaces sont au format LOCKABLE ou lorsque les deux ne sont pas verrouillables.

Le transfert de données inexistantes entraînera une erreur (par exemple, le transfert depuis une surface exclusivement de profondeur non verrouillable vers une surface D3DFMT_S8_LOCKABLE).

Le reste des 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 à n’importe quelle ressource Direct3D, y compris les textures, les tampons de vertex, les mémoires tampons d’index ou les surfaces (telles que les cibles de rendu, les mémoires tampons de gabarit de profondeur ou les surfaces plaines hors écran). Pour être partagé, vous devez désigner une ressource pour le partage 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 fait partie de la signature de l’API, mais n’a pas été utilisé et doit être défini sur null. À compter de Windows Vista, utilisez pSharedHandle de la manière suivante :

  • Définissez le pointeur (pSharedHandle) sur NULL pour ne pas partager une ressource. C’est tout comme le comportement de DirectX avant Windows Vista.
  • Pour créer une ressource partagée, appelez n’importe quelle 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 créée précédemment à 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 façon, 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, CreateOffscreenPlainSurfaceExet CreateRenderTargetEx.

Il existe certaines restrictions pour l’utilisation de ressources partagées. Voici quelques-uns des éléments 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 des D3DUSAGE_DYNAMIC, des mémoires tampons de vertex et des mémoires tampons d’index, par exemple) peuvent rencontrer des performances médiocres lors du partage. Les rendertargets verrouillables ne peuvent pas se partager sur certaines configurations matérielles.
  • Les références à une ressource partagée interprocesseur doivent avoir les mêmes dimensions que la ressource d’origine. Lorsque vous transmettez un handle entre processus, incluez les informations de dimension afin que la référence puisse être recréée de manière identique.
  • Les surfaces interprocesseurs partagées ne fournissent aucun mécanisme de synchronisation. Les modifications en lecture/écriture sur une surface partagée peuvent ne pas se refléter dans la vue du processus qui la référence comme prévu. Pour fournir une synchronisation, utilisez des requêtes d’événements ou verrouillez la texture.
  • Seul le processus qui crée initialement une ressource partagée peut le verrouiller (tout processus qui ouvre une référence à cette ressource partagée ne peut pas le 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 désormais vérifier si l’appareil peut convertir les données du pipeline en sRGB avant le mélange du frame-buffer. Cela implique que l’appareil convertit les valeurs de la cible de rendu à partir de sRGB. Pour vérifier si la conversion est prise en charge par le matériel, vérifiez cette capacité :

D3DPMISCCAPS_POSTBLENDSRGBCONVERT

Cette limite identifie le matériel qui prend en charge la conversion en sRGB avant de fusionner. Cette capacité est importante pour un rendu de haute qualité à partir des frame buffers fp16 dans le gestionnaire de fenêtres du 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 particuliers 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'usage de type render-target (D3DUSAGE_RENDERTARGET). Cette restriction est levée si vous effectuez une copie simple (où la source et lest sont au même format, de même taille et qu’il n’y a pas de sous-rectangles).

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

Les applications qui ont besoin d’une plus grande 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 la largeur x hauteur x octets par pixel.
  • Passez 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 a les restrictions suivantes :

  • Le pas de texture doit être égal à la largeur de la texture multipliée par le nombre d’octets par pixel.
  • Lorsque vous utilisez des formats compressés (formats DXT), l’application est chargée d’allouer 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 désallouez pas cette mémoire tant que vous n’en avez pas terminé l’utilisation.