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

improvement

Browse Source
This commit is contained in:
Orange
2026-07-11 23:17:14 +03:00
parent cbe220664f
commit fb1ffac240
7 changed files with 58 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files
examples/example_hud/gui/main_window.cpp
+2 -4
View File
@@ -90,7 +90,6 @@ namespace imgui_desktop::gui
if (m_canvas_glow.enabled)
{
ImGui::InputInt("Blur layers##canvas", &m_canvas_glow_layers);
ImGui::Combo("Mode##canvas", &m_canvas_glow_mode, "Inside\0Outside\0Both\0");
ImGui::InputFloat("Rounding##canvas", &m_canvas_glow_rounding);
}
}
@@ -291,9 +290,8 @@ 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,
static_cast<CanvasGlowMode>(m_canvas_glow_mode), m_canvas_glow_rounding}),
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, box_fill, m_box_outline, m_box_thickness, box_glow}),
when(m_show_cornered_box,
examples/example_hud/gui/main_window.hpp
-1
View File
@@ -78,7 +78,6 @@ namespace imgui_desktop::gui
GlowSettings m_label_glow;
GlowSettings m_canvas_glow{{1.f, 0.5f, 0.f, 0.8f}, 100.f};
int m_canvas_glow_layers = 64;
int m_canvas_glow_mode = 2;
float m_canvas_glow_rounding = 40.f;
// Skeleton
include/omath/hud/entity_overlay_widgets.hpp
-8
View File
@@ -39,18 +39,10 @@ namespace omath::hud::widget
float intensity = 1.f;
};
enum class CanvasGlowMode
{
INSIDE,
OUTSIDE,
BOTH,
};
struct CanvasGlow
{
Glow glow;
int layers = 64;
CanvasGlowMode mode = CanvasGlowMode::INSIDE;
float rounding = 20.f;
};
include/omath/hud/hud_renderer_interface.hpp
+6 -6
View File
@@ -20,6 +20,12 @@ 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;
@@ -38,12 +44,6 @@ namespace omath::hud
virtual void add_filled_circle(const Vector2<float>& center, float radius, const Color& color,
int segments = 0) = 0;
virtual void add_filled_ellipse(const Vector2<float>& center, const Vector2<float>& radius, const Color& color,
int segments = 0)
{
add_filled_circle(center, std::min(radius.x, radius.y), color, segments);
}
/// Draw an arc (partial circle outline). Angles in radians, 0 = right (+X), counter-clockwise.
virtual void add_arc(const Vector2<float>& center, float radius, float a_min, float a_max, const Color& color,
float thickness, int segments = 0) = 0;
include/omath/hud/renderer_realizations/imgui_renderer.hpp
+2 -2
View File
@@ -15,6 +15,8 @@ namespace omath::hud
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;
@@ -24,8 +26,6 @@ namespace omath::hud
int segments = 0) override;
void add_filled_circle(const Vector2<float>& center, float radius, const Color& color,
int segments = 0) override;
void add_filled_ellipse(const Vector2<float>& center, const Vector2<float>& radius, const Color& color,
int segments = 0) override;
void add_arc(const Vector2<float>& center, float radius, float a_min, float a_max, const Color& color,
float thickness, int segments = 0) override;
void add_image(const std::any& texture_id, const Vector2<float>& min, const Vector2<float>& max,
source/hud/entity_overlay.cpp
+37 -62
View File
@@ -2,6 +2,7 @@
// Created by orange on 13.03.2026.
//
#include "omath/hud/entity_overlay.hpp"
#include <limits>
namespace omath::hud
{
@@ -478,77 +479,51 @@ namespace omath::hud
void EntityOverlay::draw_canvas_glow(const widget::CanvasGlow& canvas_glow) const
{
constexpr int segments = 96;
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);
if (canvas_glow.mode == widget::CanvasGlowMode::OUTSIDE || canvas_glow.mode == widget::CanvasGlowMode::BOTH)
{
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};
}
}
m_renderer->add_polyline(points, color, stroke);
}
}
if (canvas_glow.mode == widget::CanvasGlowMode::OUTSIDE)
return;
const auto center = (min + max) * 0.5f;
const float half_width = std::abs(max.x - min.x) * 0.5f;
const float half_height = std::abs(max.y - min.y) * 0.5f;
if (half_width <= 0.f || half_height <= 0.f)
return;
const float vertical_radius = std::min(std::max(canvas_glow.glow.radius, 0.f), half_height);
const float horizontal_radius = vertical_radius * half_width / half_height;
if (vertical_radius <= 0.f || horizontal_radius <= 0.f)
return;
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 scale = 1.f - progress * 0.95f;
const float falloff = progress * progress;
const float alpha = value.w * intensity * falloff * 3.f / static_cast<float>(layers);
const Color color{value.x, value.y, value.z, alpha};
m_renderer->add_filled_ellipse(center, {horizontal_radius * scale, vertical_radius * scale}, color,
segments);
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);
}
}
source/hud/renderer_realizations/imgui_renderer.cpp
+11 -7
View File
@@ -27,6 +27,17 @@ 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()),
@@ -65,13 +76,6 @@ namespace omath::hud
ImGui::GetBackgroundDrawList()->AddCircleFilled(center.to_im_vec2(), radius, color.to_im_color(), segments);
}
void ImguiHudRenderer::add_filled_ellipse(const Vector2<float>& center, const Vector2<float>& radius,
const Color& color, const int segments)
{
ImGui::GetBackgroundDrawList()->AddEllipseFilled(center.to_im_vec2(), radius.to_im_vec2(), color.to_im_color(),
0.f, 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)
{