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.

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

Vedi anche

• Funzioni
• Specifica delle firme radice D3D12 in HLSL