Dela via

Skapa strukturresurser (Direct3D 10)

En struktur resurs är en strukturerad datasamling. Vanligtvis lagras färgvärden i texturer och används under återgivningen av pipeline i olika steg för både indata och utdata. Att skapa texturer och definiera hur de ska användas är en viktig del av att återge intressanta scener i Direct3D 10.

Även om texturer vanligtvis innehåller färginformation kan de lagra olika typer av data genom att skapa texturer med olika DXGI_FORMAT. Dessa data kan sedan användas av Direct3D 10 pipeline på icke-traditionella sätt.

Alla texturer har gränser för hur mycket minne de förbrukar och hur många texels de innehåller. Dessa gränser anges av resurskonstanter.

Skapa en struktur från en fil

Not

D3DX-verktygsbiblioteket är inaktuellt för Windows 8 och stöds inte för Windows Store-appar.

 

När du skapar en textur i Direct3D 10 måste du också skapa en vy. En vy är ett objekt som talar om för enheten hur en struktur ska nås under återgivningen. Det vanligaste sättet att komma åt en textur är att läsa från den med hjälp av en shader. En shaderresursvy talar om för en shader hur den ska läsa från en textur under renderingen. Den typ av vy som en struktur ska använda måste anges när du skapar den.

Du kan skapa en struktur och läsa in de ursprungliga data på två olika sätt: skapa en struktur och vy separat, eller skapa både texturen och vyn samtidigt. API:et innehåller båda teknikerna så att du kan välja vilka som passar dina behov bättre.

Skapa textur och vy var för sig.

Det enklaste sättet att skapa en struktur är att läsa in den från en bildfil. Om du vill skapa strukturen fyller du bara i en struktur och anger texturnamnet för D3DX10CreateTextureFromFile.

ID3D10Device *pDevice = NULL;
// Initialize D3D10 device...

D3DX10_IMAGE_LOAD_INFO loadInfo;
ZeroMemory( &loadInfo, sizeof(D3DX10_IMAGE_LOAD_INFO) );
loadInfo.BindFlags = D3D10_BIND_SHADER_RESOURCE;

ID3D10Resource *pTexture = NULL;
D3DX10CreateTextureFromFile( pDevice, L"sample.bmp", &loadInfo, NULL, &pTexture, NULL );

D3DX-funktionen D3DX10CreateTextureFromFile gör tre saker: för det första skapar den ett Direct3D 10-texturobjekt; för det andra läser den indatabildfilen; för det tredje lagrar den bilddata i texturobjektet. I exemplet ovan läses en BMP-fil in, men funktionen kan läsa in en mängd olika filtyper.

Bindningsflaggan anger att texturen kommer att skapas som en shader-resurs vilket gör det möjligt för ett shaderstadium att läsa från texturen under rendering.

Exemplet ovan anger inte alla inläsningsparametrar. I själva verket är det ofta fördelaktigt att helt enkelt nollställa inläsningsparametrarna eftersom D3DX kan välja lämpliga värden baserat på indatabilden. Om du vill att indatabilden ska fastställa alla parametrar som strukturen skapas med anger du bara NULL- för parametern loadInfo så här:

D3DX10CreateTextureFromFile( pDevice, L"sample.bmp", NULL, NULL, &pTexture, NULL );

Att ange NULL- för inläsningsinformationen är en enkel men kraftfull genväg.

Nu när en struktur har skapats måste du skapa en skuggningsresursvy så att strukturen kan bindas som indata till en skuggning. Eftersom D3DX10CreateTextureFromFile returnerar en pekare till en resurs och inte en pekare till en struktur, måste du fastställa den exakta typen av resurs som lästes in och sedan kan du skapa en skuggningsresursvy med CreateShaderResourceView.

D3D10_SHADER_RESOURCE_VIEW_DESC srvDesc;
D3D10_RESOURCE_DIMENSION type;
pTexture->GetType( &type );
switch( type )
{
    case D3D10_RESOURCE_DIMENSION_BUFFER:
    //...
    break;
    case D3D10_RESOURCE_DIMENSION_TEXTURE1D:
    //...
    break;
    case D3D10_RESOURCE_DIMENSION_TEXTURE2D:
    {
        D3D10_TEXTURE2D_DESC desc;
        ID3D10Texture2D *pTexture2D = (ID3D10Texture2D*)pTexture;
        pTexture2D->GetDesc( &desc );
        
        srvDesc.Format = desc.Format;
        srvDesc.ViewDimension = D3D10_SRV_DIMENSION_TEXTURE2D;
        srvDesc.Texture2D.MipLevels = desc.MipLevels;
        srvDesc.Texture2D.MostDetailedMip = desc.MipLevels -1;

    }
    break;
    case D3D10_RESOURCE_DIMENSION_TEXTURE3D:
    //...
    break;
    default:
    //...
    break;
}

ID3D10ShaderResourceView *pSRView = NULL;
pDevice->CreateShaderResourceView( pTexture, &srvDesc, &pSRView );

Även om exemplet ovan skapar en 2D-skuggningsresursvy är koden för att skapa andra typer av skuggningsresursvy mycket lik. Alla skuggningssteg kan nu använda den här strukturen som indata.

Att använda D3DX10CreateTextureFromFile och CreateShaderResourceView för att skapa en struktur och dess associerade vy är ett sätt att förbereda en textur som ska bindas till en skuggningsfas. Ett annat sätt att göra det är att skapa både texturen och dess vy samtidigt, vilket beskrivs i nästa avsnitt.

Skapa struktur och vy samtidigt

Direct3D 10 kräver både en struktur och en skuggningsresursvy för att läsa från en struktur under körningen. Eftersom skapandet av en textur och en skuggningsresursvy är en sådan vanlig uppgift, tillhandahåller D3DX D3DX10CreateShaderResourceViewFromFile för att göra det åt dig.

D3DX10_IMAGE_LOAD_INFO loadInfo;
ZeroMemory( &loadInfo, sizeof(D3DX10_IMAGE_LOAD_INFO) );
loadInfo.BindFlags = D3D10_BIND_SHADER_RESOURCE;
loadInfo.Format = DXGI_FORMAT_BC1_UNORM;

ID3D10ShaderResourceView *pSRView = NULL;
D3DX10CreateShaderResourceViewFromFile( pDevice, L"sample.bmp", &loadInfo, NULL, &pSRView, NULL );

Med ett enda D3DX-anrop skapas både textur- och skuggningsresursvyn. Funktionerna i parametern loadInfo är oförändrade. Du kan använda den för att anpassa hur strukturen skapas eller härleda nödvändiga parametrar från indatafilen genom att ange NULL- för parametern loadInfo.

Objektet ID3D10ShaderResourceView som returneras av D3DX10CreateShaderResourceViewFromFile-funktionen kan senare användas för att hämta det ursprungliga ID3D10Resource-gränssnittet om det behövs. Detta kan göras genom att anropa metoden GetResource.

D3DX tillhandahåller en enda funktion för att skapa en textur och skuggresursvy som en bekvämlighet; det är upp till dig att bestämma vilken metod för att skapa en textur och vy som bäst passar behoven i din applikation.

Nu när du vet hur du skapar en struktur och dess skuggningsresursvy visar nästa avsnitt hur du kan prova (läsa) från den strukturen med hjälp av en skuggning.

Skapa tomma texturer

Ibland kan program vilja skapa en struktur och beräkna data som ska lagras i strukturen, eller använda grafiken pipeline för att rendera till den här strukturen och senare använda resultatet i annan bearbetning. Dessa texturer kan uppdateras av grafikpipelinen eller av själva programmet, beroende på vilken typ av användning angavs för strukturen när den skapades.

Återgivning till en textur

Det vanligaste fallet med att skapa en tom textur som ska fyllas med data under körning är om ett program vill rendera till en struktur och sedan använda resultatet av återgivningsåtgärden i ett efterföljande pass. Texturer som skapas för detta syfte bör ange standardanvändning .

Följande kodexempel skapar en tom textur som pipelinen kan rendera till och därefter använda som indata till en shader .

// Create the render target texture
D3D10_TEXTURE2D_DESC desc;
ZeroMemory( &desc, sizeof(desc) );
desc.Width = 256;
desc.Height = 256;
desc.MipLevels = 1;
desc.ArraySize = 1;
desc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
desc.SampleDesc.Count = 1;
desc.Usage = D3D10_USAGE_DEFAULT;
desc.BindFlags = D3D10_BIND_RENDER_TARGET | D3D10_BIND_SHADER_RESOURCE;

ID3D10Texture2D *pRenderTarget = NULL;
pDevice->CreateTexture2D( &desc, NULL, &pRenderTarget );

För att skapa strukturen måste programmet ange viss information om de egenskaper som strukturen kommer att ha. Texturens bredd och höjd i texels är inställd på 256. För det här återgivningsmålet är en enda mipmap-nivå allt vi behöver. Endast ett återgivningsmål krävs så matrisstorleken är inställd på 1. Varje texel innehåller fyra 32-bitars flyttalsvärden, som kan användas för att lagra mycket exakt information (se DXGI_FORMAT). Ett exempel per pixel är allt som behövs. Användningen är inställd på standard eftersom detta möjliggör den mest effektiva placeringen av återgivningsmålet i minnet. Slutligen anges det faktum att strukturen kommer att bindas som ett återgivningsmål och en skuggningsresurs vid olika tidpunkter.

Texturer kan inte bindas för återgivning till pipelinen direkt. använd en återgivningsmålvy enligt följande kodexempel.

D3D10_RENDER_TARGET_VIEW_DESC rtDesc;
rtDesc.Format = desc.Format;
rtDesc.ViewDimension = D3D10_RTV_DIMENSION_TEXTURE2D;
rtDesc.Texture2D.MipSlice = 0;

ID3D10RenderTargetView *pRenderTargetView = NULL;
pDevice->CreateRenderTargetView( pRenderTarget, &rtDesc, &pRenderTargetView );

Formatet för återgivningsmålvyn är helt enkelt inställt på formatet för den ursprungliga strukturen. Informationen i resursen ska tolkas som en 2D-struktur och vi vill bara använda den första mipmap-nivån för återgivningsmålet.

På samma sätt som en återgivningsmålvy måste skapas så att återgivningsmålet kan bindas för utdata till pipelinen, måste en skuggningsresursvy skapas så att återgivningsmålet kan bindas till pipelinen som indata. Följande kodexempel visar detta.

// Create the shader-resource view
D3D10_SHADER_RESOURCE_VIEW_DESC srDesc;
srDesc.Format = desc.Format;
srDesc.ViewDimension = D3D10_SRV_DIMENSION_TEXTURE2D;
srDesc.Texture2D.MostDetailedMip = 0;
srDesc.Texture2D.MipLevels = 1;

ID3D10ShaderResourceView *pShaderResView = NULL;
pDevice->CreateShaderResourceView( pRenderTarget, &srDesc, &pShaderResView );

Parametrarna för shader-resursvybeskrivningar är mycket lika dem för render-target vybeskrivningar och har valts av samma skäl.

Fylla texturer manuellt

Ibland skulle program vilja beräkna värden vid körning, placera dem i en struktur manuellt och sedan ha grafiken pipeline använda den här strukturen i senare återgivningsåtgärder. För att göra detta måste programmet skapa en tom struktur på ett sådant sätt att processorn kan komma åt det underliggande minnet. Detta görs genom att skapa en dynamisk struktur och få åtkomst till det underliggande minnet genom att anropa en viss metod. Följande kodexempel visar hur du gör detta.

D3D10_TEXTURE2D_DESC desc;
desc.Width = 256;
desc.Height = 256;
desc.MipLevels = desc.ArraySize = 1;
desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
desc.SampleDesc.Count = 1;
desc.Usage = D3D10_USAGE_DYNAMIC;
desc.BindFlags = D3D10_BIND_SHADER_RESOURCE;
desc.CPUAccessFlags = D3D10_CPU_ACCESS_WRITE;
ID3D10Texture2D *pTexture = NULL;
pd3dDevice->CreateTexture2D( &desc, NULL, &pTexture );

Observera att formatet är inställt på 32 bitar per pixel där varje komponent definieras med 8 bitar. Användningsparametern är inställd på dynamisk medan bindningsflaggorna anges för att specificera att texturen ska nås av en shader. Resten av texturbeskrivningen liknar att skapa en render target.

Genom att anropa Map kan programmet komma åt strukturens underliggande minne. Pekaren som hämtas används sedan för att fylla strukturen med data. Detta visas i följande kodexempel.

D3D10_MAPPED_TEXTURE2D mappedTex;
pTexture->Map( D3D10CalcSubresource(0, 0, 1), D3D10_MAP_WRITE_DISCARD, 0, &mappedTex );

UCHAR* pTexels = (UCHAR*)mappedTex.pData;
for( UINT row = 0; row < desc.Height; row++ )
{
    UINT rowStart = row * mappedTex.RowPitch;
    for( UINT col = 0; col < desc.Width; col++ )
    {
        UINT colStart = col * 4;
        pTexels[rowStart + colStart + 0] = 255; // Red
        pTexels[rowStart + colStart + 1] = 128; // Green
        pTexels[rowStart + colStart + 2] = 64;  // Blue
        pTexels[rowStart + colStart + 3] = 32;  // Alpha
    }
}

pTexture->Unmap( D3D10CalcSubresource(0, 0, 1) );

Flera renderingsmål

Upp till åtta renderingsmålsvyer kan bindas till pipelinen vid varje tillfälle (med OMSetRenderTargets). För varje pixel (eller varje exempel om multisampling är aktiverat) görs blandning oberoende av varandra för varje återgivningsmålvy. Två av blandningstillståndsvariablerna – BlendEnable och RenderTargetWriteMask – är matriser med åtta, varje matrismedlem motsvarar en återgivningsmålvy. När du använder flera återgivningsmål måste varje återgivningsmål vara samma resurstyp (buffert, 1D-struktur, 2D-texturmatris osv.) och måste ha samma dimension (bredd, höjd, djup för 3D-texturer och matrisstorlek för texturmatriser). Om återgivningsmålen är flersamplade måste de alla ha samma antal exempel per pixel.

Det kan bara finnas en djupstencilbuffert aktiv, oavsett hur många återgivningsmål som är aktiva. När du använder texturmatriser som återgivningsmål måste alla visningsdimensioner matcha. Återgivningsmålen behöver inte ha samma strukturformat.

resurser (Direct3D 10)