gizmo_layout.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstdint>
#include <glm/glm.hpp>
#include <utility>
 
namespace toast {

enum class GizmoTool : uint8_t {
  select,
  translate,
  rotate,
  scale,
  ruler,
  volume_faces,
};

enum class GizmoHandle : int8_t {
  none = -1,
  axis_x = 0,
  axis_y = 1,
  axis_z = 2,
  plane_xy = 3,
  plane_yz = 4,
  plane_xz = 5,
  center = 6,
 
  size_neg_x = 7,
  size_pos_x = 8,
  size_neg_y = 9,
  size_pos_y = 10,
  size_neg_z = 11,
  size_pos_z = 12,
};
 
namespace gizmo_layout {
 
[[nodiscard]]
constexpr auto isSizeHandle(GizmoHandle handle) noexcept -> bool {
  return handle >= GizmoHandle::size_neg_x && handle <= GizmoHandle::size_pos_z;
}
 
[[nodiscard]]
constexpr auto sizeHandleAxis(GizmoHandle handle) noexcept -> int {
  return (static_cast<int>(handle) - static_cast<int>(GizmoHandle::size_neg_x)) / 2;
}
 
[[nodiscard]]
constexpr auto sizeHandleSign(GizmoHandle handle) noexcept -> float {
  return (static_cast<int>(handle) - static_cast<int>(GizmoHandle::size_neg_x)) % 2 == 0 ? -1.0f : 1.0f;
}
 
constexpr float k_screen_size = 0.15f;    
 
// Translate: arrow shaft + pyramid head per axis, small plane quads, center free-move handle
constexpr float k_shaft_length = 0.8f;
constexpr float k_shaft_half_size = 0.02f;
constexpr float k_head_length = 0.25f;
constexpr float k_head_half_size = 0.06f;

constexpr float k_plane_offset = 0.25f;
constexpr float k_plane_size = 0.2f;
constexpr float k_center_half_size = 0.06f;

constexpr float k_axis_hit_radius = 0.05f;
constexpr float k_center_hit_radius = 0.12f;
 
// Rotate: one flat ring per axis, lying in the plane perpendicular to that axis
constexpr float k_ring_radius = 0.9f;
constexpr float k_ring_thickness = 0.05f;    
constexpr int k_ring_segments = 48;
 
// Scale: same shaft as translate, but a cube head instead of a pyramid, plus a center cube for uniform scale
constexpr float k_scale_head_half_size = 0.07f;
 
constexpr float k_size_dot_half_size = 0.05f;
constexpr float k_size_dot_hit_radius = 0.09f;
constexpr float k_min_collider_extent = 0.01f;

inline auto ringBasis(const glm::vec3& axis) -> std::pair<glm::vec3, glm::vec3> {
  const glm::vec3 reference = std::abs(glm::dot(axis, glm::vec3(0, 0, 1))) > 0.99f ? glm::vec3(1, 0, 0) : glm::vec3(0, 0, 1);
  const glm::vec3 u = glm::normalize(glm::cross(axis, reference));
  const glm::vec3 v = glm::cross(axis, u);
  return {u, v};
}
 
}
}