orange/omath
1
0
Fork 0
mirror of https://github.com/orange-cpp/omath.git synced 2026-08-07 21:42:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #202 from orange-cpp/feature/gradient

Browse Source 
Feature/gradient
This commit is contained in:
Orange++
2026-07-12 18:09:44 +03:00
committed by GitHub
parent 78d92a3c0f 238d6aef4e
commit 945f80241c
9 changed files with 763 additions and 143 deletions
Download Patch File Download Diff File Expand all files Collapse all files
examples/example_hud/gui/main_window.cpp
+125 -7
View File
@@ -4,6 +4,7 @@
#include "main_window.hpp"
#include "omath/hud/renderer_realizations/imgui_renderer.hpp"
#include <GLFW/glfw3.h>
#include <cmath>
#include <imgui.h>
#include <imgui_impl_glfw.h>
#include <imgui_impl_opengl3.h>
@@ -65,6 +66,19 @@ namespace imgui_desktop::gui
ImGui::Begin("Controls", &m_opened,
ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse);
ImGui::PushItemWidth(160.f);
const auto draw_glow_controls = [](const char* label, GlowSettings& settings)
{
ImGui::PushID(label);
ImGui::TextUnformatted(label);
ImGui::Checkbox("Glow", &settings.enabled);
if (settings.enabled)
{
ImGui::ColorEdit4("Color", reinterpret_cast<float*>(&settings.color), ImGuiColorEditFlags_NoInputs);
ImGui::InputFloat("Radius", &settings.radius);
ImGui::InputFloat("Intensity", &settings.intensity);
}
ImGui::PopID();
};
if (ImGui::CollapsingHeader("Entity", ImGuiTreeNodeFlags_DefaultOpen))
{
@@ -72,6 +86,12 @@ namespace imgui_desktop::gui
ImGui::SliderFloat("Top Y", &m_entity_top_y, 20.f, m_entity_bottom_y - 20.f);
ImGui::SliderFloat("Bottom Y", &m_entity_bottom_y, m_entity_top_y + 20.f, vp->Size.y - 20.f);
ImGui::SliderFloat("Aspect", &m_entity_aspect, 1.f, 10.f);
draw_glow_controls("Canvas light", m_canvas_glow);
if (m_canvas_glow.enabled)
{
ImGui::InputInt("Blur layers##canvas", &m_canvas_glow_layers);
ImGui::InputFloat("Rounding##canvas", &m_canvas_glow_rounding);
}
}
if (ImGui::CollapsingHeader("Box", ImGuiTreeNodeFlags_DefaultOpen))
@@ -83,9 +103,20 @@ namespace imgui_desktop::gui
ImGui::Checkbox("Dashed", &m_show_dashed_box);
ImGui::ColorEdit4("Color##box", reinterpret_cast<float*>(&m_box_color), ImGuiColorEditFlags_NoInputs);
ImGui::ColorEdit4("Fill##box", reinterpret_cast<float*>(&m_box_fill), ImGuiColorEditFlags_NoInputs);
ImGui::Checkbox("Gradient fill", &m_gradient_box_fill);
ImGui::Checkbox("Animate gradients", &m_animate_gradients);
if (m_gradient_box_fill)
{
ImGui::ColorEdit4("Gradient top##box", reinterpret_cast<float*>(&m_box_gradient_top),
ImGuiColorEditFlags_NoInputs);
ImGui::ColorEdit4("Gradient bottom##box", reinterpret_cast<float*>(&m_box_gradient_bottom),
ImGuiColorEditFlags_NoInputs);
}
ImGui::ColorEdit4("Outline##box", reinterpret_cast<float*>(&m_box_outline), ImGuiColorEditFlags_NoInputs);
ImGui::SliderFloat("Thickness", &m_box_thickness, 0.5f, 5.f);
ImGui::SliderFloat("Corner ratio", &m_corner_ratio, 0.05f, 0.5f);
draw_glow_controls("Box glow", m_box_glow);
draw_glow_controls("Cornered box glow", m_cornered_box_glow);
ImGui::Separator();
ImGui::ColorEdit4("Dash color", reinterpret_cast<float*>(&m_dash_color), ImGuiColorEditFlags_NoInputs);
ImGui::SliderFloat("Dash length", &m_dash_len, 2.f, 30.f);
@@ -99,6 +130,7 @@ namespace imgui_desktop::gui
ImGui::ColorEdit4("BG##bar", reinterpret_cast<float*>(&m_bar_bg_color), ImGuiColorEditFlags_NoInputs);
ImGui::ColorEdit4("Outline##bar", reinterpret_cast<float*>(&m_bar_outline_color),
ImGuiColorEditFlags_NoInputs);
ImGui::Checkbox("Gradient bars", &m_gradient_bars);
ImGui::SliderFloat("Width##bar", &m_bar_width, 1.f, 20.f);
ImGui::SliderFloat("Value##bar", &m_bar_value, 0.f, 1.f);
ImGui::SliderFloat("Offset##bar", &m_bar_offset, 1.f, 20.f);
@@ -116,11 +148,20 @@ namespace imgui_desktop::gui
ImGui::Checkbox("Bot dashed##bar", &m_show_bottom_dashed_bar);
ImGui::SliderFloat("Dash len##bar", &m_bar_dash_len, 2.f, 20.f);
ImGui::SliderFloat("Dash gap##bar", &m_bar_dash_gap, 1.f, 15.f);
draw_glow_controls("Bar glow", m_bar_glow);
}
if (ImGui::CollapsingHeader("Labels", ImGuiTreeNodeFlags_DefaultOpen))
{
ImGui::Checkbox("Outlined", &m_outlined);
ImGui::Checkbox("Gradient centered label", &m_gradient_label);
if (m_gradient_label)
{
ImGui::ColorEdit4("Gradient left##lbl", reinterpret_cast<float*>(&m_label_gradient_left),
ImGuiColorEditFlags_NoInputs);
ImGui::ColorEdit4("Gradient right##lbl", reinterpret_cast<float*>(&m_label_gradient_right),
ImGuiColorEditFlags_NoInputs);
}
ImGui::SliderFloat("Offset##lbl", &m_label_offset, 0.f, 15.f);
ImGui::Checkbox("Right##lbl", &m_show_right_labels);
ImGui::SameLine();
@@ -131,6 +172,7 @@ namespace imgui_desktop::gui
ImGui::Checkbox("Ctr top##lbl", &m_show_centered_top);
ImGui::SameLine();
ImGui::Checkbox("Ctr bot##lbl", &m_show_centered_bottom);
draw_glow_controls("Label glow", m_label_glow);
}
if (ImGui::CollapsingHeader("Skeleton"))
@@ -193,9 +235,82 @@ namespace imgui_desktop::gui
using namespace omath::hud::widget;
using omath::hud::when;
const auto* vp = ImGui::GetMainViewport();
const Bar bar{m_bar_color, m_bar_outline_color, m_bar_bg_color, m_bar_width, m_bar_value, m_bar_offset};
const DashedBar dbar{m_bar_color, m_bar_outline_color, m_bar_bg_color, m_bar_width,
m_bar_value, m_bar_dash_len, m_bar_dash_gap, m_bar_offset};
const float entity_height = m_entity_bottom_y - m_entity_top_y;
const float entity_half_width = entity_height / m_entity_aspect;
const auto joint = [&](const float x, const float y)
{
return omath::Vector2<float>{m_entity_x + (x * 2.f - 1.f) * entity_half_width,
m_entity_top_y + y * entity_height};
};
const auto head = joint(0.5f, 0.1f);
const auto neck = joint(0.5f, 0.22f);
const auto torso = joint(0.5f, 0.5f);
const auto left_shoulder = joint(0.3f, 0.25f);
const auto right_shoulder = joint(0.7f, 0.25f);
const auto left_elbow = joint(0.18f, 0.42f);
const auto right_elbow = joint(0.82f, 0.42f);
const auto left_hand = joint(0.1f, 0.58f);
const auto right_hand = joint(0.9f, 0.58f);
const auto left_hip = joint(0.4f, 0.55f);
const auto right_hip = joint(0.6f, 0.55f);
const auto left_knee = joint(0.36f, 0.75f);
const auto right_knee = joint(0.64f, 0.75f);
const auto left_foot = joint(0.3f, 0.95f);
const auto right_foot = joint(0.7f, 0.95f);
const std::array skeleton_bones = {
Bone{head, neck},
Bone{neck, torso},
Bone{neck, left_shoulder},
Bone{left_shoulder, left_elbow},
Bone{left_elbow, left_hand},
Bone{neck, right_shoulder},
Bone{right_shoulder, right_elbow},
Bone{right_elbow, right_hand},
Bone{torso, left_hip},
Bone{left_hip, left_knee},
Bone{left_knee, left_foot},
Bone{torso, right_hip},
Bone{right_hip, right_knee},
Bone{right_knee, right_foot},
};
const auto animated_color = [&](const omath::Color& color, const float hue_offset)
{
if (!m_animate_gradients)
return color;
auto hsv = color.to_hsv();
hsv.hue = std::fmod(hsv.hue + static_cast<float>(ImGui::GetTime()) * 0.15f + hue_offset, 1.f);
const auto animated = omath::Color::from_hsv(hsv).value();
return omath::Color{animated.x, animated.y, animated.z, color.value().w};
};
const auto box_gradient_top = animated_color(m_box_gradient_top, 0.f);
const auto box_gradient_bottom = animated_color(m_box_gradient_bottom, 0.5f);
const auto red = omath::Color{1.f, 0.f, 0.f, 1.f};
const auto green = omath::Color{0.f, 1.f, 0.f, 1.f};
const auto make_glow = [](const GlowSettings& settings) -> std::optional<Glow>
{
if (!settings.enabled)
return std::nullopt;
return Glow{settings.color, settings.radius, settings.intensity};
};
const auto box_glow = make_glow(m_box_glow);
const auto cornered_box_glow = make_glow(m_cornered_box_glow);
const auto bar_glow = make_glow(m_bar_glow);
const auto label_glow = make_glow(m_label_glow);
const auto canvas_glow = make_glow(m_canvas_glow);
const BarPaint bar_color = m_gradient_bars ? BarPaint{BarGradient{red, green}} : BarPaint{m_bar_color};
const Bar bar{bar_color, m_bar_outline_color, m_bar_bg_color, m_bar_width, m_bar_value, m_bar_offset, bar_glow};
const Paint box_fill = m_gradient_box_fill
? Paint{omath::hud::Gradient{box_gradient_top, box_gradient_top,
box_gradient_bottom, box_gradient_bottom}}
: Paint{m_box_fill};
const Paint centered_label_color =
m_gradient_label ? Paint{omath::hud::Gradient{m_label_gradient_left, m_label_gradient_right,
m_label_gradient_right, m_label_gradient_left,
m_animate_gradients}}
: Paint{omath::Color::from_rgba(255, 255, 255, 255)};
auto outline_helper = [](const bool is_outline) -> Outlined
{
@@ -204,10 +319,13 @@ namespace imgui_desktop::gui
omath::hud::EntityOverlay({m_entity_x, m_entity_top_y}, {m_entity_x, m_entity_bottom_y}, m_entity_aspect,
std::make_shared<omath::hud::ImguiHudRenderer>())
.contents(
when(canvas_glow.has_value(), CanvasGlow{canvas_glow.value_or(Glow{m_canvas_glow.color}),
m_canvas_glow_layers, m_canvas_glow_rounding}),
// ── Boxes ────────────────────────────────────────────────────
when(m_show_box, Box{m_box_color, m_box_fill, m_box_outline, m_box_thickness}),
when(m_show_cornered_box, CorneredBox{omath::Color::from_rgba(255, 0, 255, 255), m_box_fill,
m_box_outline, m_corner_ratio, m_box_thickness}),
when(m_show_box, Box{m_box_color, box_fill, m_box_outline, m_box_thickness, box_glow}),
when(m_show_cornered_box,
CorneredBox{omath::Color::from_rgba(255, 0, 255, 255), m_box_fill, m_box_outline,
m_corner_ratio, m_box_thickness, cornered_box_glow}),
when(m_show_dashed_box, DashedBox{m_dash_color, m_dash_len, m_dash_gap, m_dash_thickness}),
RightSide{
when(m_show_right_bar, bar),
@@ -254,14 +372,14 @@ namespace imgui_desktop::gui
when(m_show_bottom_bar, bar),
when(m_show_bottom_dashed_bar, dbar),
when(m_show_centered_bottom,
Centered{Label{omath::Color::from_rgba(255, 255, 255, 255), m_label_offset,
outline_helper(m_outlined), "PlayerName"}}),
Centered{Label{centered_label_color, m_label_offset, outline_helper(m_outlined),
"Gradient PlayerName", label_glow}}),
when(m_show_bottom_labels, Label{omath::Color::from_rgba(200, 200, 0, 255),
m_label_offset, outline_helper(m_outlined), "42m"}),
},
when(m_show_aim, AimDot{{m_entity_x, m_entity_top_y + 40.f}, m_aim_color, m_aim_radius}),
when(m_show_scan, ScanMarker{m_scan_color, m_scan_outline, m_scan_outline_thickness}),
when(m_show_skeleton, Skeleton{m_skel_color, m_skel_thickness}),
when(m_show_skeleton, Skeleton{skeleton_bones, m_skel_color, m_skel_thickness}),
when(m_show_proj, ProjectileAim{{m_proj_pos_x, m_proj_pos_y},
m_proj_color,
m_proj_size,
examples/example_hud/gui/main_window.hpp
+28 -4
View File
@@ -17,6 +17,14 @@ namespace imgui_desktop::gui
void Run();
private:
struct GlowSettings
{
omath::Color color{0.f, 0.7f, 1.f, 0.8f};
float radius = 4.f;
float intensity = 0.8f;
bool enabled = false;
};
void draw_controls();
void draw_overlay();
void present();
@@ -30,8 +38,12 @@ namespace imgui_desktop::gui
// Box
omath::Color m_box_color{1.f, 1.f, 1.f, 1.f};
omath::Color m_box_fill{0.f, 0.f, 0.f, 0.f};
omath::Color m_box_gradient_top{0.1f, 0.6f, 1.f, 0.55f};
omath::Color m_box_gradient_bottom{0.7f, 0.1f, 1.f, 0.15f};
omath::Color m_box_outline{0.f, 0.f, 0.f, 0.f};
float m_box_thickness = 1.f, m_corner_ratio = 0.2f;
bool m_gradient_box_fill = true;
bool m_animate_gradients = false;
bool m_show_box = true, m_show_cornered_box = true, m_show_dashed_box = false;
// Dashed box
@@ -43,19 +55,31 @@ namespace imgui_desktop::gui
omath::Color m_bar_bg_color{0.f, 0.f, 0.f, 0.5f};
omath::Color m_bar_outline_color{0.f, 0.f, 0.f, 1.f};
float m_bar_width = 4.f, m_bar_value = 0.75f, m_bar_offset = 5.f;
bool m_show_right_bar = true, m_show_left_bar = true;
bool m_show_top_bar = true, m_show_bottom_bar = true;
bool m_gradient_bars = true;
bool m_show_right_bar = true, m_show_left_bar = true;
bool m_show_top_bar = true, m_show_bottom_bar = true;
bool m_show_right_dashed_bar = false, m_show_left_dashed_bar = false;
bool m_show_top_dashed_bar = false, m_show_bottom_dashed_bar = false;
bool m_show_top_dashed_bar = false, m_show_bottom_dashed_bar = false;
float m_bar_dash_len = 6.f, m_bar_dash_gap = 4.f;
// Labels
float m_label_offset = 3.f;
omath::Color m_label_gradient_left{0.f, 0.8f, 1.f, 1.f};
omath::Color m_label_gradient_right{1.f, 0.2f, 0.7f, 1.f};
bool m_outlined = true;
bool m_gradient_label = true;
bool m_show_right_labels = true, m_show_left_labels = true;
bool m_show_top_labels = true, m_show_bottom_labels = true;
bool m_show_top_labels = true, m_show_bottom_labels = true;
bool m_show_centered_top = true, m_show_centered_bottom = true;
GlowSettings m_box_glow;
GlowSettings m_cornered_box_glow{{1.f, 0.f, 1.f, 0.8f}};
GlowSettings m_bar_glow{{1.f, 0.f, 0.f, 0.8f}};
GlowSettings m_label_glow;
GlowSettings m_canvas_glow{{1.f, 0.5f, 0.f, 0.8f}, 100.f};
int m_canvas_glow_layers = 64;
float m_canvas_glow_rounding = 40.f;
// Skeleton
omath::Color m_skel_color = omath::Color::from_rgba(255, 255, 255, 200);
float m_skel_thickness = 1.f;
include/omath/hud/entity_overlay.hpp
+60 -28
View File
@@ -30,6 +30,9 @@ namespace omath::hud
EntityOverlay& add_2d_box(const Color& box_color, const Color& fill_color = Color{0.f, 0.f, 0.f, 0.f},
const Color& outline_color = Color{0.f, 0.f, 0.f, 0.f}, float thickness = 1.f);
EntityOverlay& add_2d_box(const Color& box_color, const Gradient& fill_gradient,
const Color& outline_color = Color{0.f, 0.f, 0.f, 0.f}, float thickness = 1.f);
EntityOverlay& add_cornered_2d_box(const Color& box_color, const Color& fill_color = Color{0.f, 0.f, 0.f, 0.f},
const Color& outline_color = Color{0.f, 0.f, 0.f, 0.f},
float corner_ratio_len = 0.2f, float thickness = 1.f);
@@ -38,17 +41,21 @@ namespace omath::hud
float thickness = 1.f);
// ── Bars ─────────────────────────────────────────────────────────
EntityOverlay& add_right_bar(const Color& color, const Color& outline_color, const Color& bg_color, float width,
float ratio, float offset = 5.f);
EntityOverlay& add_right_bar(const widget::BarPaint& color, const Color& outline_color, const Color& bg_color,
float width, float ratio, float offset = 5.f,
const std::optional<widget::Glow>& glow = std::nullopt);
EntityOverlay& add_left_bar(const Color& color, const Color& outline_color, const Color& bg_color, float width,
float ratio, float offset = 5.f);
EntityOverlay& add_left_bar(const widget::BarPaint& color, const Color& outline_color, const Color& bg_color,
float width, float ratio, float offset = 5.f,
const std::optional<widget::Glow>& glow = std::nullopt);
EntityOverlay& add_top_bar(const Color& color, const Color& outline_color, const Color& bg_color, float height,
float ratio, float offset = 5.f);
EntityOverlay& add_top_bar(const widget::BarPaint& color, const Color& outline_color, const Color& bg_color,
float height, float ratio, float offset = 5.f,
const std::optional<widget::Glow>& glow = std::nullopt);
EntityOverlay& add_bottom_bar(const Color& color, const Color& outline_color, const Color& bg_color,
float height, float ratio, float offset = 5.f);
EntityOverlay& add_bottom_bar(const widget::BarPaint& color, const Color& outline_color, const Color& bg_color,
float height, float ratio, float offset = 5.f,
const std::optional<widget::Glow>& glow = std::nullopt);
EntityOverlay& add_right_dashed_bar(const Color& color, const Color& outline_color, const Color& bg_color,
float width, float ratio, float dash_len, float gap_len,
@@ -65,26 +72,31 @@ namespace omath::hud
float offset = 5.f);
// ── Labels ───────────────────────────────────────────────────────
EntityOverlay& add_right_label(const Color& color, float offset, widget::Outlined outlined,
const std::string_view& text);
EntityOverlay& add_right_label(const widget::Paint& color, float offset, widget::Outlined outlined,
const std::string_view& text,
const std::optional<widget::Glow>& glow = std::nullopt);
EntityOverlay& add_left_label(const Color& color, float offset, widget::Outlined outlined,
const std::string_view& text);
EntityOverlay& add_left_label(const widget::Paint& color, float offset, widget::Outlined outlined,
const std::string_view& text,
const std::optional<widget::Glow>& glow = std::nullopt);
EntityOverlay& add_top_label(const Color& color, float offset, widget::Outlined outlined,
std::string_view text);
EntityOverlay& add_top_label(const widget::Paint& color, float offset, widget::Outlined outlined,
std::string_view text, const std::optional<widget::Glow>& glow = std::nullopt);
EntityOverlay& add_bottom_label(const Color& color, float offset, widget::Outlined outlined,
std::string_view text);
EntityOverlay& add_bottom_label(const widget::Paint& color, float offset, widget::Outlined outlined,
std::string_view text, const std::optional<widget::Glow>& glow = std::nullopt);
EntityOverlay& add_centered_top_label(const Color& color, float offset, widget::Outlined outlined,
const std::string_view& text);
EntityOverlay& add_centered_top_label(const widget::Paint& color, float offset, widget::Outlined outlined,
const std::string_view& text,
const std::optional<widget::Glow>& glow = std::nullopt);
EntityOverlay& add_centered_bottom_label(const Color& color, float offset, widget::Outlined outlined,
const std::string_view& text);
EntityOverlay& add_centered_bottom_label(const widget::Paint& color, float offset, widget::Outlined outlined,
const std::string_view& text,
const std::optional<widget::Glow>& glow = std::nullopt);
template<typename... Args>
EntityOverlay& add_right_label(const Color& color, const float offset, const widget::Outlined outlined,
requires(sizeof...(Args) > 0)
EntityOverlay& add_right_label(const widget::Paint& color, const float offset, const widget::Outlined outlined,
std::format_string<Args...> fmt, Args&&... args)
{
return add_right_label(color, offset, outlined,
@@ -92,7 +104,8 @@ namespace omath::hud
}
template<typename... Args>
EntityOverlay& add_left_label(const Color& color, const float offset, const widget::Outlined outlined,
requires(sizeof...(Args) > 0)
EntityOverlay& add_left_label(const widget::Paint& color, const float offset, const widget::Outlined outlined,
std::format_string<Args...> fmt, Args&&... args)
{
return add_left_label(color, offset, outlined,
@@ -100,7 +113,8 @@ namespace omath::hud
}
template<typename... Args>
EntityOverlay& add_top_label(const Color& color, const float offset, const widget::Outlined outlined,
requires(sizeof...(Args) > 0)
EntityOverlay& add_top_label(const widget::Paint& color, const float offset, const widget::Outlined outlined,
std::format_string<Args...> fmt, Args&&... args)
{
return add_top_label(color, offset, outlined,
@@ -108,7 +122,8 @@ namespace omath::hud
}
template<typename... Args>
EntityOverlay& add_bottom_label(const Color& color, const float offset, const widget::Outlined outlined,
requires(sizeof...(Args) > 0)
EntityOverlay& add_bottom_label(const widget::Paint& color, const float offset, const widget::Outlined outlined,
std::format_string<Args...> fmt, Args&&... args)
{
return add_bottom_label(color, offset, outlined,
@@ -116,15 +131,18 @@ namespace omath::hud
}
template<typename... Args>
EntityOverlay& add_centered_top_label(const Color& color, const float offset, const widget::Outlined outlined,
std::format_string<Args...> fmt, Args&&... args)
requires(sizeof...(Args) > 0)
EntityOverlay& add_centered_top_label(const widget::Paint& color, const float offset,
const widget::Outlined outlined, std::format_string<Args...> fmt,
Args&&... args)
{
return add_centered_top_label(color, offset, outlined,
std::string_view{std::vformat(fmt.get(), std::make_format_args(args...))});
}
template<typename... Args>
EntityOverlay& add_centered_bottom_label(const Color& color, const float offset,
requires(sizeof...(Args) > 0)
EntityOverlay& add_centered_bottom_label(const widget::Paint& color, const float offset,
const widget::Outlined outlined, std::format_string<Args...> fmt,
Args&&... args)
{
@@ -166,6 +184,7 @@ namespace omath::hud
EntityOverlay& add_snap_line(const Vector2<float>& start_pos, const Color& color, float width);
EntityOverlay& add_skeleton(const Color& color, float thickness = 1.f);
EntityOverlay& add_skeleton(std::span<const widget::Bone> bones, const Color& color, float thickness = 1.f);
// ── Declarative interface ─────────────────────────────────────────
/// Pass any combination of widget:: descriptor structs (and std::optional<W>
@@ -230,6 +249,7 @@ namespace omath::hud
}
void dispatch(const widget::Box& box);
void dispatch(const widget::CanvasGlow& canvas_glow);
void dispatch(const widget::CorneredBox& cornered_box);
void dispatch(const widget::DashedBox& dashed_box);
void dispatch(const widget::RightSide& right_side);
@@ -242,7 +262,19 @@ namespace omath::hud
void dispatch(const widget::AimDot& aim_dot);
void dispatch(const widget::ProjectileAim& proj_widget);
void draw_progress_ring(const Vector2<float>& center, const widget::ProgressRing& ring);
void draw_outlined_text(const Vector2<float>& position, const Color& color, const std::string_view& text);
void draw_label(const Vector2<float>& position, const widget::Paint& paint, widget::Outlined outlined,
const std::string_view& text, const std::optional<widget::Glow>& glow);
void draw_glow_polyline(const std::span<const Vector2<float>>& points, const widget::Glow& glow,
float thickness) const;
void draw_glow_line(const Vector2<float>& from, const Vector2<float>& to, const widget::Glow& glow,
float thickness) const;
void draw_glow_rectangle(const Vector2<float>& min, const Vector2<float>& max,
const std::optional<widget::Glow>& glow) const;
void draw_canvas_glow(const widget::CanvasGlow& canvas_glow) const;
void draw_filled_rectangle(const Vector2<float>& min, const Vector2<float>& max,
const widget::Paint& paint) const;
[[nodiscard]]
static widget::Paint resolve_bar_paint(const widget::BarPaint& paint, float ratio, bool vertical);
void draw_dashed_line(const Vector2<float>& from, const Vector2<float>& to, const Color& color, float dash_len,
float gap_len, float thickness) const;
void draw_dashed_fill(const Vector2<float>& origin, const Vector2<float>& step_dir,
include/omath/hud/entity_overlay_widgets.hpp
+91 -6
View File
@@ -2,16 +2,57 @@
// Created by orange on 15.03.2026.
//
#pragma once
#include "gradient.hpp"
#include "omath/linear_algebra/vector2.hpp"
#include "omath/utility/color.hpp"
#include <any>
#include <array>
#include <initializer_list>
#include <optional>
#include <span>
#include <string_view>
#include <type_traits>
#include <variant>
#include <vector>
namespace omath::hud::widget
{
struct Paint : std::variant<Color, Gradient>
{
using std::variant<Color, Gradient>::variant;
constexpr Paint(const float red, const float green, const float blue, const float alpha)
: std::variant<Color, Gradient>(Color{red, green, blue, alpha})
{
}
};
struct BarGradient
{
Color empty_color;
Color full_color;
};
struct BarPaint : std::variant<Color, Gradient, BarGradient>
{
using std::variant<Color, Gradient, BarGradient>::variant;
constexpr BarPaint(const float red, const float green, const float blue, const float alpha)
: std::variant<Color, Gradient, BarGradient>(Color{red, green, blue, alpha})
{
}
BarPaint(const Paint& paint)
{
std::visit(
[this](const auto& value)
{
this->template emplace<std::decay_t<decltype(value)>>(value);
},
paint);
}
};
// ── Overloaded helper for std::visit ──────────────────────────────────────
template<typename... Ts>
struct Overloaded : Ts...
@@ -21,13 +62,28 @@ namespace omath::hud::widget
template<typename... Ts>
Overloaded(Ts...) -> Overloaded<Ts...>;
struct Glow
{
Color color;
float radius = 4.f;
float intensity = 1.f;
};
struct CanvasGlow
{
Glow glow;
int layers = 64;
float rounding = 20.f;
};
// ── Standalone widgets ────────────────────────────────────────────────────
struct Box
{
Color color;
Color fill{0.f, 0.f, 0.f, 0.f};
Paint fill{Color{0.f, 0.f, 0.f, 0.f}};
Color outline{0.f, 0.f, 0.f, 0.f};
float thickness = 1.f;
std::optional<Glow> glow = std::nullopt;
};
enum class Outlined
@@ -42,6 +98,7 @@ namespace omath::hud::widget
Color outline{0.f, 0.f, 0.f, 0.f};
float corner_ratio = 0.2f;
float thickness = 1.f;
std::optional<Glow> glow = std::nullopt;
};
struct DashedBox
@@ -52,10 +109,37 @@ namespace omath::hud::widget
float thickness = 1.f;
};
struct Bone
{
Vector2<float> start;
Vector2<float> end;
};
struct Skeleton
{
std::vector<Bone> bones;
Color color;
float thickness = 1.f;
Skeleton(const Color& color, const float thickness = 1.f): color(color), thickness(thickness)
{
}
Skeleton(const std::span<const Bone> bones, const Color& color, const float thickness = 1.f)
: bones(bones.begin(), bones.end()), color(color), thickness(thickness)
{
}
Skeleton(const std::initializer_list<Bone> bones, const Color& color, const float thickness = 1.f)
: bones(bones), color(color), thickness(thickness)
{
}
template<std::size_t Size>
Skeleton(const std::array<Bone, Size>& bones, const Color& color, const float thickness = 1.f)
: Skeleton(std::span<const Bone>{bones}, color, thickness)
{
}
};
struct SnapLine
{
@@ -92,18 +176,18 @@ namespace omath::hud::widget
Figure figure = Figure::SQUARE;
};
// ── Side-agnostic widgets (used inside XxxSide containers) ────────────────
/// A filled bar. `size` is width for left/right sides, height for top/bottom.
struct Bar
{
Color color;
BarPaint color;
Color outline;
Color bg;
float size;
float ratio;
float offset = 5.f;
std::optional<Glow> glow = std::nullopt;
};
/// A dashed bar. Same field semantics as Bar plus dash parameters.
@@ -121,10 +205,11 @@ namespace omath::hud::widget
struct Label
{
Color color;
Paint color;
float offset;
Outlined outlined;
std::string_view text;
std::optional<Glow> glow = std::nullopt;
};
/// Wraps a Label to request horizontal centering (only applied in TopSide / BottomSide).
@@ -172,8 +257,8 @@ namespace omath::hud::widget
struct None
{
}; ///< No-op placeholder — used by widget::when for disabled elements.
using SideWidget =
std::variant<None, Bar, DashedBar, Label, Centered<Label>, SpaceVertical, SpaceHorizontal, ProgressRing, Icon>;
using SideWidget = std::variant<None, Bar, DashedBar, Label, Centered<Label>, SpaceVertical, SpaceHorizontal,
ProgressRing, Icon>;
// ── Side containers ───────────────────────────────────────────────────────
// Storing std::initializer_list<SideWidget> is safe here: the backing array
include/omath/hud/gradient.hpp
+16
View File
@@ -0,0 +1,16 @@
#pragma once
#include "omath/utility/color.hpp"
namespace omath::hud
{
struct Gradient
{
Color top_left;
Color top_right;
Color bottom_right;
Color bottom_left;
bool animated = false;
float animation_speed = 4.f;
float animation_spread = 0.7f;
};
} // namespace omath::hud
include/omath/hud/hud_renderer_interface.hpp
+19
View File
@@ -2,6 +2,7 @@
// Created by orange on 13.03.2026.
//
#pragma once
#include "gradient.hpp"
#include "omath/linear_algebra/vector2.hpp"
#include "omath/utility/color.hpp"
#include <any>
@@ -19,12 +20,24 @@ namespace omath::hud
virtual void add_polyline(const std::span<const Vector2<float>>& vertexes, const Color& color,
float thickness) = 0;
virtual void add_polyline_clipped(const std::span<const Vector2<float>>& vertexes, const Vector2<float>&,
const Vector2<float>&, const Color& color, float thickness)
{
add_polyline(vertexes, color, thickness);
}
virtual void add_filled_polyline(const std::span<const Vector2<float>>& vertexes, const Color& color) = 0;
virtual void add_rectangle(const Vector2<float>& min, const Vector2<float>& max, const Color& color) = 0;
virtual void add_filled_rectangle(const Vector2<float>& min, const Vector2<float>& max, const Color& color) = 0;
virtual void add_gradient_rectangle(const Vector2<float>& min, const Vector2<float>& max,
const Gradient& gradient)
{
add_filled_rectangle(min, max, gradient.top_left);
}
virtual void add_circle(const Vector2<float>& center, float radius, const Color& color, float thickness,
int segments = 0) = 0;
@@ -41,6 +54,12 @@ namespace omath::hud
virtual void add_text(const Vector2<float>& position, const Color& color, const std::string_view& text) = 0;
virtual void add_gradient_text(const Vector2<float>& position, const Gradient& gradient,
const std::string_view& text)
{
add_text(position, gradient.top_left, text);
}
[[nodiscard]]
virtual Vector2<float> calc_text_size(const std::string_view& text) = 0;
};
include/omath/hud/renderer_realizations/imgui_renderer.hpp
+9 -2
View File
@@ -13,10 +13,15 @@ namespace omath::hud
~ImguiHudRenderer() override;
void add_line(const Vector2<float>& line_start, const Vector2<float>& line_end, const Color& color,
float thickness) override;
void add_polyline(const std::span<const Vector2<float>>& vertexes, const Color& color, float thickness) override;
void add_polyline(const std::span<const Vector2<float>>& vertexes, const Color& color,
float thickness) override;
void add_polyline_clipped(const std::span<const Vector2<float>>& vertexes, const Vector2<float>& clip_min,
const Vector2<float>& clip_max, const Color& color, float thickness) override;
void add_filled_polyline(const std::span<const Vector2<float>>& vertexes, const Color& color) override;
void add_rectangle(const Vector2<float>& min, const Vector2<float>& max, const Color& color) override;
void add_filled_rectangle(const Vector2<float>& min, const Vector2<float>& max, const Color& color) override;
void add_gradient_rectangle(const Vector2<float>& min, const Vector2<float>& max,
const Gradient& gradient) override;
void add_circle(const Vector2<float>& center, float radius, const Color& color, float thickness,
int segments = 0) override;
void add_filled_circle(const Vector2<float>& center, float radius, const Color& color,
@@ -26,8 +31,10 @@ namespace omath::hud
void add_image(const std::any& texture_id, const Vector2<float>& min, const Vector2<float>& max,
const Color& tint = Color{1.f, 1.f, 1.f, 1.f}) override;
void add_text(const Vector2<float>& position, const Color& color, const std::string_view& text) override;
void add_gradient_text(const Vector2<float>& position, const Gradient& gradient,
const std::string_view& text) override;
[[nodiscard]]
Vector2<float> calc_text_size(const std::string_view& text) override;
};
} // namespace omath::hud
#endif // OMATH_IMGUI_INTEGRATION
#endif // OMATH_IMGUI_INTEGRATION
source/hud/entity_overlay.cpp
+332 -87
View File
@@ -2,6 +2,7 @@
// Created by orange on 13.03.2026.
//
#include "omath/hud/entity_overlay.hpp"
#include <limits>
namespace omath::hud
{
@@ -20,6 +21,20 @@ namespace omath::hud
return *this;
}
EntityOverlay& EntityOverlay::add_2d_box(const Color& box_color, const Gradient& fill_gradient,
const Color& outline_color, const float thickness)
{
const auto points = m_canvas.as_array();
if (outline_color.value().w > 0.f)
m_renderer->add_polyline({points.data(), points.size()}, outline_color, thickness + 2.f);
m_renderer->add_polyline({points.data(), points.size()}, box_color, thickness);
m_renderer->add_gradient_rectangle(m_canvas.top_left_corner, m_canvas.bottom_right_corner, fill_gradient);
return *this;
}
EntityOverlay& EntityOverlay::add_cornered_2d_box(const Color& box_color, const Color& fill_color,
const Color& outline_color, const float corner_ratio_len,
const float thickness)
@@ -38,11 +53,9 @@ namespace omath::hud
};
// Left Side
draw_corner_line(m_canvas.top_left_corner,
m_canvas.top_left_corner + Vector2<float>{corner_line_length, 0.f});
draw_corner_line(m_canvas.top_left_corner, m_canvas.top_left_corner + Vector2<float>{corner_line_length, 0.f});
draw_corner_line(m_canvas.top_left_corner,
m_canvas.top_left_corner + Vector2<float>{0.f, corner_line_length});
draw_corner_line(m_canvas.top_left_corner, m_canvas.top_left_corner + Vector2<float>{0.f, corner_line_length});
draw_corner_line(m_canvas.bottom_left_corner,
m_canvas.bottom_left_corner - Vector2<float>{0.f, corner_line_length});
@@ -64,76 +77,84 @@ namespace omath::hud
return *this;
}
EntityOverlay& EntityOverlay::add_right_bar(const Color& color, const Color& outline_color, const Color& bg_color,
const float width, float ratio, const float offset)
EntityOverlay& EntityOverlay::add_right_bar(const widget::BarPaint& color, const Color& outline_color,
const Color& bg_color, const float width, float ratio,
const float offset, const std::optional<widget::Glow>& glow)
{
ratio = std::clamp(ratio, 0.f, 1.f);
const auto max_bar_height = std::abs(m_canvas.top_right_corner.y - m_canvas.bottom_right_corner.y);
const auto bar_start = Vector2<float>{m_text_cursor_right.x + offset, m_canvas.bottom_right_corner.y};
m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>(width, -max_bar_height), bg_color);
const auto bar_min = bar_start - Vector2<float>{0.f, max_bar_height};
const auto bar_max = bar_start + Vector2<float>{width, 0.f};
const auto fill_min = bar_start - Vector2<float>{0.f, max_bar_height * ratio};
m_renderer->add_filled_rectangle(bar_min, bar_max, bg_color);
m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>(width, -max_bar_height * ratio), color);
m_renderer->add_rectangle(bar_start - Vector2<float>(1.f, 0.f),
bar_start + Vector2<float>(width, -max_bar_height), outline_color);
draw_glow_rectangle(fill_min, bar_max, glow);
draw_filled_rectangle(fill_min, bar_max, resolve_bar_paint(color, ratio, true));
m_renderer->add_rectangle(bar_min, bar_max, outline_color);
m_text_cursor_right.x += offset + width;
return *this;
}
EntityOverlay& EntityOverlay::add_left_bar(const Color& color, const Color& outline_color, const Color& bg_color,
const float width, float ratio, const float offset)
EntityOverlay& EntityOverlay::add_left_bar(const widget::BarPaint& color, const Color& outline_color,
const Color& bg_color, const float width, float ratio,
const float offset, const std::optional<widget::Glow>& glow)
{
ratio = std::clamp(ratio, 0.f, 1.f);
const auto max_bar_height = std::abs(m_canvas.top_left_corner.y - m_canvas.bottom_right_corner.y);
const auto bar_start = Vector2<float>{m_text_cursor_left.x - (offset + width), m_canvas.bottom_left_corner.y};
m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>(width, -max_bar_height), bg_color);
const auto bar_min = bar_start - Vector2<float>{0.f, max_bar_height};
const auto bar_max = bar_start + Vector2<float>{width, 0.f};
const auto fill_min = bar_start - Vector2<float>{0.f, max_bar_height * ratio};
m_renderer->add_filled_rectangle(bar_min, bar_max, bg_color);
m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>(width, -max_bar_height * ratio), color);
m_renderer->add_rectangle(bar_start - Vector2<float>(1.f, 0.f),
bar_start + Vector2<float>(width, -max_bar_height), outline_color);
draw_glow_rectangle(fill_min, bar_max, glow);
draw_filled_rectangle(fill_min, bar_max, resolve_bar_paint(color, ratio, true));
m_renderer->add_rectangle(bar_min, bar_max, outline_color);
m_text_cursor_left.x -= offset + width;
return *this;
}
EntityOverlay& EntityOverlay::add_right_label(const Color& color, const float offset,
const widget::Outlined outlined,
const std::string_view& text)
EntityOverlay& EntityOverlay::add_right_label(const widget::Paint& color, const float offset,
const widget::Outlined outlined, const std::string_view& text,
const std::optional<widget::Glow>& glow)
{
if (outlined == widget::Outlined::On)
draw_outlined_text(m_text_cursor_right + Vector2<float>{offset, 0.f}, color, text);
else
m_renderer->add_text(m_text_cursor_right + Vector2<float>{offset, 0.f}, color, text.data());
draw_label(m_text_cursor_right + Vector2<float>{offset, 0.f}, color, outlined, text, glow);
m_text_cursor_right.y += m_renderer->calc_text_size(text.data()).y;
return *this;
}
EntityOverlay& EntityOverlay::add_top_label(const Color& color, const float offset, const widget::Outlined outlined,
const std::string_view text)
EntityOverlay& EntityOverlay::add_top_label(const widget::Paint& color, const float offset,
const widget::Outlined outlined, const std::string_view text,
const std::optional<widget::Glow>& glow)
{
m_text_cursor_top.y -= m_renderer->calc_text_size(text.data()).y;
if (outlined == widget::Outlined::On)
draw_outlined_text(m_text_cursor_top + Vector2<float>{0.f, -offset}, color, text);
else
m_renderer->add_text(m_text_cursor_top + Vector2<float>{0.f, -offset}, color, text.data());
draw_label(m_text_cursor_top + Vector2<float>{0.f, -offset}, color, outlined, text, glow);
return *this;
}
EntityOverlay& EntityOverlay::add_top_bar(const Color& color, const Color& outline_color, const Color& bg_color,
const float height, float ratio, const float offset)
EntityOverlay& EntityOverlay::add_top_bar(const widget::BarPaint& color, const Color& outline_color,
const Color& bg_color, const float height, float ratio,
const float offset, const std::optional<widget::Glow>& glow)
{
ratio = std::clamp(ratio, 0.f, 1.f);
const auto max_bar_width = std::abs(m_canvas.top_left_corner.x - m_canvas.bottom_right_corner.x);
const auto bar_start = Vector2<float>{m_canvas.top_left_corner.x, m_text_cursor_top.y - offset};
m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>(max_bar_width, -height), bg_color);
const auto bar_min = bar_start - Vector2<float>{0.f, height};
const auto bar_max = bar_start + Vector2<float>{max_bar_width, 0.f};
const auto fill_max = Vector2<float>{bar_start.x + max_bar_width * ratio, bar_start.y};
m_renderer->add_filled_rectangle(bar_min, bar_max, bg_color);
m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>(max_bar_width * ratio, -height), color);
m_renderer->add_rectangle(bar_start, bar_start + Vector2<float>(max_bar_width, -height), outline_color);
draw_glow_rectangle(bar_min, fill_max, glow);
draw_filled_rectangle(bar_min, fill_max, resolve_bar_paint(color, ratio, false));
m_renderer->add_rectangle(bar_min, bar_max, outline_color);
m_text_cursor_top.y -= offset + height;
@@ -316,6 +337,14 @@ namespace omath::hud
return *this;
}
EntityOverlay& EntityOverlay::add_skeleton(const std::span<const widget::Bone> bones, const Color& color,
const float thickness)
{
for (const auto& bone : bones)
m_renderer->add_line(bone.start, bone.end, color, thickness);
return *this;
}
void EntityOverlay::draw_dashed_line(const Vector2<float>& from, const Vector2<float>& to, const Color& color,
const float dash_len, const float gap_len, const float thickness) const
{
@@ -366,84 +395,265 @@ namespace omath::hud
return *this;
}
void EntityOverlay::draw_outlined_text(const Vector2<float>& position, const Color& color,
const std::string_view& text)
void EntityOverlay::draw_label(const Vector2<float>& position, const widget::Paint& paint,
const widget::Outlined outlined, const std::string_view& text,
const std::optional<widget::Glow>& glow)
{
static constexpr std::array outline_offsets = {
Vector2<float>{-1, -1}, Vector2<float>{-1, 0}, Vector2<float>{-1, 1}, Vector2<float>{0, -1},
Vector2<float>{0, 1}, Vector2<float>{1, -1}, Vector2<float>{1, 0}, Vector2<float>{1, 1}};
if (glow)
{
const int radius = static_cast<int>(std::ceil(std::max(glow->radius, 0.f)));
for (int layer = radius; layer > 0; --layer)
{
const float alpha = glow->color.value().w * std::max(glow->intensity, 0.f)
* (1.f - static_cast<float>(layer - 1) / static_cast<float>(radius + 1));
const auto value = glow->color.value();
const Color color{value.x, value.y, value.z, alpha / static_cast<float>(radius)};
for (int x = -layer; x <= layer; ++x)
{
m_renderer->add_text(position + Vector2<float>{static_cast<float>(x), static_cast<float>(-layer)},
color, text);
m_renderer->add_text(position + Vector2<float>{static_cast<float>(x), static_cast<float>(layer)},
color, text);
}
for (int y = -layer + 1; y < layer; ++y)
{
m_renderer->add_text(position + Vector2<float>{static_cast<float>(-layer), static_cast<float>(y)},
color, text);
m_renderer->add_text(position + Vector2<float>{static_cast<float>(layer), static_cast<float>(y)},
color, text);
}
}
}
for (const auto& outline_offset : outline_offsets)
m_renderer->add_text(position + outline_offset, Color{0.f, 0.f, 0.f, 1.f}, text.data());
m_renderer->add_text(position, color, text.data());
if (outlined == widget::Outlined::On)
{
static constexpr std::array outline_offsets = {
Vector2<float>{-1, -1}, Vector2<float>{-1, 0}, Vector2<float>{-1, 1}, Vector2<float>{0, -1},
Vector2<float>{0, 1}, Vector2<float>{1, -1}, Vector2<float>{1, 0}, Vector2<float>{1, 1}};
for (const auto& outline_offset : outline_offsets)
m_renderer->add_text(position + outline_offset, Color{0.f, 0.f, 0.f, 1.f}, text);
}
std::visit(
widget::Overloaded{
[&](const Color& color)
{
m_renderer->add_text(position, color, text);
},
[&](const Gradient& gradient)
{
m_renderer->add_gradient_text(position, gradient, text);
},
},
paint);
}
EntityOverlay& EntityOverlay::add_bottom_bar(const Color& color, const Color& outline_color, const Color& bg_color,
const float height, float ratio, const float offset)
void EntityOverlay::draw_glow_polyline(const std::span<const Vector2<float>>& points, const widget::Glow& glow,
const float thickness) const
{
const int radius = static_cast<int>(std::ceil(std::max(glow.radius, 0.f)));
const auto value = glow.color.value();
for (int layer = radius; layer > 0; --layer)
{
const float falloff = 1.f - static_cast<float>(layer - 1) / static_cast<float>(radius + 1);
const Color color{value.x, value.y, value.z,
value.w * std::max(glow.intensity, 0.f) * falloff / static_cast<float>(radius)};
m_renderer->add_polyline(points, color, thickness + static_cast<float>(layer) * 2.f);
}
}
void EntityOverlay::draw_glow_line(const Vector2<float>& from, const Vector2<float>& to, const widget::Glow& glow,
const float thickness) const
{
const int radius = static_cast<int>(std::ceil(std::max(glow.radius, 0.f)));
const auto value = glow.color.value();
for (int layer = radius; layer > 0; --layer)
{
const float falloff = 1.f - static_cast<float>(layer - 1) / static_cast<float>(radius + 1);
const Color color{value.x, value.y, value.z,
value.w * std::max(glow.intensity, 0.f) * falloff / static_cast<float>(radius)};
m_renderer->add_line(from, to, color, thickness + static_cast<float>(layer) * 2.f);
}
}
void EntityOverlay::draw_glow_rectangle(const Vector2<float>& min, const Vector2<float>& max,
const std::optional<widget::Glow>& glow) const
{
if (!glow || glow->radius <= 0.f)
return;
const std::array points = {
Vector2<float>{std::min(min.x, max.x), std::min(min.y, max.y)},
Vector2<float>{std::max(min.x, max.x), std::min(min.y, max.y)},
Vector2<float>{std::max(min.x, max.x), std::max(min.y, max.y)},
Vector2<float>{std::min(min.x, max.x), std::max(min.y, max.y)},
};
draw_glow_polyline(points, *glow, 1.f);
}
void EntityOverlay::draw_canvas_glow(const widget::CanvasGlow& canvas_glow) const
{
const int layers = std::max(canvas_glow.layers, 2);
const auto min = m_canvas.top_left_corner;
const auto max = m_canvas.bottom_right_corner;
const auto value = canvas_glow.glow.color.value();
const float intensity = std::max(canvas_glow.glow.intensity, 0.f);
constexpr int corner_segments = 12;
const float max_rounding = std::min(std::abs(max.x - min.x), std::abs(max.y - min.y)) * 0.5f;
const float rounding = std::clamp(canvas_glow.rounding, 0.f, max_rounding);
const float extent = std::max(canvas_glow.glow.radius, 0.f);
const float stroke = std::max(extent / static_cast<float>(layers - 1) * 2.f, 1.f);
for (int layer = 0; layer < layers; ++layer)
{
const float progress = static_cast<float>(layer) / static_cast<float>(layers - 1);
const float expansion = extent * (1.f - progress);
const float falloff = progress * progress * (3.f - 2.f * progress);
const Color color{value.x, value.y, value.z, value.w * intensity * falloff * 0.35f};
const auto expanded_min = min - Vector2<float>{expansion, expansion};
const auto expanded_max = max + Vector2<float>{expansion, expansion};
const float expanded_rounding = rounding + expansion;
const std::array corner_centers = {
expanded_min + Vector2<float>{expanded_rounding, expanded_rounding},
Vector2<float>{expanded_max.x - expanded_rounding, expanded_min.y + expanded_rounding},
expanded_max - Vector2<float>{expanded_rounding, expanded_rounding},
Vector2<float>{expanded_min.x + expanded_rounding, expanded_max.y - expanded_rounding},
};
std::array<Vector2<float>, corner_segments * 4> points;
for (int corner = 0; corner < 4; ++corner)
{
const float start_angle =
std::numbers::pi_v<float> + static_cast<float>(corner) * std::numbers::pi_v<float> * 0.5f;
for (int segment = 0; segment < corner_segments; ++segment)
{
const float arc_progress = static_cast<float>(segment) / static_cast<float>(corner_segments - 1);
const float angle = start_angle + arc_progress * std::numbers::pi_v<float> * 0.5f;
points[corner * corner_segments + segment] =
corner_centers[corner]
+ Vector2<float>{std::cos(angle) * expanded_rounding, std::sin(angle) * expanded_rounding};
}
}
constexpr float clip_extent = std::numeric_limits<float>::max() * 0.25f;
m_renderer->add_polyline_clipped(points, {-clip_extent, -clip_extent}, {clip_extent, min.y}, color, stroke);
m_renderer->add_polyline_clipped(points, {-clip_extent, max.y}, {clip_extent, clip_extent}, color, stroke);
m_renderer->add_polyline_clipped(points, {-clip_extent, min.y}, {min.x, max.y}, color, stroke);
m_renderer->add_polyline_clipped(points, {max.x, min.y}, {clip_extent, max.y}, color, stroke);
}
}
void EntityOverlay::draw_filled_rectangle(const Vector2<float>& min, const Vector2<float>& max,
const widget::Paint& paint) const
{
const Vector2<float> top_left{std::min(min.x, max.x), std::min(min.y, max.y)};
const Vector2<float> bottom_right{std::max(min.x, max.x), std::max(min.y, max.y)};
std::visit(
widget::Overloaded{
[&](const Color& color)
{
m_renderer->add_filled_rectangle(top_left, bottom_right, color);
},
[&](const Gradient& gradient)
{
m_renderer->add_gradient_rectangle(top_left, bottom_right, gradient);
},
},
paint);
}
widget::Paint EntityOverlay::resolve_bar_paint(const widget::BarPaint& paint, const float ratio,
const bool vertical)
{
return std::visit(
widget::Overloaded{
[](const Color& color) -> widget::Paint
{
return color;
},
[](const Gradient& gradient) -> widget::Paint
{
return gradient;
},
[&](const widget::BarGradient& gradient) -> widget::Paint
{
const float value = std::clamp(ratio, 0.f, 1.f);
const auto current = Color{gradient.empty_color.value() * (1.f - value)
+ gradient.full_color.value() * value};
if (vertical)
return Gradient{current, current, gradient.empty_color, gradient.empty_color};
return Gradient{gradient.empty_color, current, current, gradient.empty_color};
},
},
paint);
}
EntityOverlay& EntityOverlay::add_bottom_bar(const widget::BarPaint& color, const Color& outline_color,
const Color& bg_color, const float height, float ratio,
const float offset, const std::optional<widget::Glow>& glow)
{
ratio = std::clamp(ratio, 0.f, 1.f);
const auto max_bar_width = std::abs(m_canvas.bottom_right_corner.x - m_canvas.bottom_left_corner.x);
const auto bar_start = Vector2<float>{m_canvas.bottom_left_corner.x, m_text_cursor_bottom.y + offset};
m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>(max_bar_width, height), bg_color);
m_renderer->add_filled_rectangle(bar_start, bar_start + Vector2<float>(max_bar_width * ratio, height), color);
m_renderer->add_rectangle(bar_start, bar_start + Vector2<float>(max_bar_width, height), outline_color);
const auto bar_min = bar_start;
const auto bar_max = bar_start + Vector2<float>{max_bar_width, height};
const auto fill_max = bar_start + Vector2<float>{max_bar_width * ratio, height};
m_renderer->add_filled_rectangle(bar_min, bar_max, bg_color);
draw_glow_rectangle(bar_min, fill_max, glow);
draw_filled_rectangle(bar_min, fill_max, resolve_bar_paint(color, ratio, false));
m_renderer->add_rectangle(bar_min, bar_max, outline_color);
m_text_cursor_bottom.y += offset + height;
return *this;
}
EntityOverlay& EntityOverlay::add_bottom_label(const Color& color, const float offset, const widget::Outlined outlined,
const std::string_view text)
EntityOverlay& EntityOverlay::add_bottom_label(const widget::Paint& color, const float offset,
const widget::Outlined outlined, const std::string_view text,
const std::optional<widget::Glow>& glow)
{
const auto text_size = m_renderer->calc_text_size(text);
if (outlined == widget::Outlined::On)
draw_outlined_text(m_text_cursor_bottom + Vector2<float>{0.f, offset}, color, text);
else
m_renderer->add_text(m_text_cursor_bottom + Vector2<float>{0.f, offset}, color, text);
draw_label(m_text_cursor_bottom + Vector2<float>{0.f, offset}, color, outlined, text, glow);
m_text_cursor_bottom.y += text_size.y;
return *this;
}
EntityOverlay& EntityOverlay::add_left_label(const Color& color, const float offset, const widget::Outlined outlined,
const std::string_view& text)
EntityOverlay& EntityOverlay::add_left_label(const widget::Paint& color, const float offset,
const widget::Outlined outlined, const std::string_view& text,
const std::optional<widget::Glow>& glow)
{
const auto text_size = m_renderer->calc_text_size(text);
const auto pos = m_text_cursor_left + Vector2<float>{-(offset + text_size.x), 0.f};
if (outlined == widget::Outlined::On)
draw_outlined_text(pos, color, text);
else
m_renderer->add_text(pos, color, text);
draw_label(pos, color, outlined, text, glow);
m_text_cursor_left.y += text_size.y;
return *this;
}
EntityOverlay& EntityOverlay::add_centered_bottom_label(const Color& color, const float offset, const widget::Outlined outlined,
const std::string_view& text)
EntityOverlay& EntityOverlay::add_centered_bottom_label(const widget::Paint& color, const float offset,
const widget::Outlined outlined,
const std::string_view& text,
const std::optional<widget::Glow>& glow)
{
const auto text_size = m_renderer->calc_text_size(text);
const auto box_center_x =
m_canvas.bottom_left_corner.x + (m_canvas.bottom_right_corner.x - m_canvas.bottom_left_corner.x) / 2.f;
const auto pos = Vector2<float>{box_center_x - text_size.x / 2.f, m_text_cursor_bottom.y + offset};
if (outlined == widget::Outlined::On)
draw_outlined_text(pos, color, text);
else
m_renderer->add_text(pos, color, text);
draw_label(pos, color, outlined, text, glow);
m_text_cursor_bottom.y += text_size.y;
return *this;
}
EntityOverlay& EntityOverlay::add_centered_top_label(const Color& color, const float offset, const widget::Outlined outlined,
const std::string_view& text)
EntityOverlay& EntityOverlay::add_centered_top_label(const widget::Paint& color, const float offset,
const widget::Outlined outlined, const std::string_view& text,
const std::optional<widget::Glow>& glow)
{
const auto text_size = m_renderer->calc_text_size(text);
const auto box_center_x =
@@ -452,10 +662,7 @@ namespace omath::hud
m_text_cursor_top.y -= text_size.y;
const auto pos = Vector2<float>{box_center_x - text_size.x / 2.f, m_text_cursor_top.y - offset};
if (outlined == widget::Outlined::On)
draw_outlined_text(pos, color, text);
else
m_renderer->add_text(pos, color, text);
draw_label(pos, color, outlined, text, glow);
return *this;
}
@@ -601,11 +808,43 @@ namespace omath::hud
// ── widget dispatch ───────────────────────────────────────────────────────
void EntityOverlay::dispatch(const widget::Box& box)
{
add_2d_box(box.color, box.fill, box.outline, box.thickness);
if (box.glow)
{
const auto points = m_canvas.as_array();
draw_glow_polyline(points, *box.glow, box.thickness);
}
std::visit(
[&](const auto& fill)
{
add_2d_box(box.color, fill, box.outline, box.thickness);
},
box.fill);
}
void EntityOverlay::dispatch(const widget::CanvasGlow& canvas_glow)
{
draw_canvas_glow(canvas_glow);
}
void EntityOverlay::dispatch(const widget::CorneredBox& cornered_box)
{
if (cornered_box.glow)
{
const float length =
std::abs(m_canvas.top_left_corner.x - m_canvas.top_right_corner.x) * cornered_box.corner_ratio;
const std::array lines = {
std::pair{m_canvas.top_left_corner, m_canvas.top_left_corner + Vector2<float>{length, 0.f}},
std::pair{m_canvas.top_left_corner, m_canvas.top_left_corner + Vector2<float>{0.f, length}},
std::pair{m_canvas.bottom_left_corner, m_canvas.bottom_left_corner - Vector2<float>{0.f, length}},
std::pair{m_canvas.bottom_left_corner, m_canvas.bottom_left_corner + Vector2<float>{length, 0.f}},
std::pair{m_canvas.top_right_corner, m_canvas.top_right_corner - Vector2<float>{length, 0.f}},
std::pair{m_canvas.top_right_corner, m_canvas.top_right_corner + Vector2<float>{0.f, length}},
std::pair{m_canvas.bottom_right_corner, m_canvas.bottom_right_corner - Vector2<float>{0.f, length}},
std::pair{m_canvas.bottom_right_corner, m_canvas.bottom_right_corner - Vector2<float>{length, 0.f}},
};
for (const auto& [from, to] : lines)
draw_glow_line(from, to, *cornered_box.glow, cornered_box.thickness);
}
add_cornered_2d_box(cornered_box.color, cornered_box.fill, cornered_box.outline, cornered_box.corner_ratio,
cornered_box.thickness);
}
@@ -617,7 +856,10 @@ namespace omath::hud
void EntityOverlay::dispatch(const widget::Skeleton& skeleton)
{
add_skeleton(skeleton.color, skeleton.thickness);
if (skeleton.bones.empty())
add_skeleton(skeleton.color, skeleton.thickness);
else
add_skeleton(skeleton.bones, skeleton.color, skeleton.thickness);
}
void EntityOverlay::dispatch(const widget::SnapLine& snap_line)
@@ -704,7 +946,7 @@ namespace omath::hud
},
[this](const widget::Bar& w)
{
add_right_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.offset);
add_right_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.offset, w.glow);
},
[this](const widget::DashedBar& w)
{
@@ -713,11 +955,12 @@ namespace omath::hud
},
[this](const widget::Label& w)
{
add_right_label(w.color, w.offset, w.outlined, w.text);
add_right_label(w.color, w.offset, w.outlined, w.text, w.glow);
},
[this](const widget::Centered<widget::Label>& w)
{
add_right_label(w.child.color, w.child.offset, w.child.outlined, w.child.text);
add_right_label(w.child.color, w.child.offset, w.child.outlined, w.child.text,
w.child.glow);
},
[this](const widget::SpaceVertical& w)
{
@@ -750,7 +993,7 @@ namespace omath::hud
},
[this](const widget::Bar& w)
{
add_left_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.offset);
add_left_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.offset, w.glow);
},
[this](const widget::DashedBar& w)
{
@@ -759,11 +1002,12 @@ namespace omath::hud
},
[this](const widget::Label& w)
{
add_left_label(w.color, w.offset, w.outlined, w.text);
add_left_label(w.color, w.offset, w.outlined, w.text, w.glow);
},
[this](const widget::Centered<widget::Label>& w)
{
add_left_label(w.child.color, w.child.offset, w.child.outlined, w.child.text);
add_left_label(w.child.color, w.child.offset, w.child.outlined, w.child.text,
w.child.glow);
},
[this](const widget::SpaceVertical& w)
{
@@ -796,7 +1040,7 @@ namespace omath::hud
},
[this](const widget::Bar& w)
{
add_top_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.offset);
add_top_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.offset, w.glow);
},
[this](const widget::DashedBar& w)
{
@@ -805,11 +1049,12 @@ namespace omath::hud
},
[this](const widget::Label& w)
{
add_top_label(w.color, w.offset, w.outlined, w.text);
add_top_label(w.color, w.offset, w.outlined, w.text, w.glow);
},
[this](const widget::Centered<widget::Label>& w)
{
add_centered_top_label(w.child.color, w.child.offset, w.child.outlined, w.child.text);
add_centered_top_label(w.child.color, w.child.offset, w.child.outlined, w.child.text,
w.child.glow);
},
[this](const widget::SpaceVertical& w)
{
@@ -841,7 +1086,7 @@ namespace omath::hud
},
[this](const widget::Bar& w)
{
add_bottom_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.offset);
add_bottom_bar(w.color, w.outline, w.bg, w.size, w.ratio, w.offset, w.glow);
},
[this](const widget::DashedBar& w)
{
@@ -850,12 +1095,12 @@ namespace omath::hud
},
[this](const widget::Label& w)
{
add_bottom_label(w.color, w.offset, w.outlined, w.text);
add_bottom_label(w.color, w.offset, w.outlined, w.text, w.glow);
},
[this](const widget::Centered<widget::Label>& w)
{
add_centered_bottom_label(w.child.color, w.child.offset, w.child.outlined,
w.child.text);
add_centered_bottom_label(w.child.color, w.child.offset, w.child.outlined, w.child.text,
w.child.glow);
},
[this](const widget::SpaceVertical& w)
{
@@ -878,4 +1123,4 @@ namespace omath::hud
child);
}
} // namespace omath::hud
} // namespace omath::hud
source/hud/renderer_realizations/imgui_renderer.cpp
+83 -9
View File
@@ -4,7 +4,9 @@
#include "omath/hud/renderer_realizations/imgui_renderer.hpp"
#ifdef OMATH_IMGUI_INTEGRATION
#include <cmath>
#include <imgui.h>
#include <imgui_internal.h>
namespace omath::hud
{
@@ -25,10 +27,21 @@ namespace omath::hud
ImDrawFlags_Closed, thickness);
}
void ImguiHudRenderer::add_polyline_clipped(const std::span<const Vector2<float>>& vertexes,
const Vector2<float>& clip_min, const Vector2<float>& clip_max,
const Color& color, const float thickness)
{
auto* draw_list = ImGui::GetBackgroundDrawList();
draw_list->PushClipRect(clip_min.to_im_vec2(), clip_max.to_im_vec2(), true);
draw_list->AddPolyline(reinterpret_cast<const ImVec2*>(vertexes.data()), static_cast<int>(vertexes.size()),
color.to_im_color(), ImDrawFlags_Closed, thickness);
draw_list->PopClipRect();
}
void ImguiHudRenderer::add_filled_polyline(const std::span<const Vector2<float>>& vertexes, const Color& color)
{
ImGui::GetBackgroundDrawList()->AddConvexPolyFilled(reinterpret_cast<const ImVec2*>(vertexes.data()),
static_cast<int>(vertexes.size()), color.to_im_color());
static_cast<int>(vertexes.size()), color.to_im_color());
}
void ImguiHudRenderer::add_rectangle(const Vector2<float>& min, const Vector2<float>& max, const Color& color)
@@ -42,30 +55,39 @@ namespace omath::hud
ImGui::GetBackgroundDrawList()->AddRectFilled(min.to_im_vec2(), max.to_im_vec2(), color.to_im_color());
}
void ImguiHudRenderer::add_circle(const Vector2<float>& center, const float radius, const Color& color,
const float thickness, const int segments)
void ImguiHudRenderer::add_gradient_rectangle(const Vector2<float>& min, const Vector2<float>& max,
const Gradient& gradient)
{
ImGui::GetBackgroundDrawList()->AddCircle(center.to_im_vec2(), radius, color.to_im_color(), segments, thickness);
ImGui::GetBackgroundDrawList()->AddRectFilledMultiColor(
min.to_im_vec2(), max.to_im_vec2(), gradient.top_left.to_im_color(), gradient.top_right.to_im_color(),
gradient.bottom_right.to_im_color(), gradient.bottom_left.to_im_color());
}
void ImguiHudRenderer::add_circle(const Vector2<float>& center, const float radius, const Color& color,
const float thickness, const int segments)
{
ImGui::GetBackgroundDrawList()->AddCircle(center.to_im_vec2(), radius, color.to_im_color(), segments,
thickness);
}
void ImguiHudRenderer::add_filled_circle(const Vector2<float>& center, const float radius, const Color& color,
const int segments)
const int segments)
{
ImGui::GetBackgroundDrawList()->AddCircleFilled(center.to_im_vec2(), radius, color.to_im_color(), segments);
}
void ImguiHudRenderer::add_arc(const Vector2<float>& center, const float radius, const float a_min, const float a_max,
const Color& color, const float thickness, const int segments)
void ImguiHudRenderer::add_arc(const Vector2<float>& center, const float radius, const float a_min,
const float a_max, const Color& color, const float thickness, const int segments)
{
ImGui::GetBackgroundDrawList()->PathArcTo(center.to_im_vec2(), radius, a_min, a_max, segments);
ImGui::GetBackgroundDrawList()->PathStroke(color.to_im_color(), ImDrawFlags_None, thickness);
}
void ImguiHudRenderer::add_image(const std::any& texture_id, const Vector2<float>& min, const Vector2<float>& max,
const Color& tint)
const Color& tint)
{
ImGui::GetBackgroundDrawList()->AddImage(std::any_cast<ImTextureID>(texture_id), min.to_im_vec2(),
max.to_im_vec2(), {0, 0}, {1, 1}, tint.to_im_color());
max.to_im_vec2(), {0, 0}, {1, 1}, tint.to_im_color());
}
void ImguiHudRenderer::add_text(const Vector2<float>& position, const Color& color, const std::string_view& text)
@@ -73,6 +95,58 @@ namespace omath::hud
ImGui::GetBackgroundDrawList()->AddText(position.to_im_vec2(), color.to_im_color(), text.data(),
text.data() + text.size());
}
void ImguiHudRenderer::add_gradient_text(const Vector2<float>& position, const Gradient& gradient,
const std::string_view& text)
{
auto* draw_list = ImGui::GetBackgroundDrawList();
if (gradient.animated)
{
const float animation_offset = static_cast<float>(ImGui::GetTime()) * gradient.animation_speed;
float cursor_x = position.x;
const char* glyph_start = text.data();
const char* const text_end = text.data() + text.size();
int glyph_index = 0;
while (glyph_start < text_end)
{
unsigned int codepoint;
const int glyph_size = ImTextCharFromUtf8(&codepoint, glyph_start, text_end);
if (glyph_size <= 0)
break;
static_cast<void>(codepoint);
const char* const glyph_end = glyph_start + glyph_size;
const float blend =
(std::sin(animation_offset + static_cast<float>(glyph_index) * gradient.animation_spread) + 1.f)
* 0.5f;
const auto color = gradient.top_left.value() * (1.f - blend) + gradient.top_right.value() * blend;
draw_list->AddText({cursor_x, position.y}, Color{color}.to_im_color(), glyph_start, glyph_end);
cursor_x += ImGui::CalcTextSize(glyph_start, glyph_end).x;
glyph_start = glyph_end;
++glyph_index;
}
return;
}
const int vertex_start = draw_list->VtxBuffer.Size;
draw_list->AddText(position.to_im_vec2(), IM_COL32_WHITE, text.data(), text.data() + text.size());
const auto size = calc_text_size(text);
const float width = std::max(size.x, 1.f);
const float height = std::max(size.y, 1.f);
for (int i = vertex_start; i < draw_list->VtxBuffer.Size; ++i)
{
auto& vertex = draw_list->VtxBuffer[i];
const float x = std::clamp((vertex.pos.x - position.x) / width, 0.f, 1.f);
const float y = std::clamp((vertex.pos.y - position.y) / height, 0.f, 1.f);
const auto top = gradient.top_left.value() * (1.f - x) + gradient.top_right.value() * x;
const auto bottom = gradient.bottom_left.value() * (1.f - x) + gradient.bottom_right.value() * x;
const auto color = top * (1.f - y) + bottom * y;
const auto alpha = static_cast<int>(((vertex.col >> IM_COL32_A_SHIFT) & 0xff) * color.w);
vertex.col = IM_COL32(static_cast<int>(color.x * 255.f), static_cast<int>(color.y * 255.f),
static_cast<int>(color.z * 255.f), alpha);
}
}
[[nodiscard]]
Vector2<float> ImguiHudRenderer::calc_text_size(const std::string_view& text)
{