Decodificação de Cmask

Cmask é uma superfície que armazena metadados para cada bloco de 8x8 pixels (bloco de Cmask) no buffer de cores associado. Os metadados são a parte essencial do mecanismo de Fast Clear, mas não se limitam a ele. Fast Clear é um método para ignorar a operação Clear nas regiões de um buffer de cores que serão substituídas pela renderização. Esse método consiste em três etapas. A primeira etapa exige que a superfície Cmask seja inicializada para que cada metadado rastreie o bloco 8x8 associado no buffer de cores como limpo. A segunda etapa emite qualquer sequência de operações de desenho que atualizam o buffer de cores configurado para usar esse Cmask. Ao mesmo tempo, o Color Block (CB) atualiza a superfície Cmask com informações sobre as regiões alteradas do buffer de cores. Quando a renderização termina, todas as regiões que permaneceram inalteradas são limpas (também conhecida como operação Fast Clear Eliminate). Isso geralmente acontece enquanto o buffer de cores faz a transição do estado gravável para o estado legível. Em muitos cenários, é vantajoso saber quais blocos 8x8 (ou até quais sub-blocos) do buffer de cores foram alterados pela renderização. Para isso, é necessário saber como decodificar a superfície Cmask.

Figura 1: O elemento Cmask é um valor de 4 bits (também conhecido como “nibble”) que codifica informações por bloco de Cmask. A decodificação geralmente requer duas etapas. A primeira é extrair o nibble de Cmask (figura 1) que corresponde às coordenadas do bloco de Cmask fornecidas. Isso pode ser feito pela função auxiliar GetCMask do ColorDecompressUtility.hlsli do MiniEngines.

Figura 2: Variantes possíveis de interpretação do nibble de Cmask (figura 1). (1) - cada bit de Cmask codifica se o sub-bloco (dentro de um bloco de Cmask 8x8) correspondente a esse bit foi alterado pela renderização (bit definido) ou permanece com Fast Clear (bit não definido). Essa variante é usada para buffers de cores sem MSAA com Fast Clear habilitado e exportação de dica de VRS desabilitada (disponível somente no XBOX Series X|S). (2) - a variante usada para buffers de cores com MSAA habilitado, com Fast Clear habilitado e exportação de dica de VRS desabilitada. Os dois bits superiores codificam informações de Fast Clear de forma semelhante a (1). Como há apenas dois bits disponíveis para Fast Clear, só pode haver dois sub-blocos dentro de um bloco de Cmask. Os dois bits inferiores codificam quantos planos de bits de Fmask são necessários para codificar os ponteiros de FMask para o bloco 8x8 em questão. O número de planos de bits é limitado pelo log2 do número de amostras no modo MSAA escolhido. (3) - é semelhante a (2), mas os dois bits superiores são definidos como 1 porque esse modo é para buffers de cores com MSAA e Fast Clear desabilitado. (4) - é para buffers de cores com MSAA em que os bits de Fast Clear são reaproveitados para armazenar a dica de taxa de VRS exportada (somente XBOX Series X|S), mas os bits inferiores, de forma semelhante a (2) e (3), codificam o número de planos de bits de Fmask para todo o bloco de Cmask. (5) - é semelhante a (4), mas é usado com buffers de cores sem MSAA, portanto os dois bits inferiores não são usados. Assim que o nibble de Cmask é recuperado, a segunda etapa precisa interpretar o significado dos quatro bits. Isso depende de vários fatores, como se o buffer de cores correspondente tem ou não MSAA habilitado, qual é a profundidade de bits do formato de cor, o modo de microblocos (no XBOX One e no XBOX Series X|S) ou o modo de swizzling (XBOX Series X|S) do buffer de cores e se a dica de VRS é exportada (XBOX Series X|S). A Figura 2 mostra cinco variantes de esquemas de codificação, dependendo de como o Color Block (CB) foi configurado durante a renderização. Se ele foi configurado para usar Fast Clear, cada nibble de Cmask codifica quais sub-blocos dentro do bloco de Cmask correspondente foram alterados. Para superfícies com e sem MSAA, as codificações são ligeiramente diferentes (variantes (1) e (2)), porque apenas dois bits estão disponíveis para rastrear os estados dos sub-blocos no bloco 8x8. A Figura 3 demonstra as configurações possíveis de sub-blocos dentro de um bloco de Cmask e os mapeamentos entre os bits de um nibble de Cmask e os sub-blocos dentro do bloco de Cmask correspondente a esse nibble. Essas configurações podem ser usadas com buffers de cores sem MSAA.

Variantes possíveis de posicionamento de sub-blocos dentro de um bloco de Cmask (8x8 pixels) para buffers de cores sem MSAA (e com exportação de dica de VRS desabilitada no XBOX Series X|S).

Figura 3: Variantes possíveis de posicionamento de sub-blocos dentro de um bloco de Cmask (8x8 pixels) para buffers de cores sem MSAA (e com exportação de dica de VRS desabilitada no XBOX Series X|S). Observe que sub-blocos diferentes correspondem a bits diferentes do nibble de Cmask (figura 1). Da esquerda para a direita: CM0 — quatro sub-blocos de 8x2 pixels cada, organizados em uma grade 1x4, CM1 — quatro sub-blocos de 2x8 pixels cada, organizados em uma grade 4x1, CM2 — quatro sub-blocos de 4x4 pixels cada, organizados em uma grade 2x2, C3 — quatro sub-blocos de 4x4 pixels cada, organizados em uma grade 2x2 (observe a ordem diferente em comparação com CM2: o bloco inferior esquerdo corresponde a um bit na posição 1) A organização dos sub-blocos nos blocos de Cmask pode ser determinada a partir da profundidade de bits do formato de cor e do modo de blocos/swizzling do buffer de cores. Essas dependências estão resumidas na tabela 1 para o XBOX Series X|S e na tabela 2 para o XBOX One e o XBOX Series X|S.

Bpp do formato de cor / Modo de swizzling	`SW_*_D`	`SW_*_R`	`SW_*_S`	`SW_*_Z`
8-bit	CM0	CM0	CM0	CM2
16-bit	CM0	CM0	CM0	CM2
32-bit	CM2	CM2	CM3	CM2
64-bit	CM0	CM0	CM2	CM2
128-bit	CM3	CM2	CM3	CM2

Tabela 1: A dependência entre a profundidade de bits do formato de cor, o modo de swizzling e os modos de posicionamento de sub-blocos de Cmask (consulte a figura 3) para buffers de cores sem MSAA no XBOX Series X|S. Os modos de swizzling são definidos por XG_SWIZZLE_MODE na biblioteca XG.

Bpp do formato de cor / Modo de microblocos	`THIN`	`DISPLAY`	`ROTATED`
8-bit	CM2	CM0	CM1
16-bit	CM2	CM0	CM1
32-bit	CM2	CM0	CM1
64-bit	CM2	CM0	CM2

Tabela 2: A dependência entre a profundidade de bits do formato de cor, o modo de microblocos e os modos de posicionamento de sub-blocos de Cmask (consulte a figura 3) para buffers de cores sem MSAA no XBOX One e no XBOX Series X|S. Os modos de microblocos correspondem aos sufixos de XG_TILE_MODE na biblioteca XG. Por exemplo, os modos de bloco XG_TILE_MODE_*_THIN usam microblocos THIN. Os microblocos ROTATED não estão em uso, mas são mostrados nesta tabela para fins de completude. As variantes de posicionamento de sub-blocos dentro de um bloco de Cmask para buffers de cores com MSAA habilitado são mostradas na figura 4. No XBOX Series X|S, CMM1 é a única opção possível, independentemente da largura de bits do formato de cor subjacente e do modo de swizzling (é sempre SW_*_R quando o MSAA está ativado). No XBOX One e no XBOX Series X|S, ambas as variantes são possíveis, mas CMM0 só é usado com microblocos ROTATED e formatos de cor com largura de bits inferior a 64 bits por pixel. Como o driver não usa microblocos ROTATED, é muito improvável encontrar esse layout.

Figura 4: Variantes possíveis de posicionamento de sub-blocos dentro de um bloco de Cmask (8x8 pixels) para buffers de cores com MSAA habilitado. CMM0 — dois sub-blocos de 4x8 pixels, CMM1 — dois sub-blocos de 8x4 pixels. As próximas duas páginas contêm o corpo do sombreador PSOverlay do exemplo CMaskDecode, que interpreta o nibble de Cmask.

[RootSignature(FullScreenQuadRS)]
float4 PSOverlay(Interpolators In) : SV_TARGET0
{
    const float4 vRed = float4( 1.0f, 0.0f, 0.0f, 0.5f );
    const float4 vGreen = float4( 0.0f, 1.0f, 0.0f, 0.5f );

    uint2 ScreenPosition = uint2(In.Position.xy);

    // Cmask tile size is always 8x8;
    uint2 CmaskTileCoord = ScreenPosition >> 3;

    // Fetch Cmask value that is has 4 bits
    uint CmaskNibble = g_texThumb[CmaskTileCoord];

#if g_bSubTile

    // Compute coordinates of 2x2 quad within Cmask 8x8 tile
    uint2 QuadLocalCoord = uint2(
        __XB_UBFE(2u, 1u, ScreenPosition.x),
        __XB_UBFE(2u, 1u, ScreenPosition.y)
    );

    /** Based on the layout mode of Cmask sub-tiles and coordinates of the current quad
     *  within Cmask 8x8 tile, determine the position of the bit within a Cmask nibble
     *  that indicates whether the sub-tile covering current quad was touched by
     *  rendering or not
     */
     uint SubTileBitPos = 0;

    if (SubTileLayoutMode == 0)
    {
        /** 2x2 mode.
         *  4x4 pixel tiles correspond to the following bits:
         *      +---+---+
         *      | 0 | 1 |
         *      +---+---+
         *      | 2 | 3 |
         *      +---+---+
         */
        SubTileBitPos = (QuadLocalCoord.x >> 1u) | (QuadLocalCoord.y & 0x2);
    }
    else if (SubTileLayoutMode == 1)
    {
        /** 2x2 rotated mode (Xbox Series X|S only).
         *  4x4 tiles correspond to the following bits:
         *      +---+---+
         *      | 0 | 2 |
         *      +---+---+
         *      | 1 | 3 |
         *      +---+---+
         */
        SubTileBitPos = (QuadLocalCoord.y >> 1u) | (QuadLocalCoord.x & 0x2);
    }
    else if (SubTileLayoutMode == 2)
    {
        /** 4x1 mode (Xbox One only).
         *  2x8 tiles correspond to the following bits:
         *      +-+-+-+-+
         *      | | | | |
         *      |0|1|2|3|
         *      | | | | |
         *      +-+-+-+-+
         */
        SubTileBitPos = QuadLocalCoord.x;
    }
    else if (SubTileLayoutMode == 3)
    {
        /** 1x4 mode.
         *  8x2 tiles correspond to the following bits:
         *      +---0---+
         *      +---1---+
         *      +---2---+
         *      +---3---+
         */
        SubTileBitPos = QuadLocalCoord.y;
    }
    else if (SubTileLayoutMode == 4)
    {
        /** 2x1 mode (Xbox One only, MSAA only).
         *  4x8 tiles correspond to the following bits:
         *      +---+---+
         *      |   |   |
         *      | 0 | 1 |
         *      |   |   |
         *      +---+---+
         */
        SubTileBitPos = 2u + (QuadLocalCoord.x >> 1u);
    }
    else if (SubTileLayoutMode == 5)
    {
        /** 1x2 mode (MSAA only).
         *  8x4 tiles correspond to the following bits:
         *      +-------+
         *      +   0   +
         *      +-------+
         *      +   1   +
         *      +-------+
         */
        SubTileBitPos = 2u + (QuadLocalCoord.y >> 1u);
    }
    return __XB_UBFE(1u, SubTileBitPos, CmaskNibble) != 0 ? vRed : vGreen;
#else
    /** Layout modes 4 and 5 are only set when Msaa is enabled.
     *  That means only upper 2 bits out of 4 are valid
     */
    if (SubTileLayoutMode >= 4)
        return (CmaskNibble & 0xc) != 0 ? vRed : vGreen;
    else
        return (CmaskNibble & 0xf) != 0 ? vRed : vGreen;
#endif
}

Consulte também

Visão geral de gráficos

Porting

Build Paths

Consulte também

​Consulte também

Consulte também