Grafico di mappatura dei concetti DirectX / OpenGL (Vulkan)

Spesso una funzionalità hardware simile viene esposta tramite DirectX e OpenGL utilizzando una terminologia diversa.

Ad esempio:
Constant Buffer / Uniform Buffer Object
RWBuffer / SSBO

Sto cercando un grafico esaustivo che descriva quale terminologia DirectX viene utilizzata per fare riferimento a quale concetto OpenGL e viceversa.
Dove posso trovare una tale risorsa?

Non sono stato in grado di trovare un grafico del genere sul Web, quindi ne ho creato uno qui. (Tutti, sentitevi liberi di aggiungere, elaborare o correggere eventuali errori. Alcuni di questi sono solo ipotesi basate su una comprensione parziale dell'API e degli interni hardware.)

Nozioni di base sulle API

D3D11                          OpenGL 4.x
-----                          ----------
device                         context
immediate context              (implicit; no specific name)
deferred context               (no cross-vendor equivalent, but see
                                GL_NV_command_list)
swap chain                     (implicit; no specific name)
(no cross-vendor equivalent)   extensions
debug layer; info queue        GL_KHR_debug extension

shaders

D3D11              OpenGL 4.x
-----              ----------
pixel shader       fragment shader
hull shader        tessellation control shader
domain shader      tessellation evaluation shader
(vertex shader, geometry shader, and compute shader
 are called the same in both)

registers          binding points
semantics          interface layouts
SV_Foo semantics   gl_Foo builtin variables

class linkage      subroutines

(no equivalent)    program objects; program linking

(D3D11's normal
 behavior; no      separate shader objects
 specific name)

Geometria e disegno

D3D11              OpenGL 4.x
-----              ----------
vertex buffer      vertex attribute array buffer; vertex buffer object
index buffer       element array buffer
input layout       vertex array object (sort of)

Draw               glDrawArrays
DrawIndexed        glDrawElements
(instancing and indirect draw are called similarly in both)
(no equivalent)    multi-draw, e.g. glMultiDrawElements​

stream-out         transform feedback
DrawAuto           glDrawTransformFeedback​

predication        conditional rendering
(no equivalent)    sync objects

Buffer e trame

D3D11                    OpenGL 4.x
-----                    ----------
constant buffer          uniform buffer object
typed buffer             texture buffer
structured buffer        (no specific name; subset of SSBO features)
UAV buffer; RWBuffer     SSBO (shader storage buffer object)
UAV texture; RWTexture   image load/store

shader resource view     texture view
sampler state            sampler object

interlocked operations   atomic operations
append/consume buffer    SSBO + atomic counter

discard buffer/texture   invalidate buffer/texture
(no equivalent)          persistent mapping
(D3D11's normal
 behavior; no            immutable storage
 specific name)
(implicitly inserted     glMemoryBarrier; glTextureBarrier
 by the API)

Obiettivi di rendering

D3D11                     OpenGL 4.x
-----                     ----------
(no equivalent)           framebuffer object
render target view        framebuffer color attachment
depth-stencil view        framebuffer depth-stencil attachment
multisample resolve       blit multisampled buffer to non-multisampled one

multiple render targets   multiple color attachments
render target array       layered image

(no equivalent)           renderbuffer

Interrogazioni

D3D11                       OpenGL 4.x
-----                       ----------
timestamp query             timer query
timestamp-disjoint query    (no equivalent)
(no equivalent)             time-elapsed query
occlusion query             samples-passed query
occlusion predicate query   any-samples-passed query
pipeline statistics query   (no equivalent in core, but see
                             GL_ARB_pipeline_statistics_query)
SO statistics query         primitives-generated/-written queries 
(no equivalent)             query buffer object

Calcola shader

D3D11                     OpenGL 4.x
-----                     ----------
thread                    invocation
thread group              work group
thread group size         local size
threadgroup variable      shared variable

group sync                "plain" barrier
group memory barrier      shared memory barrier
device memory barrier     atomic+buffer+image memory barriers
all memory barrier        group memory barrier

Altre risorse

• Porting da DirectX11 a OpenGL 4.2 - non esaustivo, ma una rapida discussione dei problemi di porting comuni
• MSDN: guida al porting da GLSL a HLSL - elenca le corrispondenze e le differenze tra i linguaggi di shading GLSL e HLSL

Ecco un elenco non esaustivo di Vulkan e DirectX 12. Questo è messo insieme usando criteri simili a quelli di Nathan.

Nel complesso entrambe le API sono sorprendentemente simili. Cose come gli shader stage rimangono invariati da DX11 e OpenGL. E ovviamente, DirectX utilizza le viste per rendere le cose visibili agli shader. Anche Vulkan utilizza le viste, ma sono meno frequenti.

Il comportamento di visibilità dello shader differisce leggermente tra i due. Vulkan utilizza una maschera per determinare se un descrittore è visibile ai vari stadi dello shader. DX12 lo gestisce in modo leggermente diverso, la visibilità delle risorse viene eseguita su uno o più livelli.

Ho rotto il descrittore set / roba dei parametri root meglio che potevo. La gestione dei descrittori è una delle aree che variano notevolmente tra le due API. Tuttavia, il risultato finale è abbastanza simile.

Nozioni di base sulle API

Vulkan                              DirectX 12
---------------                     ---------------
n/a                                 IDXGIFactory4
VkInstance                          n/a
VkPhysicalDevice                    IDXGIAdapter1
VkDevice                            ID3D12Device
VkQueue                             ID3D12CommandQueue
VkSwapchain                         IDXGISwapChain3
VkFormat                            DXGI_FORMAT
SPIR-V                              D3D12_SHADER_BYTECODE
VkFence                             fences
VkSemaphore                         n/a
VkEvent                             n/a

Il livello WSI di Vulkan fornisce immagini per lo swapchain. DX12 richiede risorse di creazione per rappresentare l'immagine.

Il comportamento generale della coda è abbastanza simile tra i due. C'è un po 'di idiosincrasia quando si invia da più thread.

Proverò ad aggiornare come ricordo più cose ...

Buffer di comando e pool

Vulkan                              DirectX 12
---------------                     ---------------
VkCommandPool                       ID3D12CommandAllocator
VkCommandBuffer                     ID3D12CommandList/ID3D12GraphicsCommandList

La discordanza sul pool di comandi / allocatore dai documenti Vulkan / DX12 afferma il comportamento in parole molto diverse, ma il comportamento effettivo è piuttosto simile. Gli utenti sono liberi di allocare molti pool / buffer di comando dal pool. Tuttavia, è possibile registrare solo un buffer / elenco comandi dal pool. I pool non possono essere condivisi tra thread. Quindi più thread richiedono più pool. Puoi anche iniziare a registrare immediatamente dopo aver inviato il buffer / elenco dei comandi su entrambi.

L'elenco dei comandi DX12 viene creato in uno stato aperto. Lo trovo un po 'fastidioso poiché sono abituato a Vulkan. DX12 richiede inoltre un ripristino esplicito dell'allocatore dei comandi e dell'elenco dei comandi. Questo è un comportamento facoltativo in Vulkan.

descrittori

Vulkan                              DirectX 12
---------------                     ---------------
VkDescriptorPool                    n/a
VkDescriptorSet                     n/a
VkDescriptorSetLayout               n/a
VkDescriptorSetLayoutBinding        RootParameter**
n/a                                 ID3D12DescriptorHeap

** RootParameter - non esattamente un equivalente di VkDescriptorSetLayoutBinding ma un pensiero simile nel quadro generale.

VkDescriptorPool e ID3D12DescriptorHeaps sono in qualche modo simili (grazie Nicolas) in quanto entrambi gestiscono l'allocazione dei descrittori stessi.

Va notato che DX12 supporta al massimo due heap di descrittori associati a un elenco di comandi in qualsiasi momento. Un CBVSRVUAV e un campionatore. Puoi avere tutte le tabelle descrittive che vuoi fare riferimento a questi heap.

Sul lato Vulkan, esiste un limite rigido al numero massimo di set di descrittori che si comunica al pool di descrittori. Su entrambi devi fare un po 'di contabilità manuale sul numero di descrittori per tipo che il pool / heap può avere. Vulkan è anche più esplicito con il tipo di descrittori. Considerando che i descrittori DX12 sono CBVSRVUAV o campionatore.

DX12 ha anche una funzione in cui è possibile in qualche modo associare un CBV al volo usando SetGraphicsRootConstantBufferView. Tuttavia, la versione SRV di questo, SetGraphicsRootShaderResourceView, non funziona sulle trame. È nei documenti, ma potrebbe anche richiedere un paio d'ore per capirlo se non sei un lettore attento.

conduttura

Vulkan                              DirectX 12
---------------                     ---------------
VkPipelineLayout                    RootSignature***
VkPipeline                          ID3D12PipelineState
VkVertexInputAttributeDescription   D3D12_INPUT_ELEMENT_DESC
VkVertexInputBindingDescription     "

* ** RootSignature - non esattamente equivalente a VkPipelineLayout .

DX12 combina l'attributo vertice e l'associazione in un'unica descrizione.

Immagini e buffer

Vulkan                              DirectX 12
---------------                     ---------------
VkImage                             ID3D12Resource
VkBuffer                            ID3D12Resource
uniform buffer                      constant buffer
index buffer                        index buffer
vertex buffer                       vertex buffer
VkSampler                           sampler
barriers/transitions                barriers/transitions

Le barriere su entrambe le API sono leggermente diverse, ma hanno un risultato netto simile.

RenderPasses / RenderTargets

Vulkan                              DirectX 12
---------------                     ---------------
VkRenderPass                        render pass
VkFramebuffer                       collection of ID3D12Resource
subpass                             n/a
n/a                                 render target

I passaggi di rendering di Vulkan hanno una bella funzione di risoluzione automatica. DX12 non ha questo AFIAK. Entrambe le API forniscono funzioni per la risoluzione manuale.

Non esiste un'equivalenza diretta tra VkFramebuffer e qualsiasi oggetto in DX12. Una raccolta di risorse ID3D12 associate a RTV è una somiglianza libera.

VkFramebuffer agisce più o meno come un pool di allegati a cui VkRenderPass fa riferimento utilizzando un indice. I sottopassi all'interno di un VkRenderPass possono fare riferimento a qualsiasi allegato in un VkFramebuffer supponendo che lo stesso allegato non faccia riferimento più di una volta per sottopassaggio. Il numero massimo di allegati colorati utilizzati contemporaneamente è limitato a VkPhysicalDeviceLimits.maxColorAttachments.

Le destinazioni di rendering di DX12 sono solo RTV supportate da oggetti ID3D12Resource. Il numero massimo di allegati colorati utilizzati contemporaneamente è limitato a D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT (8).

Entrambe le API richiedono di specificare le destinazioni / i passaggi di rendering alla creazione degli oggetti della pipeline. Tuttavia, Vulkan ti consente di utilizzare passaggi di rendering compatibili, quindi non sei bloccato in quelli specificati durante la creazione della pipeline. Non l'ho testato su DX12, ma immagino che dal momento che è solo un RTV, questo è vero anche su DX12.