> ## Documentation Index > Fetch the complete documentation index at: https://devdocs.xbox.com/llms.txt > Use this file to discover all available pages before exploring further. # Utilisation de DXC.exe et de l'interface .dll dxcompiler > Utilisation de DXC.exe et de l'interface .dll dxcompiler DXC prend en charge une interface en ligne de commande (dxc.exe) et une interface .dll (dxcompiler.dll, dxcompiler.lib, dxcapi.h et d3d12shader.h). * [Binaires du compilateur](#binaries) * [Interface en ligne de commande de DXC](#commandline) * [Hachage du nuanceur](#shaderhash) * [Réflexion](#reflection) * [PDBs](#PDBs) * [Interface DLL de DXCompiler](#dllinterface) * [Utilisation d'allocateurs personnalisés](#usingcustomallocators) * [Extensions de l'interface DLL pour XBOX](#usinginterfacexbox) ## Binaires du compilateur Pour Windows, les derniers binaires du compilateur peuvent être téléchargés depuis GitHub. Nous recommandons de toujours effectuer la mise à jour vers la [dernière version](https://github.com/microsoft/DirectXShaderCompiler/releases). Pour XBOX, les binaires sont installés avec le Microsoft Game Development Kit (GDK) et sont versionnés à chaque version. Notez que pour les .dll et les en-têtes, la convention de nommage « \_x » est utilisée pour XBOX One et la convention « \_xs » pour XBOX Series X|S. Windows ```text theme={null} dxc_\dxc.exe dxc_\dxcompiler.dll dxc_\dxcapi.h dxc_\d3d12shader.h dxc_\dxcompiler.lib ``` Outils PC pour XBOX One ```text theme={null} Microsoft GDK\\GXDK\bin\XboxOne\dxc.exe Microsoft GDK\\GXDK\bin\XboxOne\dxcompiler_x.dll Microsoft GDK\\GXDK\toolKit\Include\XboxOne\dxcapi_x.h Microsoft GDK\\GXDK\toolKit\Include\XboxOne\d3d12shader_x.h Microsoft GDK\\GXDK\toolKit\lib\amd64\XboxOne\dxcompiler_x.lib ``` Runtime de la console XBOX One ```text theme={null} Microsoft GDK\\GXDK\gameKit\Include\XboxOne\dxcapi_x.h Microsoft GDK\\GXDK\gameKit\Include\XboxOne\d3d12shader_x.h Microsoft GDK\\GXDK\gameKit\lib\amd64\XboxOne\dxcompiler_x.lib ``` Outils PC pour XBOX Series X|S ```text theme={null} Microsoft GDK\\GXDK\bin\Scarlett\dxc.exe Microsoft GDK\\GXDK\bin\Scarlett\dxcompiler_xs.dll Microsoft GDK\\GXDK\toolKit\Include\Scarlett\dxcapi_xs.h Microsoft GDK\\GXDK\toolKit\Include\Scarlett\d3d12shader_xs.h Microsoft GDK\\GXDK\toolKit\lib\amd64\Scarlett\dxcompiler_xs.lib ``` Runtime de la console XBOX Series X|S ```text theme={null} Microsoft GDK\\GXDK\gameKit\Include\Scarlett\dxcapi_xs.h Microsoft GDK\\GXDK\gameKit\Include\Scarlett\d3d12shader_xs.h Microsoft GDK\\GXDK\gameKit\lib\amd64\Scarlett\dxcompiler_xs.lib ``` L'utilisation d'un compilateur conçu et testé pour une plateforme donnée afin de compiler des nuanceurs pour une autre plateforme n'est pas prise en charge. ## Interface en ligne de commande de DXC La liste complète des indicateurs de ligne de commande s'obtient en exécutant `dxc.exe -?`. Si vous connaissez FXC, de nombreux arguments de ligne de commande sont identiques. Voici quelques indicateurs courants. ```text theme={null} -D Define macro. -E Entry point name. -Fd Write debug information to the specified file or directory; trail \ to autogenerate. -Fo Output object file. -Gec Enable backward compatibility mode. -HV HLSL version (2016, 2017, 2018). Default is 2018. -Od Disable optimizations. -T Set target profile. : ps_6_0, ps_6_1, ps_6_2, ps_6_3, ps_6_4, vs_6_0, vs_6_1, vs_6_2, vs_6_3, vs_6_4, cs_6_0, cs_6_1, cs_6_2, cs_6_3, cs_6_4, gs_6_0, gs_6_1, gs_6_2, gs_6_3, gs_6_4, ds_6_0, ds_6_1, ds_6_2, ds_6_3, ds_6_4, hs_6_0, hs_6_1, hs_6_2, hs_6_3, hs_6_4, lib_6_3, lib_6_4 -Vd Disable validation. -Zi Enable debug information. -Zpc Pack matrices in column-major order. -Zpr Pack matrices in row-major order. ``` DXC a été mis à jour pour ne plus incorporer par défaut le fichier .pdb (base de données de programme/informations de débogage) dans le nuanceur. Par défaut, les .pdb sont externes. `dxc.exe -?` indique aussi de quelle variante du compilateur il s'agit : « HLSL Compiler for Windows », « HLSL Compiler for XBOX One » ou « HLSL Compiler for XBOX Series X|S ». Voici un exemple d'utilisation de l'interface en ligne de commande. ```text theme={null} dxc -E main -T ps_6_0 -Fo myshader.bin -Zi -Fd myshader.pdb -D MYDEFINE=1 myshader.hlsl ``` Dans cet exemple, myshader.hlsl est compilé en nuanceur de pixels du modèle de nuanceur 6.0. Le nuanceur compilé est écrit dans myshader.bin, comme spécifié par l'indicateur `-Fo`. Les informations de débogage sont activées avec l'indicateur `-Zi`, et le .pdb est écrit dans myshader.pdb avec l'indicateur `-Fd`. Si vous préférez que le compilateur génère automatiquement un nom de .pdb, vous pouvez fournir `.\` comme argument de `-Fd`. Là encore, les informations de débogage du PDB ne sont pas incorporées dans le nuanceur. De plus, sur XBOX, une signature racine doit être fournie pour précompiler le nuanceur. ## Hachage du nuanceur Le hachage du nuanceur peut être enregistré dans un fichier à l'aide de l'indicateur de ligne de commande `-Fsh`. Avec l'interface .dll, il est toujours disponible par `IDxcResult::GetOutput`. Sur Windows, la valeur est déterminée par le hachage du DXIL du nuanceur. Sur XBOX, le hachage dépend du type de compilation demandé. * Si la précompilation est désactivée, le hachage porte sur le DXIL du nuanceur. * Si la précompilation est activée, le hachage porte sur le nuanceur précompilé. Pour les nuanceurs précompilés, le hachage diffère selon que le DXIL est supprimé ou non, car les nuanceurs qui incluent le DXIL prennent en charge la compilation à l'exécution (si nécessaire), contrairement aux nuanceurs dont le DXIL a été supprimé. ## Réflexion Par défaut, les données de réflexion sont stockées dans le nuanceur. L'indicateur `-Qstrip_reflect` permet de les supprimer. L'indicateur `-Fre` permet maintenant d'enregistrer vos données de réflexion dans un fichier distinct, et ce fichier est enregistré même si `-Qstrip_reflect` est utilisé. De même, `IDxcResult::GetOutput` permet d'obtenir le blob de réflexion distinct, même si `-Qstrip_reflect` est utilisé. `IDxcUtils::CreateReflection` peut créer une interface de réflexion à partir de ces blobs de réflexion distincts. ## PDBs Lorsque votre nuanceur est compilé, le nom de fichier .pdb (fourni avec l'option `-Fd`) et un hachage du nuanceur sont stockés dans le nuanceur. PIX utilise ces informations pour trouver le .pdb du nuanceur. Sur XBOX, si vous sérialisez vos nuanceurs, seul le hachage du nuanceur est conservé. Dans ce cas, il est préférable d'utiliser l'option `-Fd .\` pour utiliser le hachage du nuanceur comme nom de .pdb, afin que PIX puisse facilement trouver votre pdb. Si, pour une raison quelconque, vous devez charger un .pdb portant un autre nom, vous pouvez le charger manuellement dans PIX. ### .pdb allégés Un nouvel indicateur de compilation, « -Zs », crée un nouveau type de .pdb beaucoup plus petit que les .pdb traditionnels, qui réduit le temps de compilation lorsque des .pdb sont générés. Ces .pdb « allégés » ne contiennent que le code source et les arguments de compilation utilisés pour générer le nuanceur. PIX génère « à la demande » les informations de débogage supplémentaires nécessaires lors du débogage du nuanceur. Notez que les .pdb complets (qui contiennent tout ce que contient un .pdb allégé, plus les informations de débogage complètes utilisées par le débogueur) sont toujours pris en charge avec l'indicateur « -Zi ». ### Remarque sur le versionnage du compilateur. Lorsqu'un .pdb est généré, la version du compilateur y est stockée afin que PIX sache quel compilateur a été utilisé à l'origine pour compiler le nuanceur. PIX signale si le compilateur actuellement associé à PIX ne correspond pas à celui utilisé pour générer le nuanceur, et le compilateur correspondant peut être fourni si vous le voulez. ### Nouvelle interface pdb. Une nouvelle interface appelée IDxcPdbUtils a été introduite dans dxcapi.h. Cette interface vous permet d'inspecter le code source, les arguments de compilation, la version du compilateur et le hachage, et de recompiler le nuanceur à partir du pdb si vous le voulez. ### .pdb pour le lancer de rayons (préversion) Une prise en charge limitée des .pdb pour le lancer de rayons est maintenant activée. Pour utiliser cette fonctionnalité, compilez les bibliothèques de lancer de rayons avec les indicateurs -Zi -Qembed\_debug. Pour la création de RTPSO hors ligne côté PC comme pour la création de RTPSO à l'exécution, utilisez le nouvel appel ID3D12Device8::SetCompileTimeShaderPdbPathX pour spécifier l'emplacement du PDB. Si ce chemin est défini, le pilote stocke un fichier .pdb associé à chaque RTPSO. PIX peut ensuite charger et utiliser les .pdb générés. Vous pouvez aussi générer des .pdb allégés de lancer de rayons et les enregistrer dans des fichiers .pdb individuels au lieu de les incorporer dans les nuanceurs, à l'aide des indicateurs -Zs -Fd. L'utilisation de l'API ID3D12Device8::SetCompileTimeShaderPdbPathX reste pour l'instant nécessaire pour créer le .pdb de l'objet d'état de lancer de rayons. PIX peut utiliser les multiples .pdb de bibliothèque du RTPSO pour afficher l'intégralité du code source des nuanceurs. Pour plus de renseignements, consultez la documentation [PDB des nuanceurs dans PIX](/fr-CA/tools/tools-console/pix/gpu/pix-shader-pdbs). ## Interface DLL de DXCompiler Les informations suivantes s'appliquent aux variantes du compilateur pour Windows, XBOX One et XBOX Series X|S. Nous omettrons toute mention de « \_x » et « \_xs » lorsqu'elle n'est pas nécessaire, mais les informations s'appliquent aux trois plateformes. Pour utiliser l'interface .dll, incluez dxcapi.h et d3d12shader.h, et liez votre code à la bibliothèque dxcompiler.lib ou chargez directement dxcompiler.dll. Le chargement et le déchargement manuels d'autres .dll requises par le compilateur ne sont pas pris en charge. Nous vous recommandons de laisser la .dll chargée pendant toute la durée de vie de votre programme plutôt que de la charger et de la décharger pour chaque compilation de nuanceur. Une fois la .dll du compilateur chargée, appelez `DxcCreateInstance` pour créer les différentes interfaces du compilateur. L'appel à `DxcCreateInstance` est thread-safe, mais les objets créés par `DxcCreateInstance` ne le sont pas. Les objets du compilateur doivent être créés puis utilisés sur le même thread. ### Compilation multiplateforme Si vous choisissez de créer un seul exécutable qui compile pour plusieurs plateformes, vous ne pouvez lier votre code à aucune des bibliothèques dxcompiler. Vous devez charger directement les différentes .dll et obtenir l'adresse de la fonction `DxcCreateInstance` de chacune. Les objets créés pour une plateforme cible du compilateur ne peuvent en aucun cas être utilisés avec un objet créé pour une autre plateforme cible. Les en-têtes « \_xs » peuvent être utilisés, mais toutes les fonctionnalités ne sont pas entièrement prises en charge sur les trois plateformes. Il faut aussi veiller à ce que les .dll chargées par dxcompiler.dll soient correctement gérées. ```cpp theme={null} SetDefaultDllDirectories(LOAD_LIBRARY_SEARCH_DEFAULT_DIRS); const WCHAR* szWindowCompilerPath = L"C:\\LatestDxcCompiler"; const WCHAR* szXboxCompilerPath = L"C:\\Program Files (x86)\\Microsoft GDK\\191100\\GXDK\\bin\\XboxOne"; const WCHAR* szScarlettCompilerPath = L"C:\\Program Files (x86)\\Microsoft GDK\\191100\\GXDK\\bin\\Scarlett"; // Make sure .dll dependencies are handled correctly. AddDllDirectory(szWindowCompilerPath); AddDllDirectory(szXboxCompilerPath); AddDllDirectory(szScarlettCompilerPath); // Load the .dlls. HMODULE hModuleDxcWindows = LoadLibraryEx(L"dxcompiler.dll", NULL, 0); HMODULE hModuleDxcXbox = LoadLibraryEx(L"dxcompiler_x.dll", NULL, 0); HMODULE hModuleDxcScarlett = LoadLibraryEx(L"dxcompiler_xs.dll", NULL, 0); // Get the create interface functions for each platform. decltype(&DxcCreateInstance) m_pfnDxcCreateInstanceWindows = (decltype(&DxcCreateInstance))GetProcAddress(hModuleDxcWindows, "DxcCreateInstance"); decltype(&DxcCreateInstance) m_pfnDxcCreateInstanceXbox = (decltype(&DxcCreateInstance))GetProcAddress(hModuleDxcXbox, "DxcCreateInstance"); decltype(&DxcCreateInstance) m_pfnDxcCreateInstanceScarlett = (decltype(&DxcCreateInstance))GetProcAddress(hModuleDxcScarlett, "DxcCreateInstance"); ``` ### Utilisation de l'interface du compilateur Nous vous recommandons d'utiliser la dernière interface `IDxcCompiler3` pour tirer parti des fonctionnalités les plus récentes, notamment la possibilité de spécifier davantage d'arguments, comme en ligne de commande, les blobs nommés et l'accès direct au hachage du nuanceur. Si vous effectuez un portage depuis `IDxcCompiler2`, vous pouvez utiliser `IDxcUtils::BuildArguments` si vous préférez une interface similaire à `IDxcCompiler::Compile` ou `IDxcCompiler2::CompileWithDebug`. Bien que l'interface IDxcCompiler3::Compile ressemble à l'interface en ligne de commande, les arguments sont passés sous forme de chaînes individuelles. De plus, les guillemets utilisés en ligne de commande pour regrouper des arguments contenant des espaces en un seul argument peuvent être omis, et les séquences d'échappement requises pour les caractères spéciaux de la ligne de commande ne sont pas nécessaires. | Ligne de commande | Chaîne d'argument IDxcCompiler3::Compile incorrecte | Chaîne d'argument IDxcCompiler3::Compile correcte | | - | - | - | | -E main | L"-E main" | L"-E", L"main" | | -Fd "my filename with spaces.pdb" | L"-Fd", L""my filename with spaces.pdb"" | L"-Fd", L"my filename with spaces.pdb" | | this^\&that" | L"this^\&that" | L"this\&that" | | -D MY\_CONSTANT=2.2 | L"-D MY\_CONSTANT=2.2" | L"-D", L"MY\_CONSTANT=2.2" | | -D "MY\_CODE= 2 + 2" | L"-D "MY\_CODE= 2 + 2"" | L"-D", L"MY\_CODE= 2 + 2" | | -D \_\_XBOX\_DX12\_ROOT\_SIGNATURE=""CBV(b0), CBV(b1)"" | L"-D \_\_XBOX\_DX12\_ROOT\_SIGNATURE="CBV(b0), CBV(b1)"" | L"-D", L"\_\_XBOX\_DX12\_ROOT\_SIGNATURE="CBV(b0), CBV(b1)"" | L'exemple de code suivant utilise l'interface pour compiler myshader.hlsl tout en générant un .pdb. Le flux général consiste à appeler `IDxcCompiler3::Compile`, puis à examiner `IDxcResult` pour obtenir le tampon d'erreurs, le nuanceur compilé, le .pdb et le hachage du nuanceur. Le nom du .pdb doit être transmis à la fonction `Compile` à l'aide de l'argument `-Fd`. Comme en ligne de commande, `-Fd .\` peut être utilisé pour que le compilateur génère automatiquement le nom du PDB. Si le nom du PDB est généré automatiquement, vous devez utiliser ce nom pour enregistrer votre fichier .pdb afin que PIX puisse le trouver. Dans l'exemple suivant, la vérification courante des erreurs a été omise par souci de concision. ```cpp theme={null} #include // Common COM helpers. #include // Be sure to link with dxcompiler_x.lib. #include // Shader reflection. int main() { // // Create compiler and utils. // CComPtr pUtils; CComPtr pCompiler; DxcCreateInstance(CLSID_DxcUtils, IID_PPV_ARGS(&pUtils)); DxcCreateInstance(CLSID_DxcCompiler, IID_PPV_ARGS(&pCompiler)); // // Create default include handler. (You can create your own...) // CComPtr pIncludeHandler; pUtils->CreateDefaultIncludeHandler(&pIncludeHandler); // // COMMAND LINE: dxc myshader.hlsl -E main -T ps_6_0 -Zs -D MYDEFINE=1 -Fo myshader.bin -Fd myshader.pdb -D __XBOX_STRIP_DXIL -Qstrip_reflect // LPCWSTR pszArgs[] = { L"myshader.hlsl", // Optional shader source file name for error reporting and for PIX shader source view. L"-E", L"main", // Entry point. L"-T", L"ps_6_0", // Target. L"-Zs", // Enable smaller debug information. L"-D", L"MYDEFINE=1", // A single define. L"-Fo", L"myshader.bin", // Optional. Stored in the pdb. L"-Fd", L"myshader.pdb", // The file name of the pdb. This must either be supplied or the autogenerated file name must be used. L"-D", L"__XBOX_STRIP_DXIL", // Strip DXIL. L"-Qstrip_reflect", // Strip reflection into a separate blob. }; // // Open source file. // CComPtr pSource = nullptr; pUtils->LoadFile(L"myshader.hlsl", nullptr, &pSource); DxcBuffer Source; Source.Ptr = pSource->GetBufferPointer(); Source.Size = pSource->GetBufferSize(); Source.Encoding = DXC_CP_ACP; // Assume BOM says UTF8 or UTF16 or this is ANSI text. // // Compile it with specified arguments. // CComPtr pResults; pCompiler->Compile( &Source, // Source buffer. pszArgs, // Array of pointers to arguments. _countof(pszArgs), // Number of arguments. pIncludeHandler, // User-provided interface to handle #include directives (optional). IID_PPV_ARGS(&pResults) // Compiler output status, buffer, and errors. ); // // Print errors if present. // CComPtr pErrors = nullptr; pResults->GetOutput(DXC_OUT_ERRORS, IID_PPV_ARGS(&pErrors), nullptr); // Note that d3dcompiler would return null if no errors or warnings are present. // IDxcCompiler3::Compile will always return an error buffer, but its length will be zero if there are no warnings or errors. if (pErrors != nullptr && pErrors->GetStringLength() != 0) wprintf(L"Warnings and Errors:\n%S\n", pErrors->GetStringPointer()); // // Quit if the compilation failed. // HRESULT hrStatus; pResults->GetStatus(&hrStatus); if (FAILED(hrStatus)) { wprintf(L"Compilation Failed\n"); return 1; } // // Save shader binary. // CComPtr pShader = nullptr; CComPtr pShaderName = nullptr; pResults->GetOutput(DXC_OUT_OBJECT, IID_PPV_ARGS(&pShader), &pShaderName); if (pShader != nullptr) { FILE* fp = NULL; _wfopen_s(&fp, pShaderName->GetStringPointer(), L"wb"); fwrite(pShader->GetBufferPointer(), pShader->GetBufferSize(), 1, fp); fclose(fp); } // // Save pdb. // CComPtr pPDB = nullptr; CComPtr pPDBName = nullptr; pResults->GetOutput(DXC_OUT_PDB, IID_PPV_ARGS(&pPDB), &pPDBName); { FILE* fp = NULL; // Note that if you don't specify -Fd, a pdb name will be automatically generated. Use this file name to save the pdb so that PIX can find it quickly. _wfopen_s(&fp, pPDBName->GetStringPointer(), L"wb"); fwrite(pPDB->GetBufferPointer(), pPDB->GetBufferSize(), 1, fp); fclose(fp); } // // Print hash. // CComPtr pHash = nullptr; pResults->GetOutput(DXC_OUT_SHADER_HASH, IID_PPV_ARGS(&pHash), nullptr); if (pHash != nullptr) { wprintf(L"Hash: "); DxcShaderHash* pHashBuf = (DxcShaderHash*)pHash->GetBufferPointer(); for (int i = 0; i < _countof(pHashBuf->HashDigest); i++) wprintf(L"%x", pHashBuf->HashDigest[i]); wprintf(L"\n"); } // // Get separate reflection. // CComPtr pReflectionData; pResults->GetOutput(DXC_OUT_REFLECTION, IID_PPV_ARGS(&pReflectionData), nullptr); if (pReflectionData != nullptr) { // Optionally, save reflection blob for later here. // Create reflection interface. DxcBuffer ReflectionData; ReflectionData.Encoding = DXC_CP_ACP; ReflectionData.Ptr = pReflectionData->GetBufferPointer(); ReflectionData.Size = pReflectionData->GetBufferSize(); CComPtr< ID3D12ShaderReflection > pReflection; pUtils->CreateReflection(&ReflectionData, IID_PPV_ARGS(&pReflection)); // Use reflection interface here. } return 0; } ``` ### Utilisation d'allocateurs personnalisés DxcCreateInstance2 est un point d'entrée de dxcompiler qui permet à l'appelant de fournir une implémentation d'IMalloc qui sera utilisée pour toutes les opérations mémoire liées aux appels à cet objet. Pour fournir une implémentation d'IMalloc valide, l'utilisateur doit implémenter une méthode QueryInterface qui vérifie correctement les interfaces prises en charge, faute de quoi le compilateur risque de planter. Voici un exemple de code à titre de référence. ```cpp theme={null} HRESULT STDMETHODCALLTYPE MyAllocator::QueryInterface(REFIID iid, void** ppvObject) override { if (ppvObject == nullptr) { return E_POINTER; } *ppvObject = nullptr; if (IsEqualIID(iid, IID_IMalloc) || IsEqualIID(iid, IID_IUnknown)) { *ppvObject = reinterpret_cast(this); AddRef(); return S_OK; } return E_NOINTERFACE; } ``` ### Extensions de l'interface DLL pour XBOX Après la précompilation d'un nuanceur à l'aide de l'interface dxcompiler, des statistiques spécifiques du nuanceur peuvent être interrogées sur XBOX. Voici un exemple de code (la vérification des erreurs est omise par souci de concision). ```cpp theme={null} void PrintXboxShaderStats(IDxcBlob* pProgram) { // load shader into Xbox container CComPtr pContainer; DxcCreateInstance(CLSID_DxcXboxContainer, __uuidof(IDxcXboxContainer), (void **)&pContainer); pContainer->Load(pProgram); // get hardware stage count UINT32 Count = 0; pContainer->GetNumShaders(&Count); for (UINT32 i = 0; i < Count; i++) { // get hardware shader stage interface CComPtr hwShader; pContainer->GetShader(i, __uuidof(IDxcXboxHwShader), (void **)&hwShader); // get hardware stage name CComPtr pStageName; hwShader->GetStageName(&pStageName); const char* szStageName = pStageName->GetStringPointer(); // get hardware stage stats CComPtr pStats; hwShader->GetShaderStats(DxcXboxShaderStatsClass::V1, 0, &pStats); DxcXboxShaderStaticsV1 stats; memcpy(&stats, pStats->GetBufferPointer(), sizeof(stats)); // print stats printf("State Name: %s\n", szStageName); printf("NumVGPRs: %u\n", (UINT)stats.NumVGPR); printf("NumSGPRs: %u\n", (UINT)stats.NumSGPR); printf("WaveSize: %u\n", (UINT)stats.WaveSize); printf("Occupancy: %u\n", (UINT)stats.Occupancy); printf("ThreadGroupWaveCount: %u\n", (UINT)stats.ThreadGroupWaveCount); printf("LDSSizeInBytes: %u\n", (UINT)stats.LDSSizeInBytes); printf("PerLaneScratchSizeInBytes %u\n", (UINT)stats.PerLaneScratchSizeInBytes); } } ``` ## Voir aussi [Compilateur de nuanceurs](/fr-CA/tools/tools-console/shadercompiler/shader-compiler) ## Related topics - [Compilateur de nuanceurs HLSL (DXC) pour le GDK XBOX](/fr-CA/tools/tools-console/shadercompiler/index.md) - [Répertoire des rubriques NDA : liens actifs vers Microsoft Learn](/fr-CA/nda/nda-topic-directory.md) - [Exemples de scénarios et de configurations de matchmaking](/fr-CA/services/playfab/multiplayer/matchmaking/config-examples.md) - [Compiler et exécuter votre premier titre console GDKX](/fr-CA/home/build-first-title/first-console-title-walkthrough.md) - [Utilisation de Cognitive Services](/fr-CA/services/playfab/multiplayer/networking/party-unreal-engine-oss-cognitive-services-interface.md)