Good day. I am find for information on how to create texture arrays in d3d12. In d3d11, I calmly figured out how to create a texture array from several textures:

• I upload several dds - textures of the same resolution
• in the engine I create ID3D11Texture2D* and map date into it all loaded textures
• in shader I use texture2darray in pixel shader:

Texture2DArray textures : register(t0);

Now I am looking for something like that for d3d12. For load the textures, I use DDSTextureLoader.h/.cpp from microsoft. So I'm loading a few textures. How can I create a texture array from them and pass it to a pixel shader? I will be glad to some example. Thank.

PS: I searched the forum, but I didn’t find anything.

If you were familiar with DDSTextureLoader for DirectX 11, then you could take a look at the same tool in DirectXTK12.

47 minutes ago, zhangdoa said:

If you were familiar with DDSTextureLoader for DirectX 11, then you could take a look at the same tool in DirectXTK12.

Sorry, I meant creating a texture array in the code:)

Well, this did not really change between D3D10, D3D11 and D3D12.

You create your ID3D12Resource and upload the individual array slices using ID3D12Resource::Map+WriteToSubresource+Unmap. I hope.

The HLSL shaders are exactly the same.

19 minutes ago, pcmaster said:

Well, this did not really change between D3D10, D3D11 and D3D12.

You create your ID3D12Resource and upload the individual array slices using ID3D12Resource::Map+WriteToSubresource+Unmap. I hope.

The HLSL shaders are exactly the same.

 

Thanks, I will try it. But if you can show me an example it will be great, because I don't know so good d3d12

Sorry for my misinterpreting answer?.

In D3D12 creating a texture has more steps than D3D11, you basically need:

1. Reserve a heap memory for the resource. It could be your main memory or your dedicated video card memory, depends on the target platform memory architecture (UDMA?/DMA?) and the creation info you specified; Different heap type has different CPU/GPU accessibility;

2. Create a resource handle. You will get an ID3D12Resource* as similar as ID3D11Texture2D* for further binding or other operations;

3. Upload the texture data to the reserved heap;

4. Transit the resource barrier of your texture resource handle to the final usage stage;

5. Create the SRV or UAV by your usage case.

You have 2 or more choices to implement the 1st and 2nd steps:

A. Using ID3D12Device::CreateHeap for the 1st step, and using ID3D12Device::CreatePlacedResource for the 2nd step;

B. Using ID3D12Device::CreateCommittedResource for a combined result of 1st and 2nd steps.

When implementing the 3rd step:

 As @pcmaster mentioned, you could map-write-unmap, but your resources must stay in a heap that CPU is writable (the D3D12_CPU_PAGE_PROPERTY is not D3D12_CPU_PAGE_PROPERTY_NOT_AVAILABLE), so it should be an Upload heap or a Readback heap.

Then the better solution is, create an Upload heap, upload your resource to it and then issue an ID3D12GraphicsCommandList::CopyResource command to copy it to the Default heap in order to get the best GPU accessibility. You would need another temporary ID3D12Resource* for the resource inside the upload heap, it would be created by the same processes in the 1st and 2nd steps.

You have 2 or more choices to create and upload the texture data to the Upload heap resource:

A. Create the Upload heap and the Upload heap resource handle by your own, and then map-write-unmap;

B. Create the Upload heap by your own, then use UpdateSubresources method provided by d3dx12.h to upload.

The 4th step is easy: ID3D12GraphicsCommandList::ResourceBarrier.

The 5th step requires you to create SRV or UAV in a Descriptor Heap, this is another topic but generally speaking, if you could survive from the texture creation process above, then that won't be a problem.

Also, all command execution need you to take explicit care about synchronization.

I suggest you take a look at the DirectX 12 Graphics samples, there should be some real code examples.

If anyone found any mistakes please point out, thanks! (MESSY D3D12?)

3 hours ago, pcmaster said:

You create your ID3D12Resource and upload the individual array slices using ID3D12Resource::Map+WriteToSubresource+Unmap. I hope.

While you can do this, I'd not recommend it in general practice. This can be a great optimization for UMA (unified memory architecture, i.e. integrated) GPUs, but for discrete GPUs, this requires putting your resource in L0 memory, i.e. RAM and not VRAM, which will probably have catastrophic results on performance. As zhangdoa mentioned, the general-purpose approach is to create your resources with HEAP_TYPE_DEFAULT and use HEAP_TYPE_UPLOAD buffers to get data into them. This is much better for discrete architectures, without really harming integrated.

Thank you all for your help!

Thanks MJP