> ## Documentation Index > Fetch the complete documentation index at: https://devdocs.xbox.com/llms.txt > Use this file to discover all available pages before exploring further. # Decodificação de Cmask > 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. O elemento Cmask é um valor de 4 bits (também conhecido como "nibble") que codifica informações por bloco de 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](#cmask-nibble)) que corresponde às coordenadas do bloco de Cmask fornecidas. Isso pode ser feito pela função auxiliar `GetCMask` do **ColorDecompressUtility.hlsli** do *MiniEngines*. Variantes possíveis de interpretação do nibble de Cmask **Figura 2:** *Variantes possíveis de interpretação do nibble de Cmask ([figura 1](#cmask-nibble)). (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](#cmask-nibble-modes) 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](#non-msaa-cmask) 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](#cmask-nibble)). 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](#scarlett-cmask-modes) para o XBOX Series X|S e na [tabela 2](#scorpio-durpio-cmask-modes) 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](#non-msaa-cmask)) 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](#non-msaa-cmask)) 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](#msaa-cmask). 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. Variantes possíveis de posicionamento de sub-blocos dentro de um bloco de Cmask (8x8 pixels) para buffers de cores com MSAA habilitado. **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**](https://learn.microsoft.com/gaming/gdk/docs/gdk-dev/development-downloads/gdk-samples-list#graphics), que interpreta o nibble de Cmask. ```c theme={null} [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](/pt-BR/build/core-features/graphics/overviews/graphics) ## Related topics - [Índice de tópicos sob NDA para desenvolvimento de console com o XBOX GDK](/pt-BR/nda/nda-overview.md) - [Decodificação de áudio Opus de fluxo único com a API XAPU](/pt-BR/build/console-features/audio/overviews/xapu-overview-single-stream-audio-decode.md) - [Manipulação de áudio em tempo real](/pt-BR/services/xbox-services/multiplayer/chat/game-chat2/real-time-audio-manipulation.md) - [Visão geral da XAPU](/pt-BR/build/console-features/audio/overviews/xapu-overview.md) - [Visão geral do hardware de áudio do XBOX Series X|S](/pt-BR/build/console-features/audio/overviews/scarlett-audio.md)