ID3D12CommandQueue::UpdateTileMappings-Methode (d3d12.h)

  • Artikel

Updates Zuordnungen von Kachelspeicherorten in reservierten Ressourcen zu Speicherspeicherorten in einem Ressourcenheap.

Syntax

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

Parameter

[in] pResource

Ein Zeiger auf die reservierte Ressource.

NumResourceRegions

Die Anzahl der reservierten Ressourcenregionen.

[in, optional] pResourceRegionStartCoordinates

Ein Array von D3D12_TILED_RESOURCE_COORDINATE Strukturen, die die Startkoordinaten der reservierten Ressourcenregionen beschreiben. Der Parameter NumResourceRegions gibt die Anzahl der D3D12_TILED_RESOURCE_COORDINATE Strukturen im Array an.

[in, optional] pResourceRegionSizes

Ein Array von D3D12_TILE_REGION_SIZE Strukturen, die die Größe der reservierten Ressourcenregionen beschreiben. Der Parameter NumResourceRegions gibt die Anzahl der D3D12_TILE_REGION_SIZE Strukturen im Array an.

[in, optional] pHeap

Ein Zeiger auf den Ressourcenheap.

NumRanges

Die Anzahl der Kachelbereiche.

[in, optional] pRangeFlags

Ein Zeiger auf ein Array von D3D12_TILE_RANGE_FLAGS Werten, das jeden Kachelbereich beschreibt. Der Parameter NumRanges gibt die Anzahl der Werte im Array an.

[in, optional] pHeapRangeStartOffsets

Ein Array von Offsets in den Ressourcenheap. Hierbei handelt es sich um 0-basierte Kacheloffsets, die in Kacheln (nicht Bytes) zählen.

[in, optional] pRangeTileCounts

Ein Array von Kacheln. Ein Array von Werten, die die Anzahl der Kacheln in jedem Kachelbereich angeben. Der Parameter NumRanges gibt die Anzahl der Werte im Array an.

Flags

Eine Kombination aus D3D12_TILE_MAPPING_FLAGS Werten, die mithilfe eines bitweisen OR-Vorgangs kombiniert werden.

Rückgabewert

Keine

Bemerkungen

Verwenden Sie UpdateTileMappings , um die virtuellen Seiten einer reservierten Ressource den physischen Seiten eines Heaps zuzuordnen. Die Zuordnung muss nicht in Ordnung sein. Der Vorgang ähnelt ID3D11DeviceContext2::UpdateTileMappings mit dem einzigen Unterschied, dass D3D12 einer reservierten Ressource Kacheln aus mehreren Heaps zulässt.

In einem einzelnen Aufruf von UpdateTileMappings können Sie einen oder mehrere Bereiche von Ressourcenkacheln einem oder mehreren Bereichen von Heapkacheln zuordnen.

Sie können die Parameter von UpdateTileMappings auf folgende Weise organisieren, um ein Update auszuführen:

  • Reservierte Ressource, deren Zuordnungen aktualisiert werden. Zuordnungen beginnen mit NULL, wenn eine Ressource zuerst erstellt wird.
  • Gruppe von Kachelbereichen für die reservierte Ressource, deren Zuordnungen aktualisiert werden. Sie können einen UpdateTileMappings-Aufruf ausführen, um viele Zuordnungen oder mehrere Aufrufe mit etwas mehr API-Aufrufaufwand zu aktualisieren, wenn dies bequemer ist.
    • NumResourceRegions gibt an, wie viele Regionen vorhanden sind.
    • pResourceRegionStartCoordinates und pResourceRegionSizes sind jeweils Arrays, die den Startstandort und die Erweiterung jeder Region identifizieren. Wenn NumResourceRegions 1 ist, können zur Vereinfachung entweder oder beide Arrays, die die Regionen beschreiben, NULL sein. NULL für pResourceRegionStartCoordinates bedeutet, dass die Startkoordinate alle 0s ist, und NULL für pResourceRegionSizes identifiziert eine Standardregion, die den vollständigen Kachelsatz für die gesamte reservierte Ressource darstellt, einschließlich aller Mipmaps, Array-Slices oder beides.
    • Wenn pResourceRegionStartCoordinates nicht NULL und pResourceRegionSizes NULL ist, wird die Regionsgröße standardmäßig auf 1 Kachel für alle Regionen festgelegt. Dies erleichtert das Definieren von Zuordnungen für einen Satz einzelner Kacheln an unterschiedlichen Speicherorten, indem ein Array von Speicherorten in pResourceRegionStartCoordinates bereitgestellt wird, ohne ein Array von pResourceRegionSizes alle auf 1 festlegen zu müssen.
    Die Updates werden von der ersten Bis zur letzten Region angewendet. Wenn sich Also Regionen in einem einzigen Aufruf überschneiden, überschreiben die Updates später in der Liste die Bereiche, die sich mit vorherigen Updates überlappen.
  • Heap, der Speicher bereitstellt, in den Kachelzuordnungen verwendet werden können. Wenn UpdateTileMappings nur NULL-Zuordnungen definiert, müssen Sie keinen Heap angeben.
  • Gruppe von Kachelbereichen, in denen Zuordnungen durchgeführt werden. Jeder angegebene Kachelbereich kann einen von wenigen Arten von Bereichen angeben: einen Bereich von Kacheln in einem Heap (Standard), eine Anzahl von Kacheln in der reservierten Ressource, die einer einzelnen Kachel in einem Heap zugeordnet werden soll (freigaben der Kachel), eine Anzahl von Kachelzuordnungen in der reservierten Ressource, die übersprungen und verlassen werden sollen, wie sie sind, oder eine Anzahl von Kacheln im Heap, die NULL zugeordnet werden sollen. NumRanges gibt die Anzahl der Kachelbereiche an, bei denen die Gesamtkacheln, die in allen Bereichen identifiziert werden, mit der Gesamtzahl der Kacheln in den Kachelbereichen aus der zuvor beschriebenen reservierten Ressource übereinstimmen müssen. Zuordnungen werden definiert, indem die Kacheln in den Kachelbereichen in sequenzieller Reihenfolge durchlaufen werden – x then y then y dann z-Reihenfolge für Feldbereiche – während die Gruppe der Kachelbereiche in sequenzieller Reihenfolge durchlaufen wird. Die Aufschlüsselung der Kachelbereiche muss nicht mit der Aufschlüsselung der Kachelbereiche in Einklang stehen, aber die Gesamtzahl der Kacheln auf beiden Seiten muss gleich sein, sodass für jede angegebene reservierte Ressourcenkachel eine Zuordnung angegeben ist.

    pRangeFlags, pHeapRangeStartOffsets und pRangeTileCounts sind alle Arrays der Größe NumRanges, die die Kachelbereiche beschreiben. Wenn pRangeFlags NULL ist, sind alle Bereiche sequenzielle Kacheln im Heap. Andernfalls gibt pRangeFlags[i] für jeden Bereich i an, wie die Zuordnungen in diesem Kachelbereich funktionieren:

    • Wenn pRangeFlags[i]D3D12_TILE_RANGE_FLAG_NONE ist, definiert dieser Bereich sequenzielle Kacheln im Heap, wobei die Anzahl der Kacheln pRangeTileCounts[i] und der Startort pHeapRangeStartOffsets[i] ist. Wenn NumRanges 1 ist, kann pRangeTileCounts NULL sein und standardmäßig auf die Gesamtanzahl von Kacheln festgelegt werden, die von allen Kachelbereichen angegeben wird.
    • Wenn pRangeFlags[i]D3D12_TILE_RANGE_FLAG_REUSE_SINGLE_TILE ist, identifiziert pHeapRangeStartOffsets[i] die einzelne Kachel im Heap, der zugeordnet werden soll, und pRangeTileCounts[i] gibt an, wie viele Kacheln aus den Kachelregionen diesem Heapstandort zugeordnet werden sollen. Wenn NumRanges 1 ist, kann pRangeTileCounts NULL sein und standardmäßig auf die Gesamtanzahl von Kacheln festgelegt werden, die von allen Kachelbereichen angegeben wird.
    • Wenn pRangeFlags[i]D3D12_TILE_RANGE_FLAG_NULL ist, gibt pRangeTileCounts[i] an, wie viele Kacheln aus den Kachelregionen null zugeordnet werden sollen. Wenn NumRanges 1 ist, kann pRangeTileCounts NULL sein und standardmäßig auf die Gesamtanzahl von Kacheln festgelegt werden, die von allen Kachelbereichen angegeben wird. pHeapRangeStartOffsets[i] wird für NULL-Zuordnungen ignoriert.
    • Wenn pRangeFlags[i]D3D12_TILE_RANGE_FLAG_SKIP ist, gibt pRangeTileCounts[i] an, wie viele Kacheln aus den Kachelregionen übersprungen und vorhandene Zuordnungen unverändert bleiben sollen. Dies kann nützlich sein, wenn ein Kachelbereich bequem einen Bereich mit Kachelzuordnungen eingrenzt, der aktualisiert werden soll, außer mit einigen Ausnahmen, die mit dem identisch bleiben müssen, was sie zuvor zugeordnet wurden. pHeapRangeStartOffsets[i] wird für SKIP-Zuordnungen ignoriert.
Reservierte Ressourcen müssen dieselben Regeln für Kachelaliasing, Initialisierung und Datenvererbung wie platzierte Ressourcen befolgen. Weitere Informationen finden Sie unter CreatePlacedResource .

Hier sind einige Beispiele für gängige UpdateTileMappings-Fälle :

Beispiele

Die Beispiele beziehen sich auf die folgenden Strukturen und Aufzählungen:

Löschen der Zuordnungen einer gesamten Oberfläche zu 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);

Zuordnen eines Kachelbereichs zu einer einzelnen Kachel:

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

Definieren von Zuordnungen für eine Reihe von unzusammenigen einzelnen Kacheln:

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

Komplexes Beispiel: Definieren von Zuordnungen für Regionen mit einigen Übergängen, einigen NULL-Zuordnungen.

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

Anforderungen

   
Zielplattform Windows
Kopfzeile d3d12.h

Weitere Informationen

CopyTileMappings

ID3D12CommandQueue

Menge gekachelter Ressourcen