Condividi tramite

Metodo ID3D12CommandQueue::UpdateTileMappings (d3d12.h)

  • Articolo

Aggiornamenti mapping delle posizioni dei riquadri nelle risorse riservate ai percorsi di memoria in un heap delle risorse.

Sintassi

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
);

Parametri

[in] pResource

Puntatore alla risorsa riservata.

NumResourceRegions

Numero di aree di risorse riservate.

[in, optional] pResourceRegionStartCoordinates

Matrice di strutture D3D12_TILED_RESOURCE_COORDINATE che descrivono le coordinate iniziali delle aree di risorse riservate. Il parametro NumResourceRegions specifica il numero di strutture D3D12_TILED_RESOURCE_COORDINATE nella matrice.

[in, optional] pResourceRegionSizes

Matrice di strutture D3D12_TILE_REGION_SIZE che descrivono le dimensioni delle aree di risorse riservate. Il parametro NumResourceRegions specifica il numero di strutture D3D12_TILE_REGION_SIZE nella matrice.

[in, optional] pHeap

Puntatore all'heap delle risorse.

NumRanges

Numero di intervalli di riquadri.

[in, optional] pRangeFlags

Puntatore a una matrice di valori D3D12_TILE_RANGE_FLAGS che descrive ogni intervallo di riquadri. Il parametro NumRanges specifica il numero di valori nella matrice.

[in, optional] pHeapRangeStartOffsets

Matrice di offset nell'heap delle risorse. Si tratta di offset di riquadri basati su 0, contando in riquadri (non byte).

[in, optional] pRangeTileCounts

Matrice di riquadri. Matrice di valori che specificano il numero di riquadri in ogni intervallo di riquadri. Il parametro NumRanges specifica il numero di valori nella matrice.

Flags

Combinazione di valori D3D12_TILE_MAPPING_FLAGS combinati tramite un'operazione OR bit per bit.

Valore restituito

nessuno

Osservazioni

Usare UpdateTileMappings per eseguire il mapping delle pagine virtuali di una risorsa riservata alle pagine fisiche di un heap. Il mapping non deve essere in ordine. L'operazione è simile a ID3D11DeviceContext2::UpdateTileMappings con una differenza chiave che D3D12 consente a una risorsa riservata di avere riquadri da più heap.

In una singola chiamata a UpdateTileMappings è possibile eseguire il mapping di uno o più intervalli di riquadri di risorse a uno o più intervalli di riquadri dell'heap.

È possibile organizzare i parametri di UpdateTileMappings in questi modi per eseguire un aggiornamento:

  • Risorsa riservata i cui mapping vengono aggiornati. I mapping iniziano da tutti i valori NULL quando viene creata inizialmente una risorsa.
  • Set di aree di riquadri nella risorsa riservata i cui mapping vengono aggiornati. È possibile effettuare una chiamata UpdateTileMappings per aggiornare molti mapping o più chiamate con un sovraccarico di chiamata API leggermente maggiore, se più conveniente.
    • NumResourceRegions specifica il numero di aree presenti.
    • pResourceRegionStartCoordinates e pResourceRegionSizes sono ogni matrice che identifica la posizione iniziale ed estende ogni area. Se NumResourceRegions è 1, per praticità o entrambe le matrici che descrivono le aree possono essere NULL. NULL per pResourceRegionStartCoordinates indica che la coordinata iniziale è tutti 0s e NULL per pResourceRegionSizes identifica un'area predefinita che rappresenta il set completo di riquadri per l'intera risorsa riservata, inclusi tutti i mipmap, le sezioni di matrice o entrambi.
    • Se pResourceRegionStartCoordinates non è NULL e pResourceRegionSizes è NULL, per impostazione predefinita la dimensione dell'area è 1 riquadro per tutte le aree. In questo modo è facile definire i mapping per un set di singoli riquadri in posizioni diverse fornendo una matrice di posizioni in pResourceRegionStartCoordinates senza dover inviare una matrice di pResourceRegionSizes impostata su 1.
    Gli aggiornamenti vengono applicati dalla prima area all'ultima; pertanto, se le aree si sovrappongono in una singola chiamata, gli aggiornamenti più avanti nell'elenco sovrascrivono le aree che si sovrappongono agli aggiornamenti precedenti.
  • Heap che fornisce memoria in cui è possibile usare i mapping dei riquadri. Se UpdateTileMappings definisce solo i mapping NULL, non è necessario specificare un heap.
  • Set di intervalli di riquadri in cui vengono impostati i mapping. Ogni intervallo di riquadri specificato può specificare uno di alcuni tipi di intervalli: un intervallo di riquadri in un heap (impostazione predefinita), un numero di riquadri nella risorsa riservata per eseguire il mapping a un singolo riquadro in un heap (condivisione del riquadro), un conteggio dei mapping dei riquadri nella risorsa riservata per ignorare e lasciare invariati, o un numero di riquadri nell'heap per eseguire il mapping a NULL. NumRanges specifica il numero di intervalli di riquadri, in cui i riquadri totali identificati in tutti gli intervalli devono corrispondere al numero totale di riquadri nelle aree del riquadro della risorsa riservata descritta in precedenza. I mapping vengono definiti eseguendo l'iterazione dei riquadri nelle aree del riquadro in ordine sequenziale, x quindi y quindi z order per le aree box, mentre si scorre il set di intervalli di riquadri in ordine sequenziale. La suddivisione delle aree del riquadro non deve essere allineata alla suddivisione degli intervalli di riquadri, ma il numero totale di riquadri su entrambi i lati deve essere uguale in modo che ogni riquadro di risorsa riservata specificato abbia un mapping specificato.

    pRangeFlags, pHeapRangeStartOffsets e pRangeTileCounts sono tutte matrici, di dimensioni NumRanges, che descrivono gli intervalli di riquadri. Se pRangeFlags è NULL, tutti gli intervalli sono riquadri sequenziali nell'heap; in caso contrario, per ogni intervallo i,pRangeFlags[i] identifica il funzionamento dei mapping in tale intervallo di riquadri:

    • Se pRangeFlags[i] è D3D12_TILE_RANGE_FLAG_NONE, tale intervallo definisce riquadri sequenziali nell'heap, con il numero di riquadri pRangeTileCounts[i] e la posizione iniziale pHeapRangeStartOffsets[i]. Se NumRanges è 1, pRangeTileCounts può essere NULL e il valore predefinito è il numero totale di riquadri specificati da tutte le aree del riquadro.
    • Se pRangeFlags[i] è D3D12_TILE_RANGE_FLAG_REUSE_SINGLE_TILE, pHeapRangeStartOffsets[i] identifica il singolo riquadro nell'heap a cui eseguire il mapping e pRangeTileCounts[i] specifica il numero di riquadri delle aree del riquadro di cui eseguire il mapping alla posizione dell'heap. Se NumRanges è 1, pRangeTileCounts può essere NULL e il valore predefinito è il numero totale di riquadri specificati da tutte le aree del riquadro.
    • Se pRangeFlags[i] è D3D12_TILE_RANGE_FLAG_NULL, pRangeTileCounts[i] specifica il numero di riquadri delle aree del riquadro di cui eseguire il mapping a NULL. Se NumRanges è 1, pRangeTileCounts può essere NULL e il valore predefinito è il numero totale di riquadri specificati da tutte le aree del riquadro. pHeapRangeStartOffsets[i] viene ignorato per i mapping NULL.
    • Se pRangeFlags[i] è D3D12_TILE_RANGE_FLAG_SKIP, pRangeTileCounts[i] specifica il numero di riquadri delle aree del riquadro per cui ignorare e lasciare invariati i mapping esistenti. Ciò può essere utile se un'area del riquadro delimita facilmente un'area di mapping di riquadri da aggiornare, ad eccezione di alcune eccezioni che devono essere lasciate uguali a quelle di cui è stato eseguito il mapping in precedenza. pHeapRangeStartOffsets[i] viene ignorato per i mapping SKIP.
Le risorse riservate devono seguire le stesse regole per l'aliasing, l'inizializzazione e l'ereditarietà dei dati delle risorse inserite. Per altri dettagli, vedere CreatePlacedResource .

Ecco alcuni esempi di casi comuni di UpdateTileMappings :

Esempio

Gli esempi fanno riferimento alle strutture e alle enumerazioni seguenti:

Cancellazione dei mapping di un'intera superficie a 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);

Mapping di un'area di riquadri a un singolo riquadro:

// - 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);

Definizione dei mapping per un set di singoli riquadri non contigui:

// - 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);

Esempio complesso: definizione dei mapping per le aree con alcuni skip, alcuni mapping 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);

Requisiti

   
Piattaforma di destinazione Windows
Intestazione d3d12.h

Vedi anche

CopyTileMappings

ID3D12CommandQueue

Risorse affiancate del volume