CaptureAdjust.hpp

Go to the documentation of this file.

#pragma once
 
#include <Gfx/Graph/Scale.hpp>
 
#include <algorithm>
#include <atomic>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <mutex>
 
namespace score::gfx
{
 
struct CaptureAdjust
{
  float blackLevel[3]{0.f, 0.f, 0.f};
 
  float whiteBalance[3]{1.f, 1.f, 1.f};
 
  float exposure{1.f};
 
  float gamma{1.f};
 
  float saturation{1.f};
 
  ScaleMode scaleMode{ScaleMode::Stretch};
 
  friend bool operator==(const CaptureAdjust&, const CaptureAdjust&) noexcept
      = default;
};
 
class CaptureAdjustSlot
{
public:
  void set(const CaptureAdjust& v)
  {
    {
      std::lock_guard lk{m_mutex};
      if(m_value == v)
        return;
      m_value = v;
    }
    m_generation.fetch_add(1, std::memory_order_release);
  }
 
  bool poll(CaptureAdjust& out, std::uint32_t& lastSeen) const
  {
    const auto gen = m_generation.load(std::memory_order_acquire);
    if(gen == lastSeen)
      return false;
    {
      std::lock_guard lk{m_mutex};
      out = m_value;
    }
    lastSeen = gen;
    return true;
  }
 
  CaptureAdjust value() const
  {
    std::lock_guard lk{m_mutex};
    return m_value;
  }
 
  std::uint32_t generation() const noexcept
  {
    return m_generation.load(std::memory_order_acquire);
  }
 
private:
  mutable std::mutex m_mutex;
  CaptureAdjust m_value;
  std::atomic<std::uint32_t> m_generation{0};
};
 
#pragma pack(push, 1)
struct CaptureMaterialUBO
{
  float scale[2]{1.f, 1.f};
  float textureSize[2]{1.f, 1.f};
  float blackLevel[4]{0.f, 0.f, 0.f, 0.f};
  float whiteBalance[4]{1.f, 1.f, 1.f, 0.f};
  float params[4]{1.f, 1.f, 1.f, 0.f};
};
#pragma pack(pop)
 
static_assert(sizeof(CaptureMaterialUBO) == 64);
static_assert(offsetof(CaptureMaterialUBO, blackLevel) == 16);
static_assert(offsetof(CaptureMaterialUBO, whiteBalance) == 32);
static_assert(offsetof(CaptureMaterialUBO, params) == 48);
 
inline void applyTo(const CaptureAdjust& a, CaptureMaterialUBO& ubo) noexcept
{
  for(int i = 0; i < 3; ++i)
  {
    ubo.blackLevel[i] = a.blackLevel[i];
    ubo.whiteBalance[i] = a.whiteBalance[i];
  }
  ubo.params[0] = a.exposure;
  ubo.params[1] = a.gamma;
  ubo.params[2] = a.saturation;
}
 
inline void adjustCaptureReference(const CaptureAdjust& a, float rgb[3]) noexcept
{
  constexpr float eps = 1.f / 65535.f;
 
  for(int i = 0; i < 3; ++i)
  {
    const float bl = a.blackLevel[i];
    float c = (rgb[i] - bl) / std::max(eps, 1.f - bl);
    c *= a.whiteBalance[i];
    c *= a.exposure;
    rgb[i] = std::max(0.f, c);
  }
 
  const float l
      = 0.2126f * rgb[0] + 0.7152f * rgb[1] + 0.0722f * rgb[2];
  for(int i = 0; i < 3; ++i)
    rgb[i] = std::max(0.f, l + (rgb[i] - l) * a.saturation);
 
  const float inv = 1.f / std::max(a.gamma, eps);
  for(int i = 0; i < 3; ++i)
    rgb[i] = std::clamp(std::pow(rgb[i], inv), 0.f, 1.f);
}
 
} // namespace score::gfx