Metodo ID3D11DeviceContext2::UpdateTileMappings (d3d11_2.h)
Aggiornamenti mapping delle posizioni dei riquadri nelle risorse riquadri nei percorsi di memoria in un pool di riquadri.
Sintassi
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
);
Parametri
[in] pTiledResource
Tipo: ID3D11Resource*
Puntatore alla risorsa riquadri.
[in] NumTiledResourceRegions
Tipo: UINT
Numero di aree delle risorse riquadri.
[in, optional] pTiledResourceRegionStartCoordinates
Tipo: const D3D11_TILED_RESOURCE_COORDINATE*
Matrice di strutture D3D11_TILED_RESOURCE_COORDINATE che descrivono le coordinate iniziali delle aree delle risorse riquadri. Il parametro NumTiledResourceRegions specifica il numero di strutture D3D11_TILED_RESOURCE_COORDINATE nella matrice.
[in, optional] pTiledResourceRegionSizes
Tipo: const D3D11_TILE_REGION_SIZE*
Matrice di strutture D3D11_TILE_REGION_SIZE che descrivono le dimensioni delle aree delle risorse riquadri. Il parametro NumTiledResourceRegions specifica il numero di strutture D3D11_TILE_REGION_SIZE nella matrice.
[in, optional] pTilePool
Tipo: ID3D11Buffer*
Puntatore al pool di riquadri.
[in] NumRanges
Tipo: UINT
Numero di intervalli di pool di riquadri.
[in, optional] pRangeFlags
Tipo: const UINT*
Matrice di valori D3D11_TILE_RANGE_FLAG che descrivono ogni intervallo di pool di riquadri. Il parametro NumRanges specifica il numero di valori nella matrice.
[in, optional] pTilePoolStartOffsets
Tipo: const UINT*
Matrice di offset nel pool di riquadri. Si tratta di offset di riquadri basati su 0, conteggio nei riquadri (non byte).
[in, optional] pRangeTileCounts
Tipo: const UINT*
Matrice di riquadri.
Matrice di valori che specificano il numero di riquadri in ogni intervallo di pool di riquadri. Il parametro NumRanges specifica il numero di valori nella matrice.
[in] Flags
Tipo: UINT
Combinazione di valori D3D11_TILE_MAPPING_FLAGS combinati usando un'operazione OR bit per bit.
Valore restituito
Tipo: HRESULT
Restituisce S_OK se ha esito positivo; in caso contrario, restituisce uno dei seguenti elementi:
- Restituisce E_INVALIDARG se varie condizioni, ad esempio flag non validi, generano l'eliminazione della chiamata. Il livello di debug genererà un errore.
- Restituisce E_OUTOFMEMORY se la chiamata comporta la necessità di allocare spazio per i nuovi mapping di tabelle di pagina, ma che non eseguono memoria. Se si verifica una memoria insufficiente quando viene chiamato in un elenco di comandi e l'elenco di comandi viene eseguito, il dispositivo verrà rimosso. Le app possono evitare questa situazione eseguendo solo chiamate di aggiornamento che modificano i mapping esistenti dalle risorse riquadri all'interno di elenchi di comandi (quindi i driver non dovranno allocare memoria della tabella di pagina, modifica solo il mapping).
- Restituisce DXGI_ERROR_DEVICE_REMOVED se la scheda video è stata rimossa fisicamente dal sistema o si è verificato un aggiornamento del driver per la scheda video.
Commenti
In una singola chiamata a UpdateTileMappings è possibile eseguire il mapping di uno o più intervalli di riquadri delle risorse a uno o più intervalli di riquadri del pool di riquadri.
È possibile organizzare i parametri di UpdateTileMappings in questi modi per eseguire un aggiornamento:
- Risorsa riquadri i cui mapping vengono aggiornati. Si tratta di una risorsa creata con il flag di D3D11_RESOURCE_MISC_TILED . I mapping iniziano tutti i VALORI NULL quando viene inizialmente creata una risorsa.
- Set di aree di riquadro nella risorsa riquadri i cui mapping vengono aggiornati. È possibile effettuare una chiamata UpdateTileMappings per aggiornare molti mapping o più chiamate con un sovraccarico di chiamate API un po' più pratico. NumTiledResourceRegions specifica il numero di aree presenti, pTiledResourceRegionStartCoordinates e pTiledResourceRegionSizes che identificano la posizione iniziale e l'estensione di ogni area. Se NumTiledResourceRegions è 1, per praticità o entrambe le matrici che descrivono le aree possono essere NULL. NULL per pTiledResourceRegionStartCoordinates indica che la coordinata iniziale è tutte le 0 e NULL per pTiledResourceRegionSizes identifica un'area predefinita che corrisponde al set completo di riquadri per l'intera risorsa riquadri, inclusi tutti i mipmap, le sezioni di matrice o entrambi. Se pTiledResourceRegionStartCoordinates non è NULL e pTiledResourceRegionSizes è NULL, le dimensioni dell'area vengono predefinite su 1 riquadro per tutte le aree. Ciò semplifica la definizione dei mapping per un set di singoli riquadri in posizioni diverse fornendo una matrice di posizioni in pTiledResourceRegionStartCoordinates senza dover inviare una matrice di pTiledResourceRegionSizes impostata su 1.
Gli aggiornamenti vengono applicati dalla prima area all'ultima; quindi, se le aree si sovrappongono in una singola chiamata, gli aggiornamenti più avanti nell'elenco sovrascrivono le aree che si sovrappongono con gli aggiornamenti precedenti.
- Pool di riquadri che fornisce memoria in cui è possibile passare i mapping dei riquadri. Una risorsa riquadri può puntare a un singolo pool di riquadri alla volta. Se viene specificato un nuovo pool di riquadri (per la prima volta o diverso dall'ultima volta che è stato specificato un pool di riquadri), tutti i mapping dei riquadri esistenti per la risorsa riquadri vengono cancellati e il nuovo set di mapping nella chiamata UpdateTileMappings corrente viene applicato per il nuovo pool di riquadri. Se non viene specificato alcun pool di riquadri (NULL) o lo stesso pool di riquadri di una chiamata UpdateTileMappings precedente, la chiamata UpdateTileMappings aggiunge solo i nuovi mapping a quelli esistenti (sovrascrivendo la sovrapposizione). Se UpdateTileMappings definisce solo i mapping NULL, non è necessario specificare un pool di riquadri perché è irrilevante. Tuttavia, se si specifica un pool di riquadri, accetta lo stesso comportamento descritto in precedenza durante la fornitura di un pool di riquadri.
- Set di intervalli di riquadri in cui verranno eseguite le mapping. Ogni intervallo di riquadri specificato può specificare uno di alcuni tipi di intervalli: un intervallo di riquadri in un pool di riquadri (impostazione predefinita), un numero di riquadri nella risorsa riquadri per eseguire il mapping a un singolo riquadro in un pool di riquadri (condivisione del riquadro), un numero di mapping dei riquadri nella risorsa riquadri per ignorare e lasciare come sono, o un numero di riquadri nel pool di riquadri 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 riquadri 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 della casella, mentre si passa attraverso 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 della risorsa riquadri riquadri specificato abbia un mapping specificato.
pRangeFlags, pTilePoolStartOffsets e pRangeTileCounts sono tutte matrici, di dimensioni NumRanges, che descrivono gli intervalli di riquadri. Se pRangeFlags è NULL, tutti gli intervalli sono riquadri sequenziali nel pool di riquadri; in caso contrario, per ogni intervallo i, pRangeFlags[i] identifica il funzionamento dei mapping in tale intervallo di riquadri:
- Se pRangeFlags[i] è 0, tale intervallo definisce riquadri sequenziali nel pool di riquadri, con il numero di riquadri che sono pRangeTileCounts[i] e la posizione iniziale pTilePoolStartOffsets[i]. Se NumRanges è 1, pRangeTileCounts può essere NULL e per impostazione predefinita il numero totale di riquadri specificati da tutte le aree del riquadro.
- Se pRangeFlags[i] è D3D11_TILE_RANGE_REUSE_SINGLE_TILE, pTilePoolStartOffsets[i] identifica il singolo riquadro nel pool di riquadri a cui eseguire il mapping e pRangeTileCounts[i] specifica il numero di riquadri delle aree del riquadro da eseguire il mapping a tale percorso del pool di riquadri. Se NumRanges è 1, pRangeTileCounts può essere NULL e per impostazione predefinita il numero totale di riquadri specificati da tutte le aree del riquadro.
- Se pRangeFlags[i] è D3D11_TILE_RANGE_NULL, pRangeTileCounts[i] specifica il numero di riquadri delle aree del riquadro da eseguire il mapping a NULL. Se NumRanges è 1, pRangeTileCounts può essere NULL e per impostazione predefinita il numero totale di riquadri specificati da tutte le aree del riquadro. pTilePoolStartOffsets[i] viene ignorato per i mapping NULL.
- Se pRangeFlags[i] è D3D11_TILE_RANGE_SKIP, pRangeTileCounts[i] specifica il numero di riquadri delle aree del riquadro per ignorare e lasciare invariati i mapping esistenti. Ciò può risultare utile se un'area del riquadro delimita in modo pratico un'area di mapping di riquadri da aggiornare, ad eccezione di alcune eccezioni che devono essere lasciate uguali a quelle a cui sono stati mappati prima. pTilePoolStartOffsets[i] viene ignorato per i mapping SKIP.
- Contrassegna il parametro per le opzioni complessive.D3D11_TILE_MAPPING_NO_OVERWRITE significa che il chiamante promette che i comandi inviati in precedenza al dispositivo che potrebbero ancora essere in esecuzione non fanno riferimento a nessuno dell'area del riquadro da aggiornare. Ciò consente al dispositivo di evitare di dover scaricare il lavoro inviato in precedenza per eseguire l'aggiornamento del mapping dei riquadri. Se l'app viola questa promessa aggiornando i mapping dei riquadri per le posizioni nelle risorse riquadri ancora a cui si fa riferimento da comandi in sospeso, risultati del comportamento di rendering non definiti, che include il potenziale per rallentamenti significativi in alcune architetture. Questo è come il concetto di "non sovrascrive" che esiste altrove nell'API Direct3D, tranne applicato alla struttura di dati di mapping dei riquadri stessa, che nell'hardware è una tabella di pagine. L'assenza di questo flag richiede che gli aggiornamenti del mapping dei riquadri specificati da questa chiamata UpdateTileMappings siano completati prima che qualsiasi comando Direct3D successivo possa procedere.
Nota In Direct3D 11.2 l'hardware può ora supportare ClearView in formati di sola profondità. Per altre informazioni, vedere D3D11_FEATURE_DATA_D3D11_OPTIONS1.
Si supponga che un riquadro venga mappato in più risorse riquadri contemporaneamente e il contenuto del riquadro vengano manipolati con qualsiasi mezzo (rendering, copia e così via) tramite una delle risorse riquadri. Se quindi lo stesso riquadro deve essere eseguito il rendering tramite qualsiasi altra risorsa riquadri, il riquadro deve essere cancellato prima come descritto in precedenza.
Per altre informazioni sulle risorse riquadri, vedere Risorse riquadri.
Ecco alcuni esempi di casi comuni di UpdateTileMappings :
Esempio
Cancellare i mapping di un'intera superficie 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);
Mapping di un'area di riquadri a un singolo riquadro:
// - 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);
Definizione dei mapping per un set di singoli riquadri disgiunti:
// - 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);
Esempio complesso: definizione dei mapping per le aree con alcuni ignoramenti, 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 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).
Requisiti
| Requisito | Valore |
|---|---|
| Client minimo supportato | Windows 8.1 [app desktop | App UWP] |
| Server minimo supportato | Windows Server 2012 R2 [app desktop | App UWP] |
| Piattaforma di destinazione | Windows |
| Intestazione | d3d11_2.h |
| Libreria | D3D11.lib |