Format BC6HBC6H format

Le format BC6H est un format de compression de texture conçu pour prendre en charge les espaces de couleurs HDR (large-Dynamic Range) dans les données sources.The BC6H format is a texture compression format designed to support high-dynamic range (HDR) color spaces in source data.

À propos du format BC6H/DXGI _ _ BC6HAbout BC6H/DXGI_FORMAT_BC6H

Le format BC6H fournit une compression de haute qualité pour les images qui utilisent trois canaux de couleur HDR, avec une valeur de 16 bits pour chaque canal de couleur de la valeur (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). Il n’existe pas de prise en charge d’un canal alpha.There is no support for an alpha channel.

BC6H est spécifié par les valeurs d' _ énumération de format dxgi suivantes :BC6H is specified by the following DXGI_FORMAT enumeration values:

  • Dxgi _ FORMAT _ BC6H non _ typé.DXGI_FORMAT_BC6H_TYPELESS.
  • Dxgi _ FORMAT _ BC6H _ UF16.DXGI_FORMAT_BC6H_UF16. Ce format BC6H n’utilise pas de bit de signe dans les valeurs de canaux de couleurs à virgule flottante 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. Ce format BC6H utilise un bit de signe dans les valeurs de canaux de couleurs à virgule flottante 16 bits.This BC6H format uses a sign bit in the 16-bit floating point color channel values.

Remarque    Le format à virgule flottante de 16 bits pour les canaux de couleur est souvent appelé format à virgule flottante « demi-point ».Note   The 16 bit floating point format for color channels is often referred to as a "half" floating point format. Ce format utilise la disposition en bits suivante :This format has the following bit layout: | | | |-----------------------|-------------------------------------------------| | UF16 (unsigned float)UF16 (unsigned float) | 5 bits d’exposant + 11 bits de mantisse5 exponent bits + 11 mantissa bits | | SF16 (float signé)SF16 (signed float) | 1 bit de signe + 5 bits d’exposant + 10 bits de mantisse1 sign bit + 5 exponent bits + 10 mantissa bits |

 

 

Le format BC6H peut être utilisé pour les ressources de texture Texture2D (y compris les tableaux), Texture3D ou TextureCube (y compris les tableaux).The BC6H format can be used for Texture2D (including arrays), Texture3D, or TextureCube (including arrays) texture resources. De même, ce format s’applique à toutes les surfaces de la carte MIP associées à ces ressources.Similarly, this format applies to any MIP-map surfaces associated with these resources.

BC6H utilise une taille de bloc fixe de 16 octets (128 bits) et une taille de vignette fixe de texels 4x4.BC6H uses a fixed block size of 16 bytes (128 bits) and a fixed tile size of 4x4 texels. Comme avec les formats BC précédents, les images de texture plus volumineuses que la taille de vignette prise en charge (4x4) sont compressées à l’aide de plusieurs blocs.As with previous BC formats, texture images larger than the supported tile size (4x4) are compressed by using multiple blocks. Cette identité d’adressage s’applique également aux images tridimensionnelles, aux mappages MIP, aux mappages de cube et aux tableaux de texture.This addressing identity applies also to three-dimensional images, MIP-maps, cube maps, and texture arrays. Toutes les vignettes d’image doivent avoir le même format.All image tiles must be of the same format.

Avertissements avec le format BC6H :Caveats with the BC6H format:

  • BC6H prend en charge la dénormalisation à virgule flottante, mais ne prend pas en charge INF (Infinity) et NaN (not a Number).BC6H supports floating point denormalization, but does not support INF (infinity) and NaN (not a number). L’exception est le mode signé de BC6H (DXGI _ format _ BC6H _ SF16), qui prend en charge-INF (infini négatif).The exception is the signed mode of BC6H (DXGI_FORMAT_BC6H_SF16), which supports -INF (negative infinity). Cette prise en charge de-INF est simplement un artefact du format lui-même et n’est pas spécifiquement pris en charge par les encodeurs pour ce format.This support for -INF is merely an artifact of the format itself, and is not specifically supported by encoders for this format. En général, lorsqu’un encodeur rencontre des données d’entrée INF (positives ou négatives) ou NaN, l’encodeur doit convertir ces données en valeur de représentation non-INF autorisée maximale et mapper NaN à 0 avant la compression.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.
  • BC6H ne prend pas en charge un canal alpha.BC6H does not support an alpha channel.
  • Le décodeur BC6H effectue la décompression avant d’effectuer un filtrage de texture.The BC6H decoder performs decompression before it performs texture filtering.
  • La décompression BC6H doit être de bits précis ; autrement dit, le matériel doit retourner des résultats qui sont identiques au décodeur décrit dans cette documentation.BC6H decompression must be bit-accurate; that is, the hardware must return results that are identical to the decoder described in this documentation.

Implémentation de BC6HBC6H implementation

Un bloc BC6H comprend des bits de mode, des points de terminaison compressés, des index compressés et un index de partition facultatif.A BC6H block consists of mode bits, compressed endpoints, compressed indices, and an optional partition index. Ce format spécifie 14 modes différents.This format specifies 14 different modes.

Une couleur de point de terminaison est stockée sous la forme d’un triplet RVB.An endpoint color is stored as an RGB triplet. BC6H définit une palette de couleurs sur une ligne approximative sur un certain nombre de points de terminaison de couleur définis.BC6H defines a palette of colors on an approximate line across a number of defined color endpoints. En outre, selon le mode, une vignette peut être divisée en deux régions ou traitée comme une seule région, où une vignette à deux régions a un ensemble distinct de points de terminaison de couleur pour chaque région.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. BC6H stocke un index de palette par Texel.BC6H stores one palette index per texel.

Dans le cas de deux régions, il existe 32 partitions possibles.In the two-region case, there are 32 possible partitions.

Décodage du format BC6HDecoding the BC6H format

Le pseudo-code ci-dessous montre les étapes à suivre pour décompresser le pixel à (x, y) en fonction du bloc BC6H de 16 octets.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);
}

Le tableau suivant contient le nombre de bits et les valeurs pour chacun des 14 formats possibles pour les blocs BC6H.The following table contains the bit count and values for each of the 14 possible formats for BC6H blocks.

ModeMode Index de partitionPartition Indices PartitionPartition Points de terminaison de couleurColor Endpoints Bits de modeMode 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)

 

Chaque format de cette table peut être identifié de manière unique par les bits de mode.Each format in this table can be uniquely identified by the mode bits. Les dix premiers modes sont utilisés pour les vignettes de deux régions, et le champ de bits de mode peut avoir deux ou cinq bits de long.The first ten modes are used for two-region tiles, and the mode bit field can be either two or five bits long. Ces blocs comportent également des champs pour les points de terminaison de couleur compressés (72 ou 75 bits), la partition (5 bits) et les index de partition (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).

Pour les points de terminaison de couleur compressés, les valeurs du tableau précédent indiquent la précision des points de terminaison RVB stockés et le nombre de bits utilisés pour chaque valeur de couleur.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. Par exemple, le mode 3 spécifie un niveau de précision de point de terminaison de couleur 11 et le nombre de bits utilisés pour stocker les valeurs Delta des points de terminaison transformés pour les couleurs rouge, bleu et vert (respectivement, 5, 4 et 4).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). Le mode 10 n’utilise pas la compression Delta et stocke à la place les quatre points de terminaison de couleur de manière explicite.Mode 10 does not use delta compression, and instead stores all four color endpoints explicitly.

Les quatre derniers modes de blocage sont utilisés pour les vignettes d’une région, où le champ de mode est de 5 bits.The last four block modes are used for one-region tiles, where the mode field is 5 bits. Ces blocs ont des champs pour les points de terminaison (60 bits) et les index compressés (63 bits).These blocks have fields for the endpoints (60 bits) and the compressed indices (63 bits). Le mode 11 (comme le mode 10) n’utilise pas la compression Delta et stocke à la place les deux points de terminaison de couleur de manière explicite.Mode 11 (like Mode 10) does not use delta compression, and instead stores both color endpoints explicitly.

Les modes 10011, 10111, 11011 et 11111 (non affichés) sont réservés.Modes 10011, 10111, 11011, and 11111 (not shown) are reserved. N’utilisez pas celles-ci dans votre encodeur.Do not use these in your encoder. Si le matériel reçoit des blocs avec l’un de ces modes spécifiés, le bloc décompressé résultant doit contenir uniquement des zéros dans tous les canaux, sauf pour le canal alpha.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.

Pour BC6H, le canal alpha doit toujours retourner 1,0 quel que soit le mode.For BC6H, the alpha channel must always return 1.0 regardless of the mode.

Ensemble de partitions BC6HBC6H partition set

Il existe 32 jeux de partitions possibles pour une vignette de deux régions, qui sont définis dans le tableau ci-dessous.There are 32 possible partition sets for a two-region tile, and which are defined in the table below. Chaque bloc 4x4 représente une forme unique.Each 4x4 block represents a single shape.

Table des jeux de partitions bc6h

Dans ce tableau de jeux de partitions, l’entrée en gras et soulignée est l’emplacement de l’index de correction pour le sous-ensemble 1 (qui est spécifié avec un bit moins).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). L’index de correction pour le sous-ensemble 0 est toujours l’index 0, car le partitionnement est toujours organisé de telle sorte que l’index 0 soit toujours dans le sous-ensemble 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. L’ordre des partitions va de l’angle supérieur gauche à l’angle inférieur droit, en les déplaçant de gauche à droite, puis de haut en bas.Partition order goes from top-left to bottom-right, moving left to right and then top to bottom.

Format de point de terminaison compressé BC6HBC6H compressed endpoint format

champs de bits pour les formats de point de terminaison compressés bc6h

Ce tableau montre les champs de bits des points de terminaison compressés en tant que fonction du format de point de terminaison, chaque colonne spécifiant un encodage et chaque ligne spécifiant un champ de bits.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. Cette approche utilise 82 bits pour les vignettes à deux régions et 65 bits pour les vignettes d’une région.This approach takes up 82 bits for two-region tiles and 65 bits for one-region tiles. Par exemple, les 5 premiers bits pour l’encodage d’une région [ 16 4 ] ci-dessus (plus précisément la colonne la plus à droite) sont bits m [ 4:0 ] , les 10 bits suivants sont bits RW [ 9:0 ] , et ainsi de suite avec les 6 derniers bits contenant 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].

Les noms de champs dans le tableau ci-dessus sont définis comme suit :The field names in the table above are defined as follows:

ChampField VariableVariable
mm modemode
dd index de formeshape index
graverw Endpt [ 0 ] . [0]endpt[0].A[0]
RXrx Endpt [ 0 ] . B [ 0]endpt[0].B[0]
quêtesry Endpt [ 1 ] . [0]endpt[1].A[0]
cmrz Endpt [ 1 ] . B [ 0]endpt[1].B[0]
entrepôtgw Endpt [ 0 ] . [1]endpt[0].A[1]
GXgx Endpt [ 0 ] . B [ 1]endpt[0].B[1]
GYgy Endpt [ 1 ] . [1]endpt[1].A[1]
GZgz Endpt [ 1 ] . B [ 1]endpt[1].B[1]
p.c.bw 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]
Viabz Endpt [ 1 ] . B [ 2]endpt[1].B[2]

 

Endpt [ i ] , où i est égal à 0 ou 1, fait référence respectivement au 0 ou au 1er ensemble de points de terminaison.Endpt[i], where i is either 0 or 1, refers to the 0th or 1st set of endpoints respectively.

Extension de signe pour les valeurs de point de terminaisonSign extension for endpoint values

Pour les vignettes de deux régions, quatre valeurs de point de terminaison peuvent être étendues.For two-region tiles, there are four endpoint values that can be sign extended. Endpt [ 0 ] . Un est signé uniquement si le format est un format signé ; les autres points de terminaison sont signés uniquement si le point de terminaison a été transformé ou si le format est un format signé.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. Le code ci-dessous illustre l’algorithme permettant d’étendre le signe des valeurs de point de terminaison à deux régions.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]);
      }
    }
}

Pour les vignettes d’une région, le comportement est le même, uniquement avec Endpt [ 1 ] supprimé.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]);
    }
}

Transformer inversion pour les valeurs de point de terminaisonTransform inversion for endpoint values

Pour les vignettes de deux régions, la transformation applique l’inverse de l’encodage de différence, en ajoutant la valeur de base à Endpt [ 0 ] . À trois autres entrées pour un total de 9 opérations d’ajout.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. Dans l’image ci-dessous, la valeur de base est représentée sous la forme « a0 » et a la précision à virgule flottante la plus élevée.In the image below, the base value is represented as "A0" and has the highest floating point precision. « A1 », « B0 » et « B1 » sont tous des deltas calculés à partir de la valeur d’ancrage, et ces valeurs Delta sont représentées par une précision inférieure."A1," "B0," and "B1" are all deltas calculated from the anchor value, and these delta values are represented with lower precision. (A0 correspond à Endpt [ 0 ] . A, B0 correspond à Endpt [ 0 ] . B, a1 correspond à Endpt [ 1 ] . A, et B1 correspond à 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.)

calcul des valeurs de point de terminaison d’inversion de transformation

Pour les vignettes d’une région, il n’y a qu’un seul décalage Delta, et donc seulement 3 opérations d’ajout.For one-region tiles there is only one delta offset, and therefore only 3 add operations.

Le décompresseur doit s’assurer que les résultats de la transformation inverse ne dépassent pas la précision 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. Dans le cas d’un dépassement de capacité, les valeurs résultant de la transformation inverse doivent être encapsulées dans le même nombre de bits.In the case of an overflow, the values resulting from the inverse transform must wrap within the same number of bits. Si la précision de a0 est de « p » bits, l’algorithme de transformation est le suivant :If the precision of A0 is "p" bits, then the transform algorithm is:

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

Pour les formats signés, les résultats du calcul Delta doivent également être étendus.For signed formats, the results of the delta calculation must be sign extended as well. Si l’opération d’extension de signe prend en compte l’extension des deux signes, où 0 est positif et 1 est négatif, l’extension de signe 0 s’occupe de la bride ci-dessus.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 même, après la bride ci-dessus, seule une valeur de 1 (négatif) doit être une extension de signe.Equivalently, after the clamp above, only a value of 1 (negative) needs to be sign extended.

DÉQUANTIFICATION des points de terminaison de couleurUnquantization of color endpoints

Étant donné les points de terminaison non compressés, l’étape suivante consiste à effectuer une DÉQUANTIFICATION initiale des points de terminaison de couleur.Given the uncompressed endpoints, the next step is to perform an initial unquantization of the color endpoints. Cela implique trois étapes :This involves three steps:

  • Une non-quantification des palettes de couleursAn unquantization of the color palettes
  • Interpolation des palettesInterpolation of the palettes
  • Finalisation de la DÉQUANTIFICATIONUnquantization finalization

En séparant le processus de DÉQUANTIFICATION en deux parties (la DÉQUANTIFICATION de la palette de couleurs avant l’interpolation et la DÉQUANTIFICATION finale après l’interpolation) réduit le nombre d’opérations de multiplication requises par rapport à un processus de DÉQUANTIFICATION complet avant l’interpolation de palette.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.

Le code ci-dessous illustre le processus de récupération des estimations des valeurs de couleur 16 bits d’origine, puis l’utilisation des valeurs de pondération fournies pour ajouter 6 valeurs de couleur supplémentaires à la palette.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. La même opération est effectuée sur chaque 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);
}

L’exemple de code suivant illustre le processus d’interpolation, avec les observations suivantes :The next code sample demonstrates the interpolation process, with the following observations:

  • Étant donné que la plage complète des valeurs de couleur pour la fonction unquantification (ci-dessous) est comprise entre-32768 et 65535, l’interpolateur est implémenté à l’aide de l’arithmétique signée 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.
  • Après l’interpolation, les valeurs sont passées à la fonction de non ** _ quantification** (décrite dans le troisième exemple de cette section), qui applique la mise à l’échelle finale.After interpolation, the values are passed to the finish_unquantize function (described in the third sample in this section), which applies the final scaling.
  • Tous les décompresseurs de matériel sont requis pour retourner des résultats de bits précis avec ces fonctions.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;
}

terminer la _ désquantification est appelé après l’interpolation de palette.finish_unquantize is called after palette interpolation. La fonction unquantificateur reporte la mise à l’échelle de 31/32 pour Signed, 31/64 pour unsigned.The unquantize function postpones the scaling by 31/32 for signed, 31/64 for unsigned. Ce comportement est nécessaire pour récupérer la valeur finale dans une demi-plage valide (-0x7BFF ~ 0x7BFF) une fois l’interpolation de palette terminée afin de réduire le nombre de multiplications nécessaires.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. Terminer _ unquantificateur applique la mise à l’échelle finale et retourne une valeur short non signée qui est réinterprétée en deux.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);
    }
}

Rubriques connexesRelated topics

Compression de blocs de textureTexture block compression