Partager via

Considérations de Direct3D 9 à Direct3D 10 (Direct3D 10)

  • Article

La page suivante fournit un aperçu de base des principales différences entre Direct3D 9 et Direct3D 10. Le plan ci-dessous fournit quelques informations pour aider les développeurs avec l’expérience Direct3D 9 à explorer direct3D 10 et à s’y associer.

Bien que les informations de cette rubrique comparent Direct3D 9 à Direct3D 10, étant donné que Direct3D 11 s’appuie sur les améliorations apportées à Direct3D 10 et 10.1, vous avez également besoin de ces informations pour migrer de Direct3D 9 vers Direct3D 11. Pour plus d’informations sur le passage de Direct3D 10 à Direct3D 11, consultez Migration vers Direct3D 11.

Vue d’ensemble des principaux changements structurels de Direct3D 10

Le processus de rendu à l’aide de l’appareil Direct3D 10 est structurellement similaire à Direct3D 9.

  • Définir une source de flux de vertex
  • Définir la disposition d’entrée dans Direct3D 10 (définir la déclaration de flux de vertex dans Direct3D 9)
  • Déclarer la topologie primitive
  • Définir des textures
  • Définir des objets d’état
  • Définir des nuanceurs
  • Dessin

L’appel Draw relie les opérations ; l’ordre des appels avant l’appel Draw est arbitraire. Les principales différences dans la conception de l’API Direct3D 10 sont les suivantes :

  • Suppression de la fonction fixe
  • Suppression des bits CAPS - L’ensemble des fonctionnalités de base de Direct3D 10 est garanti
  • Gestion plus stricte des : accès aux ressources, état de l’appareil, constantes de nuanceur, liaison de nuanceur (entrées et sorties vers les nuanceurs) entre les étapes
  • Les changements de nom du point d’entrée de l’API reflètent l’utilisation de la mémoire GPU virtuelle (Map() au lieu de Lock()).
  • Une couche de débogage peut être ajoutée à l’appareil au moment de la création
  • La topologie primitive est désormais un état explicite (séparé de l’appel Draw )
  • Les constantes de nuanceur explicites sont désormais stockées dans des mémoires tampons constantes
  • La création du nuanceur s’effectue entièrement en HLSL. Le compilateur HLSL réside désormais dans la DLL Direct3D 10 principale.
  • Nouvelle étape programmable - le nuanceur de géométrie
  • Suppression de BeginScene()/EndScene()
  • Fonctionnalité de gestion 2D, de focus et d’adaptateur courante implémentée dans un nouveau composant : DXGI

Suppression de la fonction fixe

Il est parfois surprenant que même dans un moteur Direct3D 9 qui exploite entièrement le pipeline programmable, il reste un certain nombre de zones qui dépendent du pipeline à fonction fixe (FF). Les zones les plus courantes sont généralement liées au rendu aligné sur l’espace d’écran pour l’interface utilisateur. C’est pour cette raison que vous devrez probablement créer un nuanceur d’émulation FF ou un ensemble de nuanceurs qui fournissent les comportements de remplacement nécessaires.

Cette documentation contient un livre blanc contenant des sources de nuanceur de remplacement pour les comportements FF les plus courants (voir Exemple de fonction fixe EMU). Certains comportements de pixels de fonction fixe, y compris le test alpha, ont été déplacés dans des nuanceurs.

Validation du temps de création d’objet d’appareil

Le pipeline Direct3D 10 a été repensé à partir de la base dans le matériel et les logiciels avec l’intention principale de réduire la surcharge du processeur (au moment du tirage). Pour réduire les coûts, tous les types de données d’appareil se sont vu attribuer un objet avec des méthodes de création explicites fournies par l’appareil lui-même. Cela permet une validation stricte des données au moment de la création de l’objet plutôt qu’au cours de l’appel Draw, comme c’est souvent le cas avec Direct3D 9.

Abstractions du moteur / Séparation

Les applications, y compris les jeux, qui souhaitent prendre en charge Direct3D 9 et Direct3D 10 doivent avoir les couches de rendu abstraites du reste de la base de code. Il existe de nombreuses façons d’y parvenir, mais la clé de tous est la conception de la couche d’abstraction pour l’appareil Direct3D de niveau inférieur. Tous les systèmes doivent communiquer avec le matériel via la couche commune qui est conçue pour fournir des ressources GPU et une gestion de type de bas niveau.

Suppression directe des dépendances Direct3D 9

Lors du portage de bases de code volumineuses précédemment testées, il est important de réduire la quantité de modifications de code qui sont absolument nécessaires pour préserver les comportements précédemment testés dans le code. Les meilleures pratiques incluent la documentation claire où les éléments changent à l’aide de commentaires. Il est souvent utile d’avoir une norme de commentaire pour ce travail qui permet une navigation rapide dans la base de code.

Voici un exemple de liste de commentaires de bloc de ligne/de début standard qui peuvent être utilisés pour ce travail.

Élément Description
Direct3D 10 REMOVED
 Utilisez ceci lorsque les lignes/blocs de code sont supprimés
Direct3D 10 A BESOIN DE MISE À JOUR
 Il permet d’ajouter des notes supplémentaires au commentaire NEED UPDATE qui suggèrent quel travail/nouvelle API doit être utilisé pour les visites ultérieures du code pour la conversion de comportement. L’utilisation intensive de assert(false) doit également être utilisée là où \\ Direct3D 10 NEEDS UPDATE se produit pour vous assurer que vous n’exécutez pas de code errant sans le savoir
Direct3D 10 MODIFIÉ
 Les domaines où des changements importants ont eu lieu doivent être conservés pour référence ultérieurement, mais commentés
Direct3D 10 END
 Qualificateur de bloc de code de fin

 

Pour plusieurs lignes de source, vous devez également utiliser le style C /* */ commentaires, mais ajouter les commentaires de début/fin appropriés autour de ces zones.

Astuces pour résoudre rapidement les problèmes de génération d’application

Remplacement des types Direct3D 9

Il peut être utile d’insérer un fichier d’en-tête de haut niveau contenant des définitions/remplacements de type pour les types de base Direct3D 9 qui ne sont plus pris en charge par les en-têtes Direct3D 10. Cela vous aidera à réduire la quantité de modifications dans le code et les interfaces où il existe un mappage direct d’un type Direct3D 9 au type Direct3D 10 nouvellement défini. Cette approche est également utile pour conserver les comportements de code ensemble dans un fichier source. Dans ce cas, il est judicieux de définir des types sans version/généralement nommés qui décrivent les constructions courantes utilisées pour le rendu tout en couvrant les API Direct3D 9 et Direct3D 10. Exemple :

#if defined(D3D9)
typedef IDirect3DIndexBuffer9   IDirect3DIndexBuffer;
typedef IDirect3DVertexBuffer9  IDirect3DVertexBuffer;
#else //D3D10
typedef ID3D10Buffer            IDirect3DIndexBuffer;
typedef ID3D10Buffer            IDirect3DVertexBuffer
#endif

Voici d’autres exemples spécifiques à Direct3D 10 :

typedef ID3D10TextureCube   IDirect3DCubeTexture;
typedef ID3D10Texture3D     IDirect3DVolumeTexture;
typedef D3D10_VIEWPORT      D3DVIEWPORT;
typedef ID3D10VertexShader  IDirect3DVertexShader;
typedef ID3D10PixelShader   IDirect3DPixelShader;

Il est recommandé de développer des applications Direct3D 10 et Windows Vista à l’aide de la dernière version de Microsoft Visual Studio. Toutefois, il est possible de créer une application Windows Vista qui dépend de Direct3D 10 à l’aide de la version 2003 antérieure de Visual Studio. Direct3D 10 est un composant de plateforme Windows Vista qui a des dépendances (comme avec le SDK de plateforme Server 2003 SP1) sur la bibliothèque suivante : BufferOverflowU.lib est nécessaire pour résoudre les problèmes d’éditeur de liens buffer_security case activée.

Simulation des applications d’accès client d’appareil

De nombreuses applications contiennent des zones de code qui dépendent de la disponibilité des données CAPS de l’appareil. Contourez ce problème en remplaçant l’énumération des appareils et en forçant les caps d’appareil à des valeurs sensibles. Prévoyez de visiter de nouveau les zones où il y a des dépendances à l’endroit du CAPS ultérieurement pour supprimer complètement le CAPS, dans la mesure du possible.

Pilotage de l’API Direct3D 10

Cette section se concentre sur les changements de comportement provoqués par l’API Direct3D 10.

Création de ressources

L’API Direct3D 10 a conçu les ressources en tant que types de mémoires tampons génériques qui ont des indicateurs de liaison spécifiques en fonction de l’utilisation planifiée. Ce point de conception a été choisi pour faciliter l’accès quasi omniprésent aux ressources dans le pipeline pour des scénarios tels que le rendu dans une mémoire tampon de vertex, puis le dessin instantané des résultats sans interrompre le processeur. L’exemple suivant illustre l’allocation des mémoires tampons de vertex et de la mémoire tampon d’index, où vous pouvez voir que la description de la ressource diffère uniquement par les indicateurs de liaison de ressources GPU.

L’API Direct3D 10 a fourni des méthodes d’assistance de texture pour créer explicitement des ressources de type de texture, mais comme vous pouvez l’imaginer, il s’agit vraiment de fonctions d’assistance.

  • CreateTexture2D()
  • CreateTextureCube()
  • CreateTexture3D()

Lorsque vous ciblez Direct3D 10, il est probable que vous souhaitiez allouer plus d’éléments pendant la création de la ressource que vous n’en avez l’habitude avec Direct3D 9. Cela deviendra plus évident avec la création de mémoires tampons de cible de rendu et textures où vous devez également créer une vue pour accéder à la mémoire tampon et définir la ressource sur l’appareil.

Tutoriel 1 : Principes de base de Direct3D 10

Notes

Direct3D 10 et versions ultérieures de Direct3D étendent le format de fichier DDS pour prendre en charge les nouveaux formats DXGI, les tableaux de textures et les tableaux de mappage de cube. Pour plus d’informations sur l’extension de format de fichier DDS, consultez le Guide de programmation pour DDS.

 

Les vues

Une vue est une interface spécifiquement typée aux données stockées dans une mémoire tampon de pixels. Plusieurs vues peuvent être allouées à une ressource à la fois, et cette fonctionnalité est mise en surbrillance dans l’exemple De rendu à pas unique vers Cubemap contenu dans ce KIT SDK.

Page Guide du programmeur sur l’accès aux ressources

Exemple CubeMap

Accès aux ressources statiques et dynamiques

Pour de meilleures performances, les applications doivent partitionner leur utilisation des données en termes de nature statique et dynamique des données. Direct3D 10 a été conçu pour tirer parti de cette approche et, par conséquent, les règles d’accès aux ressources ont été considérablement renforcées par rapport à Direct3D 9. Pour les ressources statiques, vous devez idéalement remplir la ressource avec ses données au moment de la création. Si votre moteur a été conçu autour du point de conception Create, Lock, Fill, Unlock de Direct3D 9, vous pouvez différer le remplissage de l’heure de la création à l’aide d’une ressource intermédiaire et de la méthode UpdateSubResource sur l’interface de ressource.

Effets direct3D 10

L’utilisation du système d’effets Direct3D 10 n’entre pas dans le cadre de cet article. Le système a été écrit pour tirer pleinement parti des avantages architecturaux offerts par Direct3D 10. Pour plus d’informations sur son utilisation, consultez la section Effets (Direct3D 10 ).

HLSL sans effets

Le pipeline Direct3D 10 Shader peut être piloté sans utiliser le système d’effets Direct3D 10. Notez que dans cette instance, toutes les liaisons de mémoire tampon, de nuanceur, d’échantillonneur et de texture constante doivent être gérées par l’application elle-même. Pour plus d’informations, consultez l’exemple de lien et les sections suivantes de ce document :

Exemple HLSL sans effets

Compilation du nuanceur

Le compilateur HLSL Direct3D 10 apporte des améliorations à la définition du langage HLSL et peut donc fonctionner dans 2 modes. Pour une prise en charge complète des fonctions intrinsèques et de la sémantique de style Direct3D 9, la compilation doit être appelée à l’aide de l’indicateur MODE DE COMPATIBILITÉ qui peut être spécifié par compilation.

La sémantique et les fonctions intrinsèques du langage HLSL spécifiques au modèle de nuanceur 4.0 pour Direct3D 10 sont disponibles dans HLSL. Les changements majeurs dans la syntaxe de Direct3D 9 HLSL à prendre le plus en compte concernent le domaine de l’accès aux textures. La nouvelle syntaxe est la seule forme prise en charge par le compilateur en dehors du mode de compatibilité.

Notes

Les API de type compilateur Direct3D 10 (D3D10CompileShader et D3D10CompileEffectFromMemory) sont fournies par les runtimes Direct3D 10, 10.1 et 11 qui s’exécutent dans Windows Vista et versions ultérieures. Les API de type compilateur Direct3D 10 ont les mêmes fonctionnalités que le compilateur HLSL fourni dans le Kit de développement logiciel (SDK) DirectX (décembre 2006). Ce compilateur HLSL ne prend pas en charge les profils Direct3D 10.1 (vs_4_1, ps_4_1, gs_4_1, fx_4_1) et manque un certain nombre d’optimisations et d’améliorations. Vous pouvez obtenir un compilateur HLSL qui prend en charge les profils Direct3D 10.1 à partir de la dernière version héritée du SDK DirectX. Pour plus d’informations sur le Kit de développement logiciel (SDK) DirectX hérité, consultez Où se trouve le Kit de développement logiciel (SDK) DirectX ?. Vous pouvez obtenir la dernière version du compilateur de ligne de commande hlSL Fxc.exe et des API D3DCompiler à partir du Kit de développement logiciel (SDK) Windows.

 

Création de ressources de nuanceur

La création d’instances de nuanceur compilées en dehors du système d’effets Direct3D 10 s’effectue de manière très similaire à Direct3D 9, mais dans Direct3D 10, il est important de conserver la signature d’entrée du nuanceur pour une utilisation ultérieure. La signature est retournée par défaut dans le cadre de l’objet blob du nuanceur, mais peut être extraite pour réduire les besoins en mémoire si nécessaire. Pour plus d’informations, consultez Utilisation des nuanceurs dans Direct3D 10.

Interface de couche de réflexion du nuanceur

La couche de réflexion du nuanceur est l’interface par laquelle des informations sur les exigences du nuanceur peuvent être obtenues. Cela est particulièrement utile lors de la création de liaisons d’assembly d’entrée (voir ci-dessous) où vous devrez peut-être parcourir les exigences d’entrée du nuanceur pour vous assurer que vous fournissez la structure d’entrée correcte au nuanceur. Vous pouvez créer une instance de l’interface de couche de réflexion en même temps que la création d’un instance d’un nuanceur compilé.

La couche de réflexion du nuanceur remplace les méthodes D3DX9 qui fournissent des fonctionnalités similaires. Par exemple , IsParameterUsed est remplacé par la méthode GetDesc .

Dispositions de l’assembleur d’entrée - Liaison de nuanceur de vertex/flux d’entrée

L’assembleur d’entrée (IA) remplace la déclaration de flux de vertex de style Direct3D 9 et sa structure de description est très similaire dans la forme. La différence main que l’ia apporte est que l’objet de disposition IA créé doit être directement mappé à un format spécifique de signature d’entrée du nuanceur. L’objet de mappage créé pour lier le flux d’entrée au nuanceur peut être utilisé sur un nombre quelconque de nuanceurs où la signature d’entrée du nuanceur correspond à celle du nuanceur utilisé pour créer la disposition d’entrée.

Pour mieux piloter le pipeline avec des données statiques, vous devez prendre en compte les permutations du format de flux d’entrée en signatures d’entrée possibles du nuanceur, créer les instances d’objet de disposition IA le plus tôt possible et les réutiliser dans la mesure du possible.

Impact de la suppression du code mort du nuanceur

La section suivante détaille une différence significative entre Direct3D 9 et Direct3D 10 qui est susceptible de nécessiter une gestion minutieuse dans votre code de moteur. Les nuanceurs qui contiennent des expressions conditionnelles ont souvent certains chemins de code supprimés dans le cadre du processus de compilation. Dans Direct3D 9, deux types d’entrées peuvent être supprimés (marqués pour suppression) lorsqu’ils sont inutilisés : les entrées de signature (comme l’exemple ci-dessous) et les entrées constantes. Si la fin de la mémoire tampon constante contient des entrées inutilisées, la déclaration de taille dans le nuanceur reflète la taille de la mémoire tampon constante sans les entrées inutilisées à la fin. Ces deux types d’entrées restent dans des signatures ou des mémoires tampons constantes Direct3D 10 avec une exception spéciale dans le cas d’entrées constantes inutilisées à la fin d’une mémoire tampon constante. Cela peut avoir un impact sur le moteur lors de la gestion de nuanceurs volumineux et de la création de dispositions d’entrée. Les éléments supprimés par des optimisations de code mort dans le compilateur doivent toujours être déclarés dans la structure d’entrée. Cela est illustré par l'exemple suivant :

Exemple de structure d’entrée du nuanceur de vertex

struct VS_INPUT
{
float4 pos: SV_Position;
float2 uv1 : Texcoord1;
float2 uv2 : Texcoord2; *
};

* La suppression de code mort Direct3D 9 supprimerait la déclaration dans le nuanceur en raison de la suppression conditionnelle du code mort

float4x4  g_WorldViewProjMtx;
static const bool g_bLightMapped = false; // define a compile time constant

VS_INPUT main(VS_INPUT i) 
{
    VS_INPUT o;
    o.pos = mul( i.pos, g_WorldViewProjMtx);
    o.uv1 = i.uv1;
    if ( g_bLightMapped )
    {
        o.uv2 = i.uv2;
    }
    return o;
}

Vous pouvez également rendre encore plus évident que la constante est une constante de compilation avec la déclaration suivante :

#define LIGHT_MAPPED false

Dans l’exemple ci-dessus, sous Direct3D 9, l’élément uv2 est supprimé en raison d’optimisations de code mort dans le compilateur. Sous Direct3D 10, le code mort est toujours supprimé, mais la disposition de l’assembleur d’entrée du nuanceur nécessite que la définition des données d’entrée existe. La couche de réflexion du nuanceur fournit les moyens de gérer cette situation de manière générique, ce qui vous permet de parcourir les exigences d’entrée du nuanceur et de vous assurer de fournir une description complète du mappage de signature du flux d’entrée au nuanceur.

Voici un exemple de fonction pour détecter l’existence d’un nom/index sémantique dans une signature de fonction :

// Returns true if the SemanticName / SemanticIndex is used in the input signature.
// pReflector is a previously acquired shader reflection interface.
bool IsSignatureElementExpected(ID3D10ShaderReflection *pReflector, const LPCSTR SemanticName, UINT SemanticIndex)
{
    D3D10_SHADER_DESC               shaderDesc;
    D3D10_SIGNATURE_PARAMETER_DESC  paramDesc;

    Assert(pReflector);
    Assert(SemanticName);

    pReflector->GetDesc(&shaderDesc);

    for (UINT k=0; k<shaderDesc.InputParameters; k++)
    {
        pReflector->GetInputParameterDesc( k, &paramDesc);
        if (wcscmp( SemanticName, paramDesc.SemanticName)==0 && paramDesc.SemanticIndex == SemanticIndex) 
            return true;
    }

    return false;
}

Création d’objets d’état

Lors du portage du code du moteur, il peut être utile d’utiliser initialement un ensemble d’objets d’état par défaut et de désactiver tous les paramètres d’état/état de texture de l’appareil Direct3D 9. Cela entraîne des artefacts de rendu, mais il s’agit du moyen le plus rapide de mettre les choses en place et en cours d’exécution. Vous pourrez ensuite construire un système de gestion des objets d’état qui peut utiliser une clé composée pour permettre une réutilisation maximale du nombre d’objets d’état utilisés.

Portage des textures

Formats de fichier pris en charge

Les fonctions D3DXxxCreateXXX et D3DXxxSaveXXX qui créent ou enregistrent une texture à partir ou dans un fichier graphique (par exemple, D3DX10CreateTextureFromFile) prennent en charge un ensemble de formats de fichiers différents dans Direct3D 10 que dans Direct3D 9 :

Format de fichier Direct3D 9 Direct3D 10
.bmp x x
.jpg x x
.tga x
.png x x
.dds x x
.Ppm x
.dib x
.Hdr x
.Pfm x
.tiff x
.gif x
.tif x

 

Pour plus d’informations, comparez les énumérations D3DXIMAGE_FILEFORMAT Direct3D 9 avec les énumérations D3DX10_IMAGE_FILE_FORMAT pour Direct3D 10.

Notes

La bibliothèque d’utilitaires D3DX (D3DX 9, D3DX 10 et D3DX 11) est déconseillée pour Windows 8. Pour le traitement des fichiers de texture, nous vous recommandons d’utiliser DirectXTex.

 

Mappage des formats de texture

Le tableau suivant montre le mappage des formats de texture de Direct3D 9 à Direct3D 10. Tout contenu dans des formats non disponibles dans DXGI doit être converti par les routines de l’utilitaire.

Format Direct3D 9 Direct3D 10 Format
D3DFMT_UNKNOWN DXGI_FORMAT_UNKNOWN
D3DFMT_R8G8B8 Non disponible
D3DFMT_A8R8G8B8 DXGI_FORMAT_B8G8R8A8_UNORM & DXGI_FORMAT_B8G8R8A8_UNORM_SRGB¹
D3DFMT_X8R8G8B8 DXGI_FORMAT_B8G8R8X8_UNORM & DXGI_FORMAT_B8G8R8X8_UNORM_SRGB¹
D3DFMT_R5G6B5 DXGI_FORMAT_B5G6R5_UNORM²
D3DFMT_X1R5G5B5 Non disponible
D3DFMT_A1R5G5B5 DXGI_FORMAT_B5G5R5A1_UNORM²
D3DFMT_A4R4G4B4 DXGI_FORMAT_B4G4R4A4_UNORM³
D3DFMT_R3G3B2 Non disponible
D3DFMT_A8 DXGI_FORMAT_A8_UNORM
D3DFMT_A8R3G3B2 Non disponible
D3DFMT_X4R4G4B4 Non disponible
D3DFMT_A2B10G10R10 DXGI_FORMAT_R10G10B10A2
D3DFMT_A8B8G8R8 DXGI_FORMAT_R8G8B8A8_UNORM & DXGI_FORMAT_R8G8B8A8_UNORM_SRGB
D3DFMT_X8B8G8R8 Non disponible
D3DFMT_G16R16 DXGI_FORMAT_R16G16_UNORM
D3DFMT_A2R10G10B10 Non disponible
D3DFMT_A16B16G16R16 DXGI_FORMAT_R16G16B16A16_UNORM
D3DFMT_A8P8 Non disponible
D3DFMT_P8 Non disponible
D3DFMT_L8 DXGI_FORMAT_R8_UNORM Remarque : Utilisez .r swizzle dans le nuanceur pour dupliquer le rouge vers d’autres composants afin d’obtenir le comportement D3D9.
D3DFMT_A8L8 DXGI_FORMAT_R8G8_UNORM remarque : Utilisez swizzle .rrrg dans le nuanceur pour dupliquer le rouge et déplacer le vert vers les composants alpha pour obtenir le comportement D3D9.
D3DFMT_A4L4 Non disponible
D3DFMT_V8U8 DXGI_FORMAT_R8G8_SNORM
D3DFMT_L6V5U5 Non disponible
D3DFMT_X8L8V8U8 Non disponible
D3DFMT_Q8W8V8U8 DXGI_FORMAT_R8G8B8A8_SNORM
D3DFMT_V16U16 DXGI_FORMAT_R16G16_SNORM
D3DFMT_W11V11U10 Non disponible
D3DFMT_A2W10V10U10 Non disponible
D3DFMT_UYVY Non disponible
D3DFMT_R8G8_B8G8 DXGI_FORMAT_G8R8_G8B8_UNORM (dans DX9, les données ont été mises à l’échelle de 255,0f, mais cela peut être géré dans le code du nuanceur).
D3DFMT_YUY2 Non disponible
D3DFMT_G8R8_G8B8 DXGI_FORMAT_R8G8_B8G8_UNORM (dans DX9, les données ont été mises à l’échelle de 255.0f, mais cela peut être géré dans le code du nuanceur).
D3DFMT_DXT1 DXGI_FORMAT_BC1_UNORM & DXGI_FORMAT_BC1_UNORM_SRGB
D3DFMT_DXT2 & DXGI_FORMAT_BC1_UNORM DXGI_FORMAT_BC1_UNORM_SRGB Remarque : DXT1 et DXT2 sont identiques du point de vue de l’API/du matériel... la seule différence était « alpha prémultiplié », qui peut être suivi par une application et n’a pas besoin d’un format distinct.
D3DFMT_DXT3 DXGI_FORMAT_BC2_UNORM & DXGI_FORMAT_BC2_UNORM_SRGB
D3DFMT_DXT4 & DXGI_FORMAT_BC2_UNORM DXGI_FORMAT_BC2_UNORM_SRGB Remarque : DXT3 et DXT4 sont identiques du point de vue de l’API/du matériel... la seule différence était « alpha prémultiplié », qui peut être suivi par une application et n’a pas besoin d’un format distinct.
D3DFMT_DXT5 DXGI_FORMAT_BC3_UNORM & DXGI_FORMAT_BC3_UNORM_SRGB
D3DFMT_D16 & D3DFMT_D16_LOCKABLE DXGI_FORMAT_D16_UNORM
D3DFMT_D32 Non disponible
D3DFMT_D15S1 Non disponible
D3DFMT_D24S8 Non disponible
D3DFMT_D24X8 Non disponible
D3DFMT_D24X4S4 Non disponible
D3DFMT_D16 DXGI_FORMAT_D16_UNORM
D3DFMT_D32F_LOCKABLE DXGI_FORMAT_D32_FLOAT
D3DFMT_D24FS8 Non disponible
D3DFMT_S1D15 Non disponible
D3DFMT_S8D24 DXGI_FORMAT_D24_UNORM_S8_UINT
D3DFMT_X8D24 Non disponible
D3DFMT_X4S4D24 Non disponible
D3DFMT_L16 remarque DXGI_FORMAT_R16_UNORM : utilisez .r swizzle dans le nuanceur pour dupliquer le rouge vers d’autres composants afin d’obtenir le comportement D3D9.
D3DFMT_INDEX16 DXGI_FORMAT_R16_UINT
D3DFMT_INDEX32 DXGI_FORMAT_R32_UINT
D3DFMT_Q16W16V16U16 DXGI_FORMAT_R16G16B16A16_SNORM
D3DFMT_MULTI2_ARGB8 Non disponible
D3DFMT_R16F DXGI_FORMAT_R16_FLOAT
D3DFMT_G16R16F DXGI_FORMAT_R16G16_FLOAT
D3DFMT_A16B16G16R16F DXGI_FORMAT_R16G16B16A16_FLOAT
D3DFMT_R32F DXGI_FORMAT_R32_FLOAT
D3DFMT_G32R32F DXGI_FORMAT_R32G32_FLOAT
D3DFMT_A32B32G32R32F DXGI_FORMAT_R32G32B32A32_FLOAT
D3DFMT_CxV8U8 Non disponible
D3DDECLTYPE_FLOAT1 DXGI_FORMAT_R32_FLOAT
D3DDECLTYPE_FLOAT2 DXGI_FORMAT_R32G32_FLOAT
D3DDECLTYPE_FLOAT3 DXGI_FORMAT_R32G32B32_FLOAT
D3DDECLTYPE_FLOAT4 DXGI_FORMAT_R32G32B32A32_FLOAT
D3DDECLTYPED3DCOLOR Non disponible
D3DDECLTYPE_UBYTE4 DXGI_FORMAT_R8G8B8A8_UINT Remarque : Le nuanceur obtient les valeurs UINT, mais si des floats intégraux de style Direct3D 9 sont nécessaires (0,0f, 1.0f... 255.f), UINT peut simplement être converti en float32 dans le nuanceur.
D3DDECLTYPE_SHORT2 DXGI_FORMAT_R16G16_SINT remarque : Le nuanceur obtient les valeurs SINT, mais si des floats intégraux de style Direct3D 9 sont nécessaires, SINT peut simplement être converti en float32 dans le nuanceur.
D3DDECLTYPE_SHORT4 DXGI_FORMAT_R16G16B16A16_SINT Remarque : Le nuanceur obtient les valeurs SINT, mais si des floats intégraux de style Direct3D 9 sont nécessaires, SINT peut simplement être converti en float32 dans le nuanceur.
D3DDECLTYPE_UBYTE4N DXGI_FORMAT_R8G8B8A8_UNORM
D3DDECLTYPE_SHORT2N DXGI_FORMAT_R16G16_SNORM
D3DDECLTYPE_SHORT4N DXGI_FORMAT_R16G16B16A16_SNORM
D3DDECLTYPE_USHORT2N DXGI_FORMAT_R16G16_UNORM
D3DDECLTYPE_USHORT4N DXGI_FORMAT_R16G16B16A16_UNORM
D3DDECLTYPE_UDEC3 Non disponible
D3DDECLTYPE_DEC3N Non disponible
D3DDECLTYPE_FLOAT16_2 DXGI_FORMAT_R16G16_FLOAT
D3DDECLTYPE_FLOAT16_4 DXGI_FORMAT_R16G16B16A16_FLOAT
FourCC 'ATI1' DXGI_FORMAT_BC4_UNORM
FourCC 'ATI2' DXGI_FORMAT_BC5_UNORM

 

¹DXGI 1.1, qui est inclus dans le runtime Direct3D 11, inclut les formats BGRA. Toutefois, la prise en charge de ces formats est facultative pour les appareils Direct3D 10 et 10.1 avec des pilotes implémentés dans le modèle de pilote d’affichage Windows (WDDM) pour Windows Vista (WDDM 1.0). Envisagez plutôt d’utiliser DXGI_FORMAT_R8G8B8A8_UNORM. Vous pouvez également créer votre appareil avec D3D10_CREATE_DEVICE_BGRA_SUPPORT pour vous assurer que vous ne prenez en charge que les ordinateurs avec le runtime Direct3D 11.0 et un pilote WDDM 1.1 ou version ultérieure installé.

²DXGI 1.0 définissait les formats 5:6:5 et 5:5:5:1, mais ils n’étaient pas pris en charge par le runtime Direct3D 10.x ou Direct3D 11.0. Ces formats sont éventuellement pris en charge avec DXGI 1.2 dans le runtime DirectX 11.1, qui est requis pour les cartes vidéo de niveau de fonctionnalité 11.1 et les pilotes WDDM 1.2 (modèle de pilote d’affichage commençant par Windows 8) et déjà pris en charge sur les niveaux de fonctionnalités 10level9.

³DXGI 1.2 introduit le format 4:4:4:4. Ce format est éventuellement pris en charge dans le runtime DirectX 11.1, qui est requis pour les cartes vidéo de niveau de fonctionnalité 11.1 et les pilotes WDDM 1.2, et déjà pris en charge sur les niveaux de fonctionnalités 10level9.

Pour les formats non compressés, DXGI a limité la prise en charge des modèles de format de pixels arbitraires ; tous les formats non compressés doivent être de type RVBA. Cela peut nécessiter un basculement des formats de pixels des ressources existantes, que nous vous recommandons de calculer en tant que pass de pré-processus hors connexion dans la mesure du possible.

Portage des nuanceurs

Les nuanceurs Direct3D 10 sont créés dans HLSL

Direct3D 10 limite l’utilisation du langage d’assembly uniquement à des fins de débogage. Par conséquent, tous les nuanceurs d’assembly écrits à la main utilisés dans Direct3D 9 devront être convertis en HLSL.

Signatures et liaison du nuanceur

Nous avons discuté des conditions requises pour la liaison d’assembly d’entrée aux signatures d’entrée du nuanceur de vertex plus haut dans ce document (voir ci-dessus). Notez que le runtime Direct3D 10 a également renforcé les exigences en matière de liaison de phase à étape entre les nuanceurs. Cette modification affecte les sources du nuanceur où la liaison entre les étapes n’a peut-être pas été entièrement décrite sous Direct3D 9. Exemple :

VS_OUTPUT                       PS_INPUT
float4   pos : SV_POSITION;     float4 pos : SV_POSITION;
float4   uv1 : TEXCOORD1;       float4 uv1 : TEXCOORD1;
float4x3 tangentSp : TEXCOORD2; float4 tangent : TEXCOORD2; *
float4   Color : TEXCOORD6;     float4 color : TEXCOORD6;

* Vs rompu - Liaison PS : même si le nuanceur de pixels n’est peut-être pas intéressé par la matrice complète, la liaison doit spécifier le float4x3 complet.

Notez que la sémantique de liaison entre les étapes doit correspondre exactement, mais les entrées des étapes cibles peuvent être un préfixe des valeurs en cours de sortie. Dans l’exemple ci-dessus, le nuanceur de pixels pouvait avoir position et texcoord1 comme seules entrées, mais il ne pouvait pas avoir la position et texcoord2 comme seules entrées en raison des contraintes de classement.

Liaisons de phase HLSL Shader

La liaison entre les nuanceurs peut se produire à l’un des points suivants du pipeline :

  • Assembleur d’entrée vers le nuanceur de vertex
  • Nuanceur de vertex en nuanceur de pixels
  • Nuanceur de vertex en nuanceur de géométrie
  • Nuanceur de vertex pour diffuser la sortie
  • Nuanceur de géométrie en nuanceur de pixels
  • Nuanceur de géométrie à diffuser en continu

Mémoires tampons constantes

Pour faciliter le portage du contenu à partir de Direct3D 9, une approche initiale de la gestion constante en dehors du système Effects peut impliquer la création d’une mémoire tampon constante unique contenant toutes les constantes requises. Il est important pour les performances de classer les constantes dans les mémoires tampons selon la fréquence de mise à jour attendue. Cette organization réduit au minimum la quantité de jeux de constantes redondants.

Plans de clip utilisateur dans HLSL au niveau de fonctionnalité 9 et supérieur

À compter de Windows 8, vous pouvez utiliser l’attribut de fonction clipplanes dans une déclaration de fonction HLSL plutôt que SV_ClipDistance pour que votre nuanceur fonctionne au niveau de la fonctionnalité 9_x ainsi qu’au niveau de fonctionnalité 10 et supérieur. Pour plus d’informations, consultez Plans de clip utilisateur sur le matériel de niveau de fonctionnalité 9.

Différences supplémentaires de Direct3D 10 à surveiller

Entiers en tant qu’entrée

Dans Direct3D 9, il n’y avait aucune prise en charge matérielle réelle pour les types de données entiers, mais le matériel Direct3D 10 prend en charge les types entiers explicites. Si vous avez des données à virgule flottante dans votre mémoire tampon de vertex, vous devez disposer d’une entrée float. Sinon, un type entier sera la représentation du modèle de bits de la valeur à virgule flottante. Un type entier n’est pas autorisé pour une entrée de nuanceur de pixels, sauf si la valeur n’est marquée pour aucune interpolation (voir Modificateurs d’interpolation).

Curseurs de souris

Sur les versions précédentes de Windows, les routines de curseur de souris GDI standard ne fonctionnaient pas correctement sur tous les appareils exclusifs plein écran. Les API SetCursorProperties, ShowCursor et SetCursorPosition ont été ajoutées pour gérer ces cas. Étant donné que la version de GDI de Windows Vista comprend parfaitement les surfaces DXGI , il n’est pas nécessaire d’utiliser cette API de curseur de souris spécialisée. Il n’y a donc pas d’équivalent Direct3D 10. Les applications Direct3D 10 doivent utiliser les routines de curseur de souris GDI standard pour les curseurs de souris.

Mappage de Texels à des pixels dans Direct3D 10

Dans Direct3D 9, les centres de texel et les centres de pixels étaient séparés d’une demi-unité (voir Mappage direct de texels à pixels (Direct3D 9)). Dans Direct3D 10, les centres de texel sont déjà à demi-unités, il n’est donc pas nécessaire de déplacer les coordonnées de vertex.

Le rendu des quads plein écran est plus simple avec Direct3D 10. Les quads plein écran doivent être définis dans l’espace clipspace (-1,1) et simplement passés par le nuanceur de vertex sans aucune modification. De cette façon, il n’est pas nécessaire de recharger votre mémoire tampon de vertex chaque fois que la résolution de l’écran change, et il n’y a pas de travail supplémentaire dans le nuanceur de pixels pour manipuler les coordonnées de texture.

Modifications du comportement du comptage des références

Contrairement aux versions précédentes de Direct3D, les différentes fonctions Set ne contiennent pas de référence aux objets d’appareils. Cela signifie que l’application doit s’assurer qu’elle contient une référence sur l’objet tant qu’elle souhaite que cet objet soit lié au pipeline. Lorsque le nombre de références de l’objet passe à zéro, l’objet est déconnecté du pipeline à mesure qu’il est détruit. Ce style de conservation de référence est également appelé conservation de référence faible. Par conséquent, chaque emplacement de liaison sur l’objet Device contient une référence faible à l’interface/objet. Sauf mention contraire explicite, ce comportement doit être assumé pour toutes les méthodes Set. Chaque fois que la destruction d’un objet entraîne la définition d’un point de liaison sur NULL , la couche Debug émet un avertissement. Notez que les appels à des méthodes Get d’appareil telles que OMGetRenderTargets augmenteront le nombre de références d’objets retournés.

Niveau coopératif de test

Les fonctionnalités de l’API Direct3D 9 TestCooperativeLevel sont analogues à la définition du DXGI_PRESENT_TEST lors de l’appelde Présent.

StretchRect

Une fonction similaire à la méthode IDirect3DDevice9::StretchRect direct3D 9 n’est pas disponible dans Direct3D 10 et 10.1. Pour copier des surfaces de ressources, utilisez ID3D10Device::CopySubresourceRegion. Pour les opérations de redimensionnement, effectuez un rendu sur une texture à l’aide du filtrage de texture. Pour convertir des surfaces MSAA en surfaces non-MSAA, utilisez ID3D10Device::ResolveSubresource.

Différences supplémentaires de Direct3D 10.1

Windows Vista avec Service Pack 1 (SP1) a inclus une mise à jour mineure vers Direct3D 10 et Direct3D 10.1, qui a exposé les fonctionnalités matérielles supplémentaires suivantes :

  • NUANCEURS MSAA par exemple
  • Lecture en profondeur MSAA
  • Modes de fusion indépendants par cible de rendu
  • Tableaux de mappages de cube
  • Rendu aux formats compressés par bloc (BC)

La mise à jour Direct3D 10.1 a ajouté la prise en charge des nouvelles interfaces suivantes, qui sont dérivées des interfaces existantes :

La mise à jour Direct3D 10.1 incluait également les structures supplémentaires suivantes :

L’API Direct3D 10.1 inclut un nouveau concept nommé niveau de fonctionnalité. Ce concept signifie que vous pouvez utiliser l’API Direct3D 10.1 pour piloter du matériel Direct3D 10.0 (D3D10_FEATURE_LEVEL_10_0) ou Direct3D 10.1 (D3D10_FEATURE_LEVEL_10_1). Étant donné que l’API Direct3D 10.1 est dérivée des interfaces Direct3D 10, les applications peuvent créer un appareil Direct3D 10.1, puis l’utiliser en tant qu’appareil Direct3D 10.0, sauf si de nouvelles fonctionnalités spécifiques à la version 10.1 sont nécessaires (à condition que le D3D10_FEATURE_LEVEL_10_1 niveau de fonctionnalité soit présent et prend en charge ces fonctionnalités).

Notes

Les appareils Direct3D 10.1 peuvent utiliser les profils de nuanceur HLSL 10.0 existants (vs_4_0, ps_4_0, gs_4_0) et les nouveaux profils 10.1 (vs_4_1, ps_4_1, gs_4_1) avec des instructions et des fonctionnalités HLSL supplémentaires.

 

Windows 7 contenait une mise à jour mineure de l’API Direct3D 10.1 incluse dans le runtime Direct3D 11. Cette mise à jour ajoute la prise en charge des niveaux de fonctionnalités suivants :

Windows 7 a également ajouté la prise en charge de Direct3D 10.1 pour Windows Advanced Rasterization Platform (WARP). Vous pouvez spécifier un pilote WARP à l’aide de D3D10_DRIVER_TYPE_WARP.

Pour plus d’informations sur Direct3D 10.1, consultez Fonctionnalités Direct3D 10.1 et énumération D3D10_FEATURE_LEVEL1 .

Guide de programmation pour Direct3D 10