//------------------------------------------------------------------------------------
D3D11Texture::D3D11Texture(uint32 width, uint32 height, uint32 depth, ePixelFormat format, uint32 usage, bool bMipMap)
: Texture(eTextureType_3D, width, height, depth, format, usage, bMipMap)
, m_pTexture2D(nullptr)
, m_pTexture3D(nullptr)
, m_pRTV(nullptr)
, m_pSRV(nullptr)
, m_pDSV(nullptr)
, m_pTexStaging(nullptr)
{
ZeroMemory(m_pRTV_slices, sizeof(m_pRTV_slices));
HRESULT hr = S_OK;
const DXGI_FORMAT dxformat = ConvertToDXFormat(m_texFormat);
CD3D11_TEXTURE3D_DESC desc(dxformat, width, height, depth, 1);
// Validate usage
_AST(!((m_usage&eTextureUsage_WriteOnly) && (m_usage&eTextureUsage_ReadWrite)) && "Invalid usage!");
// Assign usage
if (m_usage & eTextureUsage_WriteOnly)
{
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
desc.Usage = D3D11_USAGE_DYNAMIC;
}
else if (m_usage & eTextureUsage_ReadWrite)
{
desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE | D3D11_CPU_ACCESS_READ;
desc.Usage = D3D11_USAGE_STAGING;
desc.BindFlags = 0;
}
if (m_usage & eTextureUsage_RenderTarget)
{
desc.BindFlags = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE;
}
V(g_pRenderSys->GetDevice()->CreateTexture3D(&desc, nullptr, &m_pTexture3D));
CreateSRV();
// Create RTV
if (m_usage & eTextureUsage_RenderTarget)
{
_AST(depth <= 32);
for (uint32 i = 0; i < depth; ++i)
{
CD3D11_RENDER_TARGET_VIEW_DESC rtvDesc(D3D11_RTV_DIMENSION_TEXTURE3D, dxformat, 0, i, 1);
V(g_pRenderSys->GetDevice()->CreateRenderTargetView(m_pTexture3D, &rtvDesc, &m_pRTV_slices[i]));
}
}
}
void DX11Engine::createSwapChainRenderTargets(IUnknown** ppRTV, IUnknown** ppRTVsRGB,
IUnknown** ppDSV, IUnknown* pNativeDevice, IUnknown* pSwapChainIn,
size_t length, const char* debugName) const
{
auto pSwapChain = reinterpret_cast<IDXGISwapChain*>(pSwapChainIn);
auto pDevice = reinterpret_cast<ID3D11Device*>(pNativeDevice);
HRESULT hr = S_OK;
std::unique_ptr<ID3D11Texture2D, COMDeleter> pD3D11Texture;
// rtv
DXGI_SWAP_CHAIN_DESC desc;
V(pSwapChain->GetDesc(&desc));
V(pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), ref(pD3D11Texture)));
STAR_SET_DEBUG_NAME(pD3D11Texture, length, debugName);
CD3D11_RENDER_TARGET_VIEW_DESC rtvDesc(D3D11_RTV_DIMENSION_TEXTURE2D);
rtvDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
ID3D11RenderTargetView* pRTV;
V(pDevice->CreateRenderTargetView(pD3D11Texture.get(), &rtvDesc, &pRTV));
*ppRTV = pRTV;
STAR_SET_DEBUG_NAME(pRTV, length, debugName);
rtvDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM_SRGB;
V(pDevice->CreateRenderTargetView(pD3D11Texture.get(), &rtvDesc, &pRTV));
*ppRTVsRGB = pRTV;
STAR_SET_DEBUG_STRING(pRTV, (debugName + std::string("_sRGB")));
// dsv
if(ppDSV) {
D3D11_TEXTURE2D_DESC descTex2D = {
desc.BufferDesc.Width,
desc.BufferDesc.Height,
1, 1, DXGI_FORMAT_D32_FLOAT,{ 1, 0 },
D3D11_USAGE_DEFAULT, D3D11_BIND_DEPTH_STENCIL,
0, 0
};
std::unique_ptr<ID3D11Texture2D, COMDeleter> pDST;
V(pDevice->CreateTexture2D(&descTex2D, nullptr, ref(pDST)));
STAR_SET_DEBUG_NAME(pDST, length, debugName);
D3D11_DEPTH_STENCIL_VIEW_DESC descV = {
DXGI_FORMAT_D32_FLOAT, D3D11_DSV_DIMENSION_TEXTURE2D, 0,{ 0 }
};
ID3D11DepthStencilView* pDSV;
V(pDevice->CreateDepthStencilView(pDST.get(), &descV, &pDSV));
*ppDSV = pDSV;
STAR_SET_DEBUG_NAME(pDSV, length, debugName);
}
}
void Texture2D::InternalConstruct(ID3D11Device* d3dDevice,
int width, int height, DXGI_FORMAT format,
UINT bindFlags, int mipLevels, int arraySize,
int sampleCount, int sampleQuality,
D3D11_RTV_DIMENSION rtvDimension,
D3D11_UAV_DIMENSION uavDimension,
D3D11_SRV_DIMENSION srvDimension)
{
// Initalize
mShaderResource = 0;
CD3D11_TEXTURE2D_DESC desc(
format,
width, height, arraySize, mipLevels,
bindFlags,
D3D11_USAGE_DEFAULT, 0,
sampleCount, sampleQuality,
// If they request mipmap levels, it's nice to be able to autogenerate them.
(mipLevels != 1 ? D3D11_RESOURCE_MISC_GENERATE_MIPS : 0));
d3dDevice->CreateTexture2D(&desc, 0, &mTexture);
// Update with actual mip levels, etc.
mTexture->GetDesc(&desc);
if (bindFlags & D3D11_BIND_RENDER_TARGET) {
for (int i = 0; i < arraySize; ++i) {
CD3D11_RENDER_TARGET_VIEW_DESC rtvDesc(
rtvDimension,
format,
0, // Mips
i, 1 // Array
);
ID3D11RenderTargetView* renderTargetView;
d3dDevice->CreateRenderTargetView(mTexture, &rtvDesc, &renderTargetView);
mRenderTargetElements.push_back(renderTargetView);
}
}
if (bindFlags & D3D11_BIND_UNORDERED_ACCESS) {
// UAV's can't point to multisampled resources!
assert(uavDimension != D3D11_UAV_DIMENSION_UNKNOWN);
for (int i = 0; i < arraySize; ++i) {
CD3D11_UNORDERED_ACCESS_VIEW_DESC uavDesc(
uavDimension,
format,
0, // Mips
i, 1 // Array
);
ID3D11UnorderedAccessView* unorderedAccessView;
d3dDevice->CreateUnorderedAccessView(mTexture, &uavDesc, &unorderedAccessView);
mUnorderedAccessElements.push_back(unorderedAccessView);
}
}
if (bindFlags & D3D11_BIND_SHADER_RESOURCE) {
// Whole resource
CD3D11_SHADER_RESOURCE_VIEW_DESC srvDesc(
srvDimension,
format,
0, desc.MipLevels, // Mips
0, desc.ArraySize // Array
);
d3dDevice->CreateShaderResourceView(mTexture, &srvDesc, &mShaderResource);
// Single elements
for (int i = 0; i < arraySize; ++i) {
CD3D11_SHADER_RESOURCE_VIEW_DESC srvElementDesc(
srvDimension,
format,
0, 1, // Mips
i, 1 // Array
);
ID3D11ShaderResourceView* shaderResourceView;
d3dDevice->CreateShaderResourceView(mTexture, &srvElementDesc, &shaderResourceView);
mShaderResourceElements.push_back(shaderResourceView);
}
}
}
