Linguagem assembly ARB - ARB assembly language

A linguagem assembly ARB é uma linguagem de sombreamento de baixo nível , que pode ser caracterizada como uma linguagem assembly . Ele foi criado pelo OpenGL Architecture Review Board (ARB) para padronizar as instruções da GPU que controlam o pipeline de gráficos de hardware .

História

A Texas Instruments criou o primeiro processador gráfico programável em 1985: o TMS34010 , que permitia aos desenvolvedores carregar e executar códigos no processador para controlar a saída de pixels em uma tela de vídeo. Isto foi seguido pelo TMS34020 e TMS34082 em 1989, fornecendo saída gráfica 3D programável.

A NVIDIA lançou sua primeira placa de vídeo NV1 em 1995, que suportava mapeamento de textura quadrática. Em seguida veio o Riva 128 (NV3) em 1997, oferecendo a primeira aceleração de hardware para Direct3D .

Vários fornecedores de placas de vídeo lançaram suas próprias placas aceleradas, cada uma com seu próprio conjunto de instruções para operações de GPU . O OpenGL Architecture Review Board (ARB) foi formado em 1992, em parte para estabelecer padrões para a indústria de GPU .

O ARB e a NVIDIA estabeleceram várias extensões OpenGL para padronizar a programação da GPU:

  • EXT_texture_env_combine - forneceu um método programável de combinar texturas.
  • NV_register_combiners - GeForce 256
  • NV_vertex_program - GeForce 3
  • NV_texture_shader - GeForce 3
  • NV_texture_shader3 - GeForce 4
  • NV_vertex_program2 - GeForce FX
  • NV_fragment_program - GeForce FX

Isso culminou com o lançamento de 2002 do ARB

  • ARB_vertex_program
  • ARB_fragment_program

Essas duas extensões forneceram um padrão da indústria para uma linguagem de montagem que controlava o pipeline da GPU para vértice 3D e propriedades de pixel interpolado, respectivamente.

Linguagens de sombreamento de alto nível subsequentes às vezes compilam para este padrão ARB. Enquanto os desenvolvedores 3D agora estão mais propensos a usar uma linguagem de sombreamento de alto nível semelhante ao C para a programação de GPU , o assembly ARB tem a vantagem de ser compatível com uma ampla variedade de hardware.

Observe, entretanto, que alguns recursos, como loops e condicionais, não estão disponíveis no assembly ARB e usá-los exige a adoção da extensão NV_gpu_program4 ou da linguagem de sombreamento GLSL.

Todos os principais fabricantes de placas de vídeo suportam a linguagem de montagem ARB há anos, desde a série NVIDIA Geforce FX , as placas baseadas em AMD R300 (série Radeon 9500 e superior) e a Intel GMA 900 . No entanto, a linguagem assembly ARB padrão está apenas no nível do Pixel Shader 2.0 e é anterior a GLSL , portanto, tem poucos recursos. Embora a nVidia tenha feito extensões proprietárias para linguagens de montagem ARB que combinam a velocidade de compilação rápida da montagem ARB com recursos OpenGL 3.x modernos, introduzidas com a série GeForce 8 , a maioria das implementações OpenGL não nVidia não fornecem as extensões proprietárias da nVidia para montagem ARB linguagem e não oferecem nenhuma outra maneira de acessar todos os recursos de shader diretamente no assembly, forçando o uso de GLSL mesmo para shaders gerados por máquina onde a montagem seria mais apropriada.

Detalhes

ARB_vertex_program

A extensão do programa ARB Vertex fornece APIs para carregar instruções de montagem ARBvp1.0, habilitar programas selecionados e definir vários parâmetros de GPU.

Os programas de vértices são usados ​​para modificar propriedades de vértices, como posição, normais e coordenadas de textura, que são passadas para o próximo processo de pipeline: geralmente um sombreador de fragmento; mais recentemente, um sombreador de geometria.

ARB_fragment_program

A extensão ARB Fragment Program fornece APIs para carregar instruções de montagem ARBfp1.0, habilitar programas selecionados e definir vários parâmetros de GPU.

Os fragmentos OpenGL são definições de pixel interpoladas. O processador de vértices da GPU calcula todos os pixels controlados por um conjunto de vértices, interpola sua posição e outras propriedades e os passa para seu processo de fragmento. Os programas de fragmento permitem que os desenvolvedores modifiquem essas propriedades de pixel antes de serem renderizados em um buffer de quadro para exibição.

Parâmetros OpenGL

  • Os parâmetros de atributo são atributos por vértice, como normais de vértice.
  • Os parâmetros locais são aplicados em todo o conjunto de dados de um programa para uma determinada passagem de sombreador.
  • Os parâmetros Env são aplicados em todos os programas.

Variáveis ​​ARB

Todas as variáveis ​​de montagem ARB são vetores float4, que podem ser endereçados pelos sufixos xyzw ou rgba.

Os registros são variáveis ​​escalares onde apenas um elemento pode ser endereçado.

  • As variáveis ADDRESS são registros.
  • ATTRIB são atributos por vértice.
  • PARAM são propriedades uniformes - constantes, Env ou Local.
  • Variáveis ​​temporárias TEMP .
  • ALIAS fornece nomes alternativos para variáveis.
  • OUTPUT designa variáveis ​​que são passadas de volta ao pipeline.

Atributos de vértice

O conjunto ARB suporta os seguintes sufixos para atributos de vértice:

  • posição
  • peso
  • normal
  • cor
  • fogcoord
  • texcoord
  • matrixindex
  • atrib

Matrizes de Estado

A montagem ARB suporta as seguintes matrizes de estado:

  • modelview
  • projeção
  • textura
  • paleta
  • programa

Os seguintes modificadores podem ser usados:

  • inverso
  • transpor
  • invtrans

Instruções de montagem ARB

O conjunto ARB suporta as seguintes instruções:

  • ABS - valor absoluto
  • ADICIONAR - adicionar
  • ARL - carga de registro de endereço
  • DP3 - produto escalar de 3 componentes
  • DP4 - produto escalar de 4 componentes
  • DPH - produto escalar homogêneo
  • DST - vetor de distância
  • EX2 - base exponencial 2
  • EXP - base exponencial 2 (aproximada)
  • FLR - piso
  • FRC - fração
  • LG2 - logaritmo de base 2
  • LIT - computar coeficientes de luz
  • LOG - logaritmo de base 2 (aproximado)
  • MAD - multiplique e adicione
  • MAX - máximo
  • MIN - mínimo
  • MOV - mover
  • MUL - multiplique
  • POW - exponencial
  • RCP - recíproco
  • RSQ - raiz quadrada recíproca
  • SGE - definido como maior ou igual
  • SLT - definido em menos de
  • SUB - subtrair
  • SWZ - swizzle estendido
  • TEX - Pesquisa de textura
  • XPD - produto cruzado

Esta é apenas uma lista parcial das instruções de montagem; uma referência pode ser encontrada aqui: Shader Assembly Language (ARB / NV) Guia de referência rápida para OpenGL .

O conjunto ARB não fornece instruções para controle de fluxo ou ramificação. SGE e SLT podem ser usados ​​para definir ou limpar condicionalmente vetores ou registros.

As interfaces ARB não fornecem nenhuma etapa de compilação para a linguagem assembly.

GL_NV_fragment_program_option estende a linguagem ARB_fragment_program com instruções adicionais. GL_NV_fragment_program2, GL_NV_vertex_program2_option e GL_NV_vertex_program3 estendem-no ainda mais.

Código de amostra

Um exemplo trivial de ARB Vertex Shader

!!ARBvp1.0
TEMP vertexClip;
DP4 vertexClip.x, state.matrix.mvp.row[0], vertex.position;
DP4 vertexClip.y, state.matrix.mvp.row[1], vertex.position;
DP4 vertexClip.z, state.matrix.mvp.row[2], vertex.position;
DP4 vertexClip.w, state.matrix.mvp.row[3], vertex.position;
MOV result.position, vertexClip;
MOV result.color, vertex.color;
MOV result.texcoord[0], vertex.texcoord;
END

Um exemplo trivial de ARB Fragment Shader

!!ARBfp1.0
TEMP color;
MUL color, fragment.texcoord[0].y, 2.0;
ADD color, 1.0, -color;
ABS color, color;
ADD result.color, 1.0, -color;
MOV result.color.a, 1.0;
END

Veja também

Referências