Fonction D3DCompile2 (d3dcompiler.h)

Compile le code HLSL (High Level Shader Language) microsoft dans un bytecode pour une cible donnée.

Syntaxe

HRESULT D3DCompile2(
  [in]            LPCVOID                pSrcData,
  [in]            SIZE_T                 SrcDataSize,
  [in, optional]  LPCSTR                 pSourceName,
  [in, optional]  const D3D_SHADER_MACRO *pDefines,
  [in, optional]  ID3DInclude            *pInclude,
  [in]            LPCSTR                 pEntrypoint,
  [in]            LPCSTR                 pTarget,
  [in]            UINT                   Flags1,
  [in]            UINT                   Flags2,
  [in]            UINT                   SecondaryDataFlags,
  [in, optional]  LPCVOID                pSecondaryData,
  [in]            SIZE_T                 SecondaryDataSize,
  [out]           ID3DBlob               **ppCode,
  [out, optional] ID3DBlob               **ppErrorMsgs
);

Paramètres

[in] pSrcData

Type : LPCVOID

Pointeur vers des données de nuanceur non compilées (code HLSL ASCII).

[in] SrcDataSize

Type : SIZE_T

Taille, en octets, du bloc de mémoire vers lequel pSrcData pointe.

[in, optional] pSourceName

Type : LPCSTR

Pointeur facultatif vers une chaîne null constante contenant le nom qui identifie les données sources à utiliser dans les messages d’erreur. S’il n’est pas utilisé, définissez sur NULL.

[in, optional] pDefines

Type : const D3D_SHADER_MACRO*

Tableau facultatif de structures D3D_SHADER_MACRO qui définissent des macros de nuanceur. Chaque définition de macro contient un nom et une définition terminée par null. S’il n’est pas utilisé, définissez sur NULL. La dernière structure du tableau sert de terminaison et doit avoir tous les membres définis sur NULL.

[in, optional] pInclude

Type : ID3DInclude*

Pointeur vers une interface ID3DInclude que le compilateur utilise pour gérer les fichiers include. Si vous définissez ce paramètre sur NULL et que le nuanceur contient une #include, une erreur de compilation se produit. Vous pouvez passer le D3D_COMPILE_STANDARD_FILE_INCLUDE macro, qui est un pointeur vers un gestionnaire include par défaut. Ce gestionnaire include par défaut inclut les fichiers relatifs au répertoire actif et les fichiers relatifs au répertoire du fichier source initial. Lorsque vous utilisez D3D_COMPILE_STANDARD_FILE_INCLUDE, vous devez spécifier le nom de fichier source dans le paramètre pSourceName ; le compilateur dérive le répertoire relatif initial de pSourceName.

#define D3D_COMPILE_STANDARD_FILE_INCLUDE ((ID3DInclude*)(UINT_PTR)1)

[in] pEntrypoint

Type : LPCSTR

Pointeur vers une chaîne null constante qui contient le nom de la fonction de point d’entrée du nuanceur où commence l’exécution du nuanceur. Lorsque vous compilez un effet, D3DCompile2 ignore pEntrypoint ; nous vous recommandons de définir pEntrypoint sur NULL , car il est recommandé de définir un paramètre de pointeur sur NULL si la fonction appelée ne l’utilise pas.

[in] pTarget

Type : LPCSTR

Pointeur vers une chaîne null constante qui spécifie la cible ou l’ensemble des fonctionnalités de nuanceur à compiler. La cible du nuanceur peut être un modèle de nuanceur (par exemple, le modèle de nuanceur 2, le modèle de nuanceur 3, le modèle de nuanceur 4 ou le modèle de nuanceur 5). La cible peut également être un type d’effet (par exemple, fx_4_1). Pour plus d’informations sur les cibles prises en charge par différents profils, consultez Spécification des cibles du compilateur.

[in] Flags1

Type : UINT

Combinaison de constantes de compilation D3D du nuanceur qui sont combinées à l’aide d’une opération OR au niveau du bit. La valeur résultante spécifie la façon dont le compilateur compile le code HLSL.

[in] Flags2

Type : UINT

Combinaison de constantes d’effet D3D de compilation d’effet qui sont combinées à l’aide d’une opération OR au niveau du bit. La valeur résultante spécifie la façon dont le compilateur compile l’effet. Lorsque vous compilez un nuanceur et non un fichier d’effet, D3DCompile2 ignore Flags2 ; nous vous recommandons de définir Flags2 sur zéro, car il est recommandé de définir un paramètre non-pointeur sur zéro si la fonction appelée ne l’utilise pas.

[in] SecondaryDataFlags

Type : UINT

Combinaison des indicateurs suivants combinés à l’aide d’une opération OR au niveau du bit. La valeur résultante spécifie la façon dont le compilateur compile le code HLSL.

Si pSecondaryData a la valeur NULL, définissez sur zéro.

[in, optional] pSecondaryData

Type : LPCVOID

Pointeur vers des données secondaires. Si vous ne transmettez pas de données secondaires, définissez sur NULL. Utilisez ces données secondaires pour aligner les emplacements DAV dans deux nuanceurs. Supposons que le nuanceur A possède des UAV et qu’ils soient liés à certains emplacements. Pour compiler le nuanceur B afin que les UAV portant les mêmes noms soient mappées dans B aux mêmes emplacements que dans A, transmettez le code d’octet de A à D3DCompile2 en tant que données secondaires.

[in] SecondaryDataSize

Type : SIZE_T

Taille, en octets, du bloc de mémoire vers lequel pSecondaryData pointe. Si pSecondaryData a la valeur NULL, définissez sur zéro.

[out] ppCode

Type : ID3DBlob**

Pointeur vers une variable qui reçoit un pointeur vers l’interface ID3DBlob que vous pouvez utiliser pour accéder au code compilé.

[out, optional] ppErrorMsgs

Type : ID3DBlob**

Pointeur vers une variable qui reçoit un pointeur vers l’interface ID3DBlob que vous pouvez utiliser pour accéder aux messages d’erreur du compilateur, ou NULL s’il n’y a aucune erreur.

Valeur retournée

Type : HRESULT

Retourne l’un des codes de retour Direct3D 11.

Remarques

La différence entre D3DCompile2 et D3DCompile est que D3DCompile2 prend certains paramètres facultatifs (SecondaryDataFlags, pSecondaryData et SecondaryDataSize) qui peuvent être utilisés pour contrôler certains aspects de la façon dont le bytecode est généré. Pour plus d’informations, reportez-vous aux descriptions de ces paramètres. Il n’y a pas de différence dans l’efficacité du bytecode généré entre D3DCompile2 et D3DCompile.

Compilation de nuanceurs pour UWP

Pour compiler des nuanceurs hors connexion, l’approche recommandée consiste à utiliser l’outil effect-compiler. Si vous ne pouvez pas compiler tous vos nuanceurs à l’avance, envisagez de compiler les plus coûteux et ceux dont votre démarrage et les chemins les plus sensibles aux performances nécessitent, et de compiler le reste au moment de l’exécution. Vous pouvez utiliser un processus similaire à ce qui suit pour compiler un nuanceur chargé ou généré dans une application UWP sans bloquer votre thread d’interface utilisateur.

• À l’aide de Visual Studio 2015+ pour développer l’application UWP, ajoutez le nouvel élément « shader.hlsl ».

  • Dans la vue Dossier de solution de Visual Studio, sélectionnez l’élément shaders.hlsl , puis cliquez avec le bouton droit sur Propriétés.
  • Vérifiez que l’élément Contenu a la valeur Oui.
  • Vérifiez que le type d’élément est défini sur Texte.
  • Ajoutez un bouton au code XAML, nommez-le correctement (« TheButton » dans cet exemple) et ajoutez un gestionnaire Click .

• Ajoutez maintenant ces éléments à votre fichier .cpp :

  #include <ppltasks.h>
  #include <d3dcompiler.h>
  #include <Robuffer.h>
  

• Utilisez le code suivant pour appeler D3DCompile2. Notez qu’il n’y a aucune vérification ou gestion des erreurs ici, et que ce code montre également que vous pouvez effectuer des E/S et une compilation en arrière-plan, ce qui rend votre interface utilisateur plus réactive.

void App1::DirectXPage::TheButton_Click(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e)
{
  std::shared_ptr<Microsoft::WRL::ComPtr<ID3DBlob>> blobRef = std::make_shared<Microsoft::WRL::ComPtr<ID3DBlob>>();

  // Load a file and compile it.
  auto fileOp = Windows::ApplicationModel::Package::Current->InstalledLocation->GetFileAsync(L"shader.hlsl");
  create_task(fileOp).then([this](Windows::Storage::StorageFile^ file) -> IAsyncOperation<Windows::Storage::Streams::IBuffer^>^
  {
    // Do file I/O in background thread (use_arbitrary).
    return Windows::Storage::FileIO::ReadBufferAsync(file);
  }, task_continuation_context::use_arbitrary())
    .then([this, blobRef](Windows::Storage::Streams::IBuffer^ buffer)
  {
    // Do compilation in background thread (use_arbitrary).

    // Cast to Object^, then to its underlying IInspectable interface.
    Microsoft::WRL::ComPtr<IInspectable> insp(reinterpret_cast<IInspectable*>(buffer));

    // Query the IBufferByteAccess interface.
    Microsoft::WRL::ComPtr<Windows::Storage::Streams::IBufferByteAccess> bufferByteAccess;
    insp.As(&bufferByteAccess);

    // Retrieve the buffer data.
    byte *pBytes = nullptr;
    bufferByteAccess->Buffer(&pBytes);

    Microsoft::WRL::ComPtr<ID3DBlob> blob;
    Microsoft::WRL::ComPtr<ID3DBlob> errMsgs;
    D3DCompile2(pBytes, buffer->Length, "shader.hlsl", nullptr, nullptr, "main", "ps_5_0", 0, 0, 0, nullptr, 0, blob.GetAddressOf(), errMsgs.GetAddressOf());
    *blobRef = blob;
  }, task_continuation_context::use_arbitrary())
    .then([this, blobRef]()
  {
    // Update UI / use shader on foreground thread.
    wchar_t message[40];
    swprintf_s(message, L"blob is %u bytes long", (unsigned)(*blobRef)->GetBufferSize());
    this->TheButton->Content = ref new Platform::String(message);
  }, task_continuation_context::use_current());
}

Configuration requise

Voir aussi

• Fonctions
• Spécification de signatures racines D3D12 dans HLSL