Gráfico de mapeamento de conceitos do DirectX / OpenGL (Vulkan)

Geralmente, um recurso de hardware semelhante é exposto via DirectX e OpenGL usando terminologia diferente.

Por exemplo:
Buffer constante / Objeto de buffer uniforme
RWBuffer / SSBO

Estou procurando um gráfico exaustivo que descreva qual terminologia do DirectX é usada para se referir a qual conceito OpenGL e vice-versa.
Onde posso encontrar esse recurso?

Não consegui encontrar esse gráfico na Web, então fiz um aqui. (Todos, sintam-se à vontade para adicionar, elaborar ou corrigir erros. Alguns desses são apenas melhores palpites com base em um entendimento parcial da API e dos componentes internos do hardware.)

Noções básicas da 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 Desenho

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

Buffers e Texturas

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)

Renderizar alvos

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

Consultas

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

Computadores Shaders

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

Outros recursos

• Portando do DirectX11 para o OpenGL 4.2 - não exaustivo, mas uma rápida discussão sobre problemas comuns de portabilidade
• MSDN: Guia de transferência de GLSL para HLSL - lista correspondências e diferenças entre os idiomas de sombreamento GLSL e HLSL

Aqui está uma lista não exaustiva do Vulkan e do DirectX 12. Isso é feito usando critérios semelhantes aos do Nathan.

No geral, as duas APIs são surpreendentemente semelhantes. Coisas como estágios de shader permanecem inalterados em relação ao DX11 e ao OpenGL. E, obviamente, o DirectX usa visualizações para tornar as coisas visíveis aos shaders. Vulkan também usa visualizações, mas são menos frequentes.

O comportamento da visibilidade do sombreador difere um pouco entre os dois. O Vulkan usa uma máscara para determinar se um descritor é visível para os vários estágios do shader. O DX12 lida com isso de maneira um pouco diferente, a visibilidade dos recursos é feita no estágio único ou em todos os estágios.

Eu quebrei o conjunto de descritores / parâmetro raiz o melhor que pude. O tratamento do descritor é uma das áreas que variam muito entre as duas APIs. No entanto, o resultado final é bastante semelhante.

Noções básicas da 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

A camada WSI da Vulkan fornece imagens para o swapchain. O DX12 requer recursos de criação para representar a imagem.

O comportamento geral da fila é bastante semelhante entre os dois. Há um pouco de idiossincrasia ao enviar de vários threads.

Vou tentar atualizar como eu me lembro de mais coisas ...

Buffer de Comando e Pool

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

A verbosidade sobre o conjunto de comandos / alocador dos documentos da Vulkan / DX12 declara o comportamento em palavras muito diferentes - mas o comportamento real é bastante semelhante. Os usuários são livres para alocar muitos buffers / listas de comando do pool. No entanto, apenas um buffer / lista de comandos do pool pode estar gravando. Pools não podem ser compartilhados entre threads. Portanto, vários encadeamentos requerem vários pools. Você também pode começar a gravar imediatamente após enviar o comando buffer / list nos dois.

A lista de comandos do DX12 é criada em um estado aberto. Acho isso um pouco chato, já que estou acostumado com o Vulkan. O DX12 também requer uma redefinição explícita do alocador de comandos e da lista de comandos. Esse é um comportamento opcional no Vulkan.

Descritores

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

** RootParameter - não é exatamente o equivalente a VkDescriptorSetLayoutBinding mas um pensamento semelhante na imagem maior.

VkDescriptorPool e ID3D12DescriptorHeaps são parecidos (graças a Nicolas), pois ambos gerenciam a alocação dos descritores.

Deve-se notar que o DX12 suporta apenas no máximo dois montadores de descritores vinculados a uma lista de comandos a qualquer momento. Um CBVSRVUAV e um amostrador. Você pode ter quantas tabelas de descritores desejar referenciar esses heaps.

No lado do Vulkan, há um limite rígido para o número máximo de conjuntos de descritores que você informa ao conjunto de descritores. Em ambos, é necessário fazer uma contabilidade manual do número de descritores por tipo que o pool / heap pode ter. Vulkan também é mais explícito com o tipo de descritores. Enquanto no DX12 os descritores são CBVSRVUAV ou sampler.

O DX12 também possui um recurso no qual você pode vincular um CBV em tempo real usando SetGraphicsRootConstantBufferView. No entanto, a versão SRV disso, SetGraphicsRootShaderResourceView, não funciona em texturas. Está na documentação - mas também pode levar algumas horas para você descobrir se não é um leitor cuidadoso.

Pipeline

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

* ** RootSignature - não é exatamente o equivalente a VkPipelineLayout .

O DX12 combina o atributo de vértice e a ligação em uma única descrição.

Imagens e buffers

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

Barreiras em ambas as APIs quebram um pouco diferente, mas têm resultado líquido semelhante.

RenderPasses / RenderTargets

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

Os passes de renderização Vulkan têm um bom recurso de resolução automática. O DX12 não possui este AFIAK. Ambas as APIs fornecem funções para resolução manual.

Não há uma equivalência direta entre o VkFramebuffer e qualquer objeto no DX12. Uma coleção de ID3D12Resource que mapeia para RTVs é uma semelhança frouxa.

O VkFramebuffer age mais ou menos como um pool de anexos que o VkRenderPass faz referência usando um índice. Subpasses dentro de um VkRenderPass podem fazer referência a qualquer um dos anexos em um VkFramebuffer assumindo que o mesmo anexo não seja referenciado mais de uma vez por subpass. O número máximo de anexos de cores usados ​​ao mesmo tempo é limitado a VkPhysicalDeviceLimits.maxColorAttachments.

Os destinos de renderização do DX12 são apenas RTVs suportados por objetos ID3D12Resource. O número máximo de anexos coloridos usados ​​de uma vez é limitado a D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT (8).

Ambas as APIs exigem que você especifique os destinos / passes de renderização na criação dos objetos de pipeline. No entanto, o Vulkan permite que você use passes de renderização compatíveis, para que você não fique bloqueado nos que especificar durante a criação do pipline. Não testei no DX12, mas acho que, como é apenas um RTV, isso também é verdade no DX12.