ArrayToTexture.hpp

#pragma once
 
#include <ossia/detail/pod_vector.hpp>
 
#include <boost/container/vector.hpp>
 
#include <halp/controls.hpp>
#include <halp/geometry.hpp>
#include <halp/meta.hpp>
#include <halp/texture.hpp>
 
#include <algorithm>
 
#if (!defined(__linux__) && !defined(_MSC_VER))
#define SCORE_LIBC_HAS_FLOAT16 1
#elif (defined(__linux__) && defined(__GLIBC__))
#if __GLIBC_PREREQ(2, 40)
#define SCORE_LIBC_HAS_FLOAT16 1
#endif
#endif
 
// when you enter the least obvious syntax competition and your opponent is clang builtins
#if defined(__is_identifier) && !defined(_MSC_VER)
#if (!__is_identifier(_Float16))
#define SCORE_COMPILER_HAS_FLOAT16 1
#endif
#endif
 
namespace Threedim
{
class ArrayToTexture
{
public:
  halp_meta(name, "Array to texture")
  halp_meta(category, "Visuals/Textures")
  halp_meta(c_name, "array_to_texture")
  halp_meta(manual_url, "https://ossia.io/score-docs/processes/array-to-texture.html")
  halp_meta(uuid, "bb5dc513-3430-4671-8c74-2bba78e53709")
 
  struct ins
  {
    struct : halp::val_port<"Input", std::vector<float>>
    {
      void update(ArrayToTexture& self) { self.recreate(); }
    } in;
    struct : halp::xy_spinboxes_i32<"Size">
    {
      void update(ArrayToTexture& self) { self.recreate(); }
    } size;
    struct : halp::enum_t<halp::custom_texture::texture_format, "Format">
    {
      void update(ArrayToTexture& self) { self.recreate(); }
    } format;
  } inputs;
 
  struct
  {
    halp::texture_output<"Output", halp::custom_texture> main;
  } outputs;
 
  void recreate()
  {
    const auto format = inputs.format;
    const auto sz = inputs.size.value;
    outputs.main.texture.request_format = format;
    outputs.main.create(sz.x, sz.y);
    std::size_t to_copy = sz.x * sz.y * outputs.main.texture.components(format);
    const auto& value = inputs.in.value;
    to_copy = std::min(to_copy, value.size());
 
    auto* out = outputs.main.texture.bytes;
    using enum halp::custom_texture::texture_format;
    switch(format)
    {
      case RGBA8:
      case BGRA8:
      case R8:
      case RG8:
      case RED_OR_ALPHA8:
      case R8UI:
        std::copy_n(value.data(), to_copy, (uint8_t*)out);
        break;
 
      case R16:
      case RG16:
        std::copy_n(value.data(), to_copy, (uint16_t*)out);
        break;
 
      case R32UI:
      case RG32UI:
      case RGBA32UI:
        std::copy_n(value.data(), to_copy, (uint32_t*)out);
        break;
 
      case R32F:
      case RGBA32F:
        std::copy_n(value.data(), to_copy, (float*)out);
        break;
 
      case R16F:
      case RGBA16F:
 
#if (SCORE_LIBC_HAS_FLOAT16 && SCORE_COMPILER_HAS_FLOAT16)
        std::copy_n(value.data(), to_copy, (_Float16*)out);
#endif
        break;
 
      default:
        break;
    }
    outputs.main.upload();
  }
};
 
}