TexturesVK.cpp

#include "TexturesVK.h"
 
#include "GraphicsDeviceVK.h"
 
#include "FormatsVK.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("TexturesVK");
}
 
void Cogs::TexturesVK::initialize(GraphicsDeviceVK * grapihcsDevice)
{
  this->graphicsDevice = grapihcsDevice;
  device = grapihcsDevice->device;
}
 
void Cogs::TexturesVK::releaseTexture(TextureHandle textureHandle)
{
  auto & texture = textures[textureHandle];
 
  vkDestroyImageView(device, texture.imageView, nullptr);
 
  if (!texture.external) {
    vkDestroyImage(device, texture.image, nullptr);
  }
}
 
Cogs::SamplerStateHandle Cogs::TexturesVK::loadSamplerState(const SamplerState & state)
{
  SamplerVK sampler = {};
 
  VkFilter filters[] = {
    VK_FILTER_NEAREST,
    VK_FILTER_LINEAR,
    VK_FILTER_NEAREST,
    VK_FILTER_LINEAR,
  };
 
  VkSamplerMipmapMode mipModes[] = {
    VK_SAMPLER_MIPMAP_MODE_NEAREST,
    VK_SAMPLER_MIPMAP_MODE_LINEAR,
    VK_SAMPLER_MIPMAP_MODE_NEAREST,
    VK_SAMPLER_MIPMAP_MODE_LINEAR,
  };
 
  VkSamplerAddressMode addressModes[] = {
    VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
    VK_SAMPLER_ADDRESS_MODE_REPEAT,
    VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT,
    VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER,
  };
 
  VkCompareOp comp[] = {
    VK_COMPARE_OP_NEVER,
    VK_COMPARE_OP_LESS,
    VK_COMPARE_OP_EQUAL,
    VK_COMPARE_OP_LESS_OR_EQUAL,
    VK_COMPARE_OP_GREATER,
    VK_COMPARE_OP_NOT_EQUAL,
    VK_COMPARE_OP_GREATER_OR_EQUAL,
    VK_COMPARE_OP_ALWAYS,
  };
 
  VkSamplerCreateInfo samplerInfo = {};
  samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
  samplerInfo.pNext = nullptr;
 
  samplerInfo.magFilter = filters[state.filter];
  samplerInfo.minFilter = filters[state.filter];
  samplerInfo.mipmapMode = mipModes[state.filter];
 
  samplerInfo.addressModeU = addressModes[state.addressModeS];
  samplerInfo.addressModeV = addressModes[state.addressModeT];
  samplerInfo.addressModeW = addressModes[state.addressModeW];
 
  samplerInfo.compareEnable = state.filter > 1;
  samplerInfo.compareOp = comp[state.comparisonFunction];
 
  samplerInfo.mipLodBias = 0.0f;
  samplerInfo.minLod = 0.0f;
  samplerInfo.maxLod = 16.0f;
 
  samplerInfo.maxAnisotropy = static_cast<float>(state.maxAnisotropy);
  samplerInfo.anisotropyEnable = state.maxAnisotropy != 0;
 
  samplerInfo.borderColor = state.borderColor[3] == 1 ?
    (state.borderColor[0] == 1 ? VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE : VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK) :
    VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
 
  auto result = vkCreateSampler(device, &samplerInfo, nullptr, &sampler.sampler);
 
  if (VK_FAILED(result)) {
    VK_LOG_ERROR(result, "Could not load sampler.");
    return SamplerStateHandle::InvalidHandle;
  }
 
  return samplers.addResource(sampler);
}
 
void Cogs::TexturesVK::releaseSamplerState(SamplerStateHandle handle)
{
}
 
void Cogs::TexturesVK::generateMipmaps(TextureHandle textureHandle)
{
}
 
void Cogs::TexturesVK::releaseResources()
{
}
 
Cogs::TextureHandle Cogs::TexturesVK::loadTexture(const TextureDescription & desc, const TextureData * data)
{
  uint32_t width = desc.width;
  uint32_t height = desc.height;
 
  TextureVK texture = {};
  texture.width = width;
  texture.height = height;
  texture.samples = desc.samples;
  texture.layout = VK_IMAGE_LAYOUT_UNDEFINED;
 
  const auto vkFormat = Vulkan::TextureFormats[(int)desc.format];
  texture.format = desc.format;
  texture.vkFormat = vkFormat;
 
  bool isDepth = (desc.flags & TextureFlags::DepthBuffer) != 0;
  const bool isStaging = (desc.flags & TextureFlagsVK::Staging) != 0;
  const bool isRenderTarget = (desc.flags & TextureFlags::RenderTarget) != 0;
 
  VkImageUsageFlags vkUsage = 0;
  VkImageTiling tiling = VK_IMAGE_TILING_OPTIMAL;
  VkImageLayout initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
 
  if (isRenderTarget) {
    vkUsage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
  }
 
  if (isDepth) {
    vkUsage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
    isDepth = true;
    texture.isDepth = true;
 
    if (desc.flags & TextureFlags::Texture) {
      vkUsage |= VK_IMAGE_USAGE_SAMPLED_BIT;
    }
  } else if (isStaging) {
    vkUsage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
    tiling = VK_IMAGE_TILING_LINEAR;
    initialLayout = VK_IMAGE_LAYOUT_PREINITIALIZED;
  } else {
    vkUsage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
  }
 
  if ((desc.flags & TextureFlags::ExternalTexture) == 0) {
    VkImageCreateInfo imageCreateInfo = {};
    imageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
    imageCreateInfo.pNext = nullptr;
    imageCreateInfo.initialLayout = initialLayout;
    imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
    imageCreateInfo.format = vkFormat;
    imageCreateInfo.extent = { width, height, 1 };
    imageCreateInfo.mipLevels = desc.levels;
    imageCreateInfo.arrayLayers = desc.layers;
    imageCreateInfo.samples = (VkSampleCountFlagBits)desc.samples;
    imageCreateInfo.tiling = tiling;
    imageCreateInfo.usage = vkUsage;
    imageCreateInfo.flags = 0;
 
    auto result = vkCreateImage(device, &imageCreateInfo, nullptr, &texture.image);
 
    if (VK_FAILED(result)) {
      VK_LOG_ERROR(result, "Could not create image.");
      return TextureHandle::InvalidHandle;
    }
 
    VkMemoryAllocateInfo allocateInfo = {};
    allocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
    allocateInfo.pNext = nullptr;
    allocateInfo.allocationSize = 0;
    allocateInfo.memoryTypeIndex = 0;
 
    VkMemoryRequirements memoryRequirements;
    vkGetImageMemoryRequirements(device, texture.image, &memoryRequirements);
 
    VkFlags memoryFlags = isStaging ? VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT : 0;
    uint32_t typeIndex = 0;
    graphicsDevice->getMemoryType(memoryRequirements.memoryTypeBits, memoryFlags, &typeIndex);
 
    allocateInfo.allocationSize = memoryRequirements.size;
    allocateInfo.memoryTypeIndex = typeIndex;
 
    result = vkAllocateMemory(device, &allocateInfo, nullptr, &texture.deviceMemory);
 
    if (VK_FAILED(result)) {
      VK_LOG_ERROR(result, "Could not allocate device memory.");
      return TextureHandle::InvalidHandle;
    }
 
    result = vkBindImageMemory(device, texture.image, texture.deviceMemory, 0);
 
    if (VK_FAILED(result)) {
      VK_LOG_ERROR(result, "Could not bind image memory.");
      return TextureHandle::InvalidHandle;
    }
 
    if (data) {
      updateTextureData(data, desc.layers, desc.levels, texture);
    }
  } else {
    texture.image = (VkImage)data->externalHandle;
    texture.external = true;
  }
 
  if (!isStaging) {
    VkImageViewCreateInfo imageViewInfo = {};
    imageViewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
    imageViewInfo.image = texture.image;
    imageViewInfo.format = vkFormat;
 
    // Only map depth component to R channel to emulate D3D behavior.
    VkComponentMapping swizzle = isDepth ?
      VkComponentMapping{ VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY } :
      VkComponentMapping{ VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A };
 
    imageViewInfo.components = swizzle;
    imageViewInfo.subresourceRange.aspectMask = isDepth ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_COLOR_BIT;
    imageViewInfo.subresourceRange.baseMipLevel = 0;
    imageViewInfo.subresourceRange.levelCount = desc.levels;
    imageViewInfo.subresourceRange.baseArrayLayer = 0;
    imageViewInfo.subresourceRange.layerCount = desc.layers;
    imageViewInfo.flags = 0;
    imageViewInfo.viewType = desc.layers > 1 ? VK_IMAGE_VIEW_TYPE_2D_ARRAY : VK_IMAGE_VIEW_TYPE_2D;
 
    auto result = vkCreateImageView(device, &imageViewInfo, nullptr, &texture.imageView);
 
    if (VK_FAILED(result)) {
      VK_LOG_ERROR(result, "Could not create image view.");
      return TextureHandle::InvalidHandle;
    }
  }
 
  return textures.addResource(texture);
}
 
void Cogs::TexturesVK::updateTextureData(const TextureData * data, const uint32_t arraySize, const uint32_t numLevels, TextureVK & texture)
{
  VkImageSubresourceRange range;
  range.aspectMask = texture.isDepth ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_COLOR_BIT;
  range.baseArrayLayer = 0;
  range.baseMipLevel = 0;
  range.layerCount = arraySize;
  range.levelCount = numLevels;
 
  setImageLayout(graphicsDevice->getCommandBuffer(),
    texture,
    range.aspectMask,
    VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
    range);
 
  for (uint32_t a = 0; a < arraySize; ++a) {
    for (uint32_t m = 0; m < numLevels; ++m) {
      const uint32_t index = a * numLevels + m;
 
      const uint32_t width = texture.width / static_cast<uint32_t>(std::pow(2ul, m));
      const uint32_t height = texture.height / static_cast<uint32_t>(std::pow(2ul, m));
 
      auto uploadHandle = loadTexture(nullptr, width, height, texture.format, TextureFlagsVK::Staging);
 
      if (!HandleIsValid(uploadHandle)) {
        LOG_ERROR(logger, "Could not create staging texture.");
        return;
      }
 
      TextureVK uploadTexture = textures[uploadHandle];
 
      VkImageSubresource imageSubresource = {};
      imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
      imageSubresource.arrayLayer = a;
      imageSubresource.mipLevel = m;
 
      VkSubresourceLayout resourceLayout;
      vkGetImageSubresourceLayout(device, uploadTexture.image, &imageSubresource, &resourceLayout);
 
      const size_t bpp = Cogs::getBlockSize(texture.format);
 
      void * vData;
      auto result = vkMapMemory(device, uploadTexture.deviceMemory, 0, VK_WHOLE_SIZE, 0, &vData);
 
      if (VK_FAILED(result)) {
        VK_LOG_ERROR(result, "Could not map upload memory.");
      }
 
      auto mappedData = static_cast<uint8_t *>(vData);
      const auto sourceData = static_cast<const uint8_t *>(data->getData(a, 0, m));
      const auto sourcePitch = data->getPitch(m);
      const auto rows = resourceLayout.size / resourceLayout.rowPitch;
 
      for (size_t i = 0; i < rows; ++i) {
        std::memcpy(mappedData, sourceData + i * sourcePitch, sourcePitch);
        mappedData += resourceLayout.rowPitch;
      }
 
      vkUnmapMemory(device, uploadTexture.deviceMemory);
 
      setImageLayout(graphicsDevice->getCommandBuffer(),
        uploadTexture,
        VK_IMAGE_ASPECT_COLOR_BIT,
        VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
 
      VkImageCopy copyRegion = {};
 
      copyRegion.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
      copyRegion.srcSubresource.baseArrayLayer = 0;
      copyRegion.srcSubresource.mipLevel = 0;
      copyRegion.srcSubresource.layerCount = 1;
      copyRegion.srcOffset = { 0, 0, 0 };
 
      copyRegion.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
      copyRegion.dstSubresource.baseArrayLayer = a;
      copyRegion.dstSubresource.mipLevel = m;
      copyRegion.dstSubresource.layerCount = 1;
      copyRegion.dstOffset = { 0, 0, 0 };
 
      copyRegion.extent.width = width;
      copyRegion.extent.height = height;
      copyRegion.extent.depth = 1;
 
      vkCmdCopyImage(
        graphicsDevice->getCommandBuffer(),
        uploadTexture.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
        texture.image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
        1, &copyRegion);
    }
  }
 
  setImageLayout(graphicsDevice->getCommandBuffer(),
    texture,
    range.aspectMask,
    VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
    range);
}
 
Cogs::TextureViewHandle Cogs::TexturesVK::createTextureView(TextureViewDescription & viewDescription)
{
  return TextureViewHandle();
}
 
void Cogs::TexturesVK::releaseTextureView(const TextureViewHandle & handle)
{
}
 
void * Cogs::TexturesVK::getNativeHandle(TextureHandle textureHandle)
{
  return nullptr;
}