RenderTargetsVK.cpp

#include "RenderTargetsVK.h"
 
#include "GraphicsDeviceVK.h"
#include "TexturesVK.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("RenderTargetsVK");
}
 
void Cogs::RenderTargetsVK::initialize(GraphicsDeviceVK * device)
{
  graphicsDevice = device;
}
 
void Cogs::RenderTargetsVK::releaseRenderTarget(RenderTargetHandle renderTargetHandle)
{
}
 
Cogs::DepthStencilHandle Cogs::RenderTargetsVK::createDepthStencilTarget(const RenderTargetHandle handle)
{
  assert(HandleIsValid(handle) && "Invalid render target handle.");
 
  auto & renderTarget = renderTargets[handle];
 
  auto & texture = *renderTarget.textures.front();
 
  auto depthTextureHandle = graphicsDevice->textures.loadTexture(nullptr, texture.width, texture.height, TextureFormat::D32_FLOAT, texture.samples, TextureFlags::DepthBuffer);
 
  return createDepthStencilTarget(handle, depthTextureHandle);
}
 
Cogs::DepthStencilHandle Cogs::RenderTargetsVK::createDepthStencilTarget(const RenderTargetHandle handle, const TextureHandle depthTexturehandle)
{
  assert(HandleIsValid(handle) && "Invalid render target handle.");
  assert(HandleIsValid(depthTexturehandle) && "Invalid depth texture handle.");
  
  //TODO: Validate compatibility.
 
  auto & renderTarget = renderTargets[handle];
  renderTarget.depthTexture = &graphicsDevice->textures.textures[depthTexturehandle];
 
  std::vector<VkImageView> attachmentViews;
  std::vector<VkAttachmentDescription> attachments;
  std::vector<VkAttachmentReference> references;
 
  uint32_t width = 0;
  uint32_t height = 0;
 
  for (auto & texture : renderTarget.textures) {
    attachmentViews.push_back(texture->imageView);
 
    if (!width) {
      width = texture->width;
      height = texture->height;
    }
 
    VkAttachmentDescription desc = {};
    desc.format = texture->vkFormat;
    desc.samples = (VkSampleCountFlagBits)texture->samples;
    desc.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
    desc.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
    desc.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
    desc.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
    desc.initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
    desc.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
 
    attachments.push_back(desc);
 
    references.push_back(VkAttachmentReference{ static_cast<uint32_t>(references.size()), VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL });
  }
 
  if (renderTarget.depthTexture) {
    auto & texture = *renderTarget.depthTexture;
 
    if (!width) {
      width = texture.width;
      height = texture.height;
    }
 
    attachmentViews.push_back(texture.imageView);
 
    VkAttachmentDescription desc = {};
    desc.format = texture.vkFormat;
    desc.samples = (VkSampleCountFlagBits)texture.samples;
    desc.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
    desc.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
    desc.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
    desc.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
    desc.initialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
    desc.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
 
    attachments.push_back(desc);
  }
 
  const VkAttachmentReference depthReference = {
    static_cast<uint32_t>(attachments.size()) - 1, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
  };
 
  VkSubpassDescription subpass = {};
  subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
  subpass.flags = 0;
  subpass.inputAttachmentCount = 0;
  subpass.pInputAttachments = nullptr;
  subpass.colorAttachmentCount = static_cast<uint32_t>(references.size());
  subpass.pColorAttachments = references.data();
  subpass.pResolveAttachments = nullptr;
  subpass.pDepthStencilAttachment = &depthReference;
  subpass.preserveAttachmentCount = 0;
  subpass.pPreserveAttachments = nullptr;
 
  VkRenderPassCreateInfo renderPassInfo = {};
  renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
  renderPassInfo.attachmentCount = static_cast<uint32_t>(attachments.size());
  renderPassInfo.pAttachments = attachments.data();
  renderPassInfo.subpassCount = 1;
  renderPassInfo.pSubpasses = &subpass;
  renderPassInfo.dependencyCount = 0;
  renderPassInfo.pDependencies = nullptr;
 
  auto result = vkCreateRenderPass(graphicsDevice->device, &renderPassInfo, nullptr, &renderTarget.renderPass);
 
  if (VK_FAILED(result)) {
    VK_LOG_ERROR(result, "Error creating render pass.");
    return DepthStencilHandle::InvalidHandle;
  }
 
  VkFramebufferCreateInfo framebufferInfo = {};
  framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
  framebufferInfo.pNext = nullptr;
  framebufferInfo.renderPass = renderTarget.renderPass;
  framebufferInfo.attachmentCount = static_cast<uint32_t>(attachmentViews.size());
  framebufferInfo.pAttachments = attachmentViews.data();
  framebufferInfo.width = width;
  framebufferInfo.height = height;
  framebufferInfo.layers = 1;
 
  result = vkCreateFramebuffer(graphicsDevice->device, &framebufferInfo, nullptr, &renderTarget.framebuffer);
  
  if (VK_FAILED(result)) {
    return DepthStencilHandle::InvalidHandle;
  }
 
  return depthTargets.addResource(DepthStencilTargetVK{});
}
 
void Cogs::RenderTargetsVK::releaseDepthStencilTarget(DepthStencilHandle depthStencilHandle)
{
}
 
Cogs::RenderTargetLayout Cogs::RenderTargetsVK::getLayout(const RenderTargetHandle renderTargetHandle, const DepthStencilHandle depthStencilHandle)
{
  RenderTargetLayout layout;
 
  if (HandleIsValid(renderTargetHandle)) {
    const RenderTargetVK & renderTarget = renderTargets[renderTargetHandle];
    layout.numColorTargets = static_cast<uint8_t>(renderTarget.textures.size());
 
    for (size_t i = 0; i < renderTarget.textures.size(); ++i) {
      layout.colorFormats[i] = renderTarget.textures[i]->format;
      layout.samples = static_cast<uint8_t>(renderTarget.textures[i]->samples);
    }
 
    if (renderTarget.depthTexture) {
      layout.depthStencilFormat = renderTarget.depthTexture->format;
    }
  } else {
    const GraphicsDeviceSettings & settings = graphicsDevice->getSettings();
    layout.numColorTargets = 1;
    layout.colorFormats[0] = settings.colorFormat;
    layout.samples = static_cast<uint8_t>(settings.numSamples);
    layout.depthStencilFormat = settings.depthFormat;
  }
 
  if (HandleIsValid(depthStencilHandle)) {
    const DepthStencilTargetVK & depthTarget = depthTargets[depthStencilHandle];
    if (HandleIsValid(depthTarget.renderTarget)) {
      const RenderTargetVK & renderTarget = renderTargets[depthTarget.renderTarget];
      if (renderTarget.depthTexture) {
        layout.depthStencilFormat = renderTarget.depthTexture->format;
      }
    }
  }
 
  return layout;
}
 
Cogs::DepthStencilStateHandle Cogs::RenderTargetsVK::loadDepthStencilState(const DepthStencilState & depthStencilState)
{
  DepthStencilStateVK ds;
 
  VkCompareOp ops[] = {
    VK_COMPARE_OP_NEVER,
    VK_COMPARE_OP_LESS,
    VK_COMPARE_OP_LESS_OR_EQUAL,
    VK_COMPARE_OP_EQUAL,
    VK_COMPARE_OP_GREATER_OR_EQUAL,
    VK_COMPARE_OP_GREATER,
    VK_COMPARE_OP_NOT_EQUAL,
    VK_COMPARE_OP_ALWAYS,
  };
 
  ds.state = {};
  ds.state.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
  ds.state.depthTestEnable = depthStencilState.depthEnabled;
  ds.state.depthWriteEnable = depthStencilState.writeEnabled;
  ds.state.depthCompareOp = ops[depthStencilState.depthFunction];
 
  ds.state.depthBoundsTestEnable = VK_FALSE;
  ds.state.minDepthBounds = 0;
  ds.state.maxDepthBounds = 1;
 
  ds.state.back.failOp = VK_STENCIL_OP_KEEP;
  ds.state.back.passOp = VK_STENCIL_OP_KEEP;
  ds.state.back.compareOp = VK_COMPARE_OP_ALWAYS;
  ds.state.stencilTestEnable = VK_FALSE;
  ds.state.front = ds.state.back;
 
  return depthStencilStates.addResource(ds);
}
 
void Cogs::RenderTargetsVK::releaseDepthStencilState(DepthStencilStateHandle handle)
{
}
 
Cogs::RasterizerStateHandle Cogs::RenderTargetsVK::loadRasterizerState(const RasterizerState & rasterizerState)
{
  RasterizerStateVK rs;
 
  VkCullModeFlagBits cullModes[] = {
    VK_CULL_MODE_FRONT_BIT,
    VK_CULL_MODE_BACK_BIT,
    VK_CULL_MODE_NONE,
  };
 
  rs.state = {};
  rs.state.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
  
  rs.state.cullMode = cullModes[rasterizerState.cullMode];
  rs.state.frontFace = rasterizerState.frontCounterClockwise ? VK_FRONT_FACE_COUNTER_CLOCKWISE : VK_FRONT_FACE_CLOCKWISE;
  
  rs.state.polygonMode = rasterizerState.wireFrame ? VK_POLYGON_MODE_LINE : VK_POLYGON_MODE_FILL;
  rs.state.lineWidth = 1.0f;
  
  rs.state.depthBiasEnable = rasterizerState.depthBias != 0;
  rs.state.depthBiasConstantFactor = rasterizerState.depthBias;
  rs.state.depthBiasSlopeFactor = rasterizerState.slopeScaledDepthBias;
  
  rs.state.depthClampEnable = rasterizerState.depthBiasClamp != 0;
  rs.state.depthBiasClamp = rasterizerState.depthBiasClamp;
 
  rs.state.rasterizerDiscardEnable = VK_FALSE;
 
  return rasterizerStates.addResource(rs);
}
 
void Cogs::RenderTargetsVK::releaseRasterizerState(RasterizerStateHandle handle)
{
}
 
namespace Cogs
{
  namespace Vulkan
  {
    VkBlendFactor BlendOptions[] = {
      VK_BLEND_FACTOR_ZERO,
      VK_BLEND_FACTOR_ONE,
      VK_BLEND_FACTOR_SRC_COLOR,
      VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR,
      VK_BLEND_FACTOR_SRC_ALPHA,
      VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
      VK_BLEND_FACTOR_DST_ALPHA,
      VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA,
      VK_BLEND_FACTOR_DST_COLOR,
      VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR,
      VK_BLEND_FACTOR_SRC_ALPHA_SATURATE,
      VK_BLEND_FACTOR_CONSTANT_COLOR,
      VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR,
    };
    static_assert(sizeof(BlendOptions)/sizeof(BlendOptions[0]) == (size_t)Cogs::BlendState::Blend::Count, "Blend size");
  }
}
 
Cogs::BlendStateHandle Cogs::RenderTargetsVK::loadBlendState(const BlendState & blendState)
{
  auto handle = blendStates.addResource(BlendStateVK{});
 
  auto & bs = blendStates[handle];
 
  bs.state = {};
  bs.state.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
 
  bs.state.attachmentCount = 1;
  bs.state.pAttachments = bs.attachmentStates;
 
  bs.attachmentStates[0].blendEnable = blendState.enabled;
  bs.attachmentStates[0].srcColorBlendFactor = Vulkan::BlendOptions[(size_t)blendState.sourceBlend];
  bs.attachmentStates[0].dstColorBlendFactor = Vulkan::BlendOptions[(size_t)blendState.destinationBlend];
  bs.attachmentStates[0].colorBlendOp = VK_BLEND_OP_ADD;
  bs.attachmentStates[0].srcAlphaBlendFactor = Vulkan::BlendOptions[(size_t)blendState.sourceBlend];
  bs.attachmentStates[0].dstAlphaBlendFactor = Vulkan::BlendOptions[(size_t)blendState.destinationBlend];
  bs.attachmentStates[0].alphaBlendOp = VK_BLEND_OP_ADD;
  bs.attachmentStates[0].colorWriteMask = 0xF;
 
  for (auto & a : bs.attachmentStates) {
    a.colorWriteMask = 0xF;
  }
 
  return handle;
}
 
void Cogs::RenderTargetsVK::releaseBlendState(BlendStateHandle handle)
{
}
 
void Cogs::RenderTargetsVK::releaseResources()
{
}
 
Cogs::RenderTargetHandle Cogs::RenderTargetsVK::createRenderTarget(const RenderTargetViewDescription * renderTargetViews, const size_t numViews)
{
  return RenderTargetHandle();
}
 
Cogs::DepthStencilHandle Cogs::RenderTargetsVK::createDepthStencilTarget(const RenderTargetHandle handle, const DepthStencilViewDescription & depthStencilView)
{
  return DepthStencilHandle();
}