EffectsVK.cpp

#include "EffectsVK.h"
 
// #include <ShaderCompiler/ShaderCompiler.h> // TODO
 
#include "GraphicsDeviceVK.h"
#include "BuffersVK.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("EffectsVK");
 
  VkShaderModule prepareShader(VkDevice device, const void * data, const size_t size)
  {
    VkShaderModuleCreateInfo moduleCreateInfo;
    VkShaderModule module;
    VkResult err;
 
    moduleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
    moduleCreateInfo.pNext = nullptr;
 
    moduleCreateInfo.codeSize = size;
    moduleCreateInfo.pCode = reinterpret_cast<const uint32_t *>(data);
    moduleCreateInfo.flags = 0;
 
    err = vkCreateShaderModule(device, &moduleCreateInfo, nullptr, &module);
 
    assert(!err);
 
    return module;
  }
}
 
void Cogs::EffectsVK::initialize(GraphicsDeviceVK * graphicsDevice)
{
  this->graphicsDevice = graphicsDevice;
 
  EffectsCommon::initialize(graphicsDevice->getBuffers());
}
 
Cogs::EffectHandle Cogs::EffectsVK::loadComputeEffect(const StringView & fileName, EffectFlags::EEffectFlags effectFlags)
{
  return EffectHandle();
}
 
Cogs::EffectHandle Cogs::EffectsVK::loadComputeEffect(const StringView & fileName, const PreprocessorDefinitions & definitions, EffectFlags::EEffectFlags effectFlags)
{
  return EffectHandle();
}
 
void Cogs::EffectsVK::releaseEffect(EffectHandle effectHandle)
{
}
 
void Cogs::EffectsVK::releaseResources()
{
}
 
bool Cogs::EffectsVK::initializeEffectLayout(EffectVK & effect)
{
  const VkDescriptorType slotTypes[] = {
    VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
    VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
    VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
    VK_DESCRIPTOR_TYPE_SAMPLER
  };
 
  const VkShaderStageFlagBits shaderTypes[] = {
    VK_SHADER_STAGE_VERTEX_BIT,
    VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT,
    VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT,
    VK_SHADER_STAGE_GEOMETRY_BIT,
    VK_SHADER_STAGE_FRAGMENT_BIT,
  };
 
  Shader * shaders[] = {
    &effect.vertexShader,
    nullptr,
    nullptr,
    &effect.geometryShader,
    &effect.pixelShader
  };
 
  for (size_t j = 0; j < ShaderType::NumShaderTypes; ++j) {
    std::vector<VkDescriptorSetLayoutBinding> layoutBindings;
 
    uint32_t binding = 0;
    for (size_t i = 0; i < SlotType::NumSlotTypes - 1; ++i) {
      auto slots = effect.signature.slots[i].values[j];
 
      if (slots) {
        for (size_t k = 0; k < slots; ++k) {
          const VkDescriptorSetLayoutBinding layoutBinding = {
            binding++,
            slotTypes[i],
            1,
            static_cast<VkShaderStageFlags>(shaderTypes[j]),
            nullptr,
          };
 
          layoutBindings.push_back(layoutBinding);
        }
      }
    }
 
    if (!layoutBindings.size()) continue;
 
    const VkDescriptorSetLayoutCreateInfo descriptorLayoutInfo = {
      VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
      nullptr,
      0,
      static_cast<uint32_t>(layoutBindings.size()),
      layoutBindings.data(),
    };
 
    VkDescriptorSetLayout descriptorSetLayout;
    
    auto result = vkCreateDescriptorSetLayout(graphicsDevice->device, &descriptorLayoutInfo, nullptr, &descriptorSetLayout);
    
    if (result != VK_SUCCESS) {
      LOG_ERROR(logger, "Error creating descriptor set layout.");
      return false;
    }
 
    effect.descriptorSetLayouts.push_back(descriptorSetLayout);
  }
 
  const VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = {
    VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
    nullptr,
    0,
    static_cast<uint32_t>(effect.descriptorSetLayouts.size()),
    effect.descriptorSetLayouts.data(),
    0,
    nullptr
  };
 
  auto result = vkCreatePipelineLayout(graphicsDevice->device, &pipelineLayoutCreateInfo, nullptr, &effect.pipelineLayout);
 
  if (result != VK_SUCCESS) {
    LOG_ERROR(logger, "Error creating pipeline layout.");
    return false;
  }
 
  return true;
}
 
Cogs::EffectHandle Cogs::EffectsVK::load(
  const ProcessedContent & vsSource,
  const ProcessedContent & hsSource,
  const ProcessedContent & dsSource,
  const ProcessedContent & gsSource,
  const ProcessedContent & psSource,
  const StringView & vsEntryPoint,
  const StringView & hsEntryPoint,
  const StringView & dsEntryPoint,
  const StringView & gsEntryPoint,
  const StringView & psEntryPoint,
  const EffectDescription & desc)
{
  // EffectByteCode byteCode;
 
  // EffectSource source;
  // source.vsSource = vsSource.content;
  // source.gsSource = gsSource.content;
  // source.psSource = psSource.content;
 
  // source.sourceLanguage = EffectLanguage::HLSL;
  // source.targetLanguage = GlslVariant::VersionVulkan;
 
  // Cogs::compileEffect(source, desc.definitions, EffectFlags::HLSL,
  //   byteCode,
  //   vsEntryPoint.size() ? vsEntryPoint.data() : nullptr,
  //   gsEntryPoint.size() ? gsEntryPoint.data() : nullptr,
  //   psEntryPoint.size() ? psEntryPoint.data() : nullptr);
 
  // EffectVK effect;
 
  // if (byteCode.vsByteCode) {
  //   Cogs::reflectShader(byteCode.vsByteCode, effect.vertexShader.reflection);
  // }
 
  // if (byteCode.gsByteCode) {
  //   Cogs::reflectShader(byteCode.gsByteCode, effect.geometryShader.reflection);
  // }
 
  // if (byteCode.psByteCode) {
  //   Cogs::reflectShader(byteCode.psByteCode, effect.pixelShader.reflection);
  // }
 
  // Cogs::crossCompileEffect(byteCode, GlslVariant::VersionVulkan, source.gsSource.size() ? CompilerFlags::GeometryShader : CompilerFlags::None, source);
 
  // const bool dumpShaderContents = (graphicsDevice->getSettings().flags & GraphicsDeviceFlags::DumpShaderContents) != 0;
 
  // StringView sources[] = {
  //   source.vsSource,
  //   nullptr,
  //   nullptr,
  //   source.gsSource,
  //   source.psSource,
  // };
 
  // StringView profiles[] = {
  //   "vs_vk",
  //   "hs_vk",
  //   "ds_vk",
  //   "gs_vk",
  //   "ps_vk",
  // };
 
  // if (dumpShaderContents && desc.name.size()) {
  //   for (int i = 0; i < ShaderType::NumShaderTypes; i++) {
  //     if (sources[i].empty()) {
  //       continue;
  //     }
 
  //     auto dumpName = desc.name.to_string() + "." + profiles[i].to_string() + ".glsl";
  //     handler->writeBinaryFile(IIOHandler::FileType::ShaderDump, dumpName, sources[i].data(), sources[i].size());
  //   }
   
  //   std::string meta;
  //   meta.reserve(4096);
 
  //   meta.append("{\n");
 
  //   meta.append("  \"name\": ");
 
  //   meta.append("\"");
  //   meta.append(desc.name.empty() ? "N/A" : desc.name.data());
  //   meta.append("\"\n");
 
  //   if (!desc.definitions.empty()) {
  //     meta.append("  \"definitions\": {\n");
 
  //     for (auto & d : desc.definitions) {
  //       meta.append("    \"");
  //       meta.append(d.first);
  //       meta.append("\": ");
 
  //       meta.append("\"");
  //       meta.append(d.second);
  //       meta.append("\",\n");
  //     }
 
  //     meta.append("  },\n");
  //   }
 
  //   size_t effectId = 0;
  //   for (int i = 0; i < ShaderType::NumShaderTypes; i++) {
  //     if (sources[i].empty()) {
  //       continue;
  //     }
 
  //     meta.append("  \"");
  //     meta.append(profiles[i].to_string());
  //     meta.append("\": ");
 
  //     auto dumpName = desc.name.to_string() + "." + profiles[i].to_string() + ".glsl";
  //     meta.append("\"");
  //     meta.append(dumpName);
  //     meta.append("\"\n");
  //   }
 
  //   meta.append("}\n");
 
  //   auto metaName = desc.name.empty() ? std::to_string(effectId) + ".json" : desc.name.to_string() + ".vk.json";
  //   handler->writeBinaryFile(IIOHandler::FileType::ShaderDump, metaName, meta.data(), meta.size());
  // }
 
  // effect.vertexShader.shaderModule = prepareShader(graphicsDevice->device, source.vsSource.data(), source.vsSource.size());
 
  // if (source.gsSource.size()) {
  //   effect.geometryShader.shaderModule = prepareShader(graphicsDevice->device, source.gsSource.data(), source.gsSource.size());
  // }
 
  // if (source.psSource.size()) {
  //   effect.pixelShader.shaderModule = prepareShader(graphicsDevice->device, source.psSource.data(), source.psSource.size());
  // }
 
  // effect.buildSignature();
 
  // initializeEffectLayout(effect);
 
  // return effects.addResource(effect);
  return Cogs::EffectHandle::NoHandle;
}