Compartilhar via

Método ID3D12CommandQueue::UpdateTileMappings (d3d12.h)

  • Artigo

Atualizações mapeamentos de locais de bloco em recursos reservados para locais de memória em um heap de recursos.

Sintaxe

void UpdateTileMappings(
  [in]           ID3D12Resource                        *pResource,
                 UINT                                  NumResourceRegions,
  [in, optional] const D3D12_TILED_RESOURCE_COORDINATE *pResourceRegionStartCoordinates,
  [in, optional] const D3D12_TILE_REGION_SIZE          *pResourceRegionSizes,
  [in, optional] ID3D12Heap                            *pHeap,
                 UINT                                  NumRanges,
  [in, optional] const D3D12_TILE_RANGE_FLAGS          *pRangeFlags,
  [in, optional] const UINT                            *pHeapRangeStartOffsets,
  [in, optional] const UINT                            *pRangeTileCounts,
                 D3D12_TILE_MAPPING_FLAGS              Flags
);

Parâmetros

[in] pResource

Um ponteiro para o recurso reservado.

NumResourceRegions

O número de regiões de recursos reservados.

[in, optional] pResourceRegionStartCoordinates

Uma matriz de estruturas de D3D12_TILED_RESOURCE_COORDINATE que descrevem as coordenadas iniciais das regiões de recursos reservados. O parâmetro NumResourceRegions especifica o número de estruturas D3D12_TILED_RESOURCE_COORDINATE na matriz.

[in, optional] pResourceRegionSizes

Uma matriz de estruturas de D3D12_TILE_REGION_SIZE que descrevem os tamanhos das regiões de recursos reservados. O parâmetro NumResourceRegions especifica o número de estruturas D3D12_TILE_REGION_SIZE na matriz.

[in, optional] pHeap

Um ponteiro para o heap de recursos.

NumRanges

O número de intervalos de blocos.

[in, optional] pRangeFlags

Um ponteiro para uma matriz de valores D3D12_TILE_RANGE_FLAGS que descreve cada intervalo de blocos. O parâmetro NumRanges especifica o número de valores na matriz.

[in, optional] pHeapRangeStartOffsets

Uma matriz de deslocamentos no heap de recursos. São deslocamentos de bloco baseados em 0, contando em blocos (não bytes).

[in, optional] pRangeTileCounts

Uma matriz de blocos. Uma matriz de valores que especificam o número de blocos em cada intervalo de blocos. O parâmetro NumRanges especifica o número de valores na matriz.

Flags

Uma combinação de valores D3D12_TILE_MAPPING_FLAGS que são combinados usando uma operação OR bit a bit.

Valor retornado

Nenhum

Comentários

Use UpdateTileMappings para mapear as páginas virtuais de um recurso reservado para as páginas físicas de um heap. O mapeamento não precisa estar em ordem. A operação é semelhante a ID3D11DeviceContext2::UpdateTileMappings com a única diferença importante de que D3D12 permite que um recurso reservado tenha blocos de vários heaps.

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

Você pode organizar os parâmetros de UpdateTileMappings destas maneiras para executar uma atualização:

  • Recurso reservado cujos mapeamentos são atualizados. Os mapeamentos iniciam todos os NULL quando um recurso é criado inicialmente.
  • Conjunto de regiões de bloco no recurso reservado 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 à API, se isso for mais conveniente.
    • NumResourceRegions especifica quantas regiões existem.
    • pResourceRegionStartCoordinates e pResourceRegionSizes são cada matriz que identificam o local inicial e a extensão de cada região. Se NumResourceRegions for 1, para conveniência, ou ambas as matrizes que descrevem as regiões poderão ser NULL. NULL para pResourceRegionStartCoordinates significa que a coordenada inicial é 0s e NULL para pResourceRegionSizes identifica uma região padrão que é o conjunto completo de blocos para todo o recurso reservado, incluindo todos os mipmaps, fatias de matriz ou ambos.
    • Se pResourceRegionStartCoordinates não for NULL e pResourceRegionSizes for NULL, o tamanho da região usará como padrão 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 pResourceRegionStartCoordinates sem precisar enviar uma matriz de pResourceRegionSizes tudo definido como 1.
    As atualizações são aplicadas da primeira região para a última; portanto, se as regiões se sobrepuserem em uma única chamada, as atualizações posteriormente na lista substituirão as áreas que se sobrepõem às atualizações anteriores.
  • Heap que fornece memória para onde os mapeamentos de bloco podem ir. Se UpdateTileMappings definir apenas mapeamentos NULL, você não precisará especificar um heap.
  • 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 heap (padrão), uma contagem de blocos no recurso reservado para mapear para um único bloco em um heap (compartilhando o bloco), uma contagem de mapeamentos de bloco no recurso reservado para ignorar e sair como estão, ou uma contagem de blocos no heap 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 reservado descrito anteriormente. Os mapeamentos são definidos iterando 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 ser alinhado 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 recurso reservado especificado tenha um mapeamento especificado.

    pRangeFlags, pHeapRangeStartOffsets 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 heap; caso contrário, para cada intervalo i,pRangeFlags[i] identifica como os mapeamentos nesse intervalo de blocos funcionam:

    • Se pRangeFlags[i] for D3D12_TILE_RANGE_FLAG_NONE, esse intervalo definirá blocos sequenciais no heap, com o número de blocos sendo pRangeTileCounts[i] e o local inicial pHeapRangeStartOffsets[i]. Se NumRanges for 1, pRangeTileCounts poderá ser NULL e o padrão será o número total de blocos especificado por todas as regiões do bloco.
    • Se pRangeFlags[i] for D3D12_TILE_RANGE_FLAG_REUSE_SINGLE_TILE, pHeapRangeStartOffsets[i] identificará o único bloco no heap para o qual mapear e pRangeTileCounts[i] especificará quantos blocos das regiões de bloco mapear para esse local de heap. Se NumRanges for 1, pRangeTileCounts poderá ser NULL e o padrão será o número total de blocos especificado por todas as regiões do bloco.
    • Se pRangeFlags[i] for D3D12_TILE_RANGE_FLAG_NULL, pRangeTileCounts[i] especificará quantos blocos das regiões de bloco mapear para NULL. Se NumRanges for 1, pRangeTileCounts poderá ser NULL e o padrão será o número total de blocos especificado por todas as regiões do bloco. pHeapRangeStartOffsets[i] é ignorado para mapeamentos NULL.
    • Se pRangeFlags[i] for D3D12_TILE_RANGE_FLAG_SKIP, pRangeTileCounts[i] especificará quantos blocos das regiões do bloco serão ignorados e deixarão os mapeamentos existentes inalterados. Isso poderá ser útil se uma região de bloco associar convenientemente uma área de mapeamentos de bloco a serem atualizados, exceto com algumas exceções que precisam ser deixadas da mesma forma que as que foram mapeadas antes. pHeapRangeStartOffsets[i] é ignorado para mapeamentos SKIP.
Os recursos reservados devem seguir as mesmas regras para alias, inicialização e herança de dados como recursos colocados. Consulte CreatePlacedResource para obter mais detalhes.

Aqui estão alguns exemplos de casos comuns de UpdateTileMappings :

Exemplos

Os exemplos fazem referência às seguintes estruturas e enumerações:

Limpando mapeamentos de uma superfície inteira para NULL
// - NULL for pResourceRegionStartCoordinates and pResourceRegionSizes defaults to the entire resource
// - NULL for pHeapRangeStartOffsets 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 resource region (which is
//   the entire surface in this case)
//
UINT RangeFlags = D3D12_TILE_RANGE_FLAG_NULL;
pCommandQueue->UpdateTileMappings(pResource, 1, NULL, NULL, NULL, 1, &RangeFlags, NULL, NULL, D3D12_TILE_MAPPING_FLAG_NONE);

Mapeando uma região de blocos para um único bloco:

// - This maps a 2x3 tile region at tile offset (1,1) in a resource to tile [12] in a heap
// 
D3D12_TILED_RESOURCE_COORDINATE TRC;
TRC.X = 1;
TRC.Y = 1;
TRC.Z = 0;
TRC.Subresource = 0;

D3D12_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 = D3D12_TILE_RANGE_FLAG_REUSE_SINGLE_TILE;
UINT StartOffset = 12;

pCommandQueue->UpdateTileMappings(pResource,1,&TRC,&TRS,pHeap,1,&RangeFlags,&StartOffset,NULL,D3D12_TILE_MAPPING_FLAG_NONE);

Definindo mapeamentos para um conjunto de blocos individuais não contíguos:

// - This can also be accomplished in multiple calls. 
//   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 pResourceRegionSizes defaults to each region in the resource
//   being a single tile.  So all that is needed are the coordinates of each one.
// - Passing NULL for pRangeFlags defaults to no flags (since none are needed in this case)
// - Passing NULL for pRangeTileCounts defaults to each range in the heap being size 1.
//   So all that is needed are the start offsets for each tile in the heap
//
D3D12_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;

pCommandQueue->UpdateTileMappings(pResource,NumSingleTiles,&TRC,NULL,pHeap,NumSingleTiles,NULL,StartOffsets,
NULL,D3D12_TILE_MAPPING_FLAG_NONE);

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 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 heap starting at
//   heap 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 (heap location [17]) and the remaining 
//   4 tiles to each map to to unique heap locations, [2], [9], [4] and [17]:
//
D3D12_TILED_RESOURCE_COORDINATE TRC[3];
D3D12_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 HeapRangeStartOffsets[8];
UINT RangeTileCounts[8];

RangeFlags[0] = 0;
HeapRangeStartOffsets[0] = 9;
RangeTileCounts[0] = 3;

RangeFlags[1] = D3D12_TILE_RANGE_FLAG_SKIP;
HeapRangeStartOffsets[1] = 0; // offset is ignored for skip mappings
RangeTileCounts[1] = 8;

RangeFlags[2] = D3D12_TILE_RANGE_FLAG_NULL;
HeapRangeStartOffsets[2] = 0; // offset is ignored for NULL mappings
RangeTileCounts[2] = 2;

RangeFlags[3] = D3D12_TILE_RANGE_FLAG_REUSE_SINGLE_TILE;
HeapRangeStartOffsets[3] = 17; 
RangeTileCounts[3] = 5;

RangeFlags[4] = 0;
HeapRangeStartOffsets[4] = 2; 
RangeTileCounts[4] = 1;

RangeFlags[5] = 0;
HeapRangeStartOffsets[5] = 9; 
RangeTileCounts[5] = 1;

RangeFlags[6] = 0;
HeapRangeStartOffsets[6] = 4; 
RangeTileCounts[6] = 1;

RangeFlags[7] = 0;
HeapRangeStartOffsets[7] = 17; 
RangeTileCounts[7] = 1;

pCommandQueue->UpdateTileMappings(pResource,NumRegions,TRC,TRS,pHeap,NumRanges,RangeFlags,
HeapRangeStartOffsets,RangeTileCounts,D3D12_TILE_MAPPING_FLAG_NONE);

Requisitos

   
Plataforma de Destino Windows
Cabeçalho d3d12.h

Confira também

CopyTileMappings

ID3D12CommandQueue

Alocação dinâmica de volumes de recursos