TextureGenerator.cpp

#include "TextureGenerator.h"
 
#include <unordered_map>
#include <numbers>
#include <glm/glm.hpp>
#include <glm/gtc/constants.hpp>
 
#include "Foundation/Platform/Threads.h"
 
#include "Resources/TextureManager.h"
#include "Utilities/NoiseSampler.h"
 
#include "Context.h"
 
namespace
{
  using namespace Cogs::Core;
  
  struct half4
  {
    glm::detail::hdata r, g, b, a;
  };
 
 
#if 0
  glm::vec3 inverseSphereGeoTexMapping(float u, float v)
  {
    glm::vec3 dir;
    dir.z = -std::cos(glm::pi<float>() * v);
    float t = 1.f / std::sqrt(1.f - dir.z*dir.z);
    dir.y = std::cos(2.f*glm::pi<float>()* u) / t;
    dir.x = (u < 0.5 ? 1 : -1.f)* std::sqrt(1.f - dir.z*dir.z - dir.y*dir.y);
 
    return dir;
  }
#endif
 
  glm::mat3 cubeMapPermutationMatrix(size_t f)
  {
    glm::mat3 R;
 
    switch (f)
    {
    case 0:
      //d = glm::vec3(1.f, V, -U); break;
      R = glm::mat3(0.f, 0.f, -1.f,
                    0.f, 1.f, 0.f,
                    1.f, 0.f, 0.f);
      break;
    case 1:
      //d = glm::vec3(-1.f, V, U); break;
      R = glm::mat3(0.f, 0.f, 1.f,
                    0.f, 1.f, 0.f,
                    -1.f, 0.f, 0.f);
      break;
    case 2:
      //d = glm::vec3(U, 1.f, -V); break;
      R = glm::mat3(1.f, 0.f, 0.f,
                    0.f, 0.f, -1.f,
                    0.f, 1.f, 0.f);
      break;
    case 3:
      //d = glm::vec3(U, -1.f, V); break;
      R = glm::mat3(1.f, 0.f, 0.f,
                    0.f, 0.f, 1.f,
                    0.f, -1.f, 0.f);
      break;
    case 4:
      // d = glm::vec3(U, V, 1.f); break;
      R = glm::mat3(1.f, 0.f, 0.f,
                    0.f, 1.f, 0.f,
                    0.f, 0.f, 1.f);
      break;
 
    default:
      //d = glm::vec3(-U, V, -1.f); break;
      R = glm::mat3(-1.f, 0.f, 0.f,
                    0.f, 1.f, 0.f,
                    0.f, 0.f, -1.f);
      break;
 
    }
    return R;
  }
 
  glm::vec3 cubeMapDir(float u, float v, size_t f)
  {
    glm::mat3 T(2.f, 0.f, 0.f,
                0.f, -2.f, 0.f,
                -1.f, 1.f, 1.f);
    return glm::normalize(cubeMapPermutationMatrix(f)*(T*glm::vec3(u, v, 1.f)));
  }
 
  template<typename Kernel, typename Collection, typename Element>
  struct Sampler
  {
    static void run(Collection& rgba, const Kernel& kernel, const size_t w, const size_t h, const size_t f);
  };
 
  template<typename Kernel, typename Collection>
  struct Sampler<Kernel, Collection, glm::u8vec4>
  {
    static void run(Collection& rgba, const Kernel& kernel, const size_t w, const size_t h, const size_t f)
    {
      for (size_t k = 0; k < f; k++) {
        for (size_t j = 0; j < h; j++) {
          for (size_t i = 0; i < w; i++) {
            const auto v = kernel(i, j, k);
            rgba[(k*h + j)*w + i].r = static_cast<uint8_t>(glm::clamp(255.f*v.r, 0.f, 255.f));
            rgba[(k*h + j)*w + i].g = static_cast<uint8_t>(glm::clamp(255.f*v.g, 0.f, 255.f));
            rgba[(k*h + j)*w + i].b = static_cast<uint8_t>(glm::clamp(255.f*v.b, 0.f, 255.f));
            rgba[(k*h + j)*w + i].a = static_cast<uint8_t>(glm::clamp(255.f*v.a, 0.f, 255.f));
          }
        }
      }
    }
  };
 
  template<typename Kernel, typename Collection>
  struct Sampler<Kernel, Collection, half4>
  {
    static void run(Collection& rgba, const Kernel& kernel, const size_t w, const size_t h, const size_t f)
    {
      for (size_t k = 0; k < f; k++) {
        for (size_t j = 0; j < h; j++) {
          for (size_t i = 0; i < w; i++) {
            const auto v = kernel(i, j, k);
            rgba[(k*h + j)*w + i].r = glm::detail::toFloat16(v.r);
            rgba[(k*h + j)*w + i].g = glm::detail::toFloat16(v.g);
            rgba[(k*h + j)*w + i].b = glm::detail::toFloat16(v.b);
            rgba[(k*h + j)*w + i].a = glm::detail::toFloat16(v.a);
          }
        }
      }
    }
  };
 
  template<typename Kernel, typename Collection>
  struct Sampler<Kernel, Collection, glm::vec4>
  {
    static void run(Collection& rgba, const Kernel& kernel, const size_t w, const size_t h, const size_t f)
    {
      for (size_t k = 0; k < f; k++) {
        for (size_t j = 0; j < h; j++) {
          for (size_t i = 0; i < w; i++) {
            const auto v = kernel(i, j, k);
            rgba[(k*h + j)*w + i].r = v.r;
            rgba[(k*h + j)*w + i].g = v.g;
            rgba[(k*h + j)*w + i].b = v.b;
            rgba[(k*h + j)*w + i].a = v.a;
          }
        }
      }
    }
  };
 
  // x,y [-1,1]
  //
  // Differential area cubemap voxel at x,y is 1/(x^2 + y^2 + 1)^{3/2}.
  //
  // We integrate this from [0,0] to [s,t],
  //
  // f(x,y) = \int_y=0^t \int_x=0^s 1/(x^2 + y^2 + 1)^{3/2} dx dy
  //        = tan^{-1}(st/sqrt(s^2 + t^2 + 1).
  //
  // If A, B, C, and D are corners of the texel, we get
  //
  // solidAngle = f(A)-F(B)+f(C)-f(D).
  //
  // See http://www.rorydriscoll.com/2012/01/15/cubemap-texel-solid-angle/ 
 
  float cubeTexelSolidAngle(float uMin, float uMax, float vMin, float vMax)
  {
    float fA = std::atan2(uMin * vMin, std::sqrt(uMin * uMin + vMin * vMin + 1));
    float fB = std::atan2(uMax * vMin, std::sqrt(uMax * uMax + vMin * vMin + 1));
    float fC = std::atan2(uMax * vMax, std::sqrt(uMax * uMax + vMax * vMax + 1));
    float fD = std::atan2(uMin * vMax, std::sqrt(uMin * uMin + vMax * vMax + 1));
    return fA - fB + fC - fD;
  }
 
  void calcIrradiance(Cogs::Memory::TypedBuffer<half4>& dst, const Cogs::Memory::TypedBuffer<glm::vec4>& radiance, const size_t W, const size_t H)
  {
    for (size_t k1 = 0; k1 < 6; k1++) {
      glm::mat3 P1 = cubeMapPermutationMatrix(k1)*glm::mat3(2.f / W, 0.f, 0.f,
                                                            0.f, -2.f / H, 0.f,
                                                            -(1.f - 1.f / W), 1.f - 1.f / H, 1.f);
      for (size_t j1 = 0; j1 < H; j1++) {
        for (size_t i1 = 0; i1 < W; i1++) {
          auto d1 = glm::normalize(P1*glm::vec3(i1, j1, 1.f));
 
          glm::vec3 irradiance;
          for (size_t k0 = 0; k0 < 6; k0++) {
            glm::mat3 P0 = cubeMapPermutationMatrix(k0)*glm::mat3(2.f / W, 0.f, 0.f,
                                                                  0.f, -2.f / H, 0.f,
                                                                  -(1.f - 1.f / W), 1.f - 1.f / H, 1.f);
            for (size_t j0 = 0; j0 < H; j0++) {
              for (size_t i0 = 0; i0 < W; i0++) {
                auto d0 = glm::normalize(P0*glm::vec3(i0, j0, 1.f));
                if (0.f < glm::dot(d0, d1)) {
 
                  float uMin = 2.f*(i0 + 0.f) / W - 1.f;
                  float uMax = 2.f*(i0 + 1.f) / W - 1.f;
                  float vMin = 2.f*(j0 + 0.f) / H - 1.f;
                  float vMax = 2.f*(j0 + 1.f) / H - 1.f;
                  float w = cubeTexelSolidAngle(uMin, uMax, vMin, vMax);
 
                  irradiance += w * glm::vec3(radiance[(k0*H + j0)*W + i0]);
                }
              }
            }
          }
 
          //irradiance = /*0.000001f */ irradiance;
          dst[(k1*H + j1)*W + i1].r = glm::detail::toFloat16(irradiance.r);
          dst[(k1*H + j1)*W + i1].g = glm::detail::toFloat16(irradiance.g);
          dst[(k1*H + j1)*W + i1].b = glm::detail::toFloat16(irradiance.b);
          dst[(k1*H + j1)*W + i1].a = glm::detail::toFloat16(1.f);
        }
      }
    }
  }
 
  template<typename T>
  void sampleSkyLuminance(Cogs::Memory::TypedBuffer<T>& rgba, const ImageDefinition & definition, const size_t w, const size_t h, bool lightBottom, bool withSky, bool withSun)
  {
    // Found some numbers where that direct sunlight at zenith gave 1050 W/m^2 irradiance, and 1120 W/m^2
    // with indirect included, i.e., 70 W/m^2:
    float indirectDirectRatio = 70.f / 1050.f;
 
    // Assuming the irradiance is uniform over the hemisphere, and using Lambert's cosine law:
    // integral_(-pi) ^ (pi)integral_(0) ^ (pi / 2) cos(x) sin(x) dxdy = pi
    // I.e., irradiance = pi radiance
    constexpr float radianceIrradianceRatio = 1.f / std::numbers::pi_v<float>;
 
    // We're in the space that cubemaps tend to be in:
    //
    // +X is to the right (cogs +X).
    // +Y is up (cogs +Z)
    // +Z is forward (cogs +Y)
    const auto& s = definition.sunDirection;
    const glm::vec3 sunDir = glm::normalize(glm::vec3(s.x, s.z, s.y));
    const glm::vec3 up = normalize(glm::vec3(0, 1, 0));
 
    auto sunIrradiance = definition.sunIrradiance;
    auto sunRadiance = radianceIrradianceRatio * indirectDirectRatio*glm::length(sunIrradiance);
    auto sunCol = (1.f / (std::max(std::max(sunIrradiance.r, sunIrradiance.g), sunIrradiance.b)))*sunIrradiance;
 
    auto kernel = [&sunDir, sunRadiance, &sunCol, lightBottom, withSky, withSun, &up, w, h](size_t i, size_t j, size_t k) {
      auto sampleDir = cubeMapDir(float(i + 0.5f) / float(w), float(j + 0.5f) / float(h), k);
      //float pi = 3.14159265;
      //float pi2 = 0.5*3.14159265;
      //  float3 sun = normalize(-positions[0].xyz);
      //  float3 up = normalize(float3(viewMatrix._m20_m21_m22));
 
 
      float zeta_cos = std::max(0.f, glm::dot(sunDir, sampleDir));
      float zeta = std::acos(zeta_cos);
      float gamma_sin = std::max(0.f, dot(sampleDir, up));
      float gamma_s_sin = std::max(0.f, dot(sunDir, up));
 
      float pi2_zeta_s = glm::half_pi<float>() - std::asin(gamma_s_sin);
      float pi2_zeta_s_cos = std::cos(pi2_zeta_s);
 
      float phi_gamma = 1.f - std::exp(-0.32f / gamma_sin); // horizon whiteness
 
      float f_zeta = 0.91f + 19.f * std::exp(-3.f * zeta) + 0.45f*zeta_cos*zeta_cos; // Sun bloom
 
      float f_pi2_zeta_s = 0.91f + 19 * std::exp(-3.f * pi2_zeta_s) + 0.45f*pi2_zeta_s_cos*pi2_zeta_s_cos;
      float phi_pi2 = 0.27385f;
 
      // Eq 3.1 of CIE spatial Distribution of Daylight, relative of clear sky luminance of zenith.
      float clear = (phi_gamma*f_zeta) / (phi_pi2* f_pi2_zeta_s);
 
      glm::vec3 rv;
      if (withSky) {
        rv = glm::mix(glm::vec3(0.f, 0.1f, 0.3f), sunCol, 0.1f*std::max(0.f, clear - 0.5f));
      }
 
      if (withSun) {
        rv += 20.f*std::pow(zeta_cos, 100.f)*sunCol;
      }
 
      if (!lightBottom && glm::dot(sampleDir, up) < 0.f) {
        rv = glm::mix(rv, glm::vec3(0, 0, 0.0), glm::clamp(-3 * glm::dot(sampleDir, up), 0.f, 1.f));
      }
      return glm::vec4(sunRadiance*rv, 1.f);
    };
    rgba.resize(w * h * 6);
    Sampler<decltype(kernel), decltype(rgba), T>::run(rgba, kernel, w, h, 6);
  }
 
  template<typename T>
  void sampleSubseaLuminance(Cogs::Memory::TypedBuffer<T>& rgba, const ImageDefinition & definition, const size_t w, const size_t h, bool /*lightBottom*/ = true)
  {
    const auto& s = definition.sunDirection;
    const glm::vec3 sunDir = glm::normalize(glm::vec3(s.x, s.z, s.y));
    auto sunRadiance = glm::length(definition.sunIrradiance);
 
    auto kernel = [&sunDir, sunRadiance, w, h](size_t i, size_t j, size_t k) {
      auto sampleDir = cubeMapDir(float(i + 0.5f) / float(w), float(j + 0.5f) / float(h), k);
 
      const glm::vec3 seaColor(0.1f, 0.7f, 1.f);
 
      float t = std::pow(1.f - (1.f / glm::pi<float>())*std::acos(glm::dot(sampleDir, sunDir)), 3.f);
 
      return glm::vec4(1e-3f*seaColor*sunRadiance*t, 1.f);
    };
    rgba.resize(w * h * 6);
    Sampler<decltype(kernel), decltype(rgba), T>::run(rgba, kernel, w, h, 6);
  }
 
  template<typename T>
  void sampleSkyCube(Cogs::Memory::TypedBuffer<T>& rgba, const ImageDefinition & /*definition*/, const size_t w, const size_t h)
  {
    auto kernel = [w, h](size_t i, size_t j, size_t k) {
      auto dir = cubeMapDir(float(i) / float(w), float(j) / float(h), k);
      float z = 0.5f*(dir.z + 1.f);
 
      const glm::vec3 waterColor(0.f, 0.2, 0.3);
      const glm::vec3 skyColorHorizon(0.3, 0.4, 0.5);
      const glm::vec3 skyColorZenith(0.8, 0.9, 1.0);
      glm::vec3 c;
      if (z < 0.45f) {
        c = glm::mix(waterColor, skyColorHorizon, 2.f*z);
      }
      else {
        c = 1.5f*glm::mix(skyColorHorizon, skyColorZenith, 2.f*(z - 0.5f));
      }
      return glm::vec4(c, 1.f);
    };
 
    rgba.resize(w * h * 6);
    Sampler<decltype(kernel), decltype(rgba), T>::run(rgba, kernel, w, h, 6);
  }
 
  template<typename Collection>
  void sampleSky(Collection & rgba, size_t w, size_t h)
  {
    glm::vec3 waterColor(0.f, 0.2, 0.3);
    glm::vec3 skyColorHorizon(0.3, 0.4, 0.5);
    glm::vec3 skyColorZenith(0.8, 0.9, 1.0);
 
    for (size_t j = 0; j < h; j++) {
      for (size_t i = 0; i < w; i++) {
        float z = float(j) / float(h);
        glm::vec3 c;
        if (z < 0.45f) {
          c = glm::mix(waterColor, skyColorHorizon, 2.f*z);
        }
        else {
          c = 1.5f*glm::mix(skyColorHorizon, skyColorZenith, 2.f*(z - 0.5f));
        }
 
        rgba[4 * (w*j + i) + 0] = static_cast<uint8_t>(255.f*glm::clamp(c.r, 0.f, 1.f));
        rgba[4 * (w*j + i) + 1] = static_cast<uint8_t>(255.f*glm::clamp(c.g, 0.f, 1.f));
        rgba[4 * (w*j + i) + 2] = static_cast<uint8_t>(255.f*glm::clamp(c.b, 0.f, 1.f));
        rgba[4 * (w*j + i) + 3] = 255;
      }
    }
  }
 
  void factory(Texture * texture, const ImageDefinition & definition)
  {
    const size_t w = std::max(1u, definition.width);
    const size_t h = std::max(1u, definition.height);
    const size_t l = std::max(1u, definition.layers);
    switch (definition.type) {
    case ImageType::CheckerBoard:
    {
      auto kernel = [](size_t i, size_t j, size_t /*k*/) {
        bool t = ((i / 16 + j / 16) & 0x1) == 1;
        return glm::vec4(1.f, 1.f, t ? 0.5f : 1.f, 1.f);
      };
      auto rgba = texture->map<glm::u8vec4>((uint16_t)w, (uint16_t)h, Cogs::TextureFormat::R8G8B8A8_UNORM_SRGB, true);
      Sampler<decltype(kernel), decltype(rgba), glm::u8vec4>::run(rgba, kernel, w, h, 1);
      break;
    }
 
    case ImageType::ColorfulCheckerBoard:
    {
      auto kernel = [A = 1.f / w, B = 1.f / h, C = 1.f / l, l](size_t i, size_t j, size_t k) {
        bool t = ((i / 16 + j / 16) & 0x1) == 1;
        return glm::vec4(t ? A * i : 1.f, t ? B * j : 1.f, t ? 0.f : C * (float(l - k)), 1.f);
      };
      Cogs::Memory::TypedBuffer<glm::u8vec4> rgba(w * h * l);
      Sampler<decltype(kernel), decltype(rgba), glm::u8vec4>::run(rgba, kernel, w, h, l);
      if (2 <= l) {
        texture->setData(Cogs::ResourceDimensions::Texture2DArray, rgba.data(), rgba.byteSize(), (uint32_t)w, (uint32_t)h, 1, uint32_t(l), 1, 1, Cogs::TextureFormat::R8G8B8A8_UNORM_SRGB, true);
      }
      else {
        texture->setData(Cogs::ResourceDimensions::Texture2D, rgba.data(), rgba.byteSize(), (uint32_t)w, (uint32_t)h, 1, uint32_t(l), 1, 1, Cogs::TextureFormat::R8G8B8A8_UNORM_SRGB, true);
      }
      break;
    }
 
    case ImageType::Dirt:
    {
      std::vector<float> noise(w*h);
      NoiseSampler noiseSampler;
      noiseSampler.gradNoise2DTurbulence(noise.data(), 16.0f, 256.f, (int)w, (int)h);
      auto kernel = [&noise, w, h](size_t i, size_t j, size_t /*k*/) {
        float n0 = 0.5f + 0.5f*noise[w*j + i];
        float n1 = 0.5f + 0.5f*noise[w*((2 * j + 15) % h) + ((2 * i + 44) % w)];
        return glm::vec4(0.3f + 0.20f*n0 + 0.15f*n1,
                         0.2f + 0.15f*n0 + 0.20f*n1,
                         0.1f + 0.05f*n0 + 0.15f*n1,
                         1.f);
      };
      auto rgba = texture->map<glm::u8vec4>((uint16_t)w, (uint16_t)h, Cogs::TextureFormat::R8G8B8A8_UNORM_SRGB, true);
      Sampler<decltype(kernel), decltype(rgba), glm::u8vec4>::run(rgba, kernel, w, h, 1);
      break;
    }
    break;
 
    case ImageType::Steel:
    {
      std::vector<float> noise(w*h);
      NoiseSampler noiseSampler;
      noiseSampler.gradNoise2DTurbulence(noise.data(), 16.0f, 64.f, (int)w, (int)h);
      auto kernel = [&noise, w, h](size_t i, size_t j, size_t /*k*/) {
        float n0 = 0.5f + 0.5f*noise[w*((j) % h) + (8 * i) % w];
        float n1 = 0.5f + 0.5f*noise[w*((j + 0) % h) + ((i) % w)];
        return glm::vec4(0.5f + 0.10f*n0 + 0.07f*n1,
                         0.5f + 0.10f*n0 + 0.06f*n1,
                         0.5f + 0.13f*n0 + 0.05f*n1,
                         1.f);
      };
      auto rgba = texture->map<glm::u8vec4>((uint16_t)w, (uint16_t)h, Cogs::TextureFormat::R8G8B8A8_UNORM_SRGB, true);
      Sampler<decltype(kernel), decltype(rgba), glm::u8vec4>::run(rgba, kernel, w, h, 1);
      break;
    }
    break;
 
    case ImageType::ColorCube:
    {
      auto kernel = [w, h](size_t i, size_t j, size_t k) {
        float U = (2.f*i) / w - 1.f;
        float V = 1.f - (2.f * j) / h;
 
 
        glm::vec3 d = cubeMapPermutationMatrix(k)*(glm::vec3(U, V, 1.f));
 
        float m = (((i / 64) + (j / 64)) & 1) ? 1.f : 0.5f;
        return glm::vec4(m, m, m, 1)*glm::vec4(0.5f*d + glm::vec3(0.5f), 1.f);
      };
      Cogs::Memory::TypedBuffer<glm::u8vec4> rgba(w * h * 6);
      Sampler<decltype(kernel), decltype(rgba), glm::u8vec4>::run(rgba, kernel, w, h, 6);
      texture->setData(Cogs::ResourceDimensions::TextureCube, rgba.data(), rgba.byteSize(), (uint32_t)w, (uint32_t)h, 1, 1, 6, 1, Cogs::TextureFormat::R8G8B8A8_UNORM_SRGB, true);
      break;
    }
 
    case ImageType::Sky:
    {
      auto rgb = texture->map((uint16_t)w, (uint16_t)h, Cogs::TextureFormat::R8G8B8A8_UNORM_SRGB, true);
      sampleSky(rgb, w, h);
    }
    break;
 
    case ImageType::SkyCube:
    {
      if (!std::isfinite(definition.sunDirection.x) ||
          !std::isfinite(definition.sunDirection.y) ||
          !std::isfinite(definition.sunDirection.z))
      {
        auto newDefininition = definition;
        newDefininition.type = ImageType::ColorCube;
        return factory(texture, newDefininition);
      }
 
      if (definition.hdr) {
        Cogs::Memory::TypedBuffer<half4> rgba(w * h * 6);
        sampleSkyLuminance(rgba, definition, w, h, false, true, true);
        texture->setData(Cogs::ResourceDimensions::TextureCube, rgba.data(), rgba.byteSize(), static_cast<uint32_t>(w), static_cast<uint32_t>(h), 1, 1, 6, 1, Cogs::TextureFormat::R16G16B16A16_FLOAT, true);
      }
      else {
        Cogs::Memory::TypedBuffer<glm::u8vec4> rgba(w * h * 6);
        sampleSkyCube(rgba, definition, w, h);
        texture->setData(Cogs::ResourceDimensions::TextureCube, rgba.data(), rgba.byteSize(), static_cast<uint32_t>(w), static_cast<uint32_t>(h), 1, 1, 6, 1, Cogs::TextureFormat::R8G8B8A8_UNORM_SRGB, true);
      }
      break;
    }
 
    case ImageType::SkyRadiance:
    {
      if (!std::isfinite(definition.sunDirection.x) ||
          !std::isfinite(definition.sunDirection.y) ||
          !std::isfinite(definition.sunDirection.z))
      {
        auto newDefininition = definition;
        newDefininition.type = ImageType::ColorCube;
        return factory(texture, newDefininition);
      }
      size_t W = std::min((size_t)128, w);
      size_t H = std::min((size_t)128, h);
 
      Cogs::Memory::TypedBuffer<half4> rgba(W * H * 6);
      sampleSkyLuminance(rgba, definition, W, H, true, true, true);
      texture->setData(Cogs::ResourceDimensions::TextureCube, rgba.data(), rgba.byteSize(), static_cast<uint32_t>(W), static_cast<uint32_t>(H), 1, 1, 6, 1, Cogs::TextureFormat::R16G16B16A16_FLOAT, true);
      break;
    }
 
    case ImageType::SkyIrradiance:
    {
      if (!std::isfinite(definition.sunDirection.x) ||
          !std::isfinite(definition.sunDirection.y) ||
          !std::isfinite(definition.sunDirection.z))
      {
        auto newDefininition = definition;
        newDefininition.type = ImageType::ColorCube;
        return factory(texture, newDefininition);
      }
      size_t W = std::min((size_t)8, w);
      size_t H = std::min((size_t)8, h);
 
      Cogs::Memory::TypedBuffer<glm::vec4> radiance(W * H * 6);
      Cogs::Memory::TypedBuffer<half4> rgba(W * H * 6);
 
      sampleSkyLuminance(radiance, definition, W, H, true, false, true);
      calcIrradiance(rgba, radiance, W, H);
      texture->setData(Cogs::ResourceDimensions::TextureCube, rgba.data(), rgba.byteSize(), static_cast<uint32_t>(W), static_cast<uint32_t>(H), 1, 1, 6, 1, Cogs::TextureFormat::R16G16B16A16_FLOAT, true);
      break;
    }
 
    case ImageType::SkyAmbientIrradiance:
    {
      if(!std::isfinite(definition.sunDirection.x) ||
        !std::isfinite(definition.sunDirection.y) ||
        !std::isfinite(definition.sunDirection.z))
      {
        auto newDefininition = definition;
        newDefininition.type = ImageType::ColorCube;
        return factory(texture, newDefininition);
      }
      size_t W = std::min((size_t)8, w);
      size_t H = std::min((size_t)8, h);
 
      Cogs::Memory::TypedBuffer<glm::vec4> radiance(W * H * 6);
      Cogs::Memory::TypedBuffer<half4> rgba(W * H * 6);
 
      sampleSkyLuminance(radiance, definition, W, H, true, true, false);
      for (size_t i = 0; i < W*H*6; i++) {
        radiance[i] = glm::vec4(0.5f*glm::vec3(radiance[i]), 1);
      }
      calcIrradiance(rgba, radiance, W, H);
      texture->setData(Cogs::ResourceDimensions::TextureCube, rgba.data(), rgba.byteSize(), static_cast<uint32_t>(W), static_cast<uint32_t>(H), 1, 1, 6, 1, Cogs::TextureFormat::R16G16B16A16_FLOAT, true);
      break;
    }
 
 
    case ImageType::SubseaRadiance:
    {
      if (!std::isfinite(definition.sunDirection.x) ||
          !std::isfinite(definition.sunDirection.y) ||
          !std::isfinite(definition.sunDirection.z))
      {
        auto newDefininition = definition;
        newDefininition.type = ImageType::ColorCube;
        return factory(texture, newDefininition);
      }
      size_t W = std::min((size_t)32, w);
      size_t H = std::min((size_t)32, h);
 
      Cogs::Memory::TypedBuffer<half4> rgba(W * H * 6);
      sampleSubseaLuminance(rgba, definition, W, H);
      texture->setData(Cogs::ResourceDimensions::TextureCube, rgba.data(), rgba.byteSize(), static_cast<uint32_t>(W), static_cast<uint32_t>(H), 1, 1, 6, 1, Cogs::TextureFormat::R16G16B16A16_FLOAT, true);
      break;
    }
 
    case ImageType::GradientRainbow:
    {
      uint8_t rgba[8 * 4] = {
        0x9d, 0x00, 0xff, 0xff,
        0x00, 0x27, 0xff, 0xff,
        0x00, 0xc4, 0xff, 0xff,
        0x00, 0xff, 0x9d, 0xff,
        0x00, 0xff, 0x00, 0xff,
        0xc4, 0xff, 0x00, 0xff,
        0xff, 0x9d, 0x00, 0xff,
        0xff, 0x00, 0x00, 0xff,
      };
      texture->setData(Cogs::ResourceDimensions::Texture2D, rgba, sizeof(rgba), 8, 1, Cogs::TextureFormat::R8G8B8A8_UNORM_SRGB, true);
      break;
    }
    case ImageType::GradientHeat:
    {
      uint8_t rgba[8 * 4] = {
        0x1e, 0x00, 0x00, 0xff,
        0x55, 0x00, 0x00, 0xff,
        0xc3, 0x26, 0x0c, 0xff,
        0xf2, 0x74, 0x29, 0xff,
        0xfb, 0xc6, 0x21, 0xff,
        0xf8, 0xf1, 0x4c, 0xff,
        0xf9, 0xf5, 0xa8, 0xff,
        0xff, 0xff, 0xff, 0xff,
      };
      texture->setData(Cogs::ResourceDimensions::Texture2D, rgba, sizeof(rgba), 8, 1, Cogs::TextureFormat::R8G8B8A8_UNORM_SRGB, true);
      break;
    }
 
    default:
      break;
    }
  }
 
  ParsedValue * getValue(ParsedValue & p, const Cogs::StringView & key)
  {
    for (auto & v : p.values) {
      if (key == v.key) return &v;
    }
 
    return nullptr;
  }
 
  int getInt(ParsedValue * p, int defaultValue)
  {
    if (!p) return defaultValue;
 
    switch (p->type)
    {
    case ParsedDataType::UInt:
    case ParsedDataType::Int:
      return p->intValue;
      break;
    case ParsedDataType::Float:
      return static_cast<int>(p->floatValue);
    default:
      break;
    }
 
    return defaultValue;
  }
 
  uint32_t getUInt(ParsedValue * p, uint32_t defaultValue)
  {
    return static_cast<uint32_t>(getInt(p, static_cast<int>(defaultValue)));
  }
 
  bool getBool(ParsedValue * p, bool defaultValue)
  {
    return p != nullptr && p->type == ParsedDataType::Bool ? p->boolValue : defaultValue;
  }
 
  glm::vec3 getFloat3(ParsedValue * p, const glm::vec3& defaultValue)
  {
    return p != nullptr && p->type == ParsedDataType::Float3 ? p->float3Value : defaultValue;
  }
 
}
 
namespace Cogs::Core
{
  struct ImageCache
  {
    Mutex lock;
    std::unordered_map<size_t, TextureHandle> images;
  };
}
 
Cogs::Core::TextureGenerator::TextureGenerator(Context * context) :
  context(context),
  cache(std::make_unique<ImageCache>())
{
}
 
Cogs::Core::TextureGenerator::~TextureGenerator()
{
}
 
void Cogs::Core::TextureGenerator::cleanup()
{
  LockGuard cacheLock(cache->lock);
 
  cache->images.clear();
}
 
Cogs::Core::TextureHandle Cogs::Core::TextureGenerator::getTexture(ImageType type)
{
  return getTexture(type, ParsedValue());
}
 
Cogs::Core::TextureHandle Cogs::Core::TextureGenerator::getTexture(ImageType type, ParsedValue parameters)
{
  ImageDefinition definition = {
    .sunDirection = getFloat3(getValue(parameters, "sunDirection"), ImageDefinition().sunDirection),
    .sunIrradiance = getFloat3(getValue(parameters, "sunIrradiance"), ImageDefinition().sunIrradiance),
    .type = type,
    .width = getUInt(getValue(parameters, "width"), ImageDefinition().width),
    .height = getUInt(getValue(parameters, "height"), ImageDefinition().height),
    .layers = getUInt(getValue(parameters, "layers"), ImageDefinition().layers),
    .hdr = getBool(getValue(parameters, "hdr"), ImageDefinition().hdr)
  };
 
  size_t hashValue = definition.hash();
 
  {
    LockGuard cacheLock(cache->lock);
 
    auto found = cache->images.find(hashValue);
 
    if (found != cache->images.end()) {
      return found->second;
    }
  }
 
  auto texture = context->textureManager->create();
 
  factory(texture.resolve(), definition);
 
  LockGuard cacheLock(cache->lock);
 
  cache->images[hashValue] = texture;
 
  return texture;
}
 
void Cogs::Core::TextureGenerator::getTexture(Texture * texture, const ImageDefinition & definition)
{
  factory(texture, definition);
}