shader_setting.hpp

Go to the documentation of this file.

#ifndef GUIK_SHADER_SETTING_HPP
#define GUIK_SHADER_SETTING_HPP
 
#include <memory>
#include <optional>
#include <unordered_map>
 
#include <glk/drawable.hpp>
#include <glk/make_shared.hpp>
#include <guik/gl_canvas.hpp>
#include <guik/imgui_application.hpp>
 
namespace guik {
 
struct ColorMode {
  enum MODE { RAINBOW = 0, FLAT_COLOR = 1, VERTEX_COLOR = 2, TEXTURE_COLOR = 3, VERTEX_COLORMAP = 4 };
};
 
struct PointScaleMode {
  enum MODE { SCREENSPACE = 0, METRIC = 1 };
};
 
struct PointShapeMode {
  enum MODE { RECTANGLE = 0, CIRCLE = 1 };
};
 
enum class ShaderDataType { INT = 0, INT2, INT3, INT4, FLOAT, FLOAT2, FLOAT3, FLOAT4, MATRIX4, INT_ARRAY, FLOAT_ARRAY, INVALID };
 
template <typename T>
ShaderDataType deduce_data_type() {
  if constexpr (std::is_same<T, int>::value) {
    return ShaderDataType::INT;
  } else if constexpr (std::is_same<T, Eigen::Vector2i>::value) {
    return ShaderDataType::INT2;
  } else if constexpr (std::is_same<T, Eigen::Vector3i>::value) {
    return ShaderDataType::INT3;
  } else if constexpr (std::is_same<T, Eigen::Vector4i>::value) {
    return ShaderDataType::INT4;
  } else if constexpr (std::is_same<T, float>::value) {
    return ShaderDataType::FLOAT;
  } else if constexpr (std::is_same<T, Eigen::Vector2f>::value) {
    return ShaderDataType::FLOAT2;
  } else if constexpr (std::is_same<T, Eigen::Vector3f>::value) {
    return ShaderDataType::FLOAT3;
  } else if constexpr (std::is_same<T, Eigen::Vector4f>::value) {
    return ShaderDataType::FLOAT4;
  } else if constexpr (std::is_same<T, Eigen::Matrix4f>::value) {
    return ShaderDataType::MATRIX4;
  } else if constexpr (std::is_same<T, std::vector<int>>::value) {
    return ShaderDataType::INT_ARRAY;
  } else if constexpr (std::is_same<T, std::vector<float>>::value) {
    return ShaderDataType::FLOAT_ARRAY;
  } else {
    return ShaderDataType::INVALID;
  }
}
 
struct ShaderParameter {
public:
  ShaderParameter() : type(ShaderDataType::INVALID), name(0), mat4f(Eigen::Matrix4f::Zero()) {}
 
  template <typename T>
  ShaderParameter(std::uint64_t name, const T& v) : type(deduce_data_type<T>()),
                                                    name(name) {
    set_value<T>(v);
  }
 
  bool valid() const { return type != ShaderDataType::INVALID && name != 0; }
 
  void invalidate() {
    type = ShaderDataType::INVALID;
    name = 0;
    mat4f.setZero();
  }
 
  template <typename T>
  T get_value() const {
    if (type != deduce_data_type<T>()) {
      std::cerr << "error: type mismatch when getting shader parameter " << name << std::endl;
      abort();
    }
 
    if constexpr (std::is_same<T, std::vector<int>>::value || std::is_same<T, std::vector<float>>::value) {
      const int* ptr = reinterpret_cast<const int*>(&mat4f);
      int num_data = ptr[0];
 
      T v(num_data);
      memcpy(v.data(), &ptr[1], sizeof(typename T::value_type) * num_data);
      return v;
    } else {
      return *reinterpret_cast<const T*>(&mat4f);
    }
  }
 
  template <typename T>
  void set_value(const T& value) {
    if (type != deduce_data_type<T>()) {
      std::cerr << "error: type mismatch when getting shader parameter " << name << std::endl;
      abort();
    }
 
    if constexpr (std::is_same<T, std::vector<int>>::value || std::is_same<T, std::vector<float>>::value) {
      if (value.size() > 15) {
        std::cerr << "error: array size exceeds the maximum limit of 15 for shader parameter " << name << std::endl;
        abort();
      }
 
      int* ptr = reinterpret_cast<int*>(&mat4f);
      ptr[0] = static_cast<int>(value.size());
      memcpy(&ptr[1], value.data(), sizeof(typename T::value_type) * value.size());
    } else {
      *reinterpret_cast<T*>(&mat4f) = value;
    }
  }
 
  void set(glk::GLSLShader& shader) const {
    switch (type) {
      case ShaderDataType::INT:
        shader.set_uniform(name, get_value<int>());
        break;
      case ShaderDataType::INT2:
        shader.set_uniform(name, get_value<Eigen::Vector2i>());
        break;
      case ShaderDataType::INT3:
        shader.set_uniform(name, get_value<Eigen::Vector3i>());
        break;
      case ShaderDataType::INT4:
        shader.set_uniform(name, get_value<Eigen::Vector4i>());
        break;
      case ShaderDataType::FLOAT:
        shader.set_uniform(name, get_value<float>());
        break;
      case ShaderDataType::FLOAT2:
        shader.set_uniform(name, get_value<Eigen::Vector2f>());
        break;
      case ShaderDataType::FLOAT3:
        shader.set_uniform(name, get_value<Eigen::Vector3f>());
        break;
      case ShaderDataType::FLOAT4:
        shader.set_uniform(name, get_value<Eigen::Vector4f>());
        break;
      case ShaderDataType::MATRIX4:
        shader.set_uniform(name, get_value<Eigen::Matrix4f>());
        break;
      case ShaderDataType::INT_ARRAY:
        shader.set_uniform(name, get_value<std::vector<int>>());
        break;
      case ShaderDataType::FLOAT_ARRAY:
        shader.set_uniform(name, get_value<std::vector<float>>());
        break;
      default:
        std::cerr << "error: invalid shader parameter type for " << name << std::endl;
        break;
    }
  }
 
public:
  ShaderDataType type;    
  std::uint64_t name;     
  Eigen::Matrix4f mat4f;  
};
 
struct ShaderSetting {
public:
  using Ptr = std::shared_ptr<ShaderSetting>;
  using ConstPtr = std::shared_ptr<const ShaderSetting>;
 
  ShaderSetting();
 
  ShaderSetting(int color_mode);
 
  ShaderSetting(int color_mode, const Eigen::Matrix4f& transform);
 
  template <typename Transform>
  ShaderSetting(int color_mode, const Transform& transform) : ShaderSetting(color_mode, (transform.template cast<float>() * Eigen::Isometry3f::Identity()).matrix()) {}
 
  ShaderSetting(const ShaderSetting& other);
 
  ShaderSetting& operator=(const ShaderSetting& other);
 
  virtual ~ShaderSetting() {}
 
  ShaderSetting clone() const;
 
  template <typename T>
  ShaderSetting& add(const std::string& name_, const T& value) {
    const std::uint64_t name = glk::hash(name_);
 
    for (int i = 0; i < params.size() && params[i].valid(); i++) {
      if (params[i].name == name) {
        params[i] = ShaderParameter(name, value);
        return *this;
      }
    }
 
    params.emplace_back(ShaderParameter(name, value));
    return *this;
  }
 
  template <typename T>
  std::optional<T> get(const std::string& name_) {
    const std::uint64_t name = glk::hash(name_);
 
    for (const auto& param : params) {
      if (!param.valid() || param.name != name) {
        continue;
      }
 
      if (param.type != deduce_data_type<T>()) {
        std::cerr << "warning: type mismatch for shader parameter " << name_ << std::endl;
        return std::nullopt;
      }
 
      return param.get_value<T>();
    }
 
    return std::nullopt;
  }
 
  template <typename T>
  std::optional<T> get(const std::string& name_) const {
    const std::uint64_t name = glk::hash(name_);
 
    for (const auto& param : params) {
      if (!param.valid() || param.name != name) {
        continue;
      }
 
      if (param.type != deduce_data_type<T>()) {
        std::cerr << "warning: type mismatch for shader parameter " << name_ << std::endl;
        return std::nullopt;
      }
 
      return param.get_value<T>();
    }
 
    return std::nullopt;
  }
 
  template <typename T>
  T cast(const std::string& name_) const {
    const std::uint64_t name = glk::hash(name_);
 
    for (const auto& param : params) {
      if (!param.valid() || param.name != name) {
        continue;
      }
 
      if (param.type != deduce_data_type<T>()) {
        std::cerr << "error: type mismatch for shader parameter " << name << std::endl;
        abort();
      }
 
      return param.get_value<T>();
    }
 
    std::cerr << "error: " << name << " not found in the param list" << std::endl;
    abort();
  }
 
  void set(glk::GLSLShader& shader) const;
 
  // Object type (static/dynamic)
  ShaderSetting& static_object();
  ShaderSetting& dynamic_object();
 
  // Color
  Eigen::Vector4f material_color() const;
  ShaderSetting& set_color(float r, float g, float b, float a);
 
  template <typename Color>
  ShaderSetting& set_color(const Color& color_) {
    const Eigen::Vector4f color = color_.template cast<float>();
    if (color.w() < 0.999f) {
      transparent = true;
    }
    return add("material_color", color);
  }
 
  ShaderSetting& set_alpha(float alpha);
  ShaderSetting& make_transparent();
 
  ShaderSetting& set_rainbow_range(const Eigen::Vector2f& minmax_z);
  ShaderSetting& set_rainbow_axis(const Eigen::Vector3f& axis);
 
  // Point size and scale
  float point_scale() const;
  ShaderSetting& set_point_scale(float scaling);
 
  float point_size() const;
  ShaderSetting& set_point_size(float size);
  ShaderSetting& set_point_size_offset(float offset);
 
  // Point shape mode
  ShaderSetting& set_point_shape_mode(guik::PointShapeMode::MODE mode);
  ShaderSetting& set_point_shape_circle();
  ShaderSetting& set_point_shape_rectangle();
 
  // Point scale mode
  ShaderSetting& set_point_scale_mode(guik::PointScaleMode::MODE mode);
  ShaderSetting& set_point_scale_screenspace();
  ShaderSetting& set_point_scale_metric();
 
  ShaderSetting& set_point_shape(float point_size, bool metric, bool circle);
 
  ShaderSetting& set_old_default_point_shape();
 
  // Calling `remove_model_matrix` invalidates model matrix operations (translate, rotate, and scale)
  ShaderSetting& remove_model_matrix();
 
  int color_mode() const;
  ShaderSetting& set_color_mode(int color_mode);
 
  Eigen::Matrix4f model_matrix() const;
  Eigen::Vector3f translation() const;
  Eigen::Matrix3f rotation() const;
 
  template <typename Transform>
  ShaderSetting& set_model_matrix(const Transform& transform) {
    Eigen::Matrix4f mat = (transform.template cast<float>() * Eigen::Isometry3f::Identity()).matrix();
 
    auto& p = params[2];
    p.set_value<Eigen::Matrix4f>(mat);
    return *this;
  }
 
  template <typename Transform>
  ShaderSetting& transform(const Transform& transform) {
    auto& p = params[2];
    Eigen::Matrix4f current = p.get_value<Eigen::Matrix4f>();
    Eigen::Matrix4f trans_mat = (transform.template cast<float>() * Eigen::Isometry3f::Identity()).matrix();
    p.set_value<Eigen::Matrix4f>(current * trans_mat);
    return *this;
  }
 
  ShaderSetting& translate(float tx, float ty, float tz);
  ShaderSetting& translate(const Eigen::Vector3f& translation);
  template <typename Vector>
  ShaderSetting& translate(const Vector& translation) {
    auto& p = params[2];
    const auto trans = translation.eval();
    p.mat4f.block<3, 1>(0, 3) += trans.template cast<float>().template head<3>();
    return *this;
  }
 
  ShaderSetting& rotate(const float angle, const Eigen::Vector3f& axis);
  template <typename Vector>
  ShaderSetting& rotate(const float angle, const Vector& axis) {
    const Eigen::Vector3f ax = axis.eval().template cast<float>();
    auto& p = params[2];
    p.mat4f = p.mat4f * (Eigen::Isometry3f::Identity() * Eigen::AngleAxisf(angle, ax)).matrix();
    return *this;
  }
  template <typename Scalar>
  ShaderSetting& rotate(const Eigen::Quaternion<Scalar>& quat) {
    auto& p = params[2];
    p.mat4f = p.mat4f * (Eigen::Isometry3f::Identity() * quat.template cast<float>()).matrix();
    return *this;
  }
  template <typename Scalar, int Dim>
  ShaderSetting& rotate(const Eigen::Matrix<Scalar, Dim, Dim>& rot) {
    Eigen::Isometry3f R = Eigen::Isometry3f::Identity();
    R.linear() = rot.template cast<float>().template block<3, 3>(0, 0);
 
    auto& p = params[2];
    p.mat4f = p.mat4f * R.matrix();
    return *this;
  }
 
  ShaderSetting& scale(float scaling);
  ShaderSetting& scale(float sx, float sy, float sz);
  ShaderSetting& scale(const Eigen::Vector3f& scaling);
  template <typename Vector>
  std::enable_if_t<!std::is_arithmetic_v<Vector>, ShaderSetting&> scale(const Vector& scaling) {
    auto& p = params[2];
    const auto s = scaling.eval();
    p.mat4f.col(0) *= s[0];
    p.mat4f.col(1) *= s[1];
    p.mat4f.col(2) *= s[2];
    return *this;
  }
 
public:
  bool transparent;                     
  std::vector<ShaderParameter> params;  
};
 
template <>
inline ShaderSetting& ShaderSetting::add(const std::string& name, const Eigen::Isometry3f& value) {
  return add<Eigen::Matrix4f>(name, value.matrix());
}
 
template <>
inline ShaderSetting& ShaderSetting::add(const std::string& name, const Eigen::Affine3f& value) {
  return add<Eigen::Matrix4f>(name, value.matrix());
}
 
struct Rainbow : public ShaderSetting {
public:
  Rainbow() : ShaderSetting(ColorMode::RAINBOW) {}
 
  template <typename Transform>
  Rainbow(const Transform& transform) : ShaderSetting(ColorMode::RAINBOW, (transform.template cast<float>() * Eigen::Isometry3f::Identity()).matrix()) {}
 
  virtual ~Rainbow() override {}
};
 
struct FlatColor : public ShaderSetting {
public:
  explicit FlatColor(float r, float g, float b, float a = 1.0f) : ShaderSetting(ColorMode::FLAT_COLOR) {
    add("material_color", Eigen::Vector4f(r, g, b, a));
    transparent = a < 0.999f;
  }
 
  explicit FlatColor(const Eigen::Vector4f& color) : ShaderSetting(ColorMode::FLAT_COLOR) {
    add("material_color", color);
    transparent = color.w() < 0.999f;
  }
 
  template <typename Transform>
  explicit FlatColor(const Eigen::Vector4f& color, const Transform& transform)
  : ShaderSetting(ColorMode::FLAT_COLOR, (transform.template cast<float>() * Eigen::Isometry3f::Identity()).matrix()) {
    add("material_color", color);
    transparent = color.w() < 0.999f;
  }
 
  template <typename Color>
  explicit FlatColor(const Color& color) : ShaderSetting(ColorMode::FLAT_COLOR) {
    const Eigen::Vector4f c = color.eval().template cast<float>();
    add("material_color", c);
    transparent = color.w() < 0.999f;
  }
 
  template <typename Transform>
  explicit FlatColor(float r, float g, float b, float a, const Transform& transform)
  : ShaderSetting(ColorMode::FLAT_COLOR, (transform.template cast<float>() * Eigen::Isometry3f::Identity()).matrix()) {
    add("material_color", Eigen::Vector4f(r, g, b, a));
    transparent = a < 0.999f;
  }
 
  template <typename Color, typename Transform>
  explicit FlatColor(const Color& color, const Transform& transform)
  : ShaderSetting(ColorMode::FLAT_COLOR, (transform.template cast<float>() * Eigen::Isometry3f::Identity()).matrix()) {
    const Eigen::Vector4f c = color.eval().template cast<float>();
    add("material_color", c);
    transparent = color.w() < 0.999f;
  }
 
  template <typename T>
  explicit FlatColor(std::initializer_list<T> i) : ShaderSetting(ColorMode::FLAT_COLOR) {
    Eigen::Vector4f color = Eigen::Vector4f::Zero();
    std::copy(i.begin(), i.end(), color.data());
    add("material_color", color);
    transparent = color.w() < 0.999f;
  }
 
  template <typename T, typename Transform>
  explicit FlatColor(std::initializer_list<T> i, const Transform& transform)
  : ShaderSetting(ColorMode::FLAT_COLOR, (transform.template cast<float>() * Eigen::Isometry3f::Identity()).matrix()) {
    Eigen::Vector4f color = Eigen::Vector4f::Zero();
    std::copy(i.begin(), i.end(), color.data());
    add("material_color", color);
    transparent = color.w() < 0.999f;
  }
 
  virtual ~FlatColor() override {}
};
 
/* primitive colors */
struct FlatRed : public FlatColor {
  FlatRed() : FlatColor(1.0f, 0.0f, 0.0f, 1.0f) {}
 
  template <typename Transform>
  FlatRed(const Transform& transform) : FlatColor(1.0f, 0.0f, 0.0f, 1.0f, transform) {}
};
 
struct FlatGreen : public FlatColor {
  FlatGreen() : FlatColor(0.0f, 1.0f, 0.0f, 1.0f) {}
 
  template <typename Transform>
  FlatGreen(const Transform& transform) : FlatColor(0.0f, 1.0f, 0.0f, 1.0f, transform) {}
};
 
struct FlatBlue : public FlatColor {
  FlatBlue() : FlatColor(0.0f, 0.0f, 1.0f, 1.0f) {}
 
  template <typename Transform>
  FlatBlue(const Transform& transform) : FlatColor(0.0f, 0.0f, 1.0f, 1.0f, transform) {}
};
 
struct FlatOrange : public FlatColor {
  FlatOrange() : FlatColor(1.0f, 0.5f, 0.0f, 1.0f) {}
 
  template <typename Transform>
  FlatOrange(const Transform& transform) : FlatColor(1.0f, 0.5f, 0.0f, 1.0f, transform) {}
};
 
struct FlatWhite : public FlatColor {
  FlatWhite() : FlatColor(1.0f, 1.0f, 1.0f, 1.0f) {}
 
  template <typename Transform>
  FlatWhite(const Transform& transform) : FlatColor(1.0f, 1.0f, 1.0f, 1.0f, transform) {}
};
 
struct FlatGray : public FlatColor {
  FlatGray() : FlatColor(0.7f, 0.7f, 0.7f, 1.0f) {}
 
  template <typename Transform>
  FlatGray(const Transform& transform) : FlatColor(0.7f, 0.7f, 0.7f, 1.0f, transform) {}
};
 
struct FlatDarkGray : public FlatColor {
  FlatDarkGray() : FlatColor(0.3f, 0.3f, 0.3f, 1.0f) {}
 
  template <typename Transform>
  FlatDarkGray(const Transform& transform) : FlatColor(0.3f, 0.3f, 0.3f, 1.0f, transform) {}
};
 
struct FlatBlack : public FlatColor {
  FlatBlack() : FlatColor(0.0f, 0.0f, 0.0f, 1.0f) {}
 
  template <typename Transform>
  FlatBlack(const Transform& transform) : FlatColor(0.0f, 0.0f, 0.0f, 1.0f, transform) {}
};
 
struct VertexColor : public ShaderSetting {
public:
  VertexColor() : ShaderSetting(ColorMode::VERTEX_COLOR) {}
 
  template <typename Transform>
  VertexColor(const Transform& transform) : ShaderSetting(ColorMode::VERTEX_COLOR, (transform.template cast<float>() * Eigen::Isometry3f::Identity()).matrix()) {}
 
  virtual ~VertexColor() override {}
};
 
struct TextureColor : public ShaderSetting {
public:
  TextureColor() : ShaderSetting(ColorMode::TEXTURE_COLOR) {}
 
  template <typename Transform>
  TextureColor(const Transform& transform) : ShaderSetting(ColorMode::TEXTURE_COLOR, (transform.template cast<float>() * Eigen::Isometry3f::Identity()).matrix()) {}
 
  virtual ~TextureColor() override {}
};
 
struct VertexColorMap : public ShaderSetting {
public:
  VertexColorMap() : ShaderSetting(ColorMode::VERTEX_COLORMAP) {}
 
  template <typename Transform>
  VertexColorMap(const Transform& transform) : ShaderSetting(ColorMode::VERTEX_COLORMAP, (transform.template cast<float>() * Eigen::Isometry3f::Identity()).matrix()) {}
 
  virtual ~VertexColorMap() override {}
};
 
}  // namespace guik
 
#endif