// Copyright 2014 Dolphin Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later

#include "VideoCommon/PostProcessing.h"

#include <sstream>
#include <string>
#include <string_view>

#include <fmt/format.h>

#include "Common/Assert.h"
#include "Common/CommonPaths.h"
#include "Common/CommonTypes.h"
#include "Common/FileSearch.h"
#include "Common/FileUtil.h"
#include "Common/IniFile.h"
#include "Common/Logging/Log.h"
#include "Common/MsgHandler.h"
#include "Common/StringUtil.h"

#include "VideoCommon/AbstractFramebuffer.h"
#include "VideoCommon/AbstractGfx.h"
#include "VideoCommon/AbstractPipeline.h"
#include "VideoCommon/AbstractShader.h"
#include "VideoCommon/AbstractTexture.h"
#include "VideoCommon/FramebufferManager.h"
#include "VideoCommon/Present.h"
#include "VideoCommon/ShaderCache.h"
#include "VideoCommon/VertexManagerBase.h"
#include "VideoCommon/VideoCommon.h"
#include "VideoCommon/VideoConfig.h"

namespace VideoCommon
{
static const char s_empty_pixel_shader[] = "void main() { SetOutput(Sample()); }\n";
static const char s_default_pixel_shader_name[] = "default_pre_post_process";
// Keep the highest quality possible to avoid losing quality on subtle gamma conversions.
// RGBA16F should have enough quality even if we store colors in gamma space on it.
static const AbstractTextureFormat s_intermediary_buffer_format = AbstractTextureFormat::RGBA16F;

static bool LoadShaderFromFile(const std::string& shader, const std::string& sub_dir,
                               std::string& out_code)
{
  std::string path = File::GetUserPath(D_SHADERS_IDX) + sub_dir + shader + ".glsl";

  if (!File::Exists(path))
  {
    // Fallback to shared user dir
    path = File::GetSysDirectory() + SHADERS_DIR DIR_SEP + sub_dir + shader + ".glsl";
  }

  if (!File::ReadFileToString(path, out_code))
  {
    out_code = "";
    ERROR_LOG_FMT(VIDEO, "Post-processing shader not found: {}", path);
    return false;
  }

  return true;
}

PostProcessingConfiguration::PostProcessingConfiguration() = default;

PostProcessingConfiguration::~PostProcessingConfiguration() = default;

void PostProcessingConfiguration::LoadShader(const std::string& shader)
{
  // Load the shader from the configuration if there isn't one sent to us.
  m_current_shader = shader;
  if (shader.empty())
  {
    LoadDefaultShader();
    return;
  }

  std::string sub_dir = "";

  if (g_Config.stereo_mode == StereoMode::Anaglyph)
  {
    sub_dir = ANAGLYPH_DIR DIR_SEP;
  }
  else if (g_Config.stereo_mode == StereoMode::Passive)
  {
    sub_dir = PASSIVE_DIR DIR_SEP;
  }

  std::string code;
  if (!LoadShaderFromFile(shader, sub_dir, code))
  {
    LoadDefaultShader();
    return;
  }

  LoadOptions(code);
  // Note that this will build the shaders with the custom options values users
  // might have set in the settings
  LoadOptionsConfiguration();
  m_current_shader_code = code;
}

void PostProcessingConfiguration::LoadDefaultShader()
{
  m_options.clear();
  m_any_options_dirty = false;
  m_current_shader = "";
  m_current_shader_code = s_empty_pixel_shader;
}

void PostProcessingConfiguration::LoadOptions(const std::string& code)
{
  const std::string config_start_delimiter = "[configuration]";
  const std::string config_end_delimiter = "[/configuration]";
  size_t configuration_start = code.find(config_start_delimiter);
  size_t configuration_end = code.find(config_end_delimiter);

  m_options.clear();
  m_any_options_dirty = true;

  if (configuration_start == std::string::npos || configuration_end == std::string::npos)
  {
    // Issue loading configuration or there isn't one.
    return;
  }

  std::string configuration_string =
      code.substr(configuration_start + config_start_delimiter.size(),
                  configuration_end - configuration_start - config_start_delimiter.size());

  std::istringstream in(configuration_string);

  struct GLSLStringOption
  {
    std::string m_type;
    std::vector<std::pair<std::string, std::string>> m_options;
  };

  std::vector<GLSLStringOption> option_strings;
  GLSLStringOption* current_strings = nullptr;
  while (!in.eof())
  {
    std::string line_str;
    if (std::getline(in, line_str))
    {
      std::string_view line = line_str;

#ifndef _WIN32
      // Check for CRLF eol and convert it to LF
      if (!line.empty() && line.at(line.size() - 1) == '\r')
        line.remove_suffix(1);
#endif

      if (!line.empty())
      {
        if (line[0] == '[')
        {
          size_t endpos = line.find("]");

          if (endpos != std::string::npos)
          {
            // New section!
            std::string_view sub = line.substr(1, endpos - 1);
            option_strings.push_back({std::string(sub)});
            current_strings = &option_strings.back();
          }
        }
        else
        {
          if (current_strings)
          {
            std::string key, value;
            Common::IniFile::ParseLine(line, &key, &value);

            if (!(key.empty() && value.empty()))
              current_strings->m_options.emplace_back(key, value);
          }
        }
      }
    }
  }

  for (const auto& it : option_strings)
  {
    ConfigurationOption option;
    option.m_dirty = true;

    if (it.m_type == "OptionBool")
      option.m_type = ConfigurationOption::OptionType::Bool;
    else if (it.m_type == "OptionRangeFloat")
      option.m_type = ConfigurationOption::OptionType::Float;
    else if (it.m_type == "OptionRangeInteger")
      option.m_type = ConfigurationOption::OptionType::Integer;

    for (const auto& string_option : it.m_options)
    {
      if (string_option.first == "GUIName")
      {
        option.m_gui_name = string_option.second;
      }
      else if (string_option.first == "OptionName")
      {
        option.m_option_name = string_option.second;
      }
      else if (string_option.first == "DependentOption")
      {
        option.m_dependent_option = string_option.second;
      }
      else if (string_option.first == "MinValue" || string_option.first == "MaxValue" ||
               string_option.first == "DefaultValue" || string_option.first == "StepAmount")
      {
        std::vector<s32>* output_integer = nullptr;
        std::vector<float>* output_float = nullptr;

        if (string_option.first == "MinValue")
        {
          output_integer = &option.m_integer_min_values;
          output_float = &option.m_float_min_values;
        }
        else if (string_option.first == "MaxValue")
        {
          output_integer = &option.m_integer_max_values;
          output_float = &option.m_float_max_values;
        }
        else if (string_option.first == "DefaultValue")
        {
          output_integer = &option.m_integer_values;
          output_float = &option.m_float_values;
        }
        else if (string_option.first == "StepAmount")
        {
          output_integer = &option.m_integer_step_values;
          output_float = &option.m_float_step_values;
        }

        if (option.m_type == ConfigurationOption::OptionType::Bool)
        {
          TryParse(string_option.second, &option.m_bool_value);
        }
        else if (option.m_type == ConfigurationOption::OptionType::Integer)
        {
          TryParseVector(string_option.second, output_integer);
          if (output_integer->size() > 4)
            output_integer->erase(output_integer->begin() + 4, output_integer->end());
        }
        else if (option.m_type == ConfigurationOption::OptionType::Float)
        {
          TryParseVector(string_option.second, output_float);
          if (output_float->size() > 4)
            output_float->erase(output_float->begin() + 4, output_float->end());
        }
      }
    }
    m_options[option.m_option_name] = option;
  }
}

void PostProcessingConfiguration::LoadOptionsConfiguration()
{
  Common::IniFile ini;
  ini.Load(File::GetUserPath(F_DOLPHINCONFIG_IDX));
  std::string section = m_current_shader + "-options";

  // We already expect all the options to be marked as "dirty" when we reach here
  for (auto& it : m_options)
  {
    switch (it.second.m_type)
    {
    case ConfigurationOption::OptionType::Bool:
      ini.GetOrCreateSection(section)->Get(it.second.m_option_name, &it.second.m_bool_value,
                                           it.second.m_bool_value);
      break;
    case ConfigurationOption::OptionType::Integer:
    {
      std::string value;
      ini.GetOrCreateSection(section)->Get(it.second.m_option_name, &value);
      if (!value.empty())
      {
        auto integer_values = it.second.m_integer_values;
        if (TryParseVector(value, &integer_values))
        {
          it.second.m_integer_values = integer_values;
        }
      }
    }
    break;
    case ConfigurationOption::OptionType::Float:
    {
      std::string value;
      ini.GetOrCreateSection(section)->Get(it.second.m_option_name, &value);
      if (!value.empty())
      {
        auto float_values = it.second.m_float_values;
        if (TryParseVector(value, &float_values))
        {
          it.second.m_float_values = float_values;
        }
      }
    }
    break;
    }
  }
}

void PostProcessingConfiguration::SaveOptionsConfiguration()
{
  Common::IniFile ini;
  ini.Load(File::GetUserPath(F_DOLPHINCONFIG_IDX));
  std::string section = m_current_shader + "-options";

  for (auto& it : m_options)
  {
    switch (it.second.m_type)
    {
    case ConfigurationOption::OptionType::Bool:
    {
      ini.GetOrCreateSection(section)->Set(it.second.m_option_name, it.second.m_bool_value);
    }
    break;
    case ConfigurationOption::OptionType::Integer:
    {
      std::string value;
      for (size_t i = 0; i < it.second.m_integer_values.size(); ++i)
      {
        value += fmt::format("{}{}", it.second.m_integer_values[i],
                             i == (it.second.m_integer_values.size() - 1) ? "" : ", ");
      }
      ini.GetOrCreateSection(section)->Set(it.second.m_option_name, value);
    }
    break;
    case ConfigurationOption::OptionType::Float:
    {
      std::ostringstream value;
      value.imbue(std::locale("C"));

      for (size_t i = 0; i < it.second.m_float_values.size(); ++i)
      {
        value << it.second.m_float_values[i];
        if (i != (it.second.m_float_values.size() - 1))
          value << ", ";
      }
      ini.GetOrCreateSection(section)->Set(it.second.m_option_name, value.str());
    }
    break;
    }
  }
  ini.Save(File::GetUserPath(F_DOLPHINCONFIG_IDX));
}

void PostProcessingConfiguration::SetOptionf(const std::string& option, int index, float value)
{
  auto it = m_options.find(option);

  it->second.m_float_values[index] = value;
  it->second.m_dirty = true;
  m_any_options_dirty = true;
}

void PostProcessingConfiguration::SetOptioni(const std::string& option, int index, s32 value)
{
  auto it = m_options.find(option);

  it->second.m_integer_values[index] = value;
  it->second.m_dirty = true;
  m_any_options_dirty = true;
}

void PostProcessingConfiguration::SetOptionb(const std::string& option, bool value)
{
  auto it = m_options.find(option);

  it->second.m_bool_value = value;
  it->second.m_dirty = true;
  m_any_options_dirty = true;
}

PostProcessing::PostProcessing()
{
  m_timer.Start();
}

PostProcessing::~PostProcessing()
{
  m_timer.Stop();
}

static std::vector<std::string> GetShaders(const std::string& sub_dir = "")
{
  std::vector<std::string> paths =
      Common::DoFileSearch({File::GetUserPath(D_SHADERS_IDX) + sub_dir,
                            File::GetSysDirectory() + SHADERS_DIR DIR_SEP + sub_dir},
                           {".glsl"});
  std::vector<std::string> result;
  for (std::string path : paths)
  {
    std::string name;
    SplitPath(path, nullptr, &name, nullptr);
    if (name == s_default_pixel_shader_name)
      continue;
    result.push_back(name);
  }
  return result;
}

std::vector<std::string> PostProcessing::GetShaderList()
{
  return GetShaders();
}

std::vector<std::string> PostProcessing::GetAnaglyphShaderList()
{
  return GetShaders(ANAGLYPH_DIR DIR_SEP);
}

std::vector<std::string> PostProcessing::GetPassiveShaderList()
{
  return GetShaders(PASSIVE_DIR DIR_SEP);
}

bool PostProcessing::Initialize(AbstractTextureFormat format)
{
  m_framebuffer_format = format;
  // CompilePixelShader() must be run first if configuration options are used.
  // Otherwise the UBO has a different member list between vertex and pixel
  // shaders, which is a link error on some backends.
  if (!CompilePixelShader() || !CompileVertexShader() || !CompilePipeline())
    return false;

  return true;
}

void PostProcessing::RecompileShader()
{
  // Note: for simplicity we already recompile all the shaders
  // and pipelines even if there might not be need to.

  m_default_pipeline.reset();
  m_pipeline.reset();
  m_default_pixel_shader.reset();
  m_pixel_shader.reset();
  m_default_vertex_shader.reset();
  m_vertex_shader.reset();
  if (!CompilePixelShader())
    return;
  if (!CompileVertexShader())
    return;

  CompilePipeline();
}

void PostProcessing::RecompilePipeline()
{
  m_default_pipeline.reset();
  m_pipeline.reset();
  CompilePipeline();
}

bool PostProcessing::IsColorCorrectionActive() const
{
  // We can skip the color correction pass if none of these settings are on
  // (it might have still helped with gamma correct sampling, but it's not worth running it).
  return g_ActiveConfig.color_correction.bCorrectColorSpace ||
         g_ActiveConfig.color_correction.bCorrectGamma ||
         m_framebuffer_format == AbstractTextureFormat::RGBA16F;
}

bool PostProcessing::NeedsIntermediaryBuffer() const
{
  // If we have no user selected post process shader,
  // there's no point in having an intermediary buffer doing nothing.
  return !m_config.GetShader().empty();
}

void PostProcessing::BlitFromTexture(const MathUtil::Rectangle<int>& dst,
                                     const MathUtil::Rectangle<int>& src,
                                     const AbstractTexture* src_tex, int src_layer)
{
  if (g_gfx->GetCurrentFramebuffer()->GetColorFormat() != m_framebuffer_format)
  {
    m_framebuffer_format = g_gfx->GetCurrentFramebuffer()->GetColorFormat();
    RecompilePipeline();
  }

  // By default all source layers will be copied into the respective target layers
  const bool copy_all_layers = src_layer < 0;
  src_layer = std::max(src_layer, 0);

  MathUtil::Rectangle<int> src_rect = src;
  g_gfx->SetSamplerState(0, RenderState::GetLinearSamplerState());
  g_gfx->SetSamplerState(1, RenderState::GetPointSamplerState());
  g_gfx->SetTexture(0, src_tex);
  g_gfx->SetTexture(1, src_tex);

  const bool needs_color_correction = IsColorCorrectionActive();
  // Rely on the default (bi)linear sampler with the default mode
  // (it might not be gamma corrected).
  const bool needs_resampling =
      g_ActiveConfig.output_resampling_mode > OutputResamplingMode::Default;
  const bool needs_intermediary_buffer = NeedsIntermediaryBuffer();
  const bool needs_default_pipeline = needs_color_correction || needs_resampling;
  const AbstractPipeline* final_pipeline = m_pipeline.get();
  std::vector<u8>* uniform_staging_buffer = &m_default_uniform_staging_buffer;
  bool default_uniform_staging_buffer = true;
  const MathUtil::Rectangle<int> present_rect = g_presenter->GetTargetRectangle();

  // Intermediary pass.
  // We draw to a high quality intermediary texture for a couple reasons:
  // -Consistently do high quality gamma corrected resampling (upscaling/downscaling)
  // -Keep quality for gamma and gamut conversions, and HDR output
  //  (low bit depths lose too much quality with gamma conversions)
  // -Keep the post process phase in linear space, to better operate with colors
  if (m_default_pipeline && needs_default_pipeline && needs_intermediary_buffer)
  {
    AbstractFramebuffer* const previous_framebuffer = g_gfx->GetCurrentFramebuffer();

    // We keep the min number of layers as the render target,
    // as in case of OpenGL, the source FBX will have two layers,
    // but we will render onto two separate frame buffers (one by one),
    // so it would be a waste to allocate two layers (see "bUsesExplictQuadBuffering").
    const u32 target_layers = copy_all_layers ? src_tex->GetLayers() : 1;

    const u32 target_width =
        needs_resampling ? present_rect.GetWidth() : static_cast<u32>(src_rect.GetWidth());
    const u32 target_height =
        needs_resampling ? present_rect.GetHeight() : static_cast<u32>(src_rect.GetHeight());

    if (!m_intermediary_frame_buffer || !m_intermediary_color_texture ||
        m_intermediary_color_texture->GetWidth() != target_width ||
        m_intermediary_color_texture->GetHeight() != target_height ||
        m_intermediary_color_texture->GetLayers() != target_layers)
    {
      const TextureConfig intermediary_color_texture_config(
          target_width, target_height, 1, target_layers, src_tex->GetSamples(),
          s_intermediary_buffer_format, AbstractTextureFlag_RenderTarget,
          AbstractTextureType::Texture_2DArray);
      m_intermediary_color_texture = g_gfx->CreateTexture(intermediary_color_texture_config,
                                                          "Intermediary post process texture");

      m_intermediary_frame_buffer =
          g_gfx->CreateFramebuffer(m_intermediary_color_texture.get(), nullptr);
    }

    g_gfx->SetFramebuffer(m_intermediary_frame_buffer.get());

    FillUniformBuffer(src_rect, src_tex, src_layer, g_gfx->GetCurrentFramebuffer()->GetRect(),
                      present_rect, uniform_staging_buffer->data(), !default_uniform_staging_buffer,
                      true);
    g_vertex_manager->UploadUtilityUniforms(uniform_staging_buffer->data(),
                                            static_cast<u32>(uniform_staging_buffer->size()));

    g_gfx->SetViewportAndScissor(g_gfx->ConvertFramebufferRectangle(
        m_intermediary_color_texture->GetRect(), m_intermediary_frame_buffer.get()));
    g_gfx->SetPipeline(m_default_pipeline.get());
    g_gfx->Draw(0, 3);

    g_gfx->SetFramebuffer(previous_framebuffer);
    src_rect = m_intermediary_color_texture->GetRect();
    src_tex = m_intermediary_color_texture.get();
    g_gfx->SetTexture(0, src_tex);
    g_gfx->SetTexture(1, src_tex);
    // The "m_intermediary_color_texture" has already copied
    // from the specified source layer onto its first one.
    // If we query for a layer that the source texture doesn't have,
    // it will fall back on the first one anyway.
    src_layer = 0;
    uniform_staging_buffer = &m_uniform_staging_buffer;
    default_uniform_staging_buffer = false;
  }
  else
  {
    // If we have no custom user shader selected, and color correction
    // is active, directly run the fixed pipeline shader instead of
    // doing two passes, with the second one doing nothing useful.
    if (m_default_pipeline && needs_default_pipeline)
    {
      final_pipeline = m_default_pipeline.get();
    }
    else
    {
      uniform_staging_buffer = &m_uniform_staging_buffer;
      default_uniform_staging_buffer = false;
    }

    m_intermediary_frame_buffer.reset();
    m_intermediary_color_texture.reset();
  }

  // TODO: ideally we'd do the user selected post process pass in the intermediary buffer in linear
  // space (instead of gamma space), so the shaders could act more accurately (and sample in linear
  // space), though that would break the look of some of current post processes we have, and thus is
  // better avoided for now.

  // Final pass, either a user selected shader or the default (fixed) shader.
  if (final_pipeline)
  {
    FillUniformBuffer(src_rect, src_tex, src_layer, g_gfx->GetCurrentFramebuffer()->GetRect(),
                      present_rect, uniform_staging_buffer->data(), !default_uniform_staging_buffer,
                      false);
    g_vertex_manager->UploadUtilityUniforms(uniform_staging_buffer->data(),
                                            static_cast<u32>(uniform_staging_buffer->size()));

    g_gfx->SetViewportAndScissor(
        g_gfx->ConvertFramebufferRectangle(dst, g_gfx->GetCurrentFramebuffer()));
    g_gfx->SetPipeline(final_pipeline);
    g_gfx->Draw(0, 3);
  }
}

std::string PostProcessing::GetUniformBufferHeader(bool user_post_process) const
{
  std::ostringstream ss;
  u32 unused_counter = 1;
  ss << "UBO_BINDING(std140, 1) uniform PSBlock {\n";

  // Builtin uniforms:

  ss << "  float4 resolution;\n";  // Source resolution
  ss << "  float4 target_resolution;\n";
  ss << "  float4 window_resolution;\n";
  // How many horizontal and vertical stereo views do we have? (set to 1 when we use layers instead)
  ss << "  int2 stereo_views;\n";
  ss << "  float4 src_rect;\n";
  // The first (but not necessarily only) source layer we target
  ss << "  int src_layer;\n";
  ss << "  uint time;\n";
  ss << "  int graphics_api;\n";
  // If true, it's an intermediary buffer (including the first), if false, it's the final one
  ss << "  int intermediary_buffer;\n";

  ss << "  int resampling_method;\n";
  ss << "  int correct_color_space;\n";
  ss << "  int game_color_space;\n";
  ss << "  int correct_gamma;\n";
  ss << "  float game_gamma;\n";
  ss << "  int sdr_display_gamma_sRGB;\n";
  ss << "  float sdr_display_custom_gamma;\n";
  ss << "  int linear_space_output;\n";
  ss << "  int hdr_output;\n";
  ss << "  float hdr_paper_white_nits;\n";
  ss << "  float hdr_sdr_white_nits;\n";

  if (user_post_process)
  {
    ss << "\n";
    // Custom options/uniforms
    for (const auto& it : m_config.GetOptions())
    {
      if (it.second.m_type == PostProcessingConfiguration::ConfigurationOption::OptionType::Bool)
      {
        ss << fmt::format("  int {};\n", it.first);
        for (u32 i = 0; i < 3; i++)
          ss << "  int ubo_align_" << unused_counter++ << "_;\n";
      }
      else if (it.second.m_type ==
               PostProcessingConfiguration::ConfigurationOption::OptionType::Integer)
      {
        u32 count = static_cast<u32>(it.second.m_integer_values.size());
        if (count == 1)
          ss << fmt::format("  int {};\n", it.first);
        else
          ss << fmt::format("  int{} {};\n", count, it.first);

        for (u32 i = count; i < 4; i++)
          ss << "  int ubo_align_" << unused_counter++ << "_;\n";
      }
      else if (it.second.m_type ==
               PostProcessingConfiguration::ConfigurationOption::OptionType::Float)
      {
        u32 count = static_cast<u32>(it.second.m_float_values.size());
        if (count == 1)
          ss << fmt::format("  float {};\n", it.first);
        else
          ss << fmt::format("  float{} {};\n", count, it.first);

        for (u32 i = count; i < 4; i++)
          ss << "  float ubo_align_" << unused_counter++ << "_;\n";
      }
    }
  }

  ss << "};\n\n";
  return ss.str();
}

std::string PostProcessing::GetHeader(bool user_post_process) const
{
  std::ostringstream ss;
  ss << GetUniformBufferHeader(user_post_process);
  ss << "SAMPLER_BINDING(0) uniform sampler2DArray samp0;\n";
  ss << "SAMPLER_BINDING(1) uniform sampler2DArray samp1;\n";

  if (g_ActiveConfig.backend_info.bSupportsGeometryShaders)
  {
    ss << "VARYING_LOCATION(0) in VertexData {\n";
    ss << "  float3 v_tex0;\n";
    ss << "};\n";
  }
  else
  {
    ss << "VARYING_LOCATION(0) in float3 v_tex0;\n";
  }

  ss << "FRAGMENT_OUTPUT_LOCATION(0) out float4 ocol0;\n";

  ss << R"(
float4 Sample() { return texture(samp0, v_tex0); }
float4 SampleLocation(float2 location) { return texture(samp0, float3(location, float(v_tex0.z))); }
float4 SampleLayer(int layer) { return texture(samp0, float3(v_tex0.xy, float(layer))); }
#define SampleOffset(offset) textureOffset(samp0, v_tex0, offset)

float2 GetTargetResolution()
{
  return target_resolution.xy;
}

float2 GetInvTargetResolution()
{
  return target_resolution.zw;
}

float2 GetWindowResolution()
{
  return window_resolution.xy;
}

float2 GetInvWindowResolution()
{
  return window_resolution.zw;
}

float2 GetResolution()
{
  return resolution.xy;
}

float2 GetInvResolution()
{
  return resolution.zw;
}

float2 GetCoordinates()
{
  return v_tex0.xy;
}

float GetLayer()
{
  return v_tex0.z;
}

uint GetTime()
{
  return time;
}

void SetOutput(float4 color)
{
  ocol0 = color;
}

#define GetOption(x) (x)
#define OptionEnabled(x) ((x) != 0)
#define OptionDisabled(x) ((x) == 0)

)";
  return ss.str();
}

std::string PostProcessing::GetFooter() const
{
  return {};
}

static std::string GetVertexShaderBody()
{
  std::ostringstream ss;
  if (g_ActiveConfig.backend_info.bSupportsGeometryShaders)
  {
    ss << "VARYING_LOCATION(0) out VertexData {\n";
    ss << "  float3 v_tex0;\n";
    ss << "};\n";
  }
  else
  {
    ss << "VARYING_LOCATION(0) out float3 v_tex0;\n";
  }

  ss << "#define id gl_VertexID\n";
  ss << "#define opos gl_Position\n";
  ss << "void main() {\n";
  ss << "  v_tex0 = float3(float((id << 1) & 2), float(id & 2), 0.0f);\n";
  ss << "  opos = float4(v_tex0.xy * float2(2.0f, -2.0f) + float2(-1.0f, 1.0f), 0.0f, 1.0f);\n";
  ss << "  v_tex0 = float3(src_rect.xy + (src_rect.zw * v_tex0.xy), float(src_layer));\n";

  // Vulkan Y needs to be inverted on every pass
  if (g_ActiveConfig.backend_info.api_type == APIType::Vulkan)
  {
    ss << "  opos.y = -opos.y;\n";
  }
  // OpenGL Y needs to be inverted in all passes except the last one
  else if (g_ActiveConfig.backend_info.api_type == APIType::OpenGL)
  {
    ss << "  if (intermediary_buffer != 0)\n";
    ss << "    opos.y = -opos.y;\n";
  }

  ss << "}\n";
  return ss.str();
}

bool PostProcessing::CompileVertexShader()
{
  std::ostringstream ss_default;
  ss_default << GetUniformBufferHeader(false);
  ss_default << GetVertexShaderBody();
  m_default_vertex_shader = g_gfx->CreateShaderFromSource(ShaderStage::Vertex, ss_default.str(),
                                                          "Default post-processing vertex shader");

  std::ostringstream ss;
  ss << GetUniformBufferHeader(true);
  ss << GetVertexShaderBody();
  m_vertex_shader =
      g_gfx->CreateShaderFromSource(ShaderStage::Vertex, ss.str(), "Post-processing vertex shader");

  if (!m_default_vertex_shader || !m_vertex_shader)
  {
    PanicAlertFmt("Failed to compile post-processing vertex shader");
    m_default_vertex_shader.reset();
    m_vertex_shader.reset();
    return false;
  }

  return true;
}

struct BuiltinUniforms
{
  // bools need to be represented as "s32"

  std::array<float, 4> source_resolution;
  std::array<float, 4> target_resolution;
  std::array<float, 4> window_resolution;
  std::array<float, 4> stereo_views;
  std::array<float, 4> src_rect;
  s32 src_layer;
  u32 time;
  s32 graphics_api;
  s32 intermediary_buffer;
  s32 resampling_method;
  s32 correct_color_space;
  s32 game_color_space;
  s32 correct_gamma;
  float game_gamma;
  s32 sdr_display_gamma_sRGB;
  float sdr_display_custom_gamma;
  s32 linear_space_output;
  s32 hdr_output;
  float hdr_paper_white_nits;
  float hdr_sdr_white_nits;
};

size_t PostProcessing::CalculateUniformsSize(bool user_post_process) const
{
  // Allocate a vec4 for each uniform to simplify allocation.
  return sizeof(BuiltinUniforms) +
         (user_post_process ? m_config.GetOptions().size() : 0) * sizeof(float) * 4;
}

void PostProcessing::FillUniformBuffer(const MathUtil::Rectangle<int>& src,
                                       const AbstractTexture* src_tex, int src_layer,
                                       const MathUtil::Rectangle<int>& dst,
                                       const MathUtil::Rectangle<int>& wnd, u8* buffer,
                                       bool user_post_process, bool intermediary_buffer)
{
  const float rcp_src_width = 1.0f / src_tex->GetWidth();
  const float rcp_src_height = 1.0f / src_tex->GetHeight();

  BuiltinUniforms builtin_uniforms;
  builtin_uniforms.source_resolution = {static_cast<float>(src_tex->GetWidth()),
                                        static_cast<float>(src_tex->GetHeight()), rcp_src_width,
                                        rcp_src_height};
  builtin_uniforms.target_resolution = {
      static_cast<float>(dst.GetWidth()), static_cast<float>(dst.GetHeight()),
      1.0f / static_cast<float>(dst.GetWidth()), 1.0f / static_cast<float>(dst.GetHeight())};
  builtin_uniforms.window_resolution = {
      static_cast<float>(wnd.GetWidth()), static_cast<float>(wnd.GetHeight()),
      1.0f / static_cast<float>(wnd.GetWidth()), 1.0f / static_cast<float>(wnd.GetHeight())};
  builtin_uniforms.src_rect = {static_cast<float>(src.left) * rcp_src_width,
                               static_cast<float>(src.top) * rcp_src_height,
                               static_cast<float>(src.GetWidth()) * rcp_src_width,
                               static_cast<float>(src.GetHeight()) * rcp_src_height};
  builtin_uniforms.src_layer = static_cast<s32>(src_layer);
  builtin_uniforms.time = static_cast<u32>(m_timer.ElapsedMs());
  builtin_uniforms.graphics_api = static_cast<s32>(g_ActiveConfig.backend_info.api_type);
  builtin_uniforms.intermediary_buffer = static_cast<s32>(intermediary_buffer);

  builtin_uniforms.resampling_method = static_cast<s32>(g_ActiveConfig.output_resampling_mode);
  // Color correction related uniforms.
  // These are mainly used by the "m_default_pixel_shader",
  // but should also be accessible to all other shaders.
  builtin_uniforms.correct_color_space = g_ActiveConfig.color_correction.bCorrectColorSpace;
  builtin_uniforms.game_color_space =
      static_cast<int>(g_ActiveConfig.color_correction.game_color_space);
  builtin_uniforms.correct_gamma = g_ActiveConfig.color_correction.bCorrectGamma;
  builtin_uniforms.game_gamma = g_ActiveConfig.color_correction.fGameGamma;
  builtin_uniforms.sdr_display_gamma_sRGB = g_ActiveConfig.color_correction.bSDRDisplayGammaSRGB;
  builtin_uniforms.sdr_display_custom_gamma =
      g_ActiveConfig.color_correction.fSDRDisplayCustomGamma;
  // scRGB (RGBA16F) expects linear values as opposed to sRGB gamma
  builtin_uniforms.linear_space_output = m_framebuffer_format == AbstractTextureFormat::RGBA16F;
  // Implies ouput values can be beyond the 0-1 range
  builtin_uniforms.hdr_output = m_framebuffer_format == AbstractTextureFormat::RGBA16F;
  builtin_uniforms.hdr_paper_white_nits = g_ActiveConfig.color_correction.fHDRPaperWhiteNits;
  // A value of 1 1 1 usually matches 80 nits in HDR
  builtin_uniforms.hdr_sdr_white_nits = 80.f;

  std::memcpy(buffer, &builtin_uniforms, sizeof(builtin_uniforms));
  buffer += sizeof(builtin_uniforms);

  // Don't include the custom pp shader options if they are not necessary,
  // having mismatching uniforms between different shaders can cause issues on some backends
  if (!user_post_process)
    return;

  for (auto& it : m_config.GetOptions())
  {
    union
    {
      u32 as_bool[4];
      s32 as_int[4];
      float as_float[4];
    } value = {};

    switch (it.second.m_type)
    {
    case PostProcessingConfiguration::ConfigurationOption::OptionType::Bool:
      value.as_bool[0] = it.second.m_bool_value ? 1 : 0;
      break;

    case PostProcessingConfiguration::ConfigurationOption::OptionType::Integer:
      ASSERT(it.second.m_integer_values.size() <= 4);
      std::copy_n(it.second.m_integer_values.begin(), it.second.m_integer_values.size(),
                  value.as_int);
      break;

    case PostProcessingConfiguration::ConfigurationOption::OptionType::Float:
      ASSERT(it.second.m_float_values.size() <= 4);
      std::copy_n(it.second.m_float_values.begin(), it.second.m_float_values.size(),
                  value.as_float);
      break;
    }

    it.second.m_dirty = false;

    std::memcpy(buffer, &value, sizeof(value));
    buffer += sizeof(value);
  }

  m_config.SetDirty(false);
}

bool PostProcessing::CompilePixelShader()
{
  m_default_pixel_shader.reset();
  m_pixel_shader.reset();

  // Generate GLSL and compile the new shaders:

  std::string default_pixel_shader_code;
  if (LoadShaderFromFile(s_default_pixel_shader_name, "", default_pixel_shader_code))
  {
    m_default_pixel_shader = g_gfx->CreateShaderFromSource(
        ShaderStage::Pixel, GetHeader(false) + default_pixel_shader_code + GetFooter(),
        "Default post-processing pixel shader");
    // We continue even if all of this failed, it doesn't matter
    m_default_uniform_staging_buffer.resize(CalculateUniformsSize(false));
  }
  else
  {
    m_default_uniform_staging_buffer.resize(0);
  }

  m_config.LoadShader(g_ActiveConfig.sPostProcessingShader);
  m_pixel_shader = g_gfx->CreateShaderFromSource(
      ShaderStage::Pixel, GetHeader(true) + m_config.GetShaderCode() + GetFooter(),
      fmt::format("User post-processing pixel shader: {}", m_config.GetShader()));
  if (!m_pixel_shader)
  {
    PanicAlertFmt("Failed to compile user post-processing shader {}", m_config.GetShader());

    // Use default shader.
    m_config.LoadDefaultShader();
    m_pixel_shader = g_gfx->CreateShaderFromSource(
        ShaderStage::Pixel, GetHeader(true) + m_config.GetShaderCode() + GetFooter(),
        "Default user post-processing pixel shader");
    if (!m_pixel_shader)
    {
      m_uniform_staging_buffer.resize(0);
      return false;
    }
  }

  m_uniform_staging_buffer.resize(CalculateUniformsSize(true));
  return true;
}

static bool UseGeometryShaderForPostProcess(bool is_intermediary_buffer)
{
  // We only return true on stereo modes that need to copy
  // both source texture layers into the target texture layers.
  // Any other case is handled manually with multiple copies, thus
  // it doesn't need a geom shader.
  switch (g_ActiveConfig.stereo_mode)
  {
  case StereoMode::QuadBuffer:
    return !g_ActiveConfig.backend_info.bUsesExplictQuadBuffering;
  case StereoMode::Anaglyph:
  case StereoMode::Passive:
    return is_intermediary_buffer;
  case StereoMode::SBS:
  case StereoMode::TAB:
  case StereoMode::Off:
  default:
    return false;
  }
}

bool PostProcessing::CompilePipeline()
{
  // Not needed. Some backends don't like making pipelines with no targets,
  // and in any case, we don't need to render anything if that happened.
  if (m_framebuffer_format == AbstractTextureFormat::Undefined)
    return true;

  // If this is true, the "m_default_pipeline" won't be the only one that runs
  const bool needs_intermediary_buffer = NeedsIntermediaryBuffer();

  AbstractPipelineConfig config = {};
  config.vertex_shader = m_default_vertex_shader.get();
  // This geometry shader will take care of reading both layer 0 and 1 on the source texture,
  // and writing to both layer 0 and 1 on the render target.
  config.geometry_shader = UseGeometryShaderForPostProcess(needs_intermediary_buffer) ?
                               g_shader_cache->GetTexcoordGeometryShader() :
                               nullptr;
  config.pixel_shader = m_default_pixel_shader.get();
  config.rasterization_state = RenderState::GetNoCullRasterizationState(PrimitiveType::Triangles);
  config.depth_state = RenderState::GetNoDepthTestingDepthState();
  config.blending_state = RenderState::GetNoBlendingBlendState();
  config.framebuffer_state = RenderState::GetColorFramebufferState(
      needs_intermediary_buffer ? s_intermediary_buffer_format : m_framebuffer_format);
  config.usage = AbstractPipelineUsage::Utility;
  // We continue even if it failed, it will be skipped later on
  if (config.pixel_shader)
    m_default_pipeline = g_gfx->CreatePipeline(config);

  config.vertex_shader = m_vertex_shader.get();
  config.geometry_shader = UseGeometryShaderForPostProcess(false) ?
                               g_shader_cache->GetTexcoordGeometryShader() :
                               nullptr;
  config.pixel_shader = m_pixel_shader.get();
  config.framebuffer_state = RenderState::GetColorFramebufferState(m_framebuffer_format);
  m_pipeline = g_gfx->CreatePipeline(config);
  if (!m_pipeline)
    return false;

  return true;
}
}  // namespace VideoCommon
