Método ID3D11DeviceContext2::UpdateTileMappings (d3d11_2.h)
Atualizações mapeamentos de locais de bloco em recursos em bloco para locais de memória em um pool de blocos.
Sintaxe
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*
Um ponteiro para o recurso em bloco.
[in] NumTiledResourceRegions
Tipo: UINT
O número de regiões de recursos em bloco.
[in, optional] pTiledResourceRegionStartCoordinates
Tipo: const D3D11_TILED_RESOURCE_COORDINATE*
Uma matriz de estruturas de D3D11_TILED_RESOURCE_COORDINATE que descrevem as coordenadas iniciais das regiões de recursos em bloco. O parâmetro NumTiledResourceRegions especifica o número de estruturas D3D11_TILED_RESOURCE_COORDINATE na matriz.
[in, optional] pTiledResourceRegionSizes
Tipo: const D3D11_TILE_REGION_SIZE*
Uma matriz de estruturas de D3D11_TILE_REGION_SIZE que descrevem os tamanhos das regiões de recursos em bloco. O parâmetro NumTiledResourceRegions especifica o número de estruturas D3D11_TILE_REGION_SIZE na matriz.
[in, optional] pTilePool
Tipo: ID3D11Buffer*
Um ponteiro para o pool de blocos.
[in] NumRanges
Tipo: UINT
O número de intervalos de pool de blocos.
[in, optional] pRangeFlags
Tipo: const UINT*
Uma matriz de valores D3D11_TILE_RANGE_FLAG que descrevem cada intervalo de pool de blocos. O parâmetro NumRanges especifica o número de valores na matriz.
[in, optional] pTilePoolStartOffsets
Tipo: const UINT*
Uma matriz de deslocamentos para o pool de blocos. São deslocamentos de bloco baseados em 0, contando em blocos (não bytes).
[in, optional] pRangeTileCounts
Tipo: const UINT*
Uma matriz de blocos.
Uma matriz de valores que especifica o número de blocos em cada intervalo de pool de blocos. O parâmetro NumRanges especifica o número de valores na matriz.
[in] Flags
Tipo: UINT
Uma combinação de valores D3D11_TILE_MAPPING_FLAGS combinados usando uma operação OR bit a bit.
Retornar valor
Tipo: HRESULT
Retorna S_OK se tiver êxito; caso contrário, retorna um dos seguintes:
- Retorna E_INVALIDARG se várias condições, como sinalizadores inválidos, resultarem na retirada da chamada. A camada de depuração emitirá um erro.
- Retorna E_OUTOFMEMORY se a chamada resultar na necessidade de alocar espaço para novos mapeamentos de tabela de página, mas ficando sem memória. Se a falta de memória ocorrer quando isso for chamado em uma lista de comandos e a lista de comandos estiver sendo executada, o dispositivo será removido. Os aplicativos podem evitar essa situação fazendo apenas chamadas de atualização que alteram mapeamentos existentes de recursos em blocos dentro de listas de comandos (portanto, os drivers não precisarão alocar memória da tabela de páginas, apenas alterar o mapeamento).
- Retorna DXGI_ERROR_DEVICE_REMOVED se o vídeo cartão foi fisicamente removido do sistema ou ocorreu uma atualização do driver para o vídeo cartão.
Comentários
Em uma única chamada para UpdateTileMappings, você pode mapear um ou mais intervalos de blocos de recursos para um ou mais intervalos de blocos de pool de blocos.
Você pode organizar os parâmetros de UpdateTileMappings destas maneiras para executar uma atualização:
- Recurso em bloco cujos mapeamentos são atualizados. Esse é um recurso que foi criado com o sinalizador D3D11_RESOURCE_MISC_TILED . Os mapeamentos iniciam todos os NULL quando um recurso é criado inicialmente.
- Conjunto de regiões de bloco no recurso em bloco cujos mapeamentos são atualizados. Você pode fazer uma chamada updateTileMappings para atualizar muitos mapeamentos ou várias chamadas com um pouco mais de sobrecarga de chamada de API, se isso for mais conveniente. NumTiledResourceRegions especifica quantas regiões existem, pTiledResourceRegionStartCoordinates e pTiledResourceRegionSizes são cada matriz que identificam o local de início e a extensão de cada região. Se NumTiledResourceRegions for 1, para conveniência ou ambas as matrizes que descrevem as regiões podem ser NULL. NULL para pTiledResourceRegionStartCoordinates significa que a coordenada inicial é de 0s e NULL para pTiledResourceRegionSizes identifica uma região padrão que é o conjunto completo de blocos para todo o recurso em bloco, incluindo todos os mipmaps, fatias de matriz ou ambos. Se pTiledResourceRegionStartCoordinates não for NULL e pTiledResourceRegionSizes for NULL, o tamanho da região padrão será 1 bloco para todas as regiões. Isso facilita a definição de mapeamentos para um conjunto de blocos individuais, cada um em locais diferentes, fornecendo uma matriz de locais em pTiledResourceRegionStartCoordinates sem precisar enviar uma matriz de pTiledResourceRegionSizes tudo definido como 1.
As atualizações são aplicadas da primeira região para a última; portanto, se as regiões se sobrepõem em uma única chamada, as atualizações posteriormente na lista substituem as áreas que se sobrepõem às atualizações anteriores.
- Pool de blocos que fornece memória para onde os mapeamentos de bloco podem ir. Um recurso em bloco pode apontar para um único pool de blocos por vez. Se um novo pool de blocos for especificado (pela primeira vez ou diferente da última vez em que um pool de blocos foi especificado), todos os mapeamentos de bloco existentes para o recurso em bloco serão limpos e o novo conjunto de mapeamentos na chamada UpdateTileMappings atual será aplicado ao novo pool de blocos. Se nenhum pool de blocos for especificado (NULL) ou o mesmo pool de blocos que uma chamada updateTileMappings anterior for fornecida, a chamada UpdateTileMappings apenas adicionará os novos mapeamentos aos existentes (substituindo na sobreposição). Se UpdateTileMappings definir apenas mapeamentos NULL, você não precisará especificar um pool de blocos porque ele é irrelevante. Mas, se você especificar um pool de blocos de qualquer maneira, ele assumirá o mesmo comportamento descrito anteriormente ao fornecer um pool de blocos.
- Conjunto de intervalos de blocos em que os mapeamentos estão indo. Cada intervalo de blocos fornecido pode especificar um dos poucos tipos de intervalos: um intervalo de blocos em um pool de blocos (padrão), uma contagem de blocos no recurso em bloco para mapear para um único bloco em um pool de blocos (compartilhando o bloco), uma contagem de mapeamentos de bloco no recurso em bloco para ignorar e sair como estão, ou uma contagem de blocos no pool de blocos a serem mapeados para NULL. NumRanges especifica o número de intervalos de blocos, em que o total de blocos identificados em todos os intervalos deve corresponder ao número total de blocos nas regiões de bloco do recurso em bloco descrito anteriormente. Os mapeamentos são definidos pela iteração pelos blocos nas regiões do bloco em ordem sequencial - x, em seguida, ordem y e z para regiões de caixa - enquanto percorrem o conjunto de intervalos de blocos em ordem sequencial. O detalhamento das regiões de bloco não precisa se alinhar com a divisão de intervalos de blocos, mas o número total de blocos em ambos os lados deve ser igual para que cada bloco de recursos em bloco especificado tenha um mapeamento especificado.
pRangeFlags, pTilePoolStartOffsets e pRangeTileCounts são todas as matrizes, de tamanho NumRanges, que descrevem os intervalos de blocos. Se pRangeFlags for NULL, todos os intervalos serão blocos sequenciais no pool de blocos; caso contrário, para cada intervalo i, pRangeFlags[i] identifica como os mapeamentos nesse intervalo de blocos funcionam:
- Se pRangeFlags[i] for 0, esse intervalo definirá blocos sequenciais no pool de blocos, com o número de blocos sendo pRangeTileCounts[i] e o local inicial pTilePoolStartOffsets[i]. Se NumRanges for 1, pRangeTileCounts poderá ser NULL e usará como padrão o número total de blocos especificado por todas as regiões de bloco.
- Se pRangeFlags[i] for D3D11_TILE_RANGE_REUSE_SINGLE_TILE, pTilePoolStartOffsets[i] identificará o único bloco no pool de blocos para o qual mapear e pRangeTileCounts[i] especificará quantos blocos das regiões de bloco mapear para esse local do pool de blocos. Se NumRanges for 1, pRangeTileCounts poderá ser NULL e usará como padrão o número total de blocos especificado por todas as regiões de bloco.
- Se pRangeFlags[i] for D3D11_TILE_RANGE_NULL, pRangeTileCounts[i] especificará quantos blocos das regiões de bloco mapear para NULL. Se NumRanges for 1, pRangeTileCounts poderá ser NULL e usará como padrão o número total de blocos especificado por todas as regiões de bloco. pTilePoolStartOffsets[i] é ignorado para mapeamentos NULL.
- Se pRangeFlags[i] for D3D11_TILE_RANGE_SKIP, pRangeTileCounts[i] especificará quantos blocos das regiões de bloco ignorar e deixar os mapeamentos existentes inalterados. Isso pode ser útil se uma região de bloco convenientemente associar uma área de mapeamentos de bloco a ser atualizada, exceto com algumas exceções que precisam ser deixadas da mesma forma que o que foram mapeados antes. pTilePoolStartOffsets[i] é ignorado para mapeamentos SKIP.
- Parâmetro flags para opções gerais.D3D11_TILE_MAPPING_NO_OVERWRITE significa que o chamador promete que os comandos enviados anteriormente para o dispositivo que ainda podem estar sendo executados não fazem referência a nenhuma região do bloco que está sendo atualizada. Isso permite que o dispositivo evite ter que liberar o trabalho enviado anteriormente para fazer a atualização de mapeamento de bloco. Se o aplicativo violar essa promessa atualizando mapeamentos de bloco para locais em recursos em bloco ainda sendo referenciados por comandos pendentes, resultados de comportamento de renderização indefinidos, o que inclui o potencial de lentidão significativa em algumas arquiteturas. Isso é como o conceito "sem substituição" que existe em outro lugar na API do Direct3D, exceto aplicado à própria estrutura de dados de mapeamento de blocos, que no hardware é uma tabela de páginas. A ausência desse sinalizador requer que as atualizações de mapeamento de bloco especificadas por esta chamada UpdateTileMappings precisem ser concluídas antes que qualquer comando Direct3D subsequente possa continuar.
Nota No Direct3D 11.2, o hardware agora pode dar suporte ao ClearView em formatos somente de profundidade. Para obter mais informações, consulte D3D11_FEATURE_DATA_D3D11_OPTIONS1.
Suponha que um bloco seja mapeado em vários recursos em bloco ao mesmo tempo e o conteúdo do bloco seja manipulado por qualquer meio (renderização, cópia e assim por diante) por meio de um dos recursos em bloco. Em seguida, se o mesmo bloco for renderizado por meio de qualquer outro recurso em bloco, o bloco deverá ser limpo primeiro, conforme descrito anteriormente.
Para obter mais informações sobre recursos em bloco, consulte Recursos em bloco.
Aqui estão alguns exemplos de casos comuns de UpdateTileMappings :
Exemplos
Limpando os mapeamentos de uma superfície inteira para 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);
Mapeando uma região de blocos para um único bloco:
// - 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);
Definindo mapeamentos para um conjunto de blocos individuais desarticulados:
// - 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);
Exemplo complexo – definindo mapeamentos para regiões com alguns saltos, alguns mapeamentos 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 | Valor |
|---|---|
| Cliente mínimo com suporte | Windows 8.1 [aplicativos da área de trabalho | Aplicativos UWP] |
| Servidor mínimo com suporte | Windows Server 2012 R2 [aplicativos da área de trabalho | Aplicativos UWP] |
| Plataforma de Destino | Windows |
| Cabeçalho | d3d11_2.h |
| Biblioteca | D3D11.lib |