Dela via

Ladda upp texturdata via buffertar

Uppladdning av 2D- eller 3D-texturdata liknar uppladdning av 1D-data, förutom att program måste vara mer uppmärksamma på datajustering som rör radhöjd. Buffertar kan användas ortoggoniskt och samtidigt från flera delar av grafikpipelinen och är mycket flexibla.

Ladda upp strukturdata via buffertar

Program måste ladda upp data via ID3D12GraphicsCommandList::CopyTextureRegion eller ID3D12GraphicsCommandList::CopyBufferRegion. Texturdata har en mycket större sannolikhet att vara större, användas upprepade gånger och dra nytta av den förbättrade cache-samstämmigheten för icke-linjära minneslayouter än andra resursdata. När buffertar används i D3D12 har program fullständig kontroll över dataplacering och arrangemang som är associerade med att kopiera resursdata runt, så länge kraven på minnesjustering är uppfyllda.

Exemplet visar var programmet helt enkelt plattar ut 2D-data till 1D innan det placeras i bufferten. För mipmap 2D-scenariot kan programmet antingen platta ut varje underresurs diskret och snabbt använda en algoritm för 1D-underallokering, eller använda en mer komplicerad 2D-underallokeringsteknik för att minimera användningen av videominne. Den första tekniken förväntas användas oftare eftersom den är enklare. Den andra tekniken kan vara användbar när du packar data på en disk eller i ett nätverk. I båda fallen måste programmet fortfarande anropa kopierings-API:erna för varje underresurs.

// Prepare a pBitmap in memory, with bitmapWidth, bitmapHeight, and pixel format of DXGI_FORMAT_B8G8R8A8_UNORM. 
//
// Sub-allocate from the buffer for texture data.
//

D3D12_SUBRESOURCE_FOOTPRINT pitchedDesc = { 0 };
pitchedDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
pitchedDesc.Width = bitmapWidth;
pitchedDesc.Height = bitmapHeight;
pitchedDesc.Depth = 1;
pitchedDesc.RowPitch = Align(bitmapWidth * sizeof(DWORD), D3D12_TEXTURE_DATA_PITCH_ALIGNMENT);

//
// Note that the helper function UpdateSubresource in D3DX12.h, and ID3D12Device::GetCopyableFootprints 
// can help applications fill out D3D12_SUBRESOURCE_FOOTPRINT and D3D12_PLACED_SUBRESOURCE_FOOTPRINT structures.
//
// Refer to the D3D12 Code example for the previous section "Uploading Different Types of Resources"
// for the code for SuballocateFromBuffer.
//

SuballocateFromBuffer(
    pitchedDesc.Height * pitchedDesc.RowPitch,
    D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT
    );

D3D12_PLACED_SUBRESOURCE_FOOTPRINT placedTexture2D = { 0 };
placedTexture2D.Offset = m_pDataCur – m_pDataBegin;
placedTexture2D.Footprint = pitchedDesc;

//
// Copy texture data from DWORD* pBitmap->pixels to the buffer
//

for (UINT y = 0; y < bitmapHeight; y++)
{
  UINT8 *pScan = m_pDataBegin + placedTexture2D.Offset + y * pitchedDesc.RowPitch;
  memcpy( pScan, &(pBitmap->pixels[y * bitmapWidth]), sizeof(DWORD) * bitmapWidth );
}

//
// Create default texture2D resource.
//

D3D12_RESOURCE_DESC  textureDesc { ... };

CComPtr<ID3D12Resource> texture2D;
d3dDevice->CreateCommittedResource( 
        &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT), 
        D3D12_HEAP_FLAG_NONE, &textureDesc, 
        D3D12_RESOURCE_STATE_COPY_DEST, 
        nullptr, 
        IID_PPV_ARGS(&texture2D) );

//
// Copy heap data to texture2D.
//

commandList->CopyTextureRegion( 
        &CD3DX12_TEXTURE_COPY_LOCATION( texture2D, 0 ), 
        0, 0, 0, 
        &CD3DX12_TEXTURE_COPY_LOCATION( m_spUploadHeap, placedTexture2D ), 
        nullptr );

Observera användningen av hjälpstrukturerna CD3DX12_HEAP_PROPERTIES och CD3DX12_TEXTURE_COPY_LOCATIONoch metoderna CreateCommittedResource och CopyTextureRegion.

Kopiering

Med D3D12-metoder kan program ersätta D3D11 UpdateSubresource, CopySubresourceRegionoch resursens initiala data. En enskild 3D-underresurs med rad-större strukturdata kan finnas i buffertresurser. CopyTextureRegion kan kopiera texturdata från bufferten till en strukturresurs med en okänd texturlayout och vice versa. Program bör föredra den här typen av teknik för att fylla I GPU-resurser som används ofta, genom att skapa stora buffertar i en UPLOAD-heap samtidigt som du skapar de GPU-resurser som används ofta i en STANDARD-heap som inte har någon CPU-åtkomst. En sådan teknik stöder effektivt diskreta GPU:er och deras stora mängder cpu-otillgängligt minne, utan att vanligtvis försämra UMA-arkitekturer.

Observera följande två konstanter:

const UINT D3D12_TEXTURE_DATA_PITCH_ALIGNMENT = 256;
const UINT D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT = 512;

Radhöjden för varje underresurs måste vara anpassad till en multipel av D3D12_TEXTURE_DATA_PITCH_ALIGNMENT (256) och startförskjutningen för varje underresurs måste anpassas till en multipel av D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT (512) såvida inte D3D12_FEATURE_DATA_D3D12_OPTIONS13::UnrestrictedBufferTextureCopyPitchSupported är TRUE.

I de fall där radavståndet är mindre än D3D12_TEXTURE_DATA_PITCH_ALIGNMENT (256), vilket är typiskt för de minsta mipparna i en textur, är det troligt att subresource offset justeringens D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT (512) kommer att lägga till extra utfyllnad mellan underresurser utöver den utfyllnad som läggs till genom att justera radavståndet.

Mappning och avmappning

Map och Unmap kan anropas av flera trådar på ett säkert sätt. Det första anropet till Map allokerar ett virtuellt processoradressintervall för resursen. Det senaste anropet till Unmap frigör det virtuella processoradressintervallet. Den virtuella CPU-adressen returneras ofta till programmet.

När data skickas mellan CPU och GPU via resurser i readback-heaps måste Map och Unmap användas för att stödja alla system som D3D12 är kompatibelt med. Att hålla intervallen så nära som möjligt maximerar effektiviteten på de system som kräver intervall (se D3D12_RANGE).

Prestanda för felsökningsverktyg drar inte bara nytta av korrekt användning av intervall på alla Map / Unmap-anrop, utan även från program som avmappar resurser när PROCESSORändringar inte längre kommer att göras.

Metoden D3D11 för att använda Map (med parameteruppsättningen DISCARD) för att byta namn på resurser stöds inte i D3D12. Applikationer måste själva hantera resursomdöpning. Alla Map-anrop är underförstått NO_OVERWRITE och använder flertrådsanvändning. Det är programmets ansvar att se till att allt relevant GPU-arbete som finns i kommandolistorna slutförs innan data med processorn används. D3D12-anrop till Map rensar inte implicit några kommandobuffertar och blockerar inte heller väntan på att GPU:n ska slutföra arbetet. Därför kan Map och Unmap till och med optimeras i vissa scenarier.

Buffertinriktning

Begränsningar för buffertjustering:

  • Linjär kopiering av underresurser måste justeras till D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT (512) byte (med radhöjden justerad till D3D12_TEXTURE_DATA_PITCH_ALIGNMENT (256) byte).
  • Konstanta dataläsningar måste vara flera av 256 byte från början av heapen (dvs. endast från adresser som är 256 byte justerade).
  • Indexdataläsningar måste vara en multipel av indexdatatypens storlek (dvs. endast från adresser som är naturligt anpassade för datatypen).
  • ID3D12GraphicsCommandList::ExecuteIndirect data måste vara med förskjutningar som är multiplar av 4 (dvs. endast från adresser som är DWORD-justerade).
  • Last updated on