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.
| Indicateur | Description |
|---|---|
| D3DCOMPILE_SECDATA_MERGE_UAV_SLOTS (0x01) | Fusionnez les emplacements de vue d’accès non ordonné (UAV) dans les données secondaires vers laquelle pointe le paramètre pSecondaryData . |
| D3DCOMPILE_SECDATA_PRESERVE_TEMPLATE_SLOTS (0x02) | Conservez les emplacements de modèle dans les données secondaires vers laquelle pointe le paramètre pSecondaryData . |
| D3DCOMPILE_SECDATA_REQUIRE_TEMPLATE_MATCH (0x04) | Exiger que des modèles dans les données secondaires que le paramètre pSecondaryData pointe pour correspondre lorsque 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
| Condition requise | Valeur |
|---|---|
| Plateforme cible | Windows |
| En-tête | d3dcompiler.h |
| Bibliothèque | D3DCompiler.lib |
| DLL | D3DCompiler_47.dll |