> ## 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.

# D3D12_FILTER

> Especifica opciones de filtrado durante el muestreo de texturas.

Especifica opciones de filtrado durante el muestreo de texturas.

## Sintaxis

```cpp theme={null}
typedef enum D3D12_FILTER
{
    D3D12_FILTER_MIN_MAG_MIP_POINT = 0,
    D3D12_FILTER_MIN_MAG_POINT_MIP_LINEAR = 1,
    D3D12_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT = 4,
    D3D12_FILTER_MIN_POINT_MAG_MIP_LINEAR = 5,
    D3D12_FILTER_MIN_LINEAR_MAG_MIP_POINT = 16,
    D3D12_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 17,
    D3D12_FILTER_MIN_MAG_LINEAR_MIP_POINT = 20,
    D3D12_FILTER_MIN_MAG_MIP_LINEAR = 21,
    D3D12_FILTER_ANISOTROPIC = 85,
    D3D12_FILTER_COMPARISON_MIN_MAG_MIP_POINT = 128,
    D3D12_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR = 129,
    D3D12_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT = 132,
    D3D12_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR = 133,
    D3D12_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT = 144,
    D3D12_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 145,
    D3D12_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT = 148,
    D3D12_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR = 149,
    D3D12_FILTER_COMPARISON_ANISOTROPIC = 213,
    D3D12_FILTER_MINIMUM_MIN_MAG_MIP_POINT = 256,
    D3D12_FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR = 257,
    D3D12_FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT = 260,
    D3D12_FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR = 261,
    D3D12_FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT = 272,
    D3D12_FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 273,
    D3D12_FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT = 276,
    D3D12_FILTER_MINIMUM_MIN_MAG_MIP_LINEAR = 277,
    D3D12_FILTER_MINIMUM_ANISOTROPIC = 341,
    D3D12_FILTER_MAXIMUM_MIN_MAG_MIP_POINT = 384,
    D3D12_FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR = 385,
    D3D12_FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT = 388,
    D3D12_FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR = 389,
    D3D12_FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT = 400,
    D3D12_FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 401,
    D3D12_FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT = 404,
    D3D12_FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR = 405,
    D3D12_FILTER_MAXIMUM_ANISOTROPIC = 469
} D3D12_FILTER
```

## Constantes

| Constante                                                       | Descripción                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| --------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| D3D12\_FILTER\_MIN\_MAG\_MIP\_POINT                             | Usa el muestreo de punto para la reducción, la ampliación y el muestreo de nivel de mip.                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| D3D12\_FILTER\_MIN\_MAG\_POINT\_MIP\_LINEAR                     | Usa el muestreo de punto para la reducción y la ampliación; usa la interpolación lineal para el muestreo de nivel de mip.                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| D3D12\_FILTER\_MIN\_POINT\_MAG\_LINEAR\_MIP\_POINT              | Usa el muestreo de punto para la reducción; usa la interpolación lineal para la ampliación; usa el muestreo de punto para el muestreo de nivel de mip.                                                                                                                                                                                                                                                                                                                                                                                                         |
| D3D12\_FILTER\_MIN\_POINT\_MAG\_MIP\_LINEAR                     | Usa el muestreo de punto para la reducción; usa la interpolación lineal para la ampliación y el muestreo de nivel de mip.                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| D3D12\_FILTER\_MIN\_LINEAR\_MAG\_MIP\_POINT                     | Usa la interpolación lineal para la reducción; usa el muestreo de punto para la ampliación y el muestreo de nivel de mip.                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| D3D12\_FILTER\_MIN\_LINEAR\_MAG\_POINT\_MIP\_LINEAR             | Usa la interpolación lineal para la reducción; usa el muestreo de punto para la ampliación; usa la interpolación lineal para el muestreo de nivel de mip.                                                                                                                                                                                                                                                                                                                                                                                                      |
| D3D12\_FILTER\_MIN\_MAG\_LINEAR\_MIP\_POINT                     | Usa la interpolación lineal para la reducción y la ampliación; usa el muestreo de punto para el muestreo de nivel de mip.                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| D3D12\_FILTER\_MIN\_MAG\_MIP\_LINEAR                            | Usa la interpolación lineal para la reducción, la ampliación y el muestreo de nivel de mip.                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| D3D12\_FILTER\_ANISOTROPIC                                      | Usa la interpolación anisotrópica para la reducción, la ampliación y el muestreo de nivel de mip.                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| D3D12\_FILTER\_COMPARISON\_MIN\_MAG\_MIP\_POINT                 | Usa el muestreo de punto para la reducción, la ampliación y el muestreo de nivel de mip. Compara el resultado con el valor de comparación.                                                                                                                                                                                                                                                                                                                                                                                                                     |
| D3D12\_FILTER\_COMPARISON\_MIN\_MAG\_POINT\_MIP\_LINEAR         | Usa el muestreo de punto para la reducción y la ampliación; usa la interpolación lineal para el muestreo de nivel de mip. Compara el resultado con el valor de comparación.                                                                                                                                                                                                                                                                                                                                                                                    |
| D3D12\_FILTER\_COMPARISON\_MIN\_POINT\_MAG\_LINEAR\_MIP\_POINT  | Usa el muestreo de punto para la reducción; usa la interpolación lineal para la ampliación; usa el muestreo de punto para el muestreo de nivel de mip. Compara el resultado con el valor de comparación.                                                                                                                                                                                                                                                                                                                                                       |
| D3D12\_FILTER\_COMPARISON\_MIN\_POINT\_MAG\_MIP\_LINEAR         | Usa el muestreo de punto para la reducción; usa la interpolación lineal para la ampliación y el muestreo de nivel de mip. Compara el resultado con el valor de comparación.                                                                                                                                                                                                                                                                                                                                                                                    |
| D3D12\_FILTER\_COMPARISON\_MIN\_LINEAR\_MAG\_MIP\_POINT         | Usa la interpolación lineal para la reducción; usa el muestreo de punto para la ampliación y el muestreo de nivel de mip. Compara el resultado con el valor de comparación.                                                                                                                                                                                                                                                                                                                                                                                    |
| D3D12\_FILTER\_COMPARISON\_MIN\_LINEAR\_MAG\_POINT\_MIP\_LINEAR | Usa la interpolación lineal para la reducción; usa el muestreo de punto para la ampliación; usa la interpolación lineal para el muestreo de nivel de mip. Compara el resultado con el valor de comparación.                                                                                                                                                                                                                                                                                                                                                    |
| D3D12\_FILTER\_COMPARISON\_MIN\_MAG\_LINEAR\_MIP\_POINT         | Usa la interpolación lineal para la reducción y la ampliación; usa el muestreo de punto para el muestreo de nivel de mip. Compara el resultado con el valor de comparación.                                                                                                                                                                                                                                                                                                                                                                                    |
| D3D12\_FILTER\_COMPARISON\_MIN\_MAG\_MIP\_LINEAR                | Usa la interpolación lineal para la reducción, la ampliación y el muestreo de nivel de mip. Compara el resultado con el valor de comparación.                                                                                                                                                                                                                                                                                                                                                                                                                  |
| D3D12\_FILTER\_COMPARISON\_ANISOTROPIC                          | Usa la interpolación anisotrópica para la reducción, la ampliación y el muestreo de nivel de mip. Compara el resultado con el valor de comparación.                                                                                                                                                                                                                                                                                                                                                                                                            |
| D3D12\_FILTER\_MINIMUM\_MIN\_MAG\_MIP\_POINT                    | Captura el mismo conjunto de texels que [D3D12\_FILTER\_MIN\_MAG\_MIP\_POINT](/reference/graphics/d3d12/enums/d3d12_filter_public) y, en lugar de filtrarlos, devuelve el mínimo de los texels.  Los texels con ponderación 0 durante el filtrado no se cuentan para el mínimo.  Puede consultar la compatibilidad con este tipo de filtro en el miembro **MinMaxFiltering** de la estructura [D3D11\_FEATURE\_DATA\_D3D11\_OPTIONS1](https://learn.microsoft.com/en-us/windows/desktop/api/d3d11/ns-d3d11-d3d11_feature_data_d3d11_options1).                 |
| D3D12\_FILTER\_MINIMUM\_MIN\_MAG\_POINT\_MIP\_LINEAR            | Captura el mismo conjunto de texels que [D3D12\_FILTER\_MIN\_MAG\_POINT\_MIP\_LINEAR](/reference/graphics/d3d12/enums/d3d12_filter_public) y, en lugar de filtrarlos, devuelve el mínimo de los texels.  Los texels con ponderación 0 durante el filtrado no se cuentan para el mínimo.  Puede consultar la compatibilidad con este tipo de filtro en el miembro **MinMaxFiltering** de la estructura [D3D11\_FEATURE\_DATA\_D3D11\_OPTIONS1](https://learn.microsoft.com/en-us/windows/desktop/api/d3d11/ns-d3d11-d3d11_feature_data_d3d11_options1).         |
| D3D12\_FILTER\_MINIMUM\_MIN\_POINT\_MAG\_LINEAR\_MIP\_POINT     | Captura el mismo conjunto de texels que [D3D12\_FILTER\_MIN\_POINT\_MAG\_LINEAR\_MIP\_POINT](/reference/graphics/d3d12/enums/d3d12_filter_public) y, en lugar de filtrarlos, devuelve el mínimo de los texels.  Los texels con ponderación 0 durante el filtrado no se cuentan para el mínimo.  Puede consultar la compatibilidad con este tipo de filtro en el miembro **MinMaxFiltering** de la estructura [D3D11\_FEATURE\_DATA\_D3D11\_OPTIONS1](https://learn.microsoft.com/en-us/windows/desktop/api/d3d11/ns-d3d11-d3d11_feature_data_d3d11_options1).  |
| D3D12\_FILTER\_MINIMUM\_MIN\_POINT\_MAG\_MIP\_LINEAR            | Captura el mismo conjunto de texels que [D3D12\_FILTER\_MIN\_POINT\_MAG\_MIP\_LINEAR](/reference/graphics/d3d12/enums/d3d12_filter_public) y, en lugar de filtrarlos, devuelve el mínimo de los texels.  Los texels con ponderación 0 durante el filtrado no se cuentan para el mínimo.  Puede consultar la compatibilidad con este tipo de filtro en el miembro **MinMaxFiltering** de la estructura [D3D11\_FEATURE\_DATA\_D3D11\_OPTIONS1](https://learn.microsoft.com/en-us/windows/desktop/api/d3d11/ns-d3d11-d3d11_feature_data_d3d11_options1).         |
| D3D12\_FILTER\_MINIMUM\_MIN\_LINEAR\_MAG\_MIP\_POINT            | Captura el mismo conjunto de texels que [D3D12\_FILTER\_MIN\_LINEAR\_MAG\_MIP\_POINT](/reference/graphics/d3d12/enums/d3d12_filter_public) y, en lugar de filtrarlos, devuelve el mínimo de los texels.  Los texels con ponderación 0 durante el filtrado no se cuentan para el mínimo.  Puede consultar la compatibilidad con este tipo de filtro en el miembro **MinMaxFiltering** de la estructura [D3D11\_FEATURE\_DATA\_D3D11\_OPTIONS1](https://learn.microsoft.com/en-us/windows/desktop/api/d3d11/ns-d3d11-d3d11_feature_data_d3d11_options1).         |
| D3D12\_FILTER\_MINIMUM\_MIN\_LINEAR\_MAG\_POINT\_MIP\_LINEAR    | Captura el mismo conjunto de texels que [D3D12\_FILTER\_MIN\_LINEAR\_MAG\_POINT\_MIP\_LINEAR](/reference/graphics/d3d12/enums/d3d12_filter_public) y, en lugar de filtrarlos, devuelve el mínimo de los texels.  Los texels con ponderación 0 durante el filtrado no se cuentan para el mínimo.  Puede consultar la compatibilidad con este tipo de filtro en el miembro **MinMaxFiltering** de la estructura [D3D11\_FEATURE\_DATA\_D3D11\_OPTIONS1](https://learn.microsoft.com/en-us/windows/desktop/api/d3d11/ns-d3d11-d3d11_feature_data_d3d11_options1). |
| D3D12\_FILTER\_MINIMUM\_MIN\_MAG\_LINEAR\_MIP\_POINT            | Captura el mismo conjunto de texels que [D3D12\_FILTER\_MIN\_MAG\_LINEAR\_MIP\_POINT](/reference/graphics/d3d12/enums/d3d12_filter_public) y, en lugar de filtrarlos, devuelve el mínimo de los texels.  Los texels con ponderación 0 durante el filtrado no se cuentan para el mínimo.  Puede consultar la compatibilidad con este tipo de filtro en el miembro **MinMaxFiltering** de la estructura [D3D11\_FEATURE\_DATA\_D3D11\_OPTIONS1](https://learn.microsoft.com/en-us/windows/desktop/api/d3d11/ns-d3d11-d3d11_feature_data_d3d11_options1).         |
| D3D12\_FILTER\_MINIMUM\_MIN\_MAG\_MIP\_LINEAR                   | Captura el mismo conjunto de texels que [D3D12\_FILTER\_MIN\_MAG\_MIP\_LINEAR](/reference/graphics/d3d12/enums/d3d12_filter_public) y, en lugar de filtrarlos, devuelve el mínimo de los texels.  Los texels con ponderación 0 durante el filtrado no se cuentan para el mínimo.  Puede consultar la compatibilidad con este tipo de filtro en el miembro **MinMaxFiltering** de la estructura [D3D11\_FEATURE\_DATA\_D3D11\_OPTIONS1](https://learn.microsoft.com/en-us/windows/desktop/api/d3d11/ns-d3d11-d3d11_feature_data_d3d11_options1).                |
| D3D12\_FILTER\_MINIMUM\_ANISOTROPIC                             | Captura el mismo conjunto de texels que [D3D12\_FILTER\_ANISOTROPIC](/reference/graphics/d3d12/enums/d3d12_filter_public) y, en lugar de filtrarlos, devuelve el mínimo de los texels.  Los texels con ponderación 0 durante el filtrado no se cuentan para el mínimo.  Puede consultar la compatibilidad con este tipo de filtro en el miembro **MinMaxFiltering** de la estructura [D3D11\_FEATURE\_DATA\_D3D11\_OPTIONS1](https://learn.microsoft.com/en-us/windows/desktop/api/d3d11/ns-d3d11-d3d11_feature_data_d3d11_options1).                          |
| D3D12\_FILTER\_MAXIMUM\_MIN\_MAG\_MIP\_POINT                    | Captura el mismo conjunto de texels que [D3D12\_FILTER\_MIN\_MAG\_MIP\_POINT](/reference/graphics/d3d12/enums/d3d12_filter_public) y, en lugar de filtrarlos, devuelve el máximo de los texels.  Los texels con ponderación 0 durante el filtrado no se cuentan para el máximo.  Puede consultar la compatibilidad con este tipo de filtro en el miembro **MinMaxFiltering** de la estructura [D3D11\_FEATURE\_DATA\_D3D11\_OPTIONS1](https://learn.microsoft.com/en-us/windows/desktop/api/d3d11/ns-d3d11-d3d11_feature_data_d3d11_options1).                 |
| D3D12\_FILTER\_MAXIMUM\_MIN\_MAG\_POINT\_MIP\_LINEAR            | Captura el mismo conjunto de texels que [D3D12\_FILTER\_MIN\_MAG\_POINT\_MIP\_LINEAR](/reference/graphics/d3d12/enums/d3d12_filter_public) y, en lugar de filtrarlos, devuelve el máximo de los texels.  Los texels con ponderación 0 durante el filtrado no se cuentan para el máximo.  Puede consultar la compatibilidad con este tipo de filtro en el miembro **MinMaxFiltering** de la estructura [D3D11\_FEATURE\_DATA\_D3D11\_OPTIONS1](https://learn.microsoft.com/en-us/windows/desktop/api/d3d11/ns-d3d11-d3d11_feature_data_d3d11_options1).         |
| D3D12\_FILTER\_MAXIMUM\_MIN\_POINT\_MAG\_LINEAR\_MIP\_POINT     | Captura el mismo conjunto de texels que [D3D12\_FILTER\_MIN\_POINT\_MAG\_LINEAR\_MIP\_POINT](/reference/graphics/d3d12/enums/d3d12_filter_public) y, en lugar de filtrarlos, devuelve el máximo de los texels.  Los texels con ponderación 0 durante el filtrado no se cuentan para el máximo.  Puede consultar la compatibilidad con este tipo de filtro en el miembro **MinMaxFiltering** de la estructura [D3D11\_FEATURE\_DATA\_D3D11\_OPTIONS1](https://learn.microsoft.com/en-us/windows/desktop/api/d3d11/ns-d3d11-d3d11_feature_data_d3d11_options1).  |
| D3D12\_FILTER\_MAXIMUM\_MIN\_POINT\_MAG\_MIP\_LINEAR            | Captura el mismo conjunto de texels que [D3D12\_FILTER\_MIN\_POINT\_MAG\_MIP\_LINEAR](/reference/graphics/d3d12/enums/d3d12_filter_public) y, en lugar de filtrarlos, devuelve el máximo de los texels.  Los texels con ponderación 0 durante el filtrado no se cuentan para el máximo.  Puede consultar la compatibilidad con este tipo de filtro en el miembro **MinMaxFiltering** de la estructura [D3D11\_FEATURE\_DATA\_D3D11\_OPTIONS1](https://learn.microsoft.com/en-us/windows/desktop/api/d3d11/ns-d3d11-d3d11_feature_data_d3d11_options1).         |
| D3D12\_FILTER\_MAXIMUM\_MIN\_LINEAR\_MAG\_MIP\_POINT            | Captura el mismo conjunto de texels que [D3D12\_FILTER\_MIN\_LINEAR\_MAG\_MIP\_POINT](/reference/graphics/d3d12/enums/d3d12_filter_public) y, en lugar de filtrarlos, devuelve el máximo de los texels.  Los texels con ponderación 0 durante el filtrado no se cuentan para el máximo.  Puede consultar la compatibilidad con este tipo de filtro en el miembro **MinMaxFiltering** de la estructura [D3D11\_FEATURE\_DATA\_D3D11\_OPTIONS1](https://learn.microsoft.com/en-us/windows/desktop/api/d3d11/ns-d3d11-d3d11_feature_data_d3d11_options1).         |
| D3D12\_FILTER\_MAXIMUM\_MIN\_LINEAR\_MAG\_POINT\_MIP\_LINEAR    | Captura el mismo conjunto de texels que [D3D12\_FILTER\_MIN\_LINEAR\_MAG\_POINT\_MIP\_LINEAR](/reference/graphics/d3d12/enums/d3d12_filter_public) y, en lugar de filtrarlos, devuelve el máximo de los texels.  Los texels con ponderación 0 durante el filtrado no se cuentan para el máximo.  Puede consultar la compatibilidad con este tipo de filtro en el miembro **MinMaxFiltering** de la estructura [D3D11\_FEATURE\_DATA\_D3D11\_OPTIONS1](https://learn.microsoft.com/en-us/windows/desktop/api/d3d11/ns-d3d11-d3d11_feature_data_d3d11_options1). |
| D3D12\_FILTER\_MAXIMUM\_MIN\_MAG\_LINEAR\_MIP\_POINT            | Captura el mismo conjunto de texels que [D3D12\_FILTER\_MIN\_MAG\_LINEAR\_MIP\_POINT](/reference/graphics/d3d12/enums/d3d12_filter_public) y, en lugar de filtrarlos, devuelve el máximo de los texels.  Los texels con ponderación 0 durante el filtrado no se cuentan para el máximo.  Puede consultar la compatibilidad con este tipo de filtro en el miembro **MinMaxFiltering** de la estructura [D3D11\_FEATURE\_DATA\_D3D11\_OPTIONS1](https://learn.microsoft.com/en-us/windows/desktop/api/d3d11/ns-d3d11-d3d11_feature_data_d3d11_options1).         |
| D3D12\_FILTER\_MAXIMUM\_MIN\_MAG\_MIP\_LINEAR                   | Captura el mismo conjunto de texels que [D3D12\_FILTER\_MIN\_MAG\_MIP\_LINEAR](/reference/graphics/d3d12/enums/d3d12_filter_public) y, en lugar de filtrarlos, devuelve el máximo de los texels.  Los texels con ponderación 0 durante el filtrado no se cuentan para el máximo.  Puede consultar la compatibilidad con este tipo de filtro en el miembro **MinMaxFiltering** de la estructura [D3D11\_FEATURE\_DATA\_D3D11\_OPTIONS1](https://learn.microsoft.com/en-us/windows/desktop/api/d3d11/ns-d3d11-d3d11_feature_data_d3d11_options1).                |
| D3D12\_FILTER\_MAXIMUM\_ANISOTROPIC                             | Captura el mismo conjunto de texels que [D3D12\_FILTER\_ANISOTROPIC](/reference/graphics/d3d12/enums/d3d12_filter_public) y, en lugar de filtrarlos, devuelve el máximo de los texels.  Los texels con ponderación 0 durante el filtrado no se cuentan para el máximo.  Puede consultar la compatibilidad con este tipo de filtro en el miembro **MinMaxFiltering** de la estructura [D3D11\_FEATURE\_DATA\_D3D11\_OPTIONS1](https://learn.microsoft.com/en-us/windows/desktop/api/d3d11/ns-d3d11-d3d11_feature_data_d3d11_options1).                          |

## Comentarios

Esta enumeración la usa la estructura [D3D12\_SAMPLER\_DESC](/reference/graphics/d3d12/structs/d3d12_sampler_desc_public).

<div class="alert">**Nota**  Si usa tipos de filtro diferentes para el filtro de reducción y el de ampliación, se produce un comportamiento indefinido en ciertos casos donde la elección entre si se produce la ampliación o la reducción es ambigua. Para evitar este comportamiento indefinido, use modos de filtro que usen operaciones de filtro similares tanto para la reducción como para la ampliación (o use el filtrado anisotrópico, que también evita el problema).</div>

<div />

Durante el muestreo de texturas, se leen y combinan uno o varios texels (esto se denomina filtrado) para generar un único valor. El muestreo de punto lee un único texel, mientras que el muestreo lineal lee dos texels (puntos de conexión) e interpola linealmente un tercer valor entre los puntos de conexión.

Las funciones de muestreo de texturas del lenguaje de sombreado de alto nivel (HLSL) de Microsoft también admiten el filtrado de comparación durante el muestreo de texturas. El filtrado de comparación compara cada texel muestreado con un valor de comparación. El resultado booleano se mezcla de la misma manera que se mezcla el filtrado de texturas normal.

Puede usar funciones intrínsecas de muestreo de texturas de HLSL que implementan solo el filtrado de texturas o funciones complementarias que usan el filtrado de texturas con el filtrado de comparación.

Tenga en cuenta también las siguientes definiciones:

```syntax theme={null}
#define D3D12_FILTER_REDUCTION_TYPE_MASK ( 0x3 )

#define D3D12_FILTER_REDUCTION_TYPE_SHIFT ( 7 )

#define D3D12_FILTER_TYPE_MASK ( 0x3 )

#define D3D12_MIN_FILTER_SHIFT ( 4 )

#define D3D12_MAG_FILTER_SHIFT ( 2 )

#define D3D12_MIP_FILTER_SHIFT ( 0 )

#define D3D12_ANISOTROPIC_FILTERING_BIT ( 0x40 )

#define D3D12_ENCODE_BASIC_FILTER( min, mag, mip, reduction )                                                     \
( ( D3D12_FILTER ) (                                                           \
( ( ( min ) &amp; D3D12_FILTER_TYPE_MASK ) &lt;&lt; D3D12_MIN_FILTER_SHIFT ) |           \
( ( ( mag ) &amp; D3D12_FILTER_TYPE_MASK ) &lt;&lt; D3D12_MAG_FILTER_SHIFT ) |           \
( ( ( mip ) &amp; D3D12_FILTER_TYPE_MASK ) &lt;&lt; D3D12_MIP_FILTER_SHIFT ) |           \
( ( ( reduction ) &amp; D3D12_FILTER_REDUCTION_TYPE_MASK ) &lt;&lt; D3D12_FILTER_REDUCTION_TYPE_SHIFT ) ) )
#define D3D12_ENCODE_ANISOTROPIC_FILTER( reduction )                                                  \
( ( D3D12_FILTER ) (                                         \
D3D12_ANISOTROPIC_FILTERING_BIT |                            \
D3D12_ENCODE_BASIC_FILTER( D3D12_FILTER_TYPE_LINEAR,         \
D3D12_FILTER_TYPE_LINEAR,         \
D3D12_FILTER_TYPE_LINEAR,         \
reduction ) ) )
#define D3D12_DECODE_MIN_FILTER( D3D12Filter )                                                              \
( ( D3D12_FILTER_TYPE )                                                    \
( ( ( D3D12Filter ) &gt;&gt; D3D12_MIN_FILTER_SHIFT ) &amp; D3D12_FILTER_TYPE_MASK ) )
#define D3D12_DECODE_MAG_FILTER( D3D12Filter )                                                              \
( ( D3D12_FILTER_TYPE )                                                    \
( ( ( D3D12Filter ) &gt;&gt; D3D12_MAG_FILTER_SHIFT ) &amp; D3D12_FILTER_TYPE_MASK ) )
#define D3D12_DECODE_MIP_FILTER( D3D12Filter )                                                              \
( ( D3D12_FILTER_TYPE )                                                    \
( ( ( D3D12Filter ) &gt;&gt; D3D12_MIP_FILTER_SHIFT ) &amp; D3D12_FILTER_TYPE_MASK ) )
#define D3D12_DECODE_FILTER_REDUCTION( D3D12Filter )                                                        \
( ( D3D12_FILTER_REDUCTION_TYPE )                                                      \
( ( ( D3D12Filter ) &gt;&gt; D3D12_FILTER_REDUCTION_TYPE_SHIFT ) &amp; D3D12_FILTER_REDUCTION_TYPE_MASK ) )
#define D3D12_DECODE_IS_COMPARISON_FILTER( D3D12Filter )                                                    \
( D3D12_DECODE_FILTER_REDUCTION( D3D12Filter ) == D3D12_FILTER_REDUCTION_TYPE_COMPARISON )
#define D3D12_DECODE_IS_ANISOTROPIC_FILTER( D3D12Filter )                                               \
( ( ( D3D12Filter ) &amp; D3D12_ANISOTROPIC_FILTERING_BIT ) &amp;&amp;                  \
( D3D12_FILTER_TYPE_LINEAR == D3D12_DECODE_MIN_FILTER( D3D12Filter ) ) &amp;&amp;   \
( D3D12_FILTER_TYPE_LINEAR == D3D12_DECODE_MAG_FILTER( D3D12Filter ) ) &amp;&amp;   \
( D3D12_FILTER_TYPE_LINEAR == D3D12_DECODE_MIP_FILTER( D3D12Filter ) ) )


```

| Función de muestreo de texturas                                                                     | Función de muestreo de texturas con filtrado de comparación                                                                                                                                                                             |
| --------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Sample](https://learn.microsoft.com/en-us/windows/desktop/direct3dhlsl/dx-graphics-hlsl-to-sample) | [SampleCmp](https://learn.microsoft.com/en-us/windows/desktop/direct3dhlsl/dx-graphics-hlsl-to-samplecmp) o [SampleCmpLevelZero](https://learn.microsoft.com/en-us/windows/desktop/direct3dhlsl/dx-graphics-hlsl-to-samplecmplevelzero) |

Los filtros de comparación solo funcionan con texturas que tienen los siguientes formatos: [DXGI\_FORMAT\_R32\_FLOAT\_X8X24\_TYPELESS](https://learn.microsoft.com/en-us/windows/desktop/api/dxgiformat/ne-dxgiformat-dxgi_format), [DXGI\_FORMAT\_R32\_FLOAT](https://learn.microsoft.com/en-us/windows/desktop/api/dxgiformat/ne-dxgiformat-dxgi_format), [DXGI\_FORMAT\_R24\_UNORM\_X8\_TYPELESS](https://learn.microsoft.com/en-us/windows/desktop/api/dxgiformat/ne-dxgiformat-dxgi_format), [DXGI\_FORMAT\_R16\_UNORM](https://learn.microsoft.com/en-us/windows/desktop/api/dxgiformat/ne-dxgiformat-dxgi_format).

## Requisitos

**Encabezado:** d3d12\_xs.h o d3d12\_x.h\
**Biblioteca:** d3d12\_xs.lib o d3d12\_x.lib\
**Plataformas compatibles**: consolas XBOX Series y familia XBOX One

## Consulte también

[Enumeraciones principales](https://learn.microsoft.com/en-us/windows/desktop/direct3d12/direct3d-12-enumerations)

[Descriptores](https://learn.microsoft.com/en-us/windows/desktop/direct3d12/descriptors)


## Related topics

- [D3D12_FILTER_TYPE](/es/reference/graphics/d3d12/enums/d3d12_filter_type_public.md)
- [D3D12_FILTER_REDUCTION_TYPE](/es/reference/graphics/d3d12/enums/d3d12_filter_reduction_type_public.md)
- [D3D12_SAMPLER_DESC](/es/reference/graphics/d3d12/structs/d3d12_sampler_desc_public.md)
- [D3D12_STATIC_SAMPLER_DESC](/es/reference/graphics/d3d12/structs/d3d12_static_sampler_desc_public.md)
- [D3D12_FEATURE](/es/reference/graphics/d3d12/enums/d3d12_feature_public.md)
