TexturesD3D12.cpp

#include "TexturesD3D12.h"
 
#include "Foundation/Logging/Logger.h"
 
#include <algorithm>
 
#include "FormatsD3D12.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("TexturesD3D12");
}
 
void Cogs::TexturesD3D12::releaseTexture(TextureHandle textureHandle)
{
  textures.removeResource(textureHandle);
}
 
Cogs::SamplerStateHandle Cogs::TexturesD3D12::loadSamplerState(const SamplerState & state)
{
  SamplerD3D12 sampler = {};
  sampler.samplerDesc.AddressU = Direct3D12::AddressModes[state.addressModeS];
  sampler.samplerDesc.AddressV = Direct3D12::AddressModes[state.addressModeT];
  sampler.samplerDesc.AddressW = Direct3D12::AddressModes[state.addressModeW];
  sampler.samplerDesc.Filter = Direct3D12::FilterModes[state.filter];
  sampler.samplerDesc.MaxAnisotropy = state.maxAnisotropy;
  sampler.samplerDesc.ComparisonFunc = Direct3D12::ComparisonFunctions[state.comparisonFunction];
  sampler.samplerDesc.MinLOD = 0;
  sampler.samplerDesc.MaxLOD = 16;
  sampler.samplerDesc.BorderColor[0] = state.borderColor[0];
  sampler.samplerDesc.BorderColor[1] = state.borderColor[1];
  sampler.samplerDesc.BorderColor[2] = state.borderColor[2];
  sampler.samplerDesc.BorderColor[3] = state.borderColor[3];
 
  return samplerStates.addResource(sampler);
}
 
void Cogs::TexturesD3D12::releaseSamplerState(SamplerStateHandle handle)
{
  samplerStates.removeResource(handle);
}
 
void Cogs::TexturesD3D12::generateMipmaps(TextureHandle textureHandle)
{
 
}
 
void Cogs::TexturesD3D12::releaseResources()
{
  samplerStates.clear();
 
  textures.clear();
}
 
Cogs::TextureViewHandle Cogs::TexturesD3D12::createTextureView(TextureViewDescription & viewDescription)
{
  TextureViewD3D12 view = {};
 
  view.texture = viewDescription.texture;
  
  createShaderResourceView(view.srvDesc, textures[view.texture], viewDescription, textures[view.texture].desc.flags);
 
  return textureViews.addResource(view);
}
 
void Cogs::TexturesD3D12::releaseTextureView(const TextureViewHandle & handle)
{
  textureViews.removeResource(handle);
}
 
void * Cogs::TexturesD3D12::getNativeHandle(TextureHandle textureHandle)
{
  auto & texture = textures[textureHandle];
 
  return &*texture.resource;
}
 
Cogs::TextureHandle Cogs::TexturesD3D12::loadTexture(const TextureDescription & desc, const TextureData * data)
{
  TextureD3D12 texture;
  texture.desc = desc;
  texture.dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
  texture.width = desc.width;
  texture.height = desc.height;
  texture.format = desc.format;
  texture.numSamples = desc.samples;
 
  D3D12_RESOURCE_FLAGS resourceFlags = D3D12_RESOURCE_FLAG_NONE;
 
  resourceFlags |= (desc.flags & TextureFlags::DepthBuffer) != 0 ? D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL : D3D12_RESOURCE_FLAG_NONE;
  resourceFlags |= (desc.flags & TextureFlags::RenderTarget) != 0 ? D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET : D3D12_RESOURCE_FLAG_NONE;
 
  D3D12_RESOURCE_DESC textureDesc;
  textureDesc.Dimension = texture.dimension;
  textureDesc.DepthOrArraySize = static_cast<UINT16>(desc.layers * desc.faces);
  textureDesc.Alignment = 0;
  textureDesc.Width = desc.width;
  textureDesc.Height = desc.height;
  textureDesc.Format = Direct3D12::Formats[(int)desc.format];
  textureDesc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN;
  textureDesc.Flags = resourceFlags;
  textureDesc.MipLevels = static_cast<UINT16>(desc.levels);
  textureDesc.SampleDesc.Count = desc.samples;
  textureDesc.SampleDesc.Quality = 0;
 
  D3D12_CLEAR_VALUE clearValue;
  HRESULT hr;
 
  if ((desc.flags & TextureFlags::DepthBuffer) != 0) {
    clearValue.Format = textureDesc.Format == DXGI_FORMAT_R32_TYPELESS ? DXGI_FORMAT_D32_FLOAT : textureDesc.Format;
    clearValue.DepthStencil.Depth = 1.0f;
    clearValue.DepthStencil.Stencil = 0;
 
    hr = device->CreateCommittedResource(
      &defaultHeapProperties,
      D3D12_HEAP_FLAG_NONE,
      &textureDesc,
      D3D12_RESOURCE_STATE_COMMON,
      &clearValue,
      IID_PPV_ARGS(texture.resource.internalPointer()));
 
    if ((desc.flags & TextureFlags::Texture) != 0) {
      TextureViewDescription viewDesc = {};
      viewDesc.numLayers = 1;
      viewDesc.numLevels = desc.levels;
      createShaderResourceView(texture.srvDesc, texture, viewDesc, desc.flags);
    }
  } else {
    clearValue.Format = textureDesc.Format;
    clearValue.Color[0] = 1;
    clearValue.Color[1] = 1;
    clearValue.Color[2] = 1;
    clearValue.Color[3] = 1;
 
    hr = device->CreateCommittedResource(
      &defaultHeapProperties,
      D3D12_HEAP_FLAG_NONE,
      &textureDesc,
      D3D12_RESOURCE_STATE_COMMON,
      (desc.flags & TextureFlags::RenderTarget) ? &clearValue : nullptr,
      IID_PPV_ARGS(texture.resource.internalPointer()));
 
    texture.numSubResources = textureDesc.DepthOrArraySize * textureDesc.MipLevels;
 
    if (data) {
      const int maxSubresources = 16;
      UINT64 uploadBufferSize = 0;
      D3D12_PLACED_SUBRESOURCE_FOOTPRINT layouts[maxSubresources];
      UINT numRows[maxSubresources];
      UINT64 rowSizesInBytes[maxSubresources];
 
      auto resourceDesc = texture.resource->GetDesc();
      device->GetCopyableFootprints(&resourceDesc, 0, texture.numSubResources, 0, layouts, numRows, rowSizesInBytes, &uploadBufferSize);
 
      CD3DX12_RESOURCE_DESC uploadBufferDesc = CD3DX12_RESOURCE_DESC::Buffer(uploadBufferSize);
 
      device->CreateCommittedResource(
        &uploadHeapProperties,
        D3D12_HEAP_FLAG_NONE,
        &uploadBufferDesc,
        D3D12_RESOURCE_STATE_GENERIC_READ,
        nullptr,
        IID_PPV_ARGS(texture.uploadResource.internalPointer()));
 
      UINT8 * resourceData;
      texture.uploadResource->Map(0, nullptr, reinterpret_cast<void**>(&resourceData));
 
      size_t subResourceIndex = 0;
      for (size_t i = 0; i < desc.layers; ++i) {
        for (size_t j = 0; j < desc.faces; ++j) {
          for (size_t k = 0; k < desc.levels; ++k) {
            D3D12_SUBRESOURCE_DATA srcData;
 
            srcData.pData = data->getData(i, j, k);
            srcData.RowPitch = static_cast<uint32_t>(data->getPitch(k));
            srcData.SlicePitch = data->getLayerSize(0, desc.faces - 1, 0, desc.levels - 1);
 
            auto & layout = layouts[subResourceIndex];
            auto & rows = numRows[subResourceIndex];
 
            D3D12_MEMCPY_DEST destData = { resourceData + layout.Offset, layout.Footprint.RowPitch, layout.Footprint.RowPitch * rows };
            MemcpySubresource(&destData, &srcData, rowSizesInBytes[subResourceIndex], rows, layout.Footprint.Depth);
 
            ++subResourceIndex;
          }
        }
      }
 
      texture.uploadResource->Unmap(0, nullptr);
      texture.needsUpload = true;
    }
 
    TextureViewDescription viewDesc = {};
    viewDesc.numLayers = 1;
    viewDesc.numLevels = desc.levels;
    createShaderResourceView(texture.srvDesc, texture, viewDesc, desc.flags);
  }
 
  if (FAILED(hr)) {
    LOG_ERROR(logger, "Error creating committed resource for texture.");
    return TextureHandle::InvalidHandle;
  }
 
  return textures.addResource(texture);
}
 
bool Cogs::TexturesD3D12::createShaderResourceView(D3D12_SHADER_RESOURCE_VIEW_DESC & srvDesc, TextureD3D12 & texture, const TextureViewDescription & viewDesc, TextureFlags::ETextureFlags flags)
{
  const bool cubeMap = (flags & TextureFlags::CubeMap) != 0;
 
  if (cubeMap && texture.desc.faces != 6) {
    LOG_ERROR(logger, "Cannot create cube map with %d faces.", texture.desc.faces);
    return false;
  }
 
  srvDesc = {};
  srvDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
  srvDesc.Format = Direct3D12::Formats[(int)texture.desc.format];
 
  if (srvDesc.Format == DXGI_FORMAT_R32_TYPELESS) {
    srvDesc.Format = DXGI_FORMAT_R32_FLOAT;
  } else if (srvDesc.Format == DXGI_FORMAT_R16_TYPELESS) {
    srvDesc.Format = DXGI_FORMAT_R16_FLOAT;
  } else if (srvDesc.Format == DXGI_FORMAT_R8G8B8A8_TYPELESS) {
    srvDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
  }
 
  const uint32_t mostDetailedMip = std::min(viewDesc.levelIndex, std::max(1u, texture.desc.levels) - 1u);
 
  if (texture.desc.layers == 1) {
    if (cubeMap) {
      srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURECUBE;
      srvDesc.TextureCube.MipLevels = texture.desc.levels;
      srvDesc.TextureCube.MostDetailedMip = mostDetailedMip;
    } else {
      srvDesc.ViewDimension = texture.desc.samples > 1 ? D3D12_SRV_DIMENSION_TEXTURE2DMS : D3D12_SRV_DIMENSION_TEXTURE2D;
      srvDesc.Texture2D.MipLevels = texture.desc.levels;
      srvDesc.Texture2D.MostDetailedMip = mostDetailedMip;
    }
  } else {
    if (cubeMap) {
      srvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURECUBEARRAY;
      srvDesc.TextureCubeArray.MipLevels = texture.desc.levels;
      srvDesc.TextureCubeArray.NumCubes = texture.desc.layers;
      srvDesc.TextureCubeArray.MostDetailedMip = mostDetailedMip;
    } else {
      srvDesc.ViewDimension = texture.desc.samples > 1 ? D3D12_SRV_DIMENSION_TEXTURE2DMSARRAY : D3D12_SRV_DIMENSION_TEXTURE2DARRAY;
      srvDesc.Texture2DArray.MipLevels = texture.desc.levels;
      srvDesc.Texture2DArray.ArraySize = static_cast<uint32_t>(texture.desc.layers);
      srvDesc.Texture2DArray.MostDetailedMip = mostDetailedMip;
    }
  }
 
  return true;
}