ImGuiUtility.h

Go to the documentation of this file.

 
#pragma once
 
#include "ncengine/type/EngineTypes.h"
#include "ncengine/ui/ImGuiConversion.h"
 
#include "imgui.h"
#include "ncmath/Color.h"
#include "ncmath/Vector.h"
#include "ncmath/Geometry.h"
 
#include <algorithm>
#include <functional>
#include <numbers>
#include <span>
#include <string>
#include <string_view>
 
#define IMGUI_SCOPE_UNIQUE_NAME_HELPER(name, lineNumber) name ## lineNumber
#define IMGUI_SCOPE_UNIQUE_NAME(name, lineNumber) IMGUI_SCOPE_UNIQUE_NAME_HELPER(name, lineNumber)
#define IMGUI_SCOPE(Property, ...) auto IMGUI_SCOPE_UNIQUE_NAME(imguiProp, __LINE__) = Property(__VA_ARGS__)
 
namespace nc::ui
{
constexpr auto g_defaultItemWidth = 50.0f;
constexpr auto g_maxPos = 5000.0f;
constexpr auto g_minPos = -g_maxPos;
constexpr auto g_maxAngle = std::numbers::pi_v<float> * 2.0f;
constexpr auto g_minAngle = -g_maxAngle;
constexpr auto g_minScale = 0.1f;
constexpr auto g_maxScale = 1000.0f;
 
template<class F>
void Window(const char* label, F&& drawContents);
 
template<class F>
void Window(const char* label, ImGuiWindowFlags flags, F&& drawContents);
 
template<class F>
void ChildWindow(const char* label, F&& drawContents);
 
template<class F>
void ChildWindow(const char* label, ImGuiChildFlags flags, F&& drawContents);
 
auto IsWindowBackgroundClicked() -> bool;
 
auto InputInt(int& value, const char* label, int step = 1) -> bool;
 
auto InputU8(uint8_t& value, const char* label) -> bool;
 
auto InputU16(uint16_t& value, const char* label) -> bool;
 
auto InputU32(uint32_t& value, const char* label) -> bool;
 
auto InputU64(uint64_t& value, const char* label) -> bool;
 
auto DragFloat(float& value, const char* label, float speed = 1.0f, float min = 0.0f, float max = 1000.0f) -> bool;
 
auto Checkbox(bool& value, const char* name) -> bool;
 
auto InputVector3(Vector3& value, const char* label, float speed = 1.0f, float min = 0.0f, float max = 100.0f) -> bool;
 
auto InputPosition(Vector3& value, const char* label) -> bool;
 
auto InputAngles(Vector3& value, const char* label) -> bool;
 
auto InputScale(Vector3& value, const char* label, float min = g_minScale, float max = g_maxScale) -> bool;
 
auto InputAxis(Vector3& value, const char* label, float min = -1.0f, float max = 1.0f) -> bool;
 
auto InputReferenceFrame(Vector3& basis, Vector3& normal, const char* basisLabel, const char* normalLabel) -> bool;
 
auto InputColor3(Vector3& value, const char* label) -> bool;
 
auto InputColor4(Vector4& value, const char* label) -> bool;
 
auto InputGradient(Gradient& value, const char* lable) -> bool;
 
auto Combobox(std::string& value, const char* label, std::span<const std::string_view> items);
 
auto FilteredCombobox(std::string& value, const char* label, std::span<const std::string_view> items, auto&& disableIf);
 
auto InputText(std::string& value, const char* label) -> bool;
 
auto SelectableWidget(bool selected, const ImVec2& size, auto&& widget) -> bool;
 
void SetTooltip(const char* text);
 
template<class Getter, class Setter>
struct Property
{
    Getter get;
    Setter set;
    const char* name = "";
};
 
auto PropertyWidget(const auto& property, auto& instance, auto&& widget, auto&&... args) -> bool;
 
template<class T>
void DragAndDropSource(T* item);
 
template<class T, std::invocable<T*> F>
void DragAndDropTarget(F&& func);
 
void SameLineSpaced();
 
void SameLineRightAligned(float itemWidth);
 
void SeparatorSpaced();
 
struct ImGuiId
{
    explicit ImGuiId(const char* id) { ImGui::PushID(id); }
    explicit ImGuiId(int id)         { ImGui::PushID(id); }
    ~ImGuiId() noexcept              { ImGui::PopID();    }
};
 
struct Indent
{
    explicit Indent()  { ImGui::Indent(); }
    ~Indent() noexcept { ImGui::Unindent(); }
};
 
struct StyleColor
{
    explicit StyleColor(ImGuiCol index, ImU32 col)          { ImGui::PushStyleColor(index, col); }
    explicit StyleColor(ImGuiCol index, const ImVec4& col)  { ImGui::PushStyleColor(index, col); }
    explicit StyleColor(ImGuiCol index, const Vector4& col) { ImGui::PushStyleColor(index, col); }
    ~StyleColor() noexcept                                  { ImGui::PopStyleColor();            }
};
 
struct StyleVar
{
    explicit StyleVar(ImGuiStyleVar index, const ImVec2& value) { ImGui::PushStyleVar(index, value); }
    ~StyleVar() noexcept                                        { ImGui::PopStyleVar();              }
};
 
struct StyleFont
{
    explicit StyleFont(ImFont* font) { ImGui::PushFont(font); }
    ~StyleFont() noexcept            { ImGui::PopFont();      }
};
 
struct ItemWidth
{
    explicit ItemWidth(float itemWidth) { ImGui::PushItemWidth(itemWidth); }
    ~ItemWidth() noexcept               { ImGui::PopItemWidth();           }
};
 
struct DisableIf
{
    explicit DisableIf(bool condition) { ImGui::BeginDisabled(condition); }
    ~DisableIf() noexcept              { ImGui::EndDisabled();            }
};
 
inline auto IsCapturingKeyboard() -> bool
{
    return ImGui::GetIO().WantCaptureKeyboard;
}
 
inline auto IsCapturingMouse() -> bool
{
    return ImGui::GetIO().WantCaptureMouse;
}
 
template<class F>
void Window(const char* label, ImGuiWindowFlags flags, F&& drawContents)
{
    if (ImGui::Begin(label, nullptr, flags))
    {
        drawContents();
    }
 
    ImGui::End();
}
 
template<class F>
void Window(const char* label, F&& drawContents)
{
    Window(label, ImGuiWindowFlags_None, std::forward<F>(drawContents));
}
 
template<class F>
void ChildWindow(const char* label, ImGuiChildFlags flags, F&& drawContents)
{
    if (ImGui::BeginChild(label, {0, 0}, flags))
    {
        drawContents();
    };
 
    ImGui::EndChild();
}
 
template<class F>
void ChildWindow(const char* label, F&& drawContents)
{
    if (ImGui::BeginChild(label, {0, 0}, true))
    {
        drawContents();
    };
 
    ImGui::EndChild();
}
 
inline auto IsWindowBackgroundClicked() -> bool
{
    return ImGui::IsWindowHovered() && ImGui::IsMouseClicked(0) && !ImGui::IsAnyItemHovered();
}
 
inline void SameLineSpaced()
{
    ImGui::SameLine();
    ImGui::Spacing();
    ImGui::SameLine();
}
 
inline void SameLineRightAligned(float itemWidth)
{
    const auto availableWidth = ImGui::GetContentRegionAvail().x;
    itemWidth += + ImGui::GetStyle().FramePadding.x * 2.0f;
    ImGui::SameLine(ImGui::GetCursorPosX() + availableWidth - itemWidth);
}
 
inline void SeparatorSpaced()
{
    ImGui::Spacing();
    ImGui::Separator();
    ImGui::Spacing();
}
 
inline auto InputInt(int& value, const char* label, int step) -> bool
{
    return ImGui::InputInt(label, &value, step);
}
 
inline auto InputU8(uint8_t& value, const char* label) -> bool
{
    constexpr uint8_t step = 1;
    return ImGui::InputScalar(label, ImGuiDataType_U8, &value, &step);
}
 
inline auto InputU16(uint16_t& value, const char* label) -> bool
{
    constexpr uint16_t step = 1;
    return ImGui::InputScalar(label, ImGuiDataType_U16, &value, &step);
}
 
inline auto InputU32(unsigned& value, const char* label) -> bool
{
    constexpr uint32_t step = 1;
    return ImGui::InputScalar(label, ImGuiDataType_U32, &value, &step);
}
 
inline auto InputU64(uint64_t& value, const char* label) -> bool
{
    constexpr uint64_t step = 1;
    return ImGui::InputScalar(label, ImGuiDataType_U64, &value, &step);
}
 
inline auto DragFloat(float& value, const char* label, float speed, float min, float max) -> bool
{
    return ImGui::DragFloat(label, &value, speed, min, max, "%.3f", ImGuiSliderFlags_AlwaysClamp);
}
 
inline auto Checkbox(bool& value, const char* name) -> bool
{
    return ImGui::Checkbox(name, &value);
}
 
inline auto InputVector3(Vector3& value, const char* label, float speed, float min, float max) -> bool
{
    return ImGui::DragFloat3(label, &value.x, speed, min, max, "%.3f", ImGuiSliderFlags_AlwaysClamp);
}
 
inline auto InputPosition(Vector3& value, const char* label) -> bool
{
    return ImGui::DragFloat3(label, &value.x, 1.0f, g_minPos, g_maxPos, "%.3f", ImGuiSliderFlags_AlwaysClamp);
}
 
inline auto InputAngles(Vector3& value, const char* label) -> bool
{
    return ImGui::DragFloat3(label, &value.x, 0.1f, g_minAngle, g_maxAngle, "%.3f", ImGuiSliderFlags_AlwaysClamp);
}
 
inline auto InputScale(Vector3& value, const char* label, float min, float max) -> bool
{
    return ImGui::DragFloat3(label, &value.x, 0.5f, min, max, "%.3f", ImGuiSliderFlags_AlwaysClamp);
}
 
inline auto InputAxis(Vector3& value, const char* label, float min, float max) -> bool
{
    const auto previous = value;
    if (ImGui::DragFloat3(label, &value.x, 0.1f, min, max, "%.3f", ImGuiSliderFlags_AlwaysClamp))
    {
        // When a component is changed to a maximum, other values are still potentially non-zero. These cases need to
        // be hard reset to the correct axis otherwise normalization prevents ever being able to reach it.
        if (value.x != previous.x && std::fabs(value.x) == 1.0f)
            value = Vector3{value.x, 0.0f, 0.0f};
        else if (value.y != previous.y && std::fabs(value.y) == 1.0f)
            value = Vector3{0.0f, value.y, 0.0f};
        else if (value.z != previous.z && std::fabs(value.z) == 1.0f)
            value = Vector3{0.0f, 0.0f, value.z};
        else if (value == Vector3::Zero()) // prevent problems when 0 is directly enterered
            value = previous;
        else
            value = Normalize(value);
 
        return true;
    }
 
    return false;
}
 
inline auto InputReferenceFrame(Vector3& basis, Vector3& normal, const char* basisLabel, const char* normalLabel) -> bool
{
    auto modified = false;
    if (InputAxis(basis, basisLabel))
    {
        normal = ClosestOrthogonal(normal, basis);
        modified = true;
    }
 
    if (InputAxis(normal, normalLabel))
    {
        basis = ClosestOrthogonal(basis, normal);
        modified = true;
    }
 
    return modified;
}
 
inline auto InputColor(Vector3& value, const char* label) -> bool
{
    return ImGui::ColorEdit3(label, &value.x, ImGuiColorEditFlags_NoInputs);
}
 
inline auto InputColor3(Vector3& value, const char* label) -> bool
{
    return ImGui::ColorEdit3(label, &value.x, ImGuiColorEditFlags_NoInputs);
}
 
inline auto InputColor4(Vector4& value, const char* label) -> bool
{
    return ImGui::ColorEdit4(label, &value.x, ImGuiColorEditFlags_NoInputs);
}
 
inline auto InputGradient(Gradient& value, const char* label) -> bool
{
    IMGUI_SCOPE(ui::ImGuiId, label);
    const auto startColor = ImGui::ColorConvertFloat4ToU32(ImVec4{value.start});
    const auto endColor = ImGui::ColorConvertFloat4ToU32(ImVec4{value.end});
    const auto canvasPos = ImGui::GetCursorScreenPos();
    const auto canvasSize = ImVec2{ImGui::CalcItemWidth(), ImGui::GetTextLineHeight()};
    auto* drawList = ImGui::GetWindowDrawList();
    drawList->AddRectFilledMultiColor(canvasPos, canvasPos + canvasSize, startColor, endColor, endColor, startColor);
    ImGui::InvisibleButton("gradientbar", canvasSize);
 
    if (ImGui::IsItemHovered() && ImGui::IsMouseClicked(0))
    {
        const auto mouseX = ImGui::GetIO().MousePos.x;
        if (mouseX < canvasPos.x + canvasSize.x * 0.5f)
            ImGui::OpenPopup("StartPicker");
        else
            ImGui::OpenPopup("EndPicker");
    }
 
    auto changed = false;
    if (ImGui::BeginPopup("StartPicker"))
    {
        changed |= ImGui::ColorPicker4("Start Color", &value.start.x);
        ImGui::EndPopup();
    }
 
    if (ImGui::BeginPopup("EndPicker"))
    {
        changed |= ImGui::ColorPicker4("End Color", &value.end.x);
        ImGui::EndPopup();
    }
 
    ImGui::SameLine();
    ImGui::TextUnformatted(label);
    ImGui::Dummy(ImVec2{0.0f, 5.0f});
    return changed;
}
 
inline auto Combobox(std::string& value, const char* label, std::span<const std::string_view> items)
{
    if (ImGui::BeginCombo(label, value.c_str()))
    {
        const auto selected = std::ranges::find_if(items, [](const auto& text)
        {
            return ImGui::Selectable(text.data());
        });
 
        ImGui::EndCombo();
 
        if (selected != std::cend(items))
        {
            value = selected->data();
            return true;
        }
    }
 
    return false;
}
 
inline auto FilteredCombobox(std::string& value, const char* label, std::span<const std::string_view> items, auto&& disableIf)
{
    if (ImGui::BeginCombo(label, value.c_str()))
    {
        const auto selected = std::ranges::find_if(items, [&disableIf](const auto& text)
        {
            IMGUI_SCOPE(DisableIf, disableIf(text));
            return ImGui::Selectable(text.data());
        });
 
        ImGui::EndCombo();
 
        if (selected != std::cend(items))
        {
            value = selected->data();
            return true;
        }
    }
 
    return false;
}
 
namespace internal
{
struct InputTextCallbackUserData
{
    std::string* string;
};
 
inline auto InputTextCallback(ImGuiInputTextCallbackData* data) -> int
{
    if(data->EventFlag == ImGuiInputTextFlags_CallbackResize)
    {
        InputTextCallbackUserData* userData = static_cast<InputTextCallbackUserData*>(data->UserData);
        auto* str = userData->string;
        str->resize(data->BufTextLen);
        data->Buf = (char*)str->c_str();
    }
 
    return 0;
}
} // namespace internal
 
inline auto InputText(std::string& text, const char* label) -> bool
{
    auto flags = ImGuiInputTextFlags_CallbackResize | ImGuiInputTextFlags_EnterReturnsTrue;
    auto userData = internal::InputTextCallbackUserData{.string = &text};
    return ImGui::InputText(label, text.data(), text.capacity() + 1, flags, internal::InputTextCallback, &userData);
}
 
auto SelectableWidget(bool selected, const ImVec2& size, auto&& widget) -> bool
{
    static constexpr auto flags = ImGuiSelectableFlags_AllowDoubleClick |
                                  ImGuiSelectableFlags_AllowOverlap;
    auto clicked = false;
    if (ImGui::Selectable("##select", selected, flags, size))
        clicked = true;
 
    ImGui::SameLine();
    widget();
    if (ImGui::IsItemClicked(0))
    {
        clicked = true;
        ImGui::SetKeyboardFocusHere(-1);
    }
 
    return clicked;
};
 
auto PropertyWidget(const auto& property, auto& instance, auto&& widget, auto&&... args) -> bool
{
    auto value = std::invoke(property.get, instance);
    if (widget(value, property.name, std::forward<decltype(args)>(args)...))
    {
        std::invoke(property.set, instance, value);
        return true;
    }
 
    return false;
}
 
template<class T>
void DragAndDropSource(T* item)
{
    if(ImGui::BeginDragDropSource(ImGuiDragDropFlags_None))
    {
        ImGui::SetDragDropPayload(type::Type<T>::name, item, sizeof(T));
        ImGui::Text(type::Type<T>::name);
        ImGui::EndDragDropSource();
    }
}
 
template<class T, std::invocable<T*> F>
void DragAndDropTarget(F&& func)
{
    if(ImGui::BeginDragDropTarget())
    {
        if(const auto* payload = ImGui::AcceptDragDropPayload(type::Type<T>::name))
        {
            func(static_cast<std::add_pointer_t<T>>(payload->Data));
        }
 
        ImGui::EndDragDropTarget();
    }
}
 
inline void SetTooltip(const char* text)
{
    if (ImGui::IsItemHovered())
    {
        ImGui::SetTooltip("%s", text);
    }
}
} // namespace nc::ui