Método ID3D11DeviceContext2::UpdateTileMappings (d3d11_2.h)
Novedades asignaciones de ubicaciones de iconos en recursos en mosaico a ubicaciones de memoria de un grupo de iconos.
Sintaxis
HRESULT UpdateTileMappings(
[in] ID3D11Resource *pTiledResource,
[in] UINT NumTiledResourceRegions,
[in, optional] const D3D11_TILED_RESOURCE_COORDINATE *pTiledResourceRegionStartCoordinates,
[in, optional] const D3D11_TILE_REGION_SIZE *pTiledResourceRegionSizes,
[in, optional] ID3D11Buffer *pTilePool,
[in] UINT NumRanges,
[in, optional] const UINT *pRangeFlags,
[in, optional] const UINT *pTilePoolStartOffsets,
[in, optional] const UINT *pRangeTileCounts,
[in] UINT Flags
);
Parámetros
[in] pTiledResource
Tipo: ID3D11Resource*
Puntero al recurso en mosaico.
[in] NumTiledResourceRegions
Tipo: UINT
Número de regiones de recursos en mosaico.
[in, optional] pTiledResourceRegionStartCoordinates
Tipo: const D3D11_TILED_RESOURCE_COORDINATE*
Matriz de estructuras de D3D11_TILED_RESOURCE_COORDINATE que describen las coordenadas iniciales de las regiones de recursos en mosaico. El parámetro NumTiledResourceRegions especifica el número de estructuras de D3D11_TILED_RESOURCE_COORDINATE de la matriz.
[in, optional] pTiledResourceRegionSizes
Tipo: const D3D11_TILE_REGION_SIZE*
Matriz de estructuras de D3D11_TILE_REGION_SIZE que describen los tamaños de las regiones de recursos en mosaico. El parámetro NumTiledResourceRegions especifica el número de estructuras de D3D11_TILE_REGION_SIZE de la matriz.
[in, optional] pTilePool
Tipo: ID3D11Buffer*
Puntero al grupo de iconos.
[in] NumRanges
Tipo: UINT
Número de intervalos de grupos de iconos.
[in, optional] pRangeFlags
Tipo: const UINT*
Matriz de valores de D3D11_TILE_RANGE_FLAG que describen cada intervalo de grupos de iconos. El parámetro NumRanges especifica el número de valores de la matriz.
[in, optional] pTilePoolStartOffsets
Tipo: const UINT*
Matriz de desplazamientos en el grupo de mosaicos. Se trata de desplazamientos de mosaico basados en 0, contando en mosaicos (no bytes).
[in, optional] pRangeTileCounts
Tipo: const UINT*
Matriz de iconos.
Matriz de valores que especifican el número de iconos en cada intervalo de grupos de iconos. El parámetro NumRanges especifica el número de valores de la matriz.
[in] Flags
Tipo: UINT
Combinación de D3D11_TILE_MAPPING_FLAGS valores que se combinan mediante una operación OR bit a bit.
Valor devuelto
Tipo: HRESULT
Devuelve S_OK si se ejecuta correctamente; de lo contrario, devuelve una de las siguientes opciones:
- Devuelve E_INVALIDARG si se quitan varias condiciones, como marcas no válidas. La capa de depuración emitirá un error.
- Devuelve E_OUTOFMEMORY si la llamada da como resultado que el controlador tenga que asignar espacio para las nuevas asignaciones de tabla de páginas, pero que se agote la memoria. Si se produce una falta de memoria cuando se llama a en una lista de comandos y se ejecuta la lista de comandos, se quitará el dispositivo. Las aplicaciones solo pueden evitar esta situación realizando llamadas de actualización que cambian las asignaciones existentes de recursos en mosaico dentro de listas de comandos (por lo que los controladores no tendrán que asignar memoria de tabla de páginas, solo cambiar la asignación).
- Devuelve DXGI_ERROR_DEVICE_REMOVED si la tarjeta de vídeo se ha quitado físicamente del sistema o se ha producido una actualización del controlador para la tarjeta de vídeo.
Comentarios
En una sola llamada a UpdateTileMappings, puede asignar uno o varios intervalos de iconos de recursos a uno o varios intervalos de iconos del grupo de iconos.
Puede organizar los parámetros de UpdateTileMappings de estas maneras para realizar una actualización:
- Recurso en mosaico cuyas asignaciones se actualizan. Se trata de un recurso que se creó con la marca D3D11_RESOURCE_MISC_TILED . Las asignaciones comienzan todas las null cuando se crea inicialmente un recurso.
- Conjunto de regiones de icono en el recurso en mosaico cuyas asignaciones se actualizan. Puede realizar una llamada a UpdateTileMappings para actualizar muchas asignaciones o varias llamadas con un poco más sobrecarga de llamadas API, así como si es más conveniente. NumTiledResourceRegions especifica cuántas regiones hay, pTiledResourceRegionStartCoordinates y pTiledResourceRegionSizes son cada matriz que identifica la ubicación de inicio y la extensión de cada región. Si NumTiledResourceRegions es 1, por comodidad o ambas matrices que describen las regiones pueden ser NULL. NULL para pTiledResourceRegionStartCoordinates significa que la coordenada de inicio es 0s y NULL para pTiledResourceRegionSizes identifica una región predeterminada que es el conjunto completo de iconos para todo el recurso en mosaico, incluidos todos los mapas MIP, segmentos de matriz o ambos. Si pTiledResourceRegionStartCoordinates no es NULL y pTiledResourceRegionSizes es NULL, el tamaño de región tiene como valor predeterminado 1 icono para todas las regiones. Esto facilita la definición de asignaciones para un conjunto de iconos individuales cada uno en ubicaciones dispares proporcionando una matriz de ubicaciones en pTiledResourceRegionStartCoordinates sin tener que enviar una matriz de pTiledResourceRegionSizes todo establecido en 1.
Las actualizaciones se aplican desde la primera región hasta la última; por lo tanto, si las regiones se superponen en una sola llamada, las actualizaciones más adelante en la lista sobrescriben las áreas que se superponen con las actualizaciones anteriores.
- Grupo de iconos que proporciona memoria donde pueden ir las asignaciones de iconos. Un recurso en mosaico puede apuntar a un único grupo de iconos a la vez. Si se especifica un nuevo grupo de iconos (por primera vez o diferente de la última vez que se especificó un grupo de iconos), se borran todas las asignaciones de iconos existentes para el recurso en mosaico y se aplica el nuevo conjunto de asignaciones en la llamada actual a UpdateTileMappings para el nuevo grupo de iconos. Si no se especifica ningún grupo de iconos (NULL) o se proporciona el mismo grupo de iconos que una llamada a UpdateTileMappings anterior, la llamada a UpdateTileMappings simplemente agrega las nuevas asignaciones a las existentes (sobrescribir en superposición). Si UpdateTileMappings solo define asignaciones NULL, no es necesario especificar un grupo de iconos porque es irrelevante. Pero si especifica un grupo de iconos de todos modos, toma el mismo comportamiento que se ha descrito anteriormente al proporcionar un grupo de iconos.
- Conjunto de intervalos de iconos en los que van las asignaciones. Cada intervalo de mosaicos determinado puede especificar uno de algunos tipos de intervalos: un intervalo de iconos en un grupo de mosaicos (valor predeterminado), un recuento de iconos en el recurso en mosaico para asignar a un único icono de un grupo de mosaicos (compartir el icono), un recuento de asignaciones de iconos en el recurso en mosaico para omitir y dejar tal y como están, o un recuento de iconos del grupo de mosaicos que se van a asignar a NULL. NumRanges especifica el número de intervalos de mosaicos, donde los iconos totales identificados en todos los intervalos deben coincidir con el número total de iconos de las regiones de icono del recurso en mosaico descrito anteriormente. Las asignaciones se definen mediante la iteración de los iconos de las regiones de mosaico en orden secuencial ( x y, a continuación, y, a continuación, el orden z para las regiones de cuadro), mientras se recorre el conjunto de intervalos de mosaicos en orden secuencial. El desglose de las regiones de mosaico no tiene que alinearse con el desglose de los intervalos de mosaicos, pero el número total de iconos en ambos lados debe ser igual para que cada icono de recurso en mosaico especificado tenga una asignación especificada.
pRangeFlags, pTilePoolStartOffsets y pRangeTileCounts son todas las matrices, de tamaño NumRanges, que describen los intervalos de mosaicos. Si pRangeFlags es NULL, todos los intervalos son iconos secuenciales en el grupo de mosaicos; de lo contrario, para cada intervalo i, pRangeFlags[i] identifica cómo funcionan las asignaciones de ese intervalo de iconos:
- Si pRangeFlags[i] es 0, ese intervalo define iconos secuenciales en el grupo de mosaicos, con el número de iconos que son pRangeTileCounts[i] y la ubicación inicial pTilePoolStartOffsets[i]. Si NumRanges es 1, pRangeTileCounts puede ser NULL y el valor predeterminado es el número total de iconos especificados por todas las regiones del icono.
- Si pRangeFlags[i] es D3D11_TILE_RANGE_REUSE_SINGLE_TILE, pTilePoolStartOffsets[i] identifica el icono único del grupo de mosaicos al que se va a asignar y pRangeTileCounts[i] especifica cuántos iconos de las regiones de mosaico se asignarán a esa ubicación del grupo de iconos. Si NumRanges es 1, pRangeTileCounts puede ser NULL y el valor predeterminado es el número total de iconos especificados por todas las regiones del icono.
- Si pRangeFlags[i] es D3D11_TILE_RANGE_NULL, pRangeTileCounts[i] especifica cuántos iconos de las regiones del icono se asignarán a NULL. Si NumRanges es 1, pRangeTileCounts puede ser NULL y el valor predeterminado es el número total de iconos especificados por todas las regiones del icono. pTilePoolStartOffsets[i] se omite para las asignaciones NULL.
- Si pRangeFlags[i] es D3D11_TILE_RANGE_SKIP, pRangeTileCounts[i] especifica el número de iconos de las regiones de mosaico para las que omitir y dejar las asignaciones existentes sin modificar. Esto puede ser útil si una región de mosaico enlaza convenientemente un área de asignaciones de iconos para actualizar, excepto con algunas excepciones que deben dejarse igual que lo que se asignaron antes. pTilePoolStartOffsets[i] se omite para las asignaciones SKIP.
- Parámetro flags para las opciones generales.D3D11_TILE_MAPPING_NO_OVERWRITE significa que el autor de la llamada promete que los comandos enviados previamente al dispositivo que todavía se están ejecutando no hacen referencia a ninguna de las regiones del icono que se están actualizando. Esto permite que el dispositivo evite tener que vaciar el trabajo enviado previamente para realizar la actualización de asignación de iconos. Si la aplicación infringe esta promesa mediante la actualización de asignaciones de iconos para ubicaciones en recursos en mosaico a las que todavía se hace referencia mediante comandos pendientes, resultados de comportamiento de representación no definidos, lo que incluye la posibilidad de ralentizaciones significativas en algunas arquitecturas. Esto es como el concepto de "no sobrescribir" que existe en otra parte de la API de Direct3D, excepto que se aplica a la propia estructura de datos de asignación de iconos, que en hardware es una tabla de páginas. La ausencia de esta marca requiere que se completen las actualizaciones de asignación de iconos especificadas por esta llamada a UpdateTileMappings antes de que pueda continuar cualquier comando direct3D posterior.
Nota En Direct3D 11.2, el hardware ahora puede admitir ClearView en formatos de solo profundidad. Para obtener más información, consulta D3D11_FEATURE_DATA_D3D11_OPTIONS1.
Supongamos que un icono se asigna a varios recursos en mosaico al mismo tiempo y el contenido del icono se manipula por cualquier medio (representación, copia, etc.) a través de uno de los recursos en mosaico. A continuación, si el mismo icono se va a representar a través de cualquier otro recurso en mosaico, el icono debe borrarse primero como se ha descrito anteriormente.
Para obtener más información sobre los recursos en mosaico, consulta Recursos en mosaico.
Estos son algunos ejemplos de casos comunes de UpdateTileMappings :
Ejemplos
Borrar las asignaciones de una superficie completa a NULL:
// - No-overwrite is specified, assuming it is known nothing else the GPU could be doing is referencing the previous mappings
// - NULL for pTiledResourceRegionStatCoordinates and pTiledResourceRegionSizes defaults to the entire resource
// - NULL for pTilePoolStartOffsets since it isn't needed for mapping tiles to NULL
// - NULL for pRangeTileCounts when NumRanges is 1 defaults to the same number of tiles as the tiled resource region (which is
// the entire surface in this case)
//
// UINT RangeFlags = D3D11_TILE_MAPPING_NULL;
// pDeviceContext2->UpdateTileMappings(pTiledResource,1,NULL,NULL,NULL,1,&RangeFlags,NULL,NULL,D3D11_TILE_MAPPING_NO_OVERWRITE);
Asignación de una región de iconos a un único icono:
// - This maps a 2x3 tile region at tile offset (1,1) in a Tiled Resource to tile [12] in a Tile Pool
//
// D3D11_TILED_RESOURCE_COORDINATE TRC;
// TRC.X = 1;
// TRC.Y = 1;
// TRC.Z = 0;
// TRC.Subresource = 0;
//
// D3D11_TILE_REGION_SIZE TRS;
// TRS.bUseBox = TRUE;
// TRS.Width = 2;
// TRS.Height = 3;
// TRS.Depth = 1;
// TRS.NumTiles = TRS.Width * TRS.Height * TRS.Depth;
//
// UINT RangeFlags = D3D11_TILE_MAPPING_REUSE_SINGLE_TILE;
// UINT StartOffset = 12;
// pDeviceContext2->UpdateTileMappings(pTiledResource,1,&TRC,&TRS,pTilePool,1,&RangeFlags,&StartOffset,
// NULL,D3D11_TILE_MAPPING_NO_OVERWRITE);
Definir asignaciones para un conjunto de iconos individuales separados:
// - This can also be accomplished in multiple calls. Using a single call to define multiple
// a single call to define multiple mapping updates can reduce CPU call overhead slightly,
// at the cost of having to pass arrays as parameters.
// - Passing NULL for pTiledResourceRegionSizes defaults to each region in the Tiled Resource
// being a single tile. So all that is needed are the coordinates of each one.
// - Passing NULL for Range Flags defaults to no flags (since none are needed in this case)
// - Passing NULL for pRangeTileCounts defaults to each range in the Tile Pool being size 1.
// So all that is needed are the start offsets for each tile in the Tile Pool
//
// D3D11_TILED_RESOURCE_COORDINATE TRC[3];
// UINT StartOffsets[3];
// UINT NumSingleTiles = 3;
//
// TRC[0].X = 1;
// TRC[0].Y = 1;
// TRC[0].Subresource = 0;
// StartOffsets[0] = 1;
//
// TRC[1].X = 4;
// TRC[1].Y = 7;
// TRC[1].Subresource = 0;
// StartOffsets[1] = 4;
//
// TRC[2].X = 2;
// TRC[2].Y = 3;
// TRC[2].Subresource = 0;
// StartOffsets[2] = 7;
//
// pDeviceContext2->UpdateTileMappings(pTiledResource,NumSingleTiles,&TRC,NULL,pTilePool,NumSingleTiles,NULL,StartOffsets,
// NULL,D3D11_TILE_MAPPING_NO_OVERWRITE);
Ejemplo complejo: definición de asignaciones para regiones con algunas omisións, algunas asignaciones NULL:
// - This complex example hard codes the parameter arrays, whereas in practice the
// application would likely configure the parameters programatically or in a data driven way.
// - Suppose we have 3 regions in a Tiled Resource to configure mappings for, 2x3 at coordinate (1,1),
// 3x3 at coordinate (4,7), and 7x1 at coordinate (20,30)
// - The tiles in the regions are walked from first to last, in X then Y then Z order,
// while stepping forward through the specified Tile Ranges to determine each mapping.
// In this example, 22 tile mappings need to be defined.
// - Suppose we want the first 3 tiles to be mapped to a contiguous range in the Tile Pool starting at
// tile pool location [9], the next 8 to be skipped (left unchanged), the next 2 to map to NULL,
// the next 5 to share a single tile (tile pool location [17]) and the remaining
// 4 tiles to each map to to unique tile pool locations, [2], [9], [4] and [17]:
//
// D3D11_TILED_RESOURCE_COORDINATE TRC[3];
// D3D11_TILE_REGION_SIZE TRS[3];
// UINT NumRegions = 3;
//
// TRC[0].X = 1;
// TRC[0].Y = 1;
// TRC[0].Subresource = 0;
// TRS[0].bUseBox = TRUE;
// TRS[0].Width = 2;
// TRS[0].Height = 3;
// TRS[0].NumTiles = TRS[0].Width * TRS[0].Height;
//
// TRC[1].X = 4;
// TRC[1].Y = 7;
// TRC[1].Subresource = 0;
// TRS[1].bUseBox = TRUE;
// TRS[1].Width = 3;
// TRS[1].Height = 3;
// TRS[1].NumTiles = TRS[1].Width * TRS[1].Height;
//
// TRC[2].X = 20;
// TRC[2].Y = 30;
// TRC[2].Subresource = 0;
// TRS[2].bUseBox = TRUE;
// TRS[2].Width = 7;
// TRS[2].Height = 1;
// TRS[2].NumTiles = TRS[2].Width * TRS[2].Height;
//
// UINT NumRanges = 8;
// UINT RangeFlags[8];
// UINT TilePoolStartOffsets[8];
// UINT RangeTileCounts[8];
//
// RangeFlags[0] = 0;
// TilePoolStartOffsets[0] = 9;
// RangeTileCounts[0] = 3;
//
// RangeFlags[1] = D3D11_TILE_MAPPING_SKIP;
// TilePoolStartOffsets[1] = 0; // offset is ignored for skip mappings
// RangeTileCounts[1] = 8;
//
// RangeFlags[2] = D3D11_TILE_MAPPING_NULL;
// TilePoolStartOffsets[2] = 0; // offset is ignored for NULL mappings
// RangeTileCounts[2] = 2;
//
// RangeFlags[3] = D3D11_TILE_MAPPING_REUSE_SINGLE_TILE;
// TilePoolStartOffsets[3] = 17;
// RangeTileCounts[3] = 5;
//
// RangeFlags[4] = 0;
// TilePoolStartOffsets[4] = 2;
// RangeTileCounts[4] = 1;
//
// RangeFlags[5] = 0;
// TilePoolStartOffsets[5] = 9;
// RangeTileCounts[5] = 1;
//
// RangeFlags[6] = 0;
// TilePoolStartOffsets[6] = 4;
// RangeTileCounts[6] = 1;
//
// RangeFlags[7] = 0;
// TilePoolStartOffsets[7] = 17;
// RangeTileCounts[7] = 1;
//
// pDeviceContext2->UpdateTileMappings(pTiledResource,NumRegions,TRC,TRS,pTilePool,NumRanges,RangeFlags,
// TilePoolStartOffsets,RangeTileCounts,D3D11_TILE_MAPPING_NO_OVERWRITE);
CopyTileMappings
// CopyTileMappings helps with tasks such as shifting mappings around within/across Tiled Resources, e.g. scrolling tiles.
// The source and dest region can overlap - the result of the copy in this case is as if the source was saved to a temp and then
// from there written to the dest, though the implementation may be able to do better.
//
// The Flags field allows D3D11_TILE_MAPPING_NO_OVERWRITE to be specified, means the caller promises that previously
// submitted commands to the device that may still be executing do not reference any of the tile region being updated.
// This allows the device to avoid having to flush previously submitted work in order to do the tile mapping
// update. If the application violates this promise by updating tile mappings for locations in Tiled Resouces
// still being referenced by outstanding commands, undefined rendering behavior results, including the potential
// for significant slowdowns on some architectures. This is like the "no overwrite" concept that exists
// elsewhere in the API, except applied to Tile Mapping data structure itself (which in hardware is a page table).
// The absence of this flag requires that tile mapping updates specified by this call must be completed before any
// subsequent D3D command can proceed.
//
// Return Values:
//
// Returns S_OK or E_INVALIDARG or E_OUTOFMEMORY. The latter can happen if the call results in the driver having to
// allocate space for new page table mappings but running out of memory.
//
// If out of memory occurs when this is called in a commandlist and the commandlist is being executed, the device will be removed.
// Applications can avoid this situation by only doing update calls that change existing mappings from Tiled Resources
// within commandlists (so drivers will not have to allocate page table memory, only change the mapping).
//
// Various other basic conditions such as invalid flags or passing in non Tiled Resources result in call being dropped
// with E_INVALIDARG.
//
// Validation remarks:
//
// The dest and the source regions must each entirely fit in their resource or behavior is undefined
// (debug layer will emit an error).
Requisitos
| Requisito | Value |
|---|---|
| Cliente mínimo compatible | Windows 8.1 [aplicaciones de escritorio | Aplicaciones para UWP] |
| Servidor mínimo compatible | Windows Server 2012 R2 [aplicaciones de escritorio | Aplicaciones para UWP] |
| Plataforma de destino | Windows |
| Encabezado | d3d11_2.h |
| Library | D3D11.lib |