Estágios de mosaico

  • Artigo

O runtime do Direct3D 11 dá suporte a três novos estágios que implementam o mosaico, que converte superfícies de subdivisão com poucos detalhes em primitivos de detalhes mais altos na GPU. O bloco de mosaico organiza (ou decompõe) as superfícies de ordem superior em estruturas adequadas para renderização.

Implementando o mosaico no hardware, um pipeline gráfico pode avaliar modelos com menos detalhes (contagem inferior de polígonos) e renderizar em maiores detalhes. Embora o mosaico de software possa ser feito, o mosaico implementado por hardware pode gerar uma quantidade incrível de detalhes visuais (incluindo suporte para o mapeamento de deslocamento) sem adicionar os detalhes visuais aos tamanhos de modelo e paralisar as taxas de atualização.

Benefícios de mosaico

Mosaico:

  • Salva muita memória e largura de banda, o que permite que um aplicativo renderize superfícies detalhadas mais altas de modelos de baixa resolução. A técnica de mosaico implementada no pipeline do Direct3D 11 também dá suporte ao mapeamento de deslocamento, que pode produzir quantidades impressionantes de detalhes da superfície.
  • Dá suporte a técnicas de renderização escalonável, como níveis de detalhes contínuos ou dependentes de exibição, que podem ser calculados em tempo real.
  • Melhora o desempenho executando cálculos caros em menor frequência (fazendo cálculos em um modelo de detalhes mais baixos). Isso pode incluir a mesclagem de cálculos usando formas de mesclagem ou destinos que mudam de forma para uma animação mais realista ou cálculos de física para a detecção de colisão ou dinâmica de corpo virtual.

O pipeline do Direct3D 11 implementa o mosaico no hardware, o que descompõe o trabalho da CPU para a GPU. Isso pode levar a melhorias de desempenho muito grandes se um aplicativo implementar um grande número de destinos que mudam de forma e/ou modelos de aplicação de capas/deformação mais sofisticados. Para acessar os novos recursos de mosaico, você deve aprender sobre alguns novos estágios de pipeline.

Novos estágios de pipeline

O mosaico usa a GPU para calcular uma superfície mais detalhada de uma superfície construída a partir de patches de quadrupleto, patches de triângulo ou isolines. Para aproximar a superfície de ordem superior, cada patch é subdividido em triângulos, pontos ou linhas usando fatores de mosaico. O pipeline do Direct3D 11 implementa o mosaico usando três novos estágios de pipeline:

  • Estágio do Sombreador de Casco – um estágio de sombreador programável que produz um patch de geometria (e constantes de patch) que correspondem a cada patch de entrada (quad, triângulo ou linha).
  • Estágio do Mosaico – um estágio de pipeline de função fixa que cria um padrão de amostragem do domínio que representa o patch de geometria e gera um conjunto de objetos menores (triângulos, pontos ou linhas) que conectam esses exemplos.
  • Estágio do Sombreador de Domínio – um estágio de sombreador programável que calcula a posição do vértice que corresponde a cada exemplo de domínio.

O diagrama a seguir realça os novos estágios do pipeline do Direct3D 11.

diagrama do pipeline do direct3d 11 que destaca os estágios do sombreador de domínio, sombreadores hull e mosaico

O diagrama a seguir mostra o progresso por meio dos estágios de mosaico. A progressão começa com a superfície subdividida em poucos detalhes. A progressão a seguir destaca o patch de entrada com o patch de geometria correspondente, amostras de domínio, e triângulos que conectam essas amostras. Por fim, a progressão destaca os vértices que correspondem a essas amostras.

diagrama da progressão de mosaico

Estágio Hull-Shader

Um sombreador de casco - que é invocado uma vez por patch - transforma pontos de controle de entrada que definem uma superfície de baixa ordem em pontos de controle que compõem um patch. Ele também faz alguns cálculos por patch para fornecer dados para o estágio de mosaico e o estágio de domínio. No nível mais simples da caixa preta, o estágio do sombreador de casco seria semelhante ao diagrama a seguir.

diagrama da fase de sombreadores hull

Um sombreador de casco é implementado com uma função HLSL e tem as seguintes propriedades:

  • A entrada do sombreador está entre 1 e 32 pontos de controle.
  • A saída do sombreador é entre 1 e 32 pontos de controle, independentemente do número de fatores de mosaico. Os pontos de controle de saída de um sombreador hull podem ser consumidos pelo estágio do sombreador de domínio. Os dados constantes de patch podem ser consumidos por um sombreador de domínio; Os fatores de mosaico podem ser consumidos pelo sombreador de domínio e pelo estágio de mosaico.
  • Os fatores de mosaico determinam quanto subdividir cada patch.
  • O sombreador declara o estado exigido pelo estágio do mosaico. Isso inclui informações como o número de pontos de controle, o tipo da face do patch e o tipo de particionamento a ser usado durante a criação do mosaico. Essas informações são exibidas como declarações normalmente na frente do código do sombreador.
  • Se o estágio do sombreador de casco definir qualquer fator de mosaico de borda como = 0 ou NaN, o patch será abatido. Como resultado, o estágio de mosaico pode ou não ser executado, o sombreador de domínio não será executado e nenhuma saída visível será produzida para esse patch.

Em um nível mais profundo, um sombreador de casco realmente opera em duas fases: uma fase de ponto de controle e uma fase de constante de patch, que são executadas em paralelo pelo hardware. O compilador HLSL extrai o paralelismo em um sombreador hull e o codifica em código de bytes que orienta o hardware.

  • A fase de ponto de controle opera uma vez para cada ponto de controle, lendo os pontos de controle para um patch e gerando um ponto de controle de saída (identificado por um ControlPointID).
  • A fase de patch constante opera uma vez por patch para gerar fatores de mosaico de borda e outras constantes por patch. Internamente, muitas fases de constante de patch podem ser executadas ao mesmo tempo. A fase de patch constante tem acesso somente leitura a todos os pontos de controle de entrada e saída.

Aqui está um exemplo de um sombreador de casco:

[patchsize(12)]
[patchconstantfunc(MyPatchConstantFunc)]
MyOutPoint main(uint Id : SV_ControlPointID,
     InputPatch<MyInPoint, 12> InPts)
{
     MyOutPoint result;
     
     ...
     
     result = TransformControlPoint( InPts[Id] );

     return result;
}

Para obter um exemplo que cria um sombreador de casco, consulte How To: Create a Hull Shader( Como criar um sombreador de casco).

Estágio do Mosaico

O mosaico é um estágio de função fixa inicializado pela associação de um sombreador de casco ao pipeline (confira Como inicializar o estágio do mosaico). O objetivo do estágio de mosaico é subdividir um domínio (quad, tri ou linha) em muitos objetos menores (triângulos, pontos ou linhas). O mosaico organiza um domínio canônico em um sistema de coordenadas normalizado (zero-para-um). Por exemplo, um domínio quadrupleto é transformado em um quadrado de unidade.

O mosaico opera uma vez por patch usando os fatores de mosaico (que especificam o quão delicadamente o domínio será transformado em mosaico) e o tipo de particionamento (que especifica o algoritmo usado para dividir um patch) que são transmitidos do estágio de sombreador hull. O mosaico gera coordenadas uv (e, opcionalmente, w) e a topologia de superfície para o estágio do sombreador de domínio.

Internamente, o mosaico opera em duas fases:

  • A primeira fase processa os fatores de mosaico, corrigindo problemas de arredondamento, manipulando fatores muito pequenos, reduzindo e combinando fatores, usar aritmética de ponto flutuante de 32 bits.
  • A segunda fase gera listas de pontos ou topologias com base no tipo de particionamento selecionado. Isso é a tarefa principal do estágio de mosaico e usa frações de 16 bits com aritmética de ponto fixo. A aritmética de ponto fixo permite a aceleração de hardware, mantendo a precisão aceitável. Por exemplo, dado um patch com 64 metros de largura, essa precisão pode colocar pontos em uma resolução de 2 mm.
Tipo de particionamento Intervalo
fractional_odd [1...63]
fractional_even Intervalo TessFactor: [2..64]
Número inteiro Intervalo TessFactor: [1..64]
pow2 Intervalo TessFactor: [1..64]

Estágio Domain-Shader

Um sombreador de domínio calcula a posição de vértice de um ponto subdividido no patch de saída. Um sombreador de domínio é executado uma vez por ponto de saída do estágio do mosaico e tem acesso somente leitura às coordenadas UV de saída do estágio do mosaico, ao patch de saída do sombreador de casco e às constantes de patch de saída do sombreador de casco, como mostra o diagrama a seguir.

diagrama do estágio do sombreador de domínio

As propriedades do sombreador de domínio incluem:

  • Um sombreador de domínio é invocado uma vez por coordenada de saída do estágio do mosaico.
  • Um sombreador de domínio consome pontos de controle de saída do estágio do sombreador de casco.
  • Um sombreador de domínio gera a posição de um vértice.
  • As entradas são as saídas do sombreador de casco, incluindo pontos de controle, dados constantes de patch e fatores de mosaico. Os fatores de mosaico podem incluir os valores usados pelo mosaico de função fixa, bem como os valores brutos (antes de arredondar por mosaico inteiro, por exemplo), o que facilita a geomorfização, por exemplo.

Depois que o sombreador de domínio for concluído, o mosaico será concluído e os dados de pipeline continuarão para o próximo estágio do pipeline (sombreador de geometria, sombreador de pixel etc. Um sombreador de geometria que espera primitivos com adjacência (por exemplo, 6 vértices por triângulo) não é válido quando mosaico está ativo (isso resulta em um comportamento indefinido, sobre o qual a camada de depuração emitirá um aviso).

Aqui está um exemplo de um sombreador de domínio:

void main( out    MyDSOutput result, 
           float2 myInputUV : SV_DomainPoint, 
           MyDSInput DSInputs,
           OutputPatch<MyOutPoint, 12> ControlPts, 
           MyTessFactors tessFactors)
{
     ...

     result.Position = EvaluateSurfaceUV(ControlPoints, myInputUV);
}

APIs para inicializar estágios de mosaico

O Mosaico é implementado com dois novos estágios de sombreador programáveis: um sombreador de casco e um sombreador de domínio. Esses novos estágios de sombreador são programados com código HLSL definido no modelo de sombreador 5. Os novos destinos do sombreador são: hs_5_0 e ds_5_0. Como todos os estágios de sombreador programáveis, o código para o hardware é extraído de sombreadores compilados passados para o runtime quando os sombreadores são associados ao pipeline usando APIs como DSSetShader e HSSetShader. Mas, primeiro, o sombreador deve ser criado usando APIs como CreateHullShader e CreateDomainShader.

Habilite o mosaico criando um sombreador hull e vinculando-o ao estágio de sombreador hull (isso configura automaticamente o estágio de mosaico). Para gerar as posições de vértice final dos patches de mosaico, você também precisará criar um sombreador domínio e associá-lo ao estágio do sombreador de domínio. Depois que o mosaico estiver habilitado, a entrada de dados para o estágio de assembler de entrada deve ser dados de patch. Ou seja, a topologia do assembler de entrada deve ser uma topologia de constante de patch de D3D11_PRIMITIVE_TOPOLOGY definida com IASetPrimitiveTopology.

Para desabilitar o mosaico, defina os sombreadores hull e o sombreador de domínio NULL. Nem o estágio de sombreador de geometry nem o estágio de saída de fluxo podem ler pontos de controle de saída do sombreador de casco ou dados de patch.

Como:

A documentação também contém exemplos para inicializar os estágios de mosaico.

Item Descrição
Como criar um sombreador de casco
 Crie um sombreador de casco.
Como criar um sombreador de casco
 Projete um sombreador de casco.
Como inicializar o estágio do mosaico
 Inicialize o estágio de mosaico.
Como criar um sombreador de domínio
 Crie um sombreador de domínio.
Como criar um sombreador de domínio
 Crie um sombreador de domínio.

Pipeline de Gráficos