Funzione D3DCompile2 (d3dcompiler.h)
Compila il codice Microsoft High Level Shader Language (HLSL) in bytecode per una determinata destinazione.
Sintassi
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
);
Parametri
[in] pSrcData
Tipo: LPCVOID
Puntatore ai dati dello shader non conformi (codice ASCII HLSL).
[in] SrcDataSize
Tipo: SIZE_T
Dimensioni, in byte, del blocco di memoria a cui pSrcData punta.
[in, optional] pSourceName
Tipo: LPCSTR
Puntatore facoltativo a una stringa con terminazione null costante contenente il nome che identifica i dati di origine da usare nei messaggi di errore. Se non usato, impostare su NULL.
[in, optional] pDefines
Tipo: const D3D_SHADER_MACRO*
Matrice facoltativa di strutture D3D_SHADER_MACRO che definiscono le macro shader. Ogni definizione di macro contiene un nome e una definizione con terminazione null. Se non usato, impostare su NULL. L'ultima struttura della matrice funge da terminatore e deve avere tutti i membri impostati su NULL.
[in, optional] pInclude
Tipo: ID3DInclude*
Puntatore a un'interfaccia ID3DInclude usata dal compilatore per gestire i file. Se si imposta questo parametro su NULL e lo shader contiene un #include, si verifica un errore di compilazione. È possibile passare la macro D3D_COMPILE_STANDARD_FILE_INCLUDE , ovvero un puntatore a un gestore di inclusione predefinito. Questo gestore di inclusione predefinito include file relativi alla directory corrente e ai file relativi alla directory del file di origine iniziale. Quando si usa D3D_COMPILE_STANDARD_FILE_INCLUDE, è necessario specificare il nome del file di origine nel parametro pSourceName ; il compilatore deriva la directory relativa iniziale da pSourceName.
#define D3D_COMPILE_STANDARD_FILE_INCLUDE ((ID3DInclude*)(UINT_PTR)1)
[in] pEntrypoint
Tipo: LPCSTR
Puntatore a una stringa con terminazione null costante contenente il nome della funzione di ingresso del punto di ingresso shader in cui inizia l'esecuzione dello shader. Quando si compila un effetto, D3DCompile2 ignora pEntrypoint; è consigliabile impostare pEntrypoint su NULL perché è consigliabile impostare un parametro puntatore su NULL se la funzione chiamata non la userà.
[in] pTarget
Tipo: LPCSTR
Puntatore a una stringa con terminazione null costante che specifica la destinazione dello shader o il set di funzionalità shader da compilare. La destinazione shader può essere un modello shader(ad esempio, modello shader 2, modello shader 3, modello shader 4 o modello shader 5). La destinazione può anche essere un tipo di effetto , ad esempio fx_4_1. Per informazioni sulle destinazioni supportate da vari profili, vedere Specificare le destinazioni del compilatore.
[in] Flags1
Tipo: UINT
Combinazione di costanti di compilazione D3D di shader combinate usando un'operazione OR bit per bit. Il valore risultante specifica come il compilatore compila il codice HLSL.
[in] Flags2
Tipo: UINT
Combinazione di costanti di effetto D3D di compilazione combinate usando un'operazione OR bit per bit. Il valore risultante specifica come il compilatore compila l'effetto. Quando si compila un shader e non un file di effetto, D3DCompile2 ignora Flags2; È consigliabile impostare Flags2 su zero perché è consigliabile impostare un parametro nonpointer su zero se la funzione chiamata non la userà.
[in] SecondaryDataFlags
Tipo: UINT
Combinazione dei flag seguenti combinati usando un'operazione OR bit per bit. Il valore risultante specifica come il compilatore compila il codice HLSL.
| Flag | Descrizione |
|---|---|
| D3DCOMPILE_SECDATA_MERGE_UAV_SLOTS (0x01) | Unire gli slot di visualizzazione di accesso non ordinati nei dati secondari a cui punta il parametro pSecondaryData . |
| D3DCOMPILE_SECDATA_PRESERVE_TEMPLATE_SLOTS (0x02) | Mantenere gli slot modello nei dati secondari a cui punta il parametro pSecondaryData . |
| D3DCOMPILE_SECDATA_REQUIRE_TEMPLATE_MATCH (0x04) | Richiedere che i modelli nei dati secondari a cui punta il parametro pSecondaryData corrispondano quando il compilatore compila il codice HLSL. |
Se pSecondaryData è NULL, impostare su zero.
[in, optional] pSecondaryData
Tipo: LPCVOID
Puntatore ai dati secondari. Se non si passano dati secondari, impostare su NULL. Usare questi dati secondari per allineare gli slot UAV in due shader. Si supponga che shader A abbia UAV e che siano associati ad alcuni slot. Per compilare shader B in modo che le UAV con gli stessi nomi vengano mappate in B agli stessi slot di A, passare il codice byte di A a D3DCompile2 come i dati secondari.
[in] SecondaryDataSize
Tipo: SIZE_T
Dimensioni, in byte, del blocco di memoria a cui pSecondaryData punta. Se pSecondaryData è NULL, impostare su zero.
[out] ppCode
Tipo: ID3DBlob**
Puntatore a una variabile che riceve un puntatore all'interfaccia ID3DBlob che è possibile usare per accedere al codice compilato.
[out, optional] ppErrorMsgs
Tipo: ID3DBlob**
Puntatore a una variabile che riceve un puntatore all'interfaccia ID3DBlob che è possibile usare per accedere ai messaggi di errore del compilatore o NULL se non sono presenti errori.
Valore restituito
Tipo: HRESULT
Restituisce uno dei codici restituiti Direct3D 11.
Commenti
La differenza tra D3DCompile2 e D3DCompile è che D3DCompile2 accetta alcuni parametri facoltativi (SecondaryDataFlags, pSecondaryData e SecondaryDataSize) che possono essere usati per controllare alcuni aspetti della modalità di generazione del bytecode. Per altre informazioni, vedere le descrizioni di questi parametri. Non esiste alcuna differenza in caso contrario per l'efficienza del bytecode generato tra D3DCompile2 e D3DCompile.
Compilazione di shader per UWP
Per compilare shader offline, l'approccio consigliato consiste nell'usare lo strumento del compilatore Effetto. Se non è possibile compilare tutti gli shader in anticipo, è consigliabile compilare quelli più costosi e quelli necessari per l'avvio e la maggior parte dei percorsi sensibili alle prestazioni e compilare il resto in fase di esecuzione. È possibile usare un processo simile al seguente per compilare un shader caricato o generato in un'applicazione UWP senza bloccare il thread dell'interfaccia utente.
Usando Visual Studio 2015+ per sviluppare l'app UWP, aggiungere il nuovo elemento "shader.hlsl".
- Nella visualizzazione Cartella della soluzione di Visual Studio selezionare l'elemento shaders.hlsl , fare clic con il pulsante destro del mouse su Proprietà.
- Assicurarsi che il contenuto dell'elemento sia impostato su Sì.
- Assicurarsi che il tipo di elemento sia impostato su Testo.
- Aggiungere un pulsante a XAML, denominarlo in modo appropriato ("TheButton" in questo esempio) e aggiungere un gestore Click .
Aggiungere ora questi elementi al file di .cpp:
#include <ppltasks.h> #include <d3dcompiler.h> #include <Robuffer.h>Usare il codice seguente per chiamare D3DCompile2. Si noti che non è presente alcun controllo o gestione degli errori qui e anche che questo codice dimostra che è possibile eseguire sia I/O che la compilazione in background, che lascia più reattiva l'interfaccia utente.
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());
}
Requisiti
| Requisito | Valore |
|---|---|
| Piattaforma di destinazione | Windows |
| Intestazione | d3dcompiler.h |
| Libreria | D3DCompiler.lib |
| DLL | D3DCompiler_47.dll |