Formato de BC6HBC6H format

O formato BC6H é um formato de compactação de textura projetado para dar suporte a espaços de cores de intervalo altamente dinâmico (HDR) nos dados de origem.The BC6H format is a texture compression format designed to support high-dynamic range (HDR) color spaces in source data.

Sobre o formato BC6H/DXGI _ _ BC6HAbout BC6H/DXGI_FORMAT_BC6H

O formato BC6H fornece compactação de alta qualidade para imagens que usam canais de cor HDR, com um valor de 16 bits para cada canal de cor do valor (16: 16:16).The BC6H format provides high-quality compression for images that use three HDR color channels, with a 16-bit value for each color channel of the value (16:16:16). Não há nenhum suporte para um canal alfa.There is no support for an alpha channel.

BC6H é especificado pelos seguintes valores de _ enumeração de formato DXGI:BC6H is specified by the following DXGI_FORMAT enumeration values:

  • Dxgi _ BC6H de formato não _ _ Type.DXGI_FORMAT_BC6H_TYPELESS.
  • Dxgi _ FORMAT _ BC6H _ UF16.DXGI_FORMAT_BC6H_UF16. Esse formato BC6H não usa um bit de sinal nos valores de canal de cor da ponto flutuante de 16 bits.This BC6H format does not use a sign bit in the 16-bit floating point color channel values.
  • Dxgi _ FORMAT _ BC6H _ SF16.DXGI_FORMAT_BC6H_SF16. Esse formato BC6H usa um bit de sinal nos valores de canal de cor da ponto flutuante de 16 bits.This BC6H format uses a sign bit in the 16-bit floating point color channel values.

Observação    O formato de ponto flutuante de 16 bits para canais de cor é geralmente chamado de formato de ponto flutuante "metade".Note   The 16 bit floating point format for color channels is often referred to as a "half" floating point format. Esse formato tem o seguinte layout de bit:This format has the following bit layout: | | | |-----------------------|-------------------------------------------------| | UF16 (float não assinado)UF16 (unsigned float) | 5 bits de expoente + 11 bits de mantissa5 exponent bits + 11 mantissa bits | | SF16 (float assinado)SF16 (signed float) | 1 bit de sinal + 5 bits de expoente + 10 bits de mantissa1 sign bit + 5 exponent bits + 10 mantissa bits |

 

 

O formato BC6H pode ser usado para o recursos de textura Texture2D (incluindo matrizes), Texture3D ou TextureCube (incluindo matrizes).The BC6H format can be used for Texture2D (including arrays), Texture3D, or TextureCube (including arrays) texture resources. Da mesma forma, esse formato se aplica a qualquer superfície de MIP-map associada a esses recursos.Similarly, this format applies to any MIP-map surfaces associated with these resources.

O BC6H usa um tamanho de bloco fixo de 16 bytes (128 bits) e um tamanho de bloco fixo de 4 x 4 texels.BC6H uses a fixed block size of 16 bytes (128 bits) and a fixed tile size of 4x4 texels. Como com os formatos BC anteriores, as imagens de textura maiores que o tamanho de bloco com suporte (4 x 4) são compactadas usando vários blocos.As with previous BC formats, texture images larger than the supported tile size (4x4) are compressed by using multiple blocks. Essa identidade endereçamento se aplica também a imagens tridimensionais, mapas MIP, mapas de cubo e matrizes de textura.This addressing identity applies also to three-dimensional images, MIP-maps, cube maps, and texture arrays. Todos os blocos de imagem devem ser do mesmo formato.All image tiles must be of the same format.

Advertências com o formato BC6H:Caveats with the BC6H format:

  • O BC6H suporta a denormalization de ponto flutuante, mas não suporta INF (infinito) e NaN (não numérico).BC6H supports floating point denormalization, but does not support INF (infinity) and NaN (not a number). A exceção é o modo assinado de BC6H ( _ formato dxgi _ BC6H _ SF16), que dá suporte a-inf (infinito negativo).The exception is the signed mode of BC6H (DXGI_FORMAT_BC6H_SF16), which supports -INF (negative infinity). Esse suporte para -INF é simplesmente um artefato do formato em si e não é especificamente permitido pela codificadores para esse formato.This support for -INF is merely an artifact of the format itself, and is not specifically supported by encoders for this format. Em geral, quando um codificador encontra dados de sinal INF (positivo ou negativo) ou NaN, o codificador deve converter os dados para o valor de representação não INF máximo permitido, e mapear NaN como 0 antes da compactação.In general, when an encoder encounters INF (positive or negative) or NaN input data, the encoder should convert that data to the maximum allowable non-INF representation value, and map NaN to 0 prior to compression.
  • O BC6H não oferece suporte a um canal alfa.BC6H does not support an alpha channel.
  • O decodificador BC6H executa descompactação antes de realizar a filtragem de textura.The BC6H decoder performs decompression before it performs texture filtering.
  • A descompactação do BC6H deve ter precisão de bit, ou seja, o hardware deve retornar resultados que são idênticos ao decodificador descrito nesta documentação.BC6H decompression must be bit-accurate; that is, the hardware must return results that are identical to the decoder described in this documentation.

Implementação do BC6HBC6H implementation

Um bloco de BC6H consiste em bits de modo, pontos de extremidade compactados, índices compactados e um índice de partição opcional.A BC6H block consists of mode bits, compressed endpoints, compressed indices, and an optional partition index. Esse formato especifica 14 modos diferentes.This format specifies 14 different modes.

Uma cor de ponto de extremidade é armazenada como um trio RGB.An endpoint color is stored as an RGB triplet. O BC6H define uma paleta de cores em uma linha aproximada em um número de pontos de extremidade de cores definidos.BC6H defines a palette of colors on an approximate line across a number of defined color endpoints. Além disso, dependendo do modo, um bloco pode ser dividido em duas regiões ou tratado como uma única região, onde um bloco de duas regiões tem um conjunto separado de pontos de extremidade de cor para cada região.Also, depending on the mode, a tile can be divided into two regions or treated as a single region, where a two-region tile has a separate set of color endpoints for each region. O BC6H armazena um índice de paleta por texel.BC6H stores one palette index per texel.

No caso de duas regiões, há 32 partições possíveis.In the two-region case, there are 32 possible partitions.

Decodificar o formato BC6HDecoding the BC6H format

O pseudocódigo a seguir mostra as etapas para descompactar o pixel em (x, y) que recebe o bloco de 16 bytes BC6H.The pseudocode below shows the steps to decompress the pixel at (x,y) given the 16 byte BC6H block.

decompress_bc6h(x, y, block)
{
    mode = extract_mode(block);
    endpoints;
    index;
    
    if(mode.type == ONE)
    {
        endpoints = extract_compressed_endpoints(mode, block);
        index = extract_index_ONE(x, y, block);
    }
    else //mode.type == TWO
    {
        partition = extract_partition(block);
        region = get_region(partition, x, y);
        endpoints = extract_compressed_endpoints(mode, region, block);
        index = extract_index_TWO(x, y, partition, block);
    }
    
    unquantize(endpoints);
    color = interpolate(index, endpoints);
    finish_unquantize(color);
}

A tabela a seguir contém os valores e a contagem de bit de cada um dos 14 formatos possíveis para blocos de BC6H.The following table contains the bit count and values for each of the 14 possible formats for BC6H blocks.

ModeMode Índices de partiçãoPartition Indices PartitionPartition Pontos de extremidade de corColor Endpoints Bits de modoMode Bits
11 46 bits46 bits 5 bits5 bits 75 bits (10.555, 10.555, 10.555)75 bits (10.555, 10.555, 10.555) 2 bits (00)2 bits (00)
22 46 bits46 bits 5 bits5 bits 75 bits (7666, 7666, 7666)75 bits (7666, 7666, 7666) 2 bits (01)2 bits (01)
33 46 bits46 bits 5 bits5 bits 72 bits (11.555, 11.444, 11.444)72 bits (11.555, 11.444, 11.444) 5 bits (00010)5 bits (00010)
44 46 bits46 bits 5 bits5 bits 72 bits (11.444, 11.555, 11.444)72 bits (11.444, 11.555, 11.444) 5 bits (00110)5 bits (00110)
55 46 bits46 bits 5 bits5 bits 72 bits (11.444, 11.444, 11.555)72 bits (11.444, 11.444, 11.555) 5 bits (01010)5 bits (01010)
66 46 bits46 bits 5 bits5 bits 72 bits (9555, 9555, 9555)72 bits (9555, 9555, 9555) 5 bits (01110)5 bits (01110)
77 46 bits46 bits 5 bits5 bits 72 bits (8666, 8555, 8555)72 bits (8666, 8555, 8555) 5 bits (10010)5 bits (10010)
88 46 bits46 bits 5 bits5 bits 72 bits (8555, 8666, 8555)72 bits (8555, 8666, 8555) 5 bits (10110)5 bits (10110)
99 46 bits46 bits 5 bits5 bits 72 bits (8555, 8555, 8666)72 bits (8555, 8555, 8666) 5 bits (11010)5 bits (11010)
1010 46 bits46 bits 5 bits5 bits 72 bits (6666, 6666, 6666)72 bits (6666, 6666, 6666) 5 bits (11110)5 bits (11110)
1111 63 bits63 bits 0 bits0 bits 60 bits (10.10, 10.10, 10.10)60 bits (10.10, 10.10, 10.10) 5 bits (00011)5 bits (00011)
1212 63 bits63 bits 0 bits0 bits 60 bits (11.9, 11.9, 11.9)60 bits (11.9, 11.9, 11.9) 5 bits (00111)5 bits (00111)
1313 63 bits63 bits 0 bits0 bits 60 bits (12.8, 12.8, 12.8)60 bits (12.8, 12.8, 12.8) 5 bits (01011)5 bits (01011)
1414 63 bits63 bits 0 bits0 bits 60 bits (16.4, 16.4, 16.4)60 bits (16.4, 16.4, 16.4) 5 bits (01111)5 bits (01111)

 

Cada formato nesta tabela pode ser identificado exclusivamente pelos bits de modo.Each format in this table can be uniquely identified by the mode bits. Os dez primeiros modos são usados para blocos de duas regiões e o campo de bit de modo pode ter dois ou cinco bits de comprimento.The first ten modes are used for two-region tiles, and the mode bit field can be either two or five bits long. Esses blocos também têm campos para os pontos de extremidade de cor compactados (72 ou 75 bits), a partição (5 bits) e os índices de partição (46 bits).These blocks also have fields for the compressed color endpoints (72 or 75 bits), the partition (5 bits), and the partition indices (46 bits).

Para os pontos de extremidade de cor compactados, os valores na tabela anterior denotam a precisão dos pontos de extremidade armazenados RGB e o número de bits usados para cada valor de cor.For the compressed color endpoints, the values in the preceding table note the precision of the stored RGB endpoints, and the number of bits used for each color value. Por exemplo, o modo 3 especifica um nível de precisão de ponto de extremidade de cor de valor 11, e o número de bits usados para armazenar os valores delta dos pontos de extremidade transformados para as cores vermelho, azul e verde (5, 4 e 4 respectivamente).For example, mode 3 specifies a color endpoint precision level of 11, and the number of bits used to store the delta values of the transformed endpoints for the red, blue and green colors (5, 4, and 4 respectively). O modo 10 não usa compactação delta e armazena em vez disso todos os pontos de extremidade de cor explicitamente.Mode 10 does not use delta compression, and instead stores all four color endpoints explicitly.

Os últimos quatro modos de bloco são usados para blocos de uma região, onde o campo de modo é 5 bits.The last four block modes are used for one-region tiles, where the mode field is 5 bits. Esses blocos têm campos para os pontos de extremidade (60 bits) e os índices compactados (63 bits).These blocks have fields for the endpoints (60 bits) and the compressed indices (63 bits). O modo 11 (assim como o modo 10) não usa compactação delta e armazena em vez disso ambos os pontos de extremidade de cor explicitamente.Mode 11 (like Mode 10) does not use delta compression, and instead stores both color endpoints explicitly.

Os modos 10011, 10111, 11011 e 11111 (não mostrados) são reservados.Modes 10011, 10111, 11011, and 11111 (not shown) are reserved. Não use-os em seu codificador.Do not use these in your encoder. Se blocos forem passados ao hardware com um desses modos especificados, o bloco descompactado resultante deverá conter todos os zeros em todos os canais, exceto para o canal alfa.If the hardware is passed blocks with one of these modes specified, the resulting decompressed block must contain all zeroes in all channels except for the alpha channel.

Para o BC6H, o canal alfa sempre deve retornar 1.0, independentemente do modo.For BC6H, the alpha channel must always return 1.0 regardless of the mode.

Conjunto de partições BC6HBC6H partition set

Há 32 conjuntos de partição possíveis para um bloco de duas regiões, e que estão definidos na tabela a seguir.There are 32 possible partition sets for a two-region tile, and which are defined in the table below. Cada bloco de 4 x 4 representa uma única forma.Each 4x4 block represents a single shape.

tabela dos conjuntos de partição bc6h

Nesta tabela de conjuntos de partição, a entrada em negrito e sublinhada é o local do índice correção para o subconjunto 1 (que é especificado com um bit a menos).In this table of partition sets, the bolded and underlined entry is the location of the fix-up index for subset 1 (which is specified with one less bit). O índice de correção de subconjunto 0 é sempre o índice 0, uma vez que o particionamento é sempre organizado de tal forma que o índice 0 esteja sempre o subconjunto 0.The fix-up index for subset 0 is always index 0, as the partitioning is always arranged such that index 0 is always in subset 0. A ordem de partição vai do canto superior esquerdo para o canto inferior direito e, em seguida, move-se da esquerda para a direita e de cima para baixo.Partition order goes from top-left to bottom-right, moving left to right and then top to bottom.

Formato de ponto de extremidade compactado BC6HBC6H compressed endpoint format

campos de bit para formatos de ponto de extremidade bc6h compactado

Esta tabela mostra os campos de bit para os pontos de extremidade compactados como uma função de formato de ponto de extremidade, com cada coluna especificando uma codificação e cada linha especificando um campo de bit.This table shows the bit fields for the compressed endpoints as a function of the endpoint format, with each column specifying an encoding and each row specifying a bit field. Essa abordagem ocupa 82 bits para blocos de duas regiões e 65 bits para blocos de uma região.This approach takes up 82 bits for two-region tiles and 65 bits for one-region tiles. Por exemplo, os primeiros 5 bits para a codificação de uma região [ 16 4 ] acima (especificamente a coluna mais à direita) são bits m [ 4:0 ] , os próximos 10 bits são bits RW [ 9:0 ] e assim por diante com os últimos 6 bits que contêm BW [ 10:15 ] .As an example, the first 5 bits for the one-region [16 4] encoding above (specifically the right-most column) are bits m[4:0], the next 10 bits are bits rw[9:0], and so on with the last 6 bits containing bw[10:15].

Os nomes dos campos na tabela acima são definidos da seguinte maneira:The field names in the table above are defined as follows:

CampoField VariávelVariable
mm modemode
dd índice de formashape index
rwrw Endpt [ 0 ] . Um [ 0]endpt[0].A[0]
rxrx Endpt [ 0 ] . B [ 0]endpt[0].B[0]
ryry Endpt [ 1 ] . Um [ 0]endpt[1].A[0]
rzrz Endpt [ 1 ] . B [ 0]endpt[1].B[0]
gwgw Endpt [ 0 ] . Um [ 1]endpt[0].A[1]
gxgx Endpt [ 0 ] . B [ 1]endpt[0].B[1]
gygy Endpt [ 1 ] . Um [ 1]endpt[1].A[1]
gzgz Endpt [ 1 ] . B [ 1]endpt[1].B[1]
bwbw Endpt [ 0 ] . A [ 2]endpt[0].A[2]
bxbx Endpt [ 0 ] . B [ 2]endpt[0].B[2]
byby Endpt [ 1 ] . A [ 2]endpt[1].A[2]
bzbz Endpt [ 1 ] . B [ 2]endpt[1].B[2]

 

Endpt [ i ] , onde eu é 0 ou 1, refere-se ao 0º ou ao primeiro conjunto de pontos de extremidade, respectivamente.Endpt[i], where i is either 0 or 1, refers to the 0th or 1st set of endpoints respectively.

Extensão de sinal para valores de ponto de extremidadeSign extension for endpoint values

Para os blocos de duas regiões, há quatro valores de ponto de extremidade que pode ter seu sinal estendido.For two-region tiles, there are four endpoint values that can be sign extended. Endpt [ 0 ] . Um será assinado somente se o formato for um formato assinado; os outros pontos de extremidade serão assinados somente se o ponto de extremidades tiver sido transformado ou se o formato for um formato assinado.Endpt[0].A is signed only if the format is a signed format; the other endpoints are signed only if the endpoint was transformed, or if the format is a signed format. O código a seguir demonstra o algoritmo para estender o sinal dos valores de ponto de extremidade de duas regiões.The code below demonstrates the algorithm for extending the sign of two-region endpoint values.

static void sign_extend_two_region(Pattern &p, IntEndpts endpts[NREGIONS_TWO])
{
    for (int i=0; i<NCHANNELS; ++i)
    {
      if (BC6H::FORMAT == SIGNED_F16)
        endpts[0].A[i] = SIGN_EXTEND(endpts[0].A[i], p.chan[i].prec);
      if (p.transformed || BC6H::FORMAT == SIGNED_F16)
      {
        endpts[0].B[i] = SIGN_EXTEND(endpts[0].B[i], p.chan[i].delta[0]);
        endpts[1].A[i] = SIGN_EXTEND(endpts[1].A[i], p.chan[i].delta[1]);
        endpts[1].B[i] = SIGN_EXTEND(endpts[1].B[i], p.chan[i].delta[2]);
      }
    }
}

Para blocos de uma região, o comportamento é o mesmo, somente com Endpt [ 1 ] removido.For one-region tiles, the behavior is the same, only with endpt[1] removed.

static void sign_extend_one_region(Pattern &p, IntEndpts endpts[NREGIONS_ONE])
{
    for (int i=0; i<NCHANNELS; ++i)
    {
    if (BC6H::FORMAT == SIGNED_F16)
        endpts[0].A[i] = SIGN_EXTEND(endpts[0].A[i], p.chan[i].prec);
    if (p.transformed || BC6H::FORMAT == SIGNED_F16) 
        endpts[0].B[i] = SIGN_EXTEND(endpts[0].B[i], p.chan[i].delta[0]);
    }
}

Transformar inversão para valores de ponto de extremidadeTransform inversion for endpoint values

Para blocos de duas regiões, a transformação aplica o inverso da codificação de diferença, adicionando o valor base em Endpt [ 0 ] . Um para as três outras entradas para um total de 9 adicionar operações.For two-region tiles, the transform applies the inverse of the difference encoding, adding the base value at endpt[0].A to the three other entries for a total of 9 add operations. Na imagem abaixo, o valor base é representado como "A0" e tem a maior precisão de ponto flutuante.In the image below, the base value is represented as "A0" and has the highest floating point precision. "A1", "B0" e "B1" são todos os deltas calculados a partir do valor de âncora, e esses valores delta são representados com precisão mais baixa."A1," "B0," and "B1" are all deltas calculated from the anchor value, and these delta values are represented with lower precision. (A0 corresponde a Endpt [ 0 ] . A, B0 corresponde a Endpt [ 0 ] . B, a1 corresponde a Endpt [ 1 ] . A e B1 corresponde a Endpt [ 1 ] . B.)(A0 corresponds to endpt[0].A, B0 corresponds to endpt[0].B, A1 corresponds to endpt[1].A, and B1 corresponds to endpt[1].B.)

cálculo dos valores de ponto de extremidade de inversão de transformação

Para blocos de uma região, há apenas um deslocamento delta e, portanto, apenas 3 operações de adição.For one-region tiles there is only one delta offset, and therefore only 3 add operations.

O descompactador deve garantir que os resultados da transformação inversa não irão exceder a precisão de Endpt [ 0 ] . a.The decompressor must ensure that that the results of the inverse transform will not overflow the precision of endpt[0].a. No caso de um estouro, os valores resultantes da transformação inversa devem ser encapsulados dentro do mesmo número de bits.In the case of an overflow, the values resulting from the inverse transform must wrap within the same number of bits. Se a precisão de A0 for "p" bits, o algoritmo de transformação é:If the precision of A0 is "p" bits, then the transform algorithm is:

B0 = (B0 + A0) & ((1 << p) - 1)

Para formatos assinados, os resultados do cálculo do delta também devem ter seu sinal estendido.For signed formats, the results of the delta calculation must be sign extended as well. Se a operação de extensão do sinal considerar estender ambos os sinais, onde 0 é positivo e 1 é negativo, a extensão de sinal de 0 se encarregará da vinculação acima.If the sign extension operation considers extending both signs, where 0 is positive and 1 is negative, then the sign extension of 0 takes care of the clamp above. De maneira equivalente, após a vinculação acima, apenas um valor de 1 (negativo) precisa ter o sinal estendido.Equivalently, after the clamp above, only a value of 1 (negative) needs to be sign extended.

Desquantização de pontos de extremidade de corUnquantization of color endpoints

Considerando os pontos de extremidade não compactados, a próxima etapa é executar uma desquantização inicial dos pontos de extremidade de cor.Given the uncompressed endpoints, the next step is to perform an initial unquantization of the color endpoints. Isso envolve três etapas:This involves three steps:

  • Um desquantização de paletas de coresAn unquantization of the color palettes
  • Interpolação de paletasInterpolation of the palettes
  • Finalização da desquantizaçãoUnquantization finalization

Dividir o processo de desquantização em duas partes (desquantização da paleta de cores antes da interpolação e desquantização final após a interpolação) reduz o número de operações de multiplicação necessárias quando comparado a um processo completo de desquantização antes da interpolação de paleta.Separating the unquantization process into two parts (color palette unquantization before interpolation and final unquantization after interpolation) reduces the number of multiplication operations required when compared to a full unquantization process before palette interpolation.

O código a seguir ilustra o processo para recuperar estimativas dos valores de cor de 16 bits original e, em seguida, usando os valores de peso fornecidos para adicionar 6 valores de cor adicional à paleta.The code below illustrates the process for retrieving estimates of the original 16-bit color values, and then using the supplied weight values to add 6 additional color values to the palette. A mesma operação é executada em cada canal.The same operation is performed on each channel.

int aWeight3[] = {0, 9, 18, 27, 37, 46, 55, 64};
int aWeight4[] = {0, 4, 9, 13, 17, 21, 26, 30, 34, 38, 43, 47, 51, 55, 60, 64};

// c1, c2: endpoints of a component
void generate_palette_unquantized(UINT8 uNumIndices, int c1, int c2, int prec, UINT16 palette[NINDICES])
{
    int* aWeights;
    if(uNumIndices == 8)
        aWeights = aWeight3;
    else  // uNumIndices == 16
        aWeights = aWeight4;

    int a = unquantize(c1, prec); 
    int b = unquantize(c2, prec);

    // interpolate
    for(int i = 0; i < uNumIndices; ++i)
        palette[i] = finish_unquantize((a * (64 - aWeights[i]) + b * aWeights[i] + 32) >> 6);
}

O exemplo de código a seguir demonstra o processo de interpolação, com as seguintes observações:The next code sample demonstrates the interpolation process, with the following observations:

  • Como a gama completa de valores de cor para a função unquantize (abaixo) fica entre -32768 e 65535, o interpolador é implementado usando aritmética assinada de 17 bits.Since the full range of color values for the unquantize function (below) are from -32768 to 65535, the interpolator is implemented using 17-bit signed arithmetic.
  • Após a interpolação, os valores são passados para a função de ** _ desquantificação de término** (descrita no terceiro exemplo nesta seção), que aplica o dimensionamento final.After interpolation, the values are passed to the finish_unquantize function (described in the third sample in this section), which applies the final scaling.
  • Todos os descompactadores de hardware são obrigatórios para retornar resultados precisos de bit com essas funções.All hardware decompressors are required to return bit-accurate results with these functions.
int unquantize(int comp, int uBitsPerComp)
{
    int unq, s = 0;
    switch(BC6H::FORMAT)
    {
    case UNSIGNED_F16:
        if(uBitsPerComp >= 15)
            unq = comp;
        else if(comp == 0)
            unq = 0;
        else if(comp == ((1 << uBitsPerComp) - 1))
            unq = 0xFFFF;
        else
            unq = ((comp << 16) + 0x8000) >> uBitsPerComp;
        break;

    case SIGNED_F16:
        if(uBitsPerComp >= 16)
            unq = comp;
        else
        {
            if(comp < 0)
            {
                s = 1;
                comp = -comp;
            }

            if(comp == 0)
                unq = 0;
            else if(comp >= ((1 << (uBitsPerComp - 1)) - 1))
                unq = 0x7FFF;
            else
                unq = ((comp << 15) + 0x4000) >> (uBitsPerComp-1);

            if(s)
                unq = -unq;
        }
        break;
    }
    return unq;
}

concluir _ unquantificate é chamado após a interpolação da paleta.finish_unquantize is called after palette interpolation. A função unquantize adia o dimensionamento por 31/32 para assinado, 31/64 para não assinado.The unquantize function postpones the scaling by 31/32 for signed, 31/64 for unsigned. Esse comportamento é necessário para obter o valor final no intervalo de metade válido (-0x7BFF ~ 0x7BFF) após a interpolação de paleta para reduzir o número de multiplicações necessárias.This behavior is required to get the final value into valid half range(-0x7BFF ~ 0x7BFF) after the palette interpolation is completed in order to reduce the number of necessary multiplications. terminar _ desquantificar aplica o dimensionamento final e retorna um valor curto sem sinal que é reinterpretado na metade.finish_unquantize applies the final scaling and returns an unsigned short value that gets reinterpreted into half.

unsigned short finish_unquantize(int comp)
{
    if(BC6H::FORMAT == UNSIGNED_F16)
    {
        comp = (comp * 31) >> 6;                                         // scale the magnitude by 31/64
        return (unsigned short) comp;
    }
    else // (BC6H::FORMAT == SIGNED_F16)
    {
        comp = (comp < 0) ? -(((-comp) * 31) >> 5) : (comp * 31) >> 5;   // scale the magnitude by 31/32
        int s = 0;
        if(comp < 0)
        {
            s = 0x8000;
            comp = -comp;
        }
        return (unsigned short) (s | comp);
    }
}

Tópicos relacionadosRelated topics

Compactação de bloco de texturaTexture block compression